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

JPL

R/O
SSH
HTTPS

jpl: コミット

コミットメタ情報

リビジョン	335 (tree)
日時	2018-11-26 04:15:11
作者	jakobthomsen

ログメッセージ

qualifiers

変更サマリ

modified: trunk/advanced/compiler.compiled.c (diff)
modified: trunk/advanced/compiler.source.c (diff)
modified: trunk/advanced/unit_tests/unit_test_inplace_block.c (diff)
modified: trunk/advanced/unit_tests/unit_test_nested_loops.c (diff)
modified: trunk/advanced/unit_tests/unit_test_stack_list2.c (diff)
added: trunk/advanced/verify_error_detection_compile_time/verify_qualified_parameter.c (diff)
added: trunk/advanced/verify_error_detection_compile_time/verify_qualified_parameter.err (diff)
added: trunk/advanced/verify_error_detection_compile_time/verify_qualified_variable.c (diff)
added: trunk/advanced/verify_error_detection_compile_time/verify_qualified_variable.err (diff)

差分

--- trunk/advanced/compiler.compiled.c (revision 334)

+++ trunk/advanced/compiler.compiled.c (revision 335)

		@@ -2711,7 +2711,9 @@
2711	2711	break;
2712	2712	}
2713	2713	case 0xFFFFFFFFFFFFFF3ELLU:
2714		-/* SP = 2LLU // SP = 2LLU */
	2714	+/* SP = 2LLU */
	2715	+{/* set exit-value */stack[16LLU] = 255LLU; }
	2716	+{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 2LLU */
2715	2717	case 18446744073709551442LLU: /* skip to here */
2716	2718
2717	2719	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 3LLU // SP - 1LLU = 2LLU // RESULT */

		@@ -2767,6 +2769,39 @@
2767	2769	{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 0LLU]; }
2768	2770	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2769	2771	/* function requires 16LLU 64-bit chunks of memory (including 0LLU for parameters) */
	2772	+case /PARSEIDOPT/0x40149314910F4140LLU:/* SP = 1LLU // SPMAX = 1LLU // predicate */
	2773	+
	2774	+{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU // SPMAX = 2LLU */
	2775	+{ /* TOP /stack[stackbase + 1LLU] = isalpha(/ TOP */stack[stackbase + 1LLU]); }
	2776	+if(!/* SP - 1LLU = 1LLU // POP */stack[stackbase + 1LLU])
	2777	+{ /* JUMP / fnaddr = 18446744073709551417LLU; break; } / skip consequent */
	2778	+/* consequent */
	2779	+ {
	2780	+ /* CALLBEGIN */
	2781	+ /* reserve space for 1LLU returned values // SP + 1LLU = 2LLU */
	2782	+{/* PUSH /stack[stackbase + 2LLU] = stackbase; }/ SP + 1LLU = 3LLU // SPMAX = 3LLU */
	2783	+ /* leave place for return addr // SP + 1LLU = 4LLU // SPMAX = 4LLU */
	2784	+ }/* SP + 13LLU = 17LLU // SPMAX = 17LLU // SP - 13LLU = 4LLU */
	2785	+{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 5LLU */
	2786	+ {
	2787	+ /CALLEND/
	2788	+ stackbase += 4LLU;
	2789	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF37LLU;
	2790	+ fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
	2791	+{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); } }
	2792	+ break;
	2793	+ }
	2794	+case 0xFFFFFFFFFFFFFF37LLU:
	2795	+/* SP = 2LLU // SP = 1LLU */
	2796	+{ /* JUMP / fnaddr = 18446744073709551416LLU; break; } / skip alternative */
	2797	+case 18446744073709551417LLU: /* alternative */
	2798	+{/* PUSH /stack[stackbase + 1LLU] = 0LLU; }/ SP + 1LLU = 2LLU */
	2799	+case 18446744073709551416LLU: /* skip to here */
	2800	+/* SP - 1LLU = 1LLU // RESULT */
	2801	+{ /* RESULT /stack[stackbase + 1LLU] = stack[stackbase + 1LLU]; }/ SP = 2LLU // SP - 1LLU = 1LLU // RESULT */
	2802	+{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 1LLU]; }
	2803	+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
	2804	+/* function requires 17LLU 64-bit chunks of memory (including 1LLU for parameters) */
2770	2805	case /parseprops/0xADCB6E82BB6AAEE0LLU:/* SP = 1LLU // SPMAX = 1LLU */
2771	2806	{
2772	2807	/* CALLBEGIN */

		@@ -2777,12 +2812,12 @@
2777	2812	{
2778	2813	/CALLEND/
2779	2814	stackbase += 6LLU;
2780		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF39LLU;
	2815	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF36LLU;
2781	2816	fnaddr = /emptyprops/0x828AEFD2BB6AAEE0LLU;/* SP = 0LLU */
2782	2817	{ if(stackbase + 4LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emptyprops/\n"); exit(-1); } }
2783	2818	break;
2784	2819	}
2785		-case 0xFFFFFFFFFFFFFF39LLU:
	2820	+case 0xFFFFFFFFFFFFFF36LLU:
2786	2821	/* SP = 4LLU // predicate */
2787	2822
2788	2823	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 5LLU */

		@@ -2790,7 +2825,7 @@
2790	2825	{
2791	2826	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 4LLU] == stack[stackbase + 5LLU]; }/ SP + 1LLU = 5LLU */ }
2792	2827	if(!/* SP - 1LLU = 4LLU // POP */stack[stackbase + 4LLU])
2793		-{ /* JUMP / fnaddr = 18446744073709551416LLU; break; } / skip consequent */
	2828	+{ /* JUMP / fnaddr = 18446744073709551413LLU; break; } / skip consequent */
2794	2829	/* consequent // predicate */
2795	2830
2796	2831	{

		@@ -2803,15 +2838,15 @@
2803	2838	{
2804	2839	/CALLEND/
2805	2840	stackbase += 7LLU;
2806		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF34LLU;
	2841	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF31LLU;
2807	2842	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
2808	2843	{ if(stackbase + 8LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); } }
2809	2844	break;
2810	2845	}
2811		-case 0xFFFFFFFFFFFFFF34LLU:
	2846	+case 0xFFFFFFFFFFFFFF31LLU:
2812	2847	/* SP = 5LLU */
2813	2848	if(!/* SP - 1LLU = 4LLU // POP */stack[stackbase + 4LLU])
2814		-{ /* JUMP / fnaddr = 18446744073709551414LLU; break; } / skip consequent */
	2849	+{ /* JUMP / fnaddr = 18446744073709551411LLU; break; } / skip consequent */
2815	2850	/* consequent // SP + 3LLU = 7LLU // SP - 3LLU = 4LLU */
2816	2851	{/* PUSH /stack[stackbase + 4LLU] = 11433139418452459520LLU; }/ SP + 1LLU = 5LLU // SP + 2LLU = 7LLU // SP - 2LLU = 5LLU */
2817	2852	{/* PUSH /stack[stackbase + 5LLU] = 13116716846516535296LLU; }/ SP + 1LLU = 6LLU // SP + 1LLU = 7LLU // SP - 1LLU = 6LLU */

		@@ -2819,8 +2854,8 @@
2819	2854	{ /* RESULT */stack[stackbase + 1LLU] = stack[stackbase + 4LLU]; }
2820	2855	{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 5LLU]; }
2821	2856	{ /* RESULT /stack[stackbase + 3LLU] = stack[stackbase + 6LLU]; }/ SP = 4LLU // SP = 4LLU */
2822		-{ /* JUMP / fnaddr = 18446744073709551413LLU; break; } / skip alternative */
2823		-case 18446744073709551414LLU: /* alternative // SP + 3LLU = 7LLU // SP - 3LLU = 4LLU */
	2857	+{ /* JUMP / fnaddr = 18446744073709551410LLU; break; } / skip alternative */
	2858	+case 18446744073709551411LLU: /* alternative // SP + 3LLU = 7LLU // SP - 3LLU = 4LLU */
2824	2859	{/* PUSH /stack[stackbase + 4LLU] = 11433139418452459520LLU; }/ SP + 1LLU = 5LLU // SP + 2LLU = 7LLU // SP - 2LLU = 5LLU */
2825	2860	{/* PUSH /stack[stackbase + 5LLU] = 12009798930018598912LLU; }/ SP + 1LLU = 6LLU // SP + 1LLU = 7LLU // SP - 1LLU = 6LLU */
2826	2861	{/* PUSH /stack[stackbase + 6LLU] = 8838925176472076288LLU; }/ SP + 1LLU = 7LLU // SP + 1LLU = 8LLU // SP - 1LLU = 7LLU // SP = 4LLU // assign */

		@@ -2827,10 +2862,10 @@
2827	2862	{ /* RESULT */stack[stackbase + 1LLU] = stack[stackbase + 4LLU]; }
2828	2863	{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 5LLU]; }
2829	2864	{ /* RESULT /stack[stackbase + 3LLU] = stack[stackbase + 6LLU]; }/ SP = 4LLU */
2830		-case 18446744073709551413LLU: /* skip to here */
	2865	+case 18446744073709551410LLU: /* skip to here */
2831	2866	/* SP = 4LLU // SP = 4LLU */
2832		-{ /* JUMP / fnaddr = 18446744073709551415LLU; break; } / skip alternative */
2833		-case 18446744073709551416LLU: /* alternative // predicate */
	2867	+{ /* JUMP / fnaddr = 18446744073709551412LLU; break; } / skip alternative */
	2868	+case 18446744073709551413LLU: /* alternative // predicate */
2834	2869
2835	2870	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 5LLU */
2836	2871	{/* PUSH /stack[stackbase + 5LLU] = 9676657516565495808LLU; }/ SP + 1LLU = 6LLU // SP = 4LLU */

		@@ -2837,7 +2872,7 @@
2837	2872	{
2838	2873	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 4LLU] == stack[stackbase + 5LLU]; }/ SP + 1LLU = 5LLU */ }
2839	2874	if(!/* SP - 1LLU = 4LLU // POP */stack[stackbase + 4LLU])
2840		-{ /* JUMP / fnaddr = 18446744073709551411LLU; break; } / skip consequent */
	2875	+{ /* JUMP / fnaddr = 18446744073709551408LLU; break; } / skip consequent */
2841	2876	/* consequent // predicate */
2842	2877
2843	2878	{

		@@ -2850,15 +2885,15 @@
2850	2885	{
2851	2886	/CALLEND/
2852	2887	stackbase += 7LLU;
2853		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2FLLU;
	2888	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2CLLU;
2854	2889	fnaddr = /matchopt__/0xA1CBDE8EAAEF0000LLU;/* SP = 0LLU */
2855	2890	{ if(stackbase + 8LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /matchopt__/\n"); exit(-1); } }
2856	2891	break;
2857	2892	}
2858		-case 0xFFFFFFFFFFFFFF2FLLU:
	2893	+case 0xFFFFFFFFFFFFFF2CLLU:
2859	2894	/* SP = 5LLU */
2860	2895	if(!/* SP - 1LLU = 4LLU // POP */stack[stackbase + 4LLU])
2861		-{ /* JUMP / fnaddr = 18446744073709551409LLU; break; } / skip consequent */
	2896	+{ /* JUMP / fnaddr = 18446744073709551406LLU; break; } / skip consequent */
2862	2897	/* consequent // SP + 3LLU = 7LLU // SP - 3LLU = 4LLU */
2863	2898	{/* PUSH /stack[stackbase + 4LLU] = 11433139418452459520LLU; }/ SP + 1LLU = 5LLU // SP + 2LLU = 7LLU // SP - 2LLU = 5LLU */
2864	2899	{/* PUSH /stack[stackbase + 5LLU] = 13116716846516535296LLU; }/ SP + 1LLU = 6LLU // SP + 1LLU = 7LLU // SP - 1LLU = 6LLU */

		@@ -2866,8 +2901,8 @@
2866	2901	{ /* RESULT */stack[stackbase + 1LLU] = stack[stackbase + 4LLU]; }
2867	2902	{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 5LLU]; }
2868	2903	{ /* RESULT /stack[stackbase + 3LLU] = stack[stackbase + 6LLU]; }/ SP = 4LLU // SP = 4LLU */
2869		-{ /* JUMP / fnaddr = 18446744073709551408LLU; break; } / skip alternative */
2870		-case 18446744073709551409LLU: /* alternative // SP + 3LLU = 7LLU // SP - 3LLU = 4LLU */
	2904	+{ /* JUMP / fnaddr = 18446744073709551405LLU; break; } / skip alternative */
	2905	+case 18446744073709551406LLU: /* alternative // SP + 3LLU = 7LLU // SP - 3LLU = 4LLU */
2871	2906	{/* PUSH /stack[stackbase + 4LLU] = 11433139418452459520LLU; }/ SP + 1LLU = 5LLU // SP + 2LLU = 7LLU // SP - 2LLU = 5LLU */
2872	2907	{/* PUSH /stack[stackbase + 5LLU] = 12009798930018598912LLU; }/ SP + 1LLU = 6LLU // SP + 1LLU = 7LLU // SP - 1LLU = 6LLU */
2873	2908	{/* PUSH /stack[stackbase + 6LLU] = 10563099066900725248LLU; }/ SP + 1LLU = 7LLU // SP + 1LLU = 8LLU // SP - 1LLU = 7LLU // SP = 4LLU // assign */

		@@ -2874,10 +2909,10 @@
2874	2909	{ /* RESULT */stack[stackbase + 1LLU] = stack[stackbase + 4LLU]; }
2875	2910	{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 5LLU]; }
2876	2911	{ /* RESULT /stack[stackbase + 3LLU] = stack[stackbase + 6LLU]; }/ SP = 4LLU */
2877		-case 18446744073709551408LLU: /* skip to here */
	2912	+case 18446744073709551405LLU: /* skip to here */
2878	2913	/* SP = 4LLU // SP = 4LLU */
2879		-{ /* JUMP / fnaddr = 18446744073709551410LLU; break; } / skip alternative */
2880		-case 18446744073709551411LLU: /* alternative // predicate */
	2914	+{ /* JUMP / fnaddr = 18446744073709551407LLU; break; } / skip alternative */
	2915	+case 18446744073709551408LLU: /* alternative // predicate */
2881	2916
2882	2917	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 5LLU */
2883	2918	{/* PUSH /stack[stackbase + 5LLU] = 8838925176472076288LLU; }/ SP + 1LLU = 6LLU // SP = 4LLU */

		@@ -2884,7 +2919,7 @@
2884	2919	{
2885	2920	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 4LLU] == stack[stackbase + 5LLU]; }/ SP + 1LLU = 5LLU */ }
2886	2921	if(!/* SP - 1LLU = 4LLU // POP */stack[stackbase + 4LLU])
2887		-{ /* JUMP / fnaddr = 18446744073709551406LLU; break; } / skip consequent */
	2922	+{ /* JUMP / fnaddr = 18446744073709551403LLU; break; } / skip consequent */
2888	2923	/* consequent // SP + 3LLU = 7LLU // SP - 3LLU = 4LLU */
2889	2924	{/* PUSH /stack[stackbase + 4LLU] = 11433139456356156928LLU; }/ SP + 1LLU = 5LLU // SP + 1LLU = 6LLU // SP - 1LLU = 5LLU */
2890	2925	{/* PUSH /stack[stackbase + 5LLU] = 0LLU; }/ SP + 1LLU = 6LLU */

		@@ -2892,8 +2927,8 @@
2892	2927	{ /* RESULT */stack[stackbase + 1LLU] = stack[stackbase + 4LLU]; }
2893	2928	{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 5LLU]; }
2894	2929	{ /* RESULT /stack[stackbase + 3LLU] = stack[stackbase + 6LLU]; }/ SP = 4LLU // SP = 4LLU */
2895		-{ /* JUMP / fnaddr = 18446744073709551405LLU; break; } / skip alternative */
2896		-case 18446744073709551406LLU: /* alternative // predicate */
	2930	+{ /* JUMP / fnaddr = 18446744073709551402LLU; break; } / skip alternative */
	2931	+case 18446744073709551403LLU: /* alternative // predicate */
2897	2932
2898	2933	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 5LLU */
2899	2934	{/* PUSH /stack[stackbase + 5LLU] = 12523225860779540480LLU; }/ SP + 1LLU = 6LLU // SP = 4LLU */

		@@ -2900,7 +2935,7 @@
2900	2935	{
2901	2936	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 4LLU] == stack[stackbase + 5LLU]; }/ SP + 1LLU = 5LLU */ }
2902	2937	if(!/* SP - 1LLU = 4LLU // POP */stack[stackbase + 4LLU])
2903		-{ /* JUMP / fnaddr = 18446744073709551404LLU; break; } / skip consequent */
	2938	+{ /* JUMP / fnaddr = 18446744073709551401LLU; break; } / skip consequent */
2904	2939	/* consequent // SP + 3LLU = 7LLU // SP - 3LLU = 4LLU */
2905	2940	{/* PUSH /stack[stackbase + 4LLU] = 11433139456356156928LLU; }/ SP + 1LLU = 5LLU // SP + 1LLU = 6LLU // SP - 1LLU = 5LLU */
2906	2941	{/* PUSH /stack[stackbase + 5LLU] = 0LLU; }/ SP + 1LLU = 6LLU */

		@@ -2908,8 +2943,8 @@
2908	2943	{ /* RESULT */stack[stackbase + 1LLU] = stack[stackbase + 4LLU]; }
2909	2944	{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 5LLU]; }
2910	2945	{ /* RESULT /stack[stackbase + 3LLU] = stack[stackbase + 6LLU]; }/ SP = 4LLU // SP = 4LLU */
2911		-{ /* JUMP / fnaddr = 18446744073709551403LLU; break; } / skip alternative */
2912		-case 18446744073709551404LLU: /* alternative */
	2946	+{ /* JUMP / fnaddr = 18446744073709551400LLU; break; } / skip alternative */
	2947	+case 18446744073709551401LLU: /* alternative */
2913	2948	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("\nmissing property before id ", stderr);
2914	2949	{
2915	2950	/* CALLBEGIN */

		@@ -2921,22 +2956,22 @@
2921	2956	{
2922	2957	/CALLEND/
2923	2958	stackbase += 6LLU;
2924		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF2ALLU;
	2959	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF27LLU;
2925	2960	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
2926	2961	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
2927	2962	break;
2928	2963	}
2929		-case 0xFFFFFFFFFFFFFF2ALLU:
	2964	+case 0xFFFFFFFFFFFFFF27LLU:
2930	2965	/* SP = 4LLU */fputs(" - accepted properties are: total!, total, finite!, finite, complete, partial\n", stderr);
2931	2966	{/* set exit-value */stack[16LLU] = 255LLU; }
2932	2967	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 4LLU */
2933		-case 18446744073709551403LLU: /* skip to here */
	2968	+case 18446744073709551400LLU: /* skip to here */
2934	2969
2935		-case 18446744073709551405LLU: /* skip to here */
	2970	+case 18446744073709551402LLU: /* skip to here */
2936	2971
2937		-case 18446744073709551410LLU: /* skip to here */
	2972	+case 18446744073709551407LLU: /* skip to here */
2938	2973
2939		-case 18446744073709551415LLU: /* skip to here */
	2974	+case 18446744073709551412LLU: /* skip to here */
2940	2975
2941	2976	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 5LLU */
2942	2977	{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 6LLU */

		@@ -2960,12 +2995,12 @@
2960	2995	{
2961	2996	/CALLEND/
2962	2997	stackbase += 3LLU;
2963		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF29LLU;
	2998	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF26LLU;
2964	2999	fnaddr = /printid___/0xAED929BE47C00000LLU;/* SP = 0LLU */
2965	3000	{ if(stackbase + 10LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printid___/\n"); exit(-1); } }
2966	3001	break;
2967	3002	}
2968		-case 0xFFFFFFFFFFFFFF29LLU:
	3003	+case 0xFFFFFFFFFFFFFF26LLU:
2969	3004	/* SP = 1LLU // SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
2970	3005	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
2971	3006	/* function requires 13LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -2982,15 +3017,15 @@
2982	3017	{
2983	3018	/CALLEND/
2984	3019	stackbase += 5LLU;
2985		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF26LLU;
	3020	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF23LLU;
2986	3021	fnaddr = /typeislist/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
2987	3022	{ if(stackbase + 5LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeislist/\n"); exit(-1); } }
2988	3023	break;
2989	3024	}
2990		-case 0xFFFFFFFFFFFFFF26LLU:
	3025	+case 0xFFFFFFFFFFFFFF23LLU:
2991	3026	/* SP = 3LLU */
2992	3027	if(!/* SP - 1LLU = 2LLU // POP */stack[stackbase + 2LLU])
2993		-{ /* JUMP / fnaddr = 18446744073709551400LLU; break; } / skip consequent */
	3028	+{ /* JUMP / fnaddr = 18446744073709551397LLU; break; } / skip consequent */
2994	3029	/* consequent */fputs("[", stdout);
2995	3030	{
2996	3031	/* CALLBEGIN */

		@@ -3009,25 +3044,25 @@
3009	3044	{
3010	3045	/CALLEND/
3011	3046	stackbase += 7LLU;
3012		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF25LLU;
	3047	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF22LLU;
3013	3048	fnaddr = /typetosub_/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
3014	3049	{ if(stackbase + 5LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typetosub_/\n"); exit(-1); } }
3015	3050	break;
3016	3051	}
3017		-case 0xFFFFFFFFFFFFFF25LLU:
	3052	+case 0xFFFFFFFFFFFFFF22LLU:
3018	3053	/* SP = 5LLU */
3019	3054	{
3020	3055	/CALLEND/
3021	3056	stackbase += 4LLU;
3022		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF24LLU;
	3057	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF21LLU;
3023	3058	fnaddr = /printstype/0xAED929BEEBF4AE00LLU;/* SP = 0LLU */
3024	3059	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printstype/\n"); exit(-1); } }
3025	3060	break;
3026	3061	}
3027		-case 0xFFFFFFFFFFFFFF24LLU:
	3062	+case 0xFFFFFFFFFFFFFF21LLU:
3028	3063	/* SP = 2LLU /fputs("]", stdout); / SP = 2LLU // SP = 2LLU */
3029		-{ /* JUMP / fnaddr = 18446744073709551399LLU; break; } / skip alternative */
3030		-case 18446744073709551400LLU: /* alternative */
	3064	+{ /* JUMP / fnaddr = 18446744073709551396LLU; break; } / skip alternative */
	3065	+case 18446744073709551397LLU: /* alternative */
3031	3066	{
3032	3067	/* CALLBEGIN */
3033	3068	/* reserve space for 0LLU returned values // SP + 0LLU = 2LLU */

		@@ -3045,27 +3080,68 @@
3045	3080	{
3046	3081	/CALLEND/
3047	3082	stackbase += 7LLU;
3048		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF23LLU;
	3083	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF20LLU;
3049	3084	fnaddr = /typetosub_/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
3050	3085	{ if(stackbase + 5LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typetosub_/\n"); exit(-1); } }
3051	3086	break;
3052	3087	}
3053		-case 0xFFFFFFFFFFFFFF23LLU:
	3088	+case 0xFFFFFFFFFFFFFF20LLU:
3054	3089	/* SP = 5LLU */
3055	3090	{
3056	3091	/CALLEND/
3057	3092	stackbase += 4LLU;
3058		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF22LLU;
	3093	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1FLLU;
3059	3094	fnaddr = /printstype/0xAED929BEEBF4AE00LLU;/* SP = 0LLU */
3060	3095	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printstype/\n"); exit(-1); } }
3061	3096	break;
3062	3097	}
3063		-case 0xFFFFFFFFFFFFFF22LLU:
	3098	+case 0xFFFFFFFFFFFFFF1FLLU:
3064	3099	/* SP = 2LLU // SP = 2LLU */
3065		-case 18446744073709551399LLU: /* skip to here */
	3100	+case 18446744073709551396LLU: /* skip to here */
3066	3101	/* SP = 2LLU // SP - 0LLU = 2LLU // RESULT */
3067	3102	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
3068	3103	/* function requires 17LLU 64-bit chunks of memory (including 2LLU for parameters) */
	3104	+case /printqtype/0xAED929BECBF4AE00LLU:/* SP = 3LLU // SPMAX = 3LLU // parse data */
	3105	+
	3106	+{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 4LLU // SPMAX = 4LLU // match-predicate */
	3107	+
	3108	+if(/const_____/0x7AAA6EBC00000000LLU != stack[stackbase + 3LLU])
	3109	+{ /* JUMP / fnaddr = 18446744073709551390LLU; break; } / skip match */
	3110	+/* match /fputs("", stdout); / SP = 4LLU // SP - 0LLU = 4LLU / / MATCH-RESULT // SP = 3LLU */
	3111	+{ /* JUMP / fnaddr = 18446744073709551389LLU; break; } / skip other */
	3112	+case 18446744073709551390LLU: /* other // SP = 3LLU // parse data */
	3113	+
	3114	+{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 4LLU // match-predicate */
	3115	+
	3116	+if(/mutable___/0xA30BDC7678000000LLU != stack[stackbase + 3LLU])
	3117	+{ /* JUMP / fnaddr = 18446744073709551388LLU; break; } / skip match */
	3118	+/* match /fputs("mut ", stdout); / SP = 4LLU // SP - 0LLU = 4LLU / / MATCH-RESULT // SP = 3LLU */
	3119	+{ /* JUMP / fnaddr = 18446744073709551387LLU; break; } / skip other */
	3120	+case 18446744073709551388LLU: /* other // SP = 3LLU /fputs("???", stdout); / SP = 3LLU */
	3121	+case 18446744073709551387LLU: /* skip to here */
	3122	+
	3123	+case 18446744073709551389LLU: /* skip to here */
	3124	+
	3125	+ {
	3126	+ /* CALLBEGIN */
	3127	+ /* reserve space for 0LLU returned values // SP + 0LLU = 3LLU */
	3128	+{/* PUSH /stack[stackbase + 3LLU] = stackbase; }/ SP + 1LLU = 4LLU */
	3129	+ /* leave place for return addr // SP + 1LLU = 5LLU // SPMAX = 5LLU */
	3130	+ }/* SP + 17LLU = 22LLU // SPMAX = 22LLU // SP - 17LLU = 5LLU */
	3131	+{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 6LLU */
	3132	+{/* PUSH /stack[stackbase + 6LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 7LLU */
	3133	+ {
	3134	+ /CALLEND/
	3135	+ stackbase += 5LLU;
	3136	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1ALLU;
	3137	+ fnaddr = /printtype_/0xAED929BEFD2B8000LLU;/* SP = 0LLU */
	3138	+{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printtype_/\n"); exit(-1); } }
	3139	+ break;
	3140	+ }
	3141	+case 0xFFFFFFFFFFFFFF1ALLU:
	3142	+/* SP = 3LLU // SP = 3LLU // SP - 0LLU = 3LLU // RESULT */
	3143	+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
	3144	+/* function requires 22LLU 64-bit chunks of memory (including 3LLU for parameters) */
3069	3145	case /reportstyp/0xB60AEAB6FBAFD2B0LLU:/* SP = 1LLU // SPMAX = 1LLU */
3070	3146	{
3071	3147	/* CALLBEGIN */

		@@ -3077,12 +3153,12 @@
3077	3153	{
3078	3154	/CALLEND/
3079	3155	stackbase += 3LLU;
3080		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF21LLU;
	3156	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF19LLU;
3081	3157	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
3082	3158	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
3083	3159	break;
3084	3160	}
3085		-case 0xFFFFFFFFFFFFFF21LLU:
	3161	+case 0xFFFFFFFFFFFFFF19LLU:
3086	3162	/* SP = 1LLU // SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
3087	3163	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
3088	3164	/* function requires 10LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -3099,15 +3175,15 @@
3099	3175	{
3100	3176	/CALLEND/
3101	3177	stackbase += 5LLU;
3102		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1ELLU;
	3178	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF16LLU;
3103	3179	fnaddr = /typeislist/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
3104	3180	{ if(stackbase + 5LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeislist/\n"); exit(-1); } }
3105	3181	break;
3106	3182	}
3107		-case 0xFFFFFFFFFFFFFF1ELLU:
	3183	+case 0xFFFFFFFFFFFFFF16LLU:
3108	3184	/* SP = 3LLU */
3109	3185	if(!/* SP - 1LLU = 2LLU // POP */stack[stackbase + 2LLU])
3110		-{ /* JUMP / fnaddr = 18446744073709551392LLU; break; } / skip consequent */
	3186	+{ /* JUMP / fnaddr = 18446744073709551384LLU; break; } / skip consequent */
3111	3187	/* consequent */fputs("[", stderr);
3112	3188	{
3113	3189	/* CALLBEGIN */

		@@ -3126,25 +3202,25 @@
3126	3202	{
3127	3203	/CALLEND/
3128	3204	stackbase += 7LLU;
3129		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1DLLU;
	3205	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF15LLU;
3130	3206	fnaddr = /typetosub_/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
3131	3207	{ if(stackbase + 5LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typetosub_/\n"); exit(-1); } }
3132	3208	break;
3133	3209	}
3134		-case 0xFFFFFFFFFFFFFF1DLLU:
	3210	+case 0xFFFFFFFFFFFFFF15LLU:
3135	3211	/* SP = 5LLU */
3136	3212	{
3137	3213	/CALLEND/
3138	3214	stackbase += 4LLU;
3139		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1CLLU;
	3215	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF14LLU;
3140	3216	fnaddr = /reportstyp/0xB60AEAB6FBAFD2B0LLU;/* SP = 0LLU */
3141	3217	{ if(stackbase + 10LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportstyp/\n"); exit(-1); } }
3142	3218	break;
3143	3219	}
3144		-case 0xFFFFFFFFFFFFFF1CLLU:
	3220	+case 0xFFFFFFFFFFFFFF14LLU:
3145	3221	/* SP = 2LLU /fputs("]", stderr); / SP = 2LLU // SP = 2LLU */
3146		-{ /* JUMP / fnaddr = 18446744073709551391LLU; break; } / skip alternative */
3147		-case 18446744073709551392LLU: /* alternative */
	3222	+{ /* JUMP / fnaddr = 18446744073709551383LLU; break; } / skip alternative */
	3223	+case 18446744073709551384LLU: /* alternative */
3148	3224	{
3149	3225	/* CALLBEGIN */
3150	3226	/* reserve space for 0LLU returned values // SP + 0LLU = 2LLU */

		@@ -3162,77 +3238,118 @@
3162	3238	{
3163	3239	/CALLEND/
3164	3240	stackbase += 7LLU;
3165		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1BLLU;
	3241	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF13LLU;
3166	3242	fnaddr = /typetosub_/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
3167	3243	{ if(stackbase + 5LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typetosub_/\n"); exit(-1); } }
3168	3244	break;
3169	3245	}
3170		-case 0xFFFFFFFFFFFFFF1BLLU:
	3246	+case 0xFFFFFFFFFFFFFF13LLU:
3171	3247	/* SP = 5LLU */
3172	3248	{
3173	3249	/CALLEND/
3174	3250	stackbase += 4LLU;
3175		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF1ALLU;
	3251	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF12LLU;
3176	3252	fnaddr = /reportstyp/0xB60AEAB6FBAFD2B0LLU;/* SP = 0LLU */
3177	3253	{ if(stackbase + 10LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportstyp/\n"); exit(-1); } }
3178	3254	break;
3179	3255	}
3180		-case 0xFFFFFFFFFFFFFF1ALLU:
	3256	+case 0xFFFFFFFFFFFFFF12LLU:
3181	3257	/* SP = 2LLU // SP = 2LLU */
3182		-case 18446744073709551391LLU: /* skip to here */
	3258	+case 18446744073709551383LLU: /* skip to here */
3183	3259	/* SP = 2LLU // SP - 0LLU = 2LLU // RESULT */
3184	3260	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
3185	3261	/* function requires 14LLU 64-bit chunks of memory (including 2LLU for parameters) */
	3262	+case /reportqtyp/0xB60AEAB6FB2FD2B0LLU:/* SP = 3LLU // SPMAX = 3LLU // parse data */
	3263	+
	3264	+{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 4LLU // SPMAX = 4LLU // match-predicate */
	3265	+
	3266	+if(/const_____/0x7AAA6EBC00000000LLU != stack[stackbase + 3LLU])
	3267	+{ /* JUMP / fnaddr = 18446744073709551377LLU; break; } / skip match */
	3268	+/* match // SP = 4LLU // SP - 0LLU = 4LLU / / MATCH-RESULT // SP = 3LLU */
	3269	+{ /* JUMP / fnaddr = 18446744073709551376LLU; break; } / skip other */
	3270	+case 18446744073709551377LLU: /* other // SP = 3LLU // parse data */
	3271	+
	3272	+{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 4LLU // match-predicate */
	3273	+
	3274	+if(/mutable___/0xA30BDC7678000000LLU != stack[stackbase + 3LLU])
	3275	+{ /* JUMP / fnaddr = 18446744073709551375LLU; break; } / skip match */
	3276	+/* match /fputs("mut ", stderr); / SP = 4LLU // SP - 0LLU = 4LLU / / MATCH-RESULT // SP = 3LLU */
	3277	+{ /* JUMP / fnaddr = 18446744073709551374LLU; break; } / skip other */
	3278	+case 18446744073709551375LLU: /* other // SP = 3LLU /fputs("???", stderr); / SP = 3LLU */
	3279	+case 18446744073709551374LLU: /* skip to here */
	3280	+
	3281	+case 18446744073709551376LLU: /* skip to here */
	3282	+
	3283	+ {
	3284	+ /* CALLBEGIN */
	3285	+ /* reserve space for 0LLU returned values // SP + 0LLU = 3LLU */
	3286	+{/* PUSH /stack[stackbase + 3LLU] = stackbase; }/ SP + 1LLU = 4LLU */
	3287	+ /* leave place for return addr // SP + 1LLU = 5LLU // SPMAX = 5LLU */
	3288	+ }/* SP + 14LLU = 19LLU // SPMAX = 19LLU // SP - 14LLU = 5LLU */
	3289	+{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 6LLU */
	3290	+{/* PUSH /stack[stackbase + 6LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 7LLU */
	3291	+ {
	3292	+ /CALLEND/
	3293	+ stackbase += 5LLU;
	3294	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0DLLU;
	3295	+ fnaddr = /reporttype/0xB60AEAB6FBF4AE00LLU;/* SP = 0LLU */
	3296	+{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reporttype/\n"); exit(-1); } }
	3297	+ break;
	3298	+ }
	3299	+case 0xFFFFFFFFFFFFFF0DLLU:
	3300	+/* SP = 3LLU // SP = 3LLU // SP - 0LLU = 3LLU // RESULT */
	3301	+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
	3302	+/* function requires 19LLU 64-bit chunks of memory (including 3LLU for parameters) */
3186	3303	case /reportflag/0xB60AEAB6F8677220LLU:/* SP = 1LLU // SPMAX = 1LLU // parse data */
3187	3304
3188	3305	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU // SPMAX = 2LLU // match-predicate */
3189	3306
3190	3307	if(/clear_____/0x7A781CB400000000LLU != stack[stackbase + 1LLU])
3191		-{ /* JUMP / fnaddr = 18446744073709551385LLU; break; } / skip match */
	3308	+{ /* JUMP / fnaddr = 18446744073709551372LLU; break; } / skip match */
3192	3309	/* match /fputs("", stderr); / SP = 2LLU // SP - 0LLU = 2LLU / / MATCH-RESULT // SP = 1LLU */
3193		-{ /* JUMP / fnaddr = 18446744073709551384LLU; break; } / skip other */
3194		-case 18446744073709551385LLU: /* other // SP = 1LLU // parse data */
	3310	+{ /* JUMP / fnaddr = 18446744073709551371LLU; break; } / skip other */
	3311	+case 18446744073709551372LLU: /* other // SP = 1LLU // parse data */
3195	3312
3196	3313	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU // match-predicate */
3197	3314
3198	3315	if(/struct____/0xBAFB707AF0000000LLU != stack[stackbase + 1LLU])
3199		-{ /* JUMP / fnaddr = 18446744073709551383LLU; break; } / skip match */
	3316	+{ /* JUMP / fnaddr = 18446744073709551370LLU; break; } / skip match */
3200	3317	/* match /fputs("struct ", stderr); / SP = 2LLU // SP - 0LLU = 2LLU / / MATCH-RESULT // SP = 1LLU */
3201		-{ /* JUMP / fnaddr = 18446744073709551382LLU; break; } / skip other */
3202		-case 18446744073709551383LLU: /* other // SP = 1LLU // parse data */
	3318	+{ /* JUMP / fnaddr = 18446744073709551369LLU; break; } / skip other */
	3319	+case 18446744073709551370LLU: /* other // SP = 1LLU // parse data */
3203	3320
3204	3321	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU // match-predicate */
3205	3322
3206	3323	if(/union_____/0xC2992AA400000000LLU != stack[stackbase + 1LLU])
3207		-{ /* JUMP / fnaddr = 18446744073709551381LLU; break; } / skip match */
	3324	+{ /* JUMP / fnaddr = 18446744073709551368LLU; break; } / skip match */
3208	3325	/* match /fputs("union ", stderr); / SP = 2LLU // SP - 0LLU = 2LLU / / MATCH-RESULT // SP = 1LLU */
3209		-{ /* JUMP / fnaddr = 18446744073709551380LLU; break; } / skip other */
3210		-case 18446744073709551381LLU: /* other // SP = 1LLU // parse data */
	3326	+{ /* JUMP / fnaddr = 18446744073709551367LLU; break; } / skip other */
	3327	+case 18446744073709551368LLU: /* other // SP = 1LLU // parse data */
3211	3328
3212	3329	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU // match-predicate */
3213	3330
3214	3331	if(/data______/0x7DCBDC0000000000LLU != stack[stackbase + 1LLU])
3215		-{ /* JUMP / fnaddr = 18446744073709551379LLU; break; } / skip match */
	3332	+{ /* JUMP / fnaddr = 18446744073709551366LLU; break; } / skip match */
3216	3333	/* match /fputs("data ", stderr); / SP = 2LLU // SP - 0LLU = 2LLU / / MATCH-RESULT // SP = 1LLU */
3217		-{ /* JUMP / fnaddr = 18446744073709551378LLU; break; } / skip other */
3218		-case 18446744073709551379LLU: /* other // SP = 1LLU /fputs("??? ", stderr); / SP = 1LLU */
3219		-case 18446744073709551378LLU: /* skip to here */
	3334	+{ /* JUMP / fnaddr = 18446744073709551365LLU; break; } / skip other */
	3335	+case 18446744073709551366LLU: /* other // SP = 1LLU /fputs("??? ", stderr); / SP = 1LLU */
	3336	+case 18446744073709551365LLU: /* skip to here */
3220	3337
3221		-case 18446744073709551380LLU: /* skip to here */
	3338	+case 18446744073709551367LLU: /* skip to here */
3222	3339
3223		-case 18446744073709551382LLU: /* skip to here */
	3340	+case 18446744073709551369LLU: /* skip to here */
3224	3341
3225		-case 18446744073709551384LLU: /* skip to here */
	3342	+case 18446744073709551371LLU: /* skip to here */
3226	3343	/* SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
3227	3344	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
3228	3345	/* function requires 2LLU 64-bit chunks of memory (including 1LLU for parameters) */
3229	3346	case /reportdefs/0xB60AEAB6F7E086E0LLU:/* SP = 1LLU // SPMAX = 1LLU */
3230	3347	{/* PUSH /stack[stackbase + 1LLU] = 0LLU; }/ SP + 1LLU = 2LLU // SPMAX = 2LLU */
3231		-case 0xFFFFFFFFFFFFFF11LLU: /* loop to here // predicate: list non-empty? */
	3348	+case 0xFFFFFFFFFFFFFF04LLU: /* loop to here // predicate: list non-empty? */
3232	3349
3233	3350	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 3LLU // SPMAX = 3LLU */
3234	3351	if(!/* SP - 1LLU = 2LLU // POP */stack[stackbase + 2LLU])
3235		-{ /* JUMP / fnaddr = 18446744073709551376LLU; break; } / skip loop */
	3352	+{ /* JUMP / fnaddr = 18446744073709551363LLU; break; } / skip loop */
3236	3353	/* loop // parse data */
3237	3354
3238	3355	{ /* LIST-READ */

		@@ -3255,7 +3372,7 @@
3255	3372	{/* PUSH /stack[stackbase + 10LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 9LLU]; }/ SP + 1LLU = 11LLU // SPMAX = 11LLU / }/ match-predicate */
3256	3373
3257	3374	if(/def_______/0x7E08400000000000LLU != stack[stackbase + 2LLU])
3258		-{ /* JUMP / fnaddr = 18446744073709551375LLU; break; } / skip match */
	3375	+{ /* JUMP / fnaddr = 18446744073709551362LLU; break; } / skip match */
3259	3376	/* match */fputs("\n", stderr);
3260	3377	{
3261	3378	/* CALLBEGIN */

		@@ -3267,12 +3384,12 @@
3267	3384	{
3268	3385	/CALLEND/
3269	3386	stackbase += 13LLU;
3270		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0DLLU;
	3387	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFF00LLU;
3271	3388	fnaddr = /reportnr__/0xB60AEAB6FA6D0000LLU;/* SP = 0LLU */
3272	3389	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportnr__/\n"); exit(-1); } }
3273	3390	break;
3274	3391	}
3275		-case 0xFFFFFFFFFFFFFF0DLLU:
	3392	+case 0xFFFFFFFFFFFFFF00LLU:
3276	3393	/* SP = 11LLU */fputs(" ", stderr);
3277	3394	{
3278	3395	/* CALLBEGIN */

		@@ -3286,12 +3403,12 @@
3286	3403	{
3287	3404	/CALLEND/
3288	3405	stackbase += 13LLU;
3289		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0CLLU;
	3406	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFFLLU;
3290	3407	fnaddr = /reportprop/0xB60AEAB6FAEDAAB0LLU;/* SP = 0LLU */
3291	3408	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportprop/\n"); exit(-1); } }
3292	3409	break;
3293	3410	}
3294		-case 0xFFFFFFFFFFFFFF0CLLU:
	3411	+case 0xFFFFFFFFFFFFFEFFLLU:
3295	3412	/* SP = 11LLU */fputs(" ", stderr);
3296	3413	{
3297	3414	/* CALLBEGIN */

		@@ -3303,12 +3420,12 @@
3303	3420	{
3304	3421	/CALLEND/
3305	3422	stackbase += 13LLU;
3306		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0BLLU;
	3423	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFELLU;
3307	3424	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
3308	3425	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
3309	3426	break;
3310	3427	}
3311		-case 0xFFFFFFFFFFFFFF0BLLU:
	3428	+case 0xFFFFFFFFFFFFFEFELLU:
3312	3429	/* SP = 11LLU */fputs(" ", stderr);
3313	3430	{
3314	3431	/* CALLBEGIN */

		@@ -3320,12 +3437,12 @@
3320	3437	{
3321	3438	/CALLEND/
3322	3439	stackbase += 13LLU;
3323		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF0ALLU;
	3440	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFDLLU;
3324	3441	fnaddr = /reportflag/0xB60AEAB6F8677220LLU;/* SP = 0LLU */
3325	3442	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportflag/\n"); exit(-1); } }
3326	3443	break;
3327	3444	}
3328		-case 0xFFFFFFFFFFFFFF0ALLU:
	3445	+case 0xFFFFFFFFFFFFFEFDLLU:
3329	3446	/* SP = 11LLU */
3330	3447	{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 12LLU */
3331	3448	{/* PUSH /stack[stackbase + 12LLU] = 1LLU; }/ SP + 1LLU = 13LLU // SP = 11LLU */

		@@ -3332,8 +3449,8 @@
3332	3449	{
3333	3450	{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 11LLU] + stack[stackbase + 12LLU]; }/ SP + 1LLU = 12LLU / }/ SP = 11LLU // assign */
3334	3451	{ /* RESULT /stack[stackbase + 1LLU] = stack[stackbase + 11LLU]; }/ SP = 11LLU // SP - 0LLU = 11LLU / / MATCH-RESULT // SP = 2LLU */
3335		-{ /* JUMP / fnaddr = 18446744073709551374LLU; break; } / skip other */
3336		-case 18446744073709551375LLU: /* other // SP = 2LLU // parse data */
	3452	+{ /* JUMP / fnaddr = 18446744073709551361LLU; break; } / skip other */
	3453	+case 18446744073709551362LLU: /* other // SP = 2LLU // parse data */
3337	3454
3338	3455	{ /* LIST-READ */
3339	3456	{/* PUSH /stack[stackbase + 2LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 1LLU]; }/ SP + 1LLU = 3LLU */ }

		@@ -3355,39 +3472,40 @@
3355	3472	{/* PUSH /stack[stackbase + 10LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 9LLU]; }/ SP + 1LLU = 11LLU / }/ match-predicate */
3356	3473
3357	3474	if(/var_______/0xC5CB400000000000LLU != stack[stackbase + 2LLU])
3358		-{ /* JUMP / fnaddr = 18446744073709551369LLU; break; } / skip match */
	3475	+{ /* JUMP / fnaddr = 18446744073709551356LLU; break; } / skip match */
3359	3476	/* match */
3360	3477	{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 12LLU */
3361	3478	{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 13LLU */
3362	3479	{/* PUSH /stack[stackbase + 13LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 14LLU */
3363	3480	{/* PUSH /stack[stackbase + 14LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 15LLU */
3364		-{/* PUSH /stack[stackbase + 15LLU] = stack[stackbase + 7LLU]; }/ SP + 1LLU = 16LLU */fputs(" ", stderr);
	3481	+{/* PUSH /stack[stackbase + 15LLU] = stack[stackbase + 7LLU]; }/ SP + 1LLU = 16LLU */
	3482	+{/* PUSH /stack[stackbase + 16LLU] = stack[stackbase + 8LLU]; }/ SP + 1LLU = 17LLU */fputs(" ", stderr);
3365	3483	{
3366	3484	/* CALLBEGIN */
3367		- /* reserve space for 0LLU returned values // SP + 0LLU = 16LLU */
3368		-{/* PUSH /stack[stackbase + 16LLU] = stackbase; }/ SP + 1LLU = 17LLU */
3369		- /* leave place for return addr // SP + 1LLU = 18LLU */
3370		- }/* SP + 7LLU = 25LLU // SP - 7LLU = 18LLU */
3371		-{/* PUSH /stack[stackbase + 18LLU] = stack[stackbase + 11LLU]; }/ SP + 1LLU = 19LLU */
	3485	+ /* reserve space for 0LLU returned values // SP + 0LLU = 17LLU */
	3486	+{/* PUSH /stack[stackbase + 17LLU] = stackbase; }/ SP + 1LLU = 18LLU */
	3487	+ /* leave place for return addr // SP + 1LLU = 19LLU */
	3488	+ }/* SP + 7LLU = 26LLU // SP - 7LLU = 19LLU */
	3489	+{/* PUSH /stack[stackbase + 19LLU] = stack[stackbase + 11LLU]; }/ SP + 1LLU = 20LLU */
3372	3490	{
3373	3491	/CALLEND/
3374		- stackbase += 18LLU;
3375		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF07LLU;
	3492	+ stackbase += 19LLU;
	3493	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFALLU;
3376	3494	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
3377	3495	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
3378	3496	break;
3379	3497	}
3380		-case 0xFFFFFFFFFFFFFF07LLU:
3381		-/* SP = 16LLU // SP = 11LLU // SP - 0LLU = 11LLU / / MATCH-RESULT // SP = 2LLU */
3382		-{ /* JUMP / fnaddr = 18446744073709551368LLU; break; } / skip other */
3383		-case 18446744073709551369LLU: /* other // SP = 2LLU // SP = 2LLU */
3384		-case 18446744073709551368LLU: /* skip to here */
	3498	+case 0xFFFFFFFFFFFFFEFALLU:
	3499	+/* SP = 17LLU // SP = 11LLU // SP - 0LLU = 11LLU / / MATCH-RESULT // SP = 2LLU */
	3500	+{ /* JUMP / fnaddr = 18446744073709551355LLU; break; } / skip other */
	3501	+case 18446744073709551356LLU: /* other // SP = 2LLU // SP = 2LLU */
	3502	+case 18446744073709551355LLU: /* skip to here */
3385	3503
3386		-case 18446744073709551374LLU: /* skip to here */
	3504	+case 18446744073709551361LLU: /* skip to here */
3387	3505	/* SP = 2LLU */
3388	3506	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
3389		-{ /* JUMP / fnaddr = 18446744073709551377LLU; break; } / loop */
3390		-case 18446744073709551376LLU: /* skip to here /fputs("\n", stderr); / SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
	3507	+{ /* JUMP / fnaddr = 18446744073709551364LLU; break; } / loop */
	3508	+case 18446744073709551363LLU: /* skip to here /fputs("\n", stderr); / SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
3391	3509	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
3392	3510	/* function requires 27LLU 64-bit chunks of memory (including 1LLU for parameters) */
3393	3511	case /existsdef_/0x83392EBEE7E08400LLU:/* SP = 2LLU // SPMAX = 2LLU // predicate */

		@@ -3403,7 +3521,7 @@
3403	3521	{
3404	3522	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 2LLU] \|\| stack[stackbase + 3LLU]; }/ SP + 1LLU = 3LLU */ }
3405	3523	if(!/* SP - 1LLU = 2LLU // POP */stack[stackbase + 2LLU])
3406		-{ /* JUMP / fnaddr = 18446744073709551366LLU; break; } / skip consequent */
	3524	+{ /* JUMP / fnaddr = 18446744073709551353LLU; break; } / skip consequent */
3407	3525	/* consequent */
3408	3526	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("\nre-definition of built-in ", stderr);
3409	3527	{

		@@ -3416,22 +3534,22 @@
3416	3534	{
3417	3535	/CALLEND/
3418	3536	stackbase += 4LLU;
3419		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFF05LLU;
	3537	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF8LLU;
3420	3538	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
3421	3539	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
3422	3540	break;
3423	3541	}
3424		-case 0xFFFFFFFFFFFFFF05LLU:
	3542	+case 0xFFFFFFFFFFFFFEF8LLU:
3425	3543	/* SP = 2LLU */fputs("\n", stderr);
3426	3544	{/* set exit-value */stack[16LLU] = 255LLU; }
3427	3545	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 2LLU */
3428		-case 18446744073709551366LLU: /* alternative */
	3546	+case 18446744073709551353LLU: /* alternative */
3429	3547	{/* PUSH /stack[stackbase + 2LLU] = 0LLU; }/ SP + 1LLU = 3LLU */
3430		-case 0xFFFFFFFFFFFFFF04LLU: /* loop to here // predicate: list non-empty? */
	3548	+case 0xFFFFFFFFFFFFFEF7LLU: /* loop to here // predicate: list non-empty? */
3431	3549
3432	3550	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 4LLU */
3433	3551	if(!/* SP - 1LLU = 3LLU // POP */stack[stackbase + 3LLU])
3434		-{ /* JUMP / fnaddr = 18446744073709551363LLU; break; } / skip loop */
	3552	+{ /* JUMP / fnaddr = 18446744073709551350LLU; break; } / skip loop */
3435	3553	/* loop // parse data */
3436	3554
3437	3555	{ /* LIST-READ */

		@@ -3454,7 +3572,7 @@
3454	3572	{/* PUSH /stack[stackbase + 11LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 9LLU]; }/ SP + 1LLU = 12LLU // SPMAX = 12LLU / }/ match-predicate */
3455	3573
3456	3574	if(/def_______/0x7E08400000000000LLU != stack[stackbase + 3LLU])
3457		-{ /* JUMP / fnaddr = 18446744073709551362LLU; break; } / skip match */
	3575	+{ /* JUMP / fnaddr = 18446744073709551349LLU; break; } / skip match */
3458	3576	/* match // predicate */
3459	3577
3460	3578	{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 13LLU // SPMAX = 13LLU */

		@@ -3462,19 +3580,19 @@
3462	3580	{
3463	3581	{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 12LLU] == stack[stackbase + 13LLU]; }/ SP + 1LLU = 13LLU */ }
3464	3582	if(!/* SP - 1LLU = 12LLU // POP */stack[stackbase + 12LLU])
3465		-{ /* JUMP / fnaddr = 18446744073709551360LLU; break; } / skip consequent */
	3583	+{ /* JUMP / fnaddr = 18446744073709551347LLU; break; } / skip consequent */
3466	3584	/* consequent */
3467	3585	{/* PUSH /stack[stackbase + 12LLU] = 1LLU; }/ SP + 1LLU = 13LLU // SP = 12LLU // assign */
3468	3586	{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 12LLU]; }
3469	3587	{stack[stackbase + 0LLU] = 0;}/* SP = 12LLU */
3470		-case 18446744073709551360LLU: /* alternative // SP = 12LLU // SP - 0LLU = 12LLU / / MATCH-RESULT // SP = 3LLU */
3471		-{ /* JUMP / fnaddr = 18446744073709551361LLU; break; } / skip other */
3472		-case 18446744073709551362LLU: /* other // SP = 3LLU // SP = 3LLU */
3473		-case 18446744073709551361LLU: /* skip to here */
	3588	+case 18446744073709551347LLU: /* alternative // SP = 12LLU // SP - 0LLU = 12LLU / / MATCH-RESULT // SP = 3LLU */
	3589	+{ /* JUMP / fnaddr = 18446744073709551348LLU; break; } / skip other */
	3590	+case 18446744073709551349LLU: /* other // SP = 3LLU // SP = 3LLU */
	3591	+case 18446744073709551348LLU: /* skip to here */
3474	3592	/* SP = 3LLU */
3475	3593	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
3476		-{ /* JUMP / fnaddr = 18446744073709551364LLU; break; } / loop */
3477		-case 18446744073709551363LLU: /* skip to here */
	3594	+{ /* JUMP / fnaddr = 18446744073709551351LLU; break; } / loop */
	3595	+case 18446744073709551350LLU: /* skip to here */
3478	3596	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 4LLU // SP - 1LLU = 3LLU // RESULT */
3479	3597	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 3LLU]; }/ SP = 3LLU // SP - 1LLU = 2LLU // RESULT */
3480	3598	{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 2LLU]; }

		@@ -3495,12 +3613,12 @@
3495	3613	{
3496	3614	/CALLEND/
3497	3615	stackbase += 12LLU;
3498		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFFLLU;
	3616	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEF2LLU;
3499	3617	fnaddr = /emptyprops/0x828AEFD2BB6AAEE0LLU;/* SP = 0LLU */
3500	3618	{ if(stackbase + 4LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emptyprops/\n"); exit(-1); } }
3501	3619	break;
3502	3620	}
3503		-case 0xFFFFFFFFFFFFFEFFLLU:
	3621	+case 0xFFFFFFFFFFFFFEF2LLU:
3504	3622	/* SP = 10LLU */
3505	3623	{/* PUSH /stack[stackbase + 10LLU] = 0LLU; }/ SP + 1LLU = 11LLU // predicate */
3506	3624

		@@ -3515,16 +3633,16 @@
3515	3633	{
3516	3634	/CALLEND/
3517	3635	stackbase += 14LLU;
3518		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFCLLU;
	3636	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEFLLU;
3519	3637	fnaddr = /existsdef_/0x83392EBEE7E08400LLU;/* SP = 0LLU */
3520	3638	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /existsdef_/\n"); exit(-1); } }
3521	3639	break;
3522	3640	}
3523		-case 0xFFFFFFFFFFFFFEFCLLU:
	3641	+case 0xFFFFFFFFFFFFFEEFLLU:
3524	3642	/* SP = 12LLU */
3525	3643	{ /* TOP /stack[stackbase + 11LLU] = !/ TOP */stack[stackbase + 11LLU]; }
3526	3644	if(!/* SP - 1LLU = 11LLU // POP */stack[stackbase + 11LLU])
3527		-{ /* JUMP / fnaddr = 18446744073709551358LLU; break; } / skip consequent */
	3645	+{ /* JUMP / fnaddr = 18446744073709551345LLU; break; } / skip consequent */
3528	3646	/* consequent */
3529	3647	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("\ndefined functions\n", stderr);
3530	3648	{

		@@ -3537,12 +3655,12 @@
3537	3655	{
3538	3656	/CALLEND/
3539	3657	stackbase += 13LLU;
3540		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFBLLU;
	3658	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEELLU;
3541	3659	fnaddr = /reportdefs/0xB60AEAB6F7E086E0LLU;/* SP = 0LLU */
3542	3660	{ if(stackbase + 27LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportdefs/\n"); exit(-1); } }
3543	3661	break;
3544	3662	}
3545		-case 0xFFFFFFFFFFFFFEFBLLU:
	3663	+case 0xFFFFFFFFFFFFFEEELLU:
3546	3664	/* SP = 11LLU */fputs("\nundefined function ", stderr);
3547	3665	{
3548	3666	/* CALLBEGIN */

		@@ -3554,35 +3672,35 @@
3554	3672	{
3555	3673	/CALLEND/
3556	3674	stackbase += 13LLU;
3557		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEFALLU;
	3675	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEDLLU;
3558	3676	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
3559	3677	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
3560	3678	break;
3561	3679	}
3562		-case 0xFFFFFFFFFFFFFEFALLU:
	3680	+case 0xFFFFFFFFFFFFFEEDLLU:
3563	3681	/* SP = 11LLU */fputs("\n", stderr);
3564	3682	{/* set exit-value */stack[16LLU] = 255LLU; }
3565	3683	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 11LLU // SP = 11LLU */
3566		-{ /* JUMP / fnaddr = 18446744073709551357LLU; break; } / skip alternative */
3567		-case 18446744073709551358LLU: /* alternative */
	3684	+{ /* JUMP / fnaddr = 18446744073709551344LLU; break; } / skip alternative */
	3685	+case 18446744073709551345LLU: /* alternative */
3568	3686	{/* PUSH /stack[stackbase + 11LLU] = 11720583387163918336LLU; }/ SP + 1LLU = 12LLU // SP + 1LLU = 13LLU // SP - 1LLU = 12LLU */
3569		-case 0xFFFFFFFFFFFFFEF9LLU: /* loop to here // predicate: list non-empty? */
	3687	+case 0xFFFFFFFFFFFFFEECLLU: /* loop to here // predicate: list non-empty? */
3570	3688
3571	3689	{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 13LLU */
3572	3690	if(!/* SP - 1LLU = 12LLU // POP */stack[stackbase + 12LLU])
3573		-{ /* JUMP / fnaddr = 18446744073709551352LLU; break; } / skip loop */
	3691	+{ /* JUMP / fnaddr = 18446744073709551339LLU; break; } / skip loop */
3574	3692	/* loop // parse data */
3575	3693
3576	3694	{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 11LLU]; }/ SP + 1LLU = 13LLU // match-predicate */
3577	3695
3578	3696	if(/modepar___/0xA2A7E0ADCB400000LLU != stack[stackbase + 12LLU])
3579		-{ /* JUMP / fnaddr = 18446744073709551351LLU; break; } / skip match */
	3697	+{ /* JUMP / fnaddr = 18446744073709551338LLU; break; } / skip match */
3580	3698	/* match */
3581		-case 0xFFFFFFFFFFFFFEF5LLU: /* loop to here // predicate: list non-empty? */
	3699	+case 0xFFFFFFFFFFFFFEE8LLU: /* loop to here // predicate: list non-empty? */
3582	3700
3583	3701	{/* PUSH /stack[stackbase + 13LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 14LLU */
3584	3702	if(!/* SP - 1LLU = 13LLU // POP */stack[stackbase + 13LLU])
3585		-{ /* JUMP / fnaddr = 18446744073709551348LLU; break; } / skip loop */
	3703	+{ /* JUMP / fnaddr = 18446744073709551335LLU; break; } / skip loop */
3586	3704	/* loop // parse data */
3587	3705
3588	3706	{ /* LIST-READ */

		@@ -3605,7 +3723,7 @@
3605	3723	{/* PUSH /stack[stackbase + 21LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 9LLU]; }/ SP + 1LLU = 22LLU / }/ match-predicate */
3606	3724
3607	3725	if(/var_______/0xC5CB400000000000LLU != stack[stackbase + 13LLU])
3608		-{ /* JUMP / fnaddr = 18446744073709551347LLU; break; } / skip match */
	3726	+{ /* JUMP / fnaddr = 18446744073709551334LLU; break; } / skip match */
3609	3727	/* match */
3610	3728	{/* PUSH /stack[stackbase + 22LLU] = stack[stackbase + 10LLU]; }/ SP + 1LLU = 23LLU */
3611	3729	{/* PUSH /stack[stackbase + 23LLU] = 1LLU; }/ SP + 1LLU = 24LLU // SP = 22LLU */

		@@ -3612,16 +3730,16 @@
3612	3730	{
3613	3731	{/* PUSH /stack[stackbase + 22LLU] = stack[stackbase + 22LLU] + stack[stackbase + 23LLU]; }/ SP + 1LLU = 23LLU / }/ SP = 22LLU // assign */
3614	3732	{ /* RESULT /stack[stackbase + 10LLU] = stack[stackbase + 22LLU]; }/ SP = 22LLU // SP - 0LLU = 22LLU / / MATCH-RESULT // SP = 13LLU */
3615		-{ /* JUMP / fnaddr = 18446744073709551346LLU; break; } / skip other */
3616		-case 18446744073709551347LLU: /* other // SP = 13LLU */
	3733	+{ /* JUMP / fnaddr = 18446744073709551333LLU; break; } / skip other */
	3734	+case 18446744073709551334LLU: /* other // SP = 13LLU */
3617	3735	{stack[stackbase + 0LLU] = 0;}/* SP = 13LLU */
3618		-case 18446744073709551346LLU: /* skip to here */
	3736	+case 18446744073709551333LLU: /* skip to here */
3619	3737	/* SP = 13LLU */
3620	3738	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
3621		-{ /* JUMP / fnaddr = 18446744073709551349LLU; break; } / loop */
3622		-case 18446744073709551348LLU: /* skip to here // SP = 13LLU // SP - 0LLU = 13LLU / / MATCH-RESULT // SP = 12LLU */
3623		-{ /* JUMP / fnaddr = 18446744073709551350LLU; break; } / skip other */
3624		-case 18446744073709551351LLU: /* other // SP = 12LLU // parse data */
	3739	+{ /* JUMP / fnaddr = 18446744073709551336LLU; break; } / loop */
	3740	+case 18446744073709551335LLU: /* skip to here // SP = 13LLU // SP - 0LLU = 13LLU / / MATCH-RESULT // SP = 12LLU */
	3741	+{ /* JUMP / fnaddr = 18446744073709551337LLU; break; } / skip other */
	3742	+case 18446744073709551338LLU: /* other // SP = 12LLU // parse data */
3625	3743
3626	3744	{ /* LIST-READ */
3627	3745	{/* PUSH /stack[stackbase + 12LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 1LLU]; }/ SP + 1LLU = 13LLU */ }

		@@ -3643,7 +3761,7 @@
3643	3761	{/* PUSH /stack[stackbase + 20LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 9LLU]; }/ SP + 1LLU = 21LLU / }/ match-predicate */
3644	3762
3645	3763	if(/def_______/0x7E08400000000000LLU != stack[stackbase + 12LLU])
3646		-{ /* JUMP / fnaddr = 18446744073709551345LLU; break; } / skip match */
	3764	+{ /* JUMP / fnaddr = 18446744073709551332LLU; break; } / skip match */
3647	3765	/* match // predicate */
3648	3766
3649	3767	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 22LLU */

		@@ -3651,7 +3769,7 @@
3651	3769	{
3652	3770	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
3653	3771	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
3654		-{ /* JUMP / fnaddr = 18446744073709551343LLU; break; } / skip consequent */
	3772	+{ /* JUMP / fnaddr = 18446744073709551330LLU; break; } / skip consequent */
3655	3773	/* consequent */
3656	3774	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 13LLU]; }/ SP + 1LLU = 22LLU */
3657	3775	{/* PUSH /stack[stackbase + 22LLU] = stack[stackbase + 14LLU]; }/ SP + 1LLU = 23LLU */

		@@ -3673,23 +3791,23 @@
3673	3791	{ /* RESULT */stack[stackbase + 10LLU] = stack[stackbase + 21LLU]; }
3674	3792	{/* PUSH /stack[stackbase + 21LLU] = 11720583592298938368LLU; }/ SP + 1LLU = 22LLU // SP + 1LLU = 23LLU // SP - 1LLU = 22LLU // SP = 21LLU // assign */
3675	3793	{ /* RESULT /stack[stackbase + 11LLU] = stack[stackbase + 21LLU]; }/ SP = 21LLU */
3676		-case 18446744073709551343LLU: /* alternative // SP = 21LLU // SP - 0LLU = 21LLU / / MATCH-RESULT // SP = 12LLU */
3677		-{ /* JUMP / fnaddr = 18446744073709551344LLU; break; } / skip other */
3678		-case 18446744073709551345LLU: /* other // SP = 12LLU // SP = 12LLU */
3679		-case 18446744073709551344LLU: /* skip to here */
	3794	+case 18446744073709551330LLU: /* alternative // SP = 21LLU // SP - 0LLU = 21LLU / / MATCH-RESULT // SP = 12LLU */
	3795	+{ /* JUMP / fnaddr = 18446744073709551331LLU; break; } / skip other */
	3796	+case 18446744073709551332LLU: /* other // SP = 12LLU // SP = 12LLU */
	3797	+case 18446744073709551331LLU: /* skip to here */
3680	3798	/* SP = 12LLU */
3681		-case 18446744073709551350LLU: /* skip to here */
	3799	+case 18446744073709551337LLU: /* skip to here */
3682	3800	/* SP = 12LLU */
3683	3801	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
3684		-{ /* JUMP / fnaddr = 18446744073709551353LLU; break; } / loop */
3685		-case 18446744073709551352LLU: /* skip to here // SP = 11LLU */
3686		-case 18446744073709551357LLU: /* skip to here */
	3802	+{ /* JUMP / fnaddr = 18446744073709551340LLU; break; } / loop */
	3803	+case 18446744073709551339LLU: /* skip to here // SP = 11LLU */
	3804	+case 18446744073709551344LLU: /* skip to here */
3687	3805	/* parse data */
3688	3806
3689	3807	{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 12LLU // match-predicate */
3690	3808
3691	3809	if(/union_____/0xC2992AA400000000LLU != stack[stackbase + 11LLU])
3692		-{ /* JUMP / fnaddr = 18446744073709551342LLU; break; } / skip match */
	3810	+{ /* JUMP / fnaddr = 18446744073709551329LLU; break; } / skip match */
3693	3811	/* match */
3694	3812	{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 10LLU]; }/ SP + 1LLU = 13LLU */
3695	3813	{/* PUSH /stack[stackbase + 13LLU] = 1LLU; }/ SP + 1LLU = 14LLU // SP = 12LLU */

		@@ -3696,9 +3814,9 @@
3696	3814	{
3697	3815	{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 12LLU] - stack[stackbase + 13LLU]; }/ SP + 1LLU = 13LLU / }/ SP = 12LLU // assign */
3698	3816	{ /* RESULT /stack[stackbase + 10LLU] = stack[stackbase + 12LLU]; }/ SP = 12LLU // SP - 0LLU = 12LLU / / MATCH-RESULT // SP = 11LLU */
3699		-{ /* JUMP / fnaddr = 18446744073709551341LLU; break; } / skip other */
3700		-case 18446744073709551342LLU: /* other // SP = 11LLU // SP = 11LLU */
3701		-case 18446744073709551341LLU: /* skip to here */
	3817	+{ /* JUMP / fnaddr = 18446744073709551328LLU; break; } / skip other */
	3818	+case 18446744073709551329LLU: /* other // SP = 11LLU // SP = 11LLU */
	3819	+case 18446744073709551328LLU: /* skip to here */
3702	3820
3703	3821	{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 12LLU */
3704	3822	{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 13LLU */

		@@ -3745,16 +3863,16 @@
3745	3863	{
3746	3864	/CALLEND/
3747	3865	stackbase += 9LLU;
3748		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEEALLU;
	3866	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDDLLU;
3749	3867	fnaddr = /existsdef_/0x83392EBEE7E08400LLU;/* SP = 0LLU */
3750	3868	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /existsdef_/\n"); exit(-1); } }
3751	3869	break;
3752	3870	}
3753		-case 0xFFFFFFFFFFFFFEEALLU:
	3871	+case 0xFFFFFFFFFFFFFEDDLLU:
3754	3872	/* SP = 7LLU */
3755	3873	{ /* TOP /stack[stackbase + 6LLU] = !/ TOP */stack[stackbase + 6LLU]; }
3756	3874	if(!/* SP - 1LLU = 6LLU // POP */stack[stackbase + 6LLU])
3757		-{ /* JUMP / fnaddr = 18446744073709551340LLU; break; } / skip consequent */
	3875	+{ /* JUMP / fnaddr = 18446744073709551327LLU; break; } / skip consequent */
3758	3876	/* consequent */
3759	3877	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("\ndefined functions\n", stderr);
3760	3878	{

		@@ -3767,12 +3885,12 @@
3767	3885	{
3768	3886	/CALLEND/
3769	3887	stackbase += 8LLU;
3770		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE9LLU;
	3888	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDCLLU;
3771	3889	fnaddr = /reportdefs/0xB60AEAB6F7E086E0LLU;/* SP = 0LLU */
3772	3890	{ if(stackbase + 27LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportdefs/\n"); exit(-1); } }
3773	3891	break;
3774	3892	}
3775		-case 0xFFFFFFFFFFFFFEE9LLU:
	3893	+case 0xFFFFFFFFFFFFFEDCLLU:
3776	3894	/* SP = 6LLU */fputs("\nundefined function ", stderr);
3777	3895	{
3778	3896	/* CALLBEGIN */

		@@ -3784,35 +3902,35 @@
3784	3902	{
3785	3903	/CALLEND/
3786	3904	stackbase += 8LLU;
3787		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEE8LLU;
	3905	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDBLLU;
3788	3906	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
3789	3907	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
3790	3908	break;
3791	3909	}
3792		-case 0xFFFFFFFFFFFFFEE8LLU:
	3910	+case 0xFFFFFFFFFFFFFEDBLLU:
3793	3911	/* SP = 6LLU */fputs("\n", stderr);
3794	3912	{/* set exit-value */stack[16LLU] = 255LLU; }
3795	3913	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 6LLU // SP = 6LLU */
3796		-{ /* JUMP / fnaddr = 18446744073709551339LLU; break; } / skip alternative */
3797		-case 18446744073709551340LLU: /* alternative */
	3914	+{ /* JUMP / fnaddr = 18446744073709551326LLU; break; } / skip alternative */
	3915	+case 18446744073709551327LLU: /* alternative */
3798	3916	{/* PUSH /stack[stackbase + 6LLU] = 11720583387163918336LLU; }/ SP + 1LLU = 7LLU // SP + 1LLU = 8LLU // SP - 1LLU = 7LLU */
3799		-case 0xFFFFFFFFFFFFFEE7LLU: /* loop to here // predicate: list non-empty? */
	3917	+case 0xFFFFFFFFFFFFFEDALLU: /* loop to here // predicate: list non-empty? */
3800	3918
3801	3919	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 8LLU */
3802	3920	if(!/* SP - 1LLU = 7LLU // POP */stack[stackbase + 7LLU])
3803		-{ /* JUMP / fnaddr = 18446744073709551334LLU; break; } / skip loop */
	3921	+{ /* JUMP / fnaddr = 18446744073709551321LLU; break; } / skip loop */
3804	3922	/* loop // parse data */
3805	3923
3806	3924	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 8LLU // match-predicate */
3807	3925
3808	3926	if(/modepar___/0xA2A7E0ADCB400000LLU != stack[stackbase + 7LLU])
3809		-{ /* JUMP / fnaddr = 18446744073709551333LLU; break; } / skip match */
	3927	+{ /* JUMP / fnaddr = 18446744073709551320LLU; break; } / skip match */
3810	3928	/* match */
3811		-case 0xFFFFFFFFFFFFFEE3LLU: /* loop to here // predicate: list non-empty? */
	3929	+case 0xFFFFFFFFFFFFFED6LLU: /* loop to here // predicate: list non-empty? */
3812	3930
3813	3931	{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 9LLU */
3814	3932	if(!/* SP - 1LLU = 8LLU // POP */stack[stackbase + 8LLU])
3815		-{ /* JUMP / fnaddr = 18446744073709551330LLU; break; } / skip loop */
	3933	+{ /* JUMP / fnaddr = 18446744073709551317LLU; break; } / skip loop */
3816	3934	/* loop // predicate */
3817	3935
3818	3936	{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 9LLU */

		@@ -3820,7 +3938,7 @@
3820	3938	{
3821	3939	{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 8LLU] == stack[stackbase + 9LLU]; }/ SP + 1LLU = 9LLU */ }
3822	3940	if(!/* SP - 1LLU = 8LLU // POP */stack[stackbase + 8LLU])
3823		-{ /* JUMP / fnaddr = 18446744073709551329LLU; break; } / skip consequent */
	3941	+{ /* JUMP / fnaddr = 18446744073709551316LLU; break; } / skip consequent */
3824	3942	/* consequent // parse data */
3825	3943
3826	3944	{ /* LIST-READ */

		@@ -3843,17 +3961,17 @@
3843	3961	{/* PUSH /stack[stackbase + 16LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 9LLU]; }/ SP + 1LLU = 17LLU / }/ match-predicate */
3844	3962
3845	3963	if(/var_______/0xC5CB400000000000LLU != stack[stackbase + 8LLU])
3846		-{ /* JUMP / fnaddr = 18446744073709551327LLU; break; } / skip match */
	3964	+{ /* JUMP / fnaddr = 18446744073709551314LLU; break; } / skip match */
3847	3965	/* match */
3848	3966	{/* PUSH /stack[stackbase + 17LLU] = stack[stackbase + 10LLU]; }/ SP + 1LLU = 18LLU // SP = 17LLU // assign */
3849	3967	{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 17LLU]; }
3850		-{/* PUSH /stack[stackbase + 17LLU] = stack[stackbase + 11LLU]; }/ SP + 1LLU = 18LLU */
3851		-{/* PUSH /stack[stackbase + 18LLU] = stack[stackbase + 12LLU]; }/ SP + 1LLU = 19LLU // SP = 17LLU // assign */
	3968	+{/* PUSH /stack[stackbase + 17LLU] = stack[stackbase + 12LLU]; }/ SP + 1LLU = 18LLU */
	3969	+{/* PUSH /stack[stackbase + 18LLU] = stack[stackbase + 13LLU]; }/ SP + 1LLU = 19LLU // SP = 17LLU // assign */
3852	3970	{ /* RESULT */stack[stackbase + 4LLU] = stack[stackbase + 17LLU]; }
3853	3971	{ /* RESULT */stack[stackbase + 5LLU] = stack[stackbase + 18LLU]; }
3854	3972	{stack[stackbase + 0LLU] = 0;}/* SP = 17LLU // SP - 0LLU = 17LLU / / MATCH-RESULT // SP = 8LLU */
3855		-{ /* JUMP / fnaddr = 18446744073709551326LLU; break; } / skip other */
3856		-case 18446744073709551327LLU: /* other // SP = 8LLU */
	3973	+{ /* JUMP / fnaddr = 18446744073709551313LLU; break; } / skip other */
	3974	+case 18446744073709551314LLU: /* other // SP = 8LLU */
3857	3975	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("call to ", stderr);
3858	3976	{
3859	3977	/* CALLBEGIN */

		@@ -3865,31 +3983,31 @@
3865	3983	{
3866	3984	/CALLEND/
3867	3985	stackbase += 10LLU;
3868		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEDDLLU;
	3986	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFED0LLU;
3869	3987	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
3870	3988	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
3871	3989	break;
3872	3990	}
3873		-case 0xFFFFFFFFFFFFFEDDLLU:
	3991	+case 0xFFFFFFFFFFFFFED0LLU:
3874	3992	/* SP = 8LLU */fputs(" argument-count exceeds parameter-count", stderr); fputs("\n", stderr);
3875	3993	{/* set exit-value */stack[16LLU] = 255LLU; }
3876	3994	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 8LLU */
3877		-case 18446744073709551326LLU: /* skip to here */
	3995	+case 18446744073709551313LLU: /* skip to here */
3878	3996	/* SP = 8LLU // SP = 8LLU */
3879		-{ /* JUMP / fnaddr = 18446744073709551328LLU; break; } / skip alternative */
3880		-case 18446744073709551329LLU: /* alternative */
	3997	+{ /* JUMP / fnaddr = 18446744073709551315LLU; break; } / skip alternative */
	3998	+case 18446744073709551316LLU: /* alternative */
3881	3999	{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 9LLU */
3882	4000	{/* PUSH /stack[stackbase + 9LLU] = 1LLU; }/ SP + 1LLU = 10LLU // SP = 8LLU */
3883	4001	{
3884	4002	{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 8LLU] - stack[stackbase + 9LLU]; }/ SP + 1LLU = 9LLU / }/ SP = 8LLU // assign */
3885	4003	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 8LLU]; }/ SP = 8LLU */
3886		-case 18446744073709551328LLU: /* skip to here */
	4004	+case 18446744073709551315LLU: /* skip to here */
3887	4005	/* SP = 8LLU */
3888	4006	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
3889		-{ /* JUMP / fnaddr = 18446744073709551331LLU; break; } / loop */
3890		-case 18446744073709551330LLU: /* skip to here // SP = 8LLU // SP - 0LLU = 8LLU / / MATCH-RESULT // SP = 7LLU */
3891		-{ /* JUMP / fnaddr = 18446744073709551332LLU; break; } / skip other */
3892		-case 18446744073709551333LLU: /* other // SP = 7LLU // parse data */
	4007	+{ /* JUMP / fnaddr = 18446744073709551318LLU; break; } / loop */
	4008	+case 18446744073709551317LLU: /* skip to here // SP = 8LLU // SP - 0LLU = 8LLU / / MATCH-RESULT // SP = 7LLU */
	4009	+{ /* JUMP / fnaddr = 18446744073709551319LLU; break; } / skip other */
	4010	+case 18446744073709551320LLU: /* other // SP = 7LLU // parse data */
3893	4011
3894	4012	{ /* LIST-READ */
3895	4013	{/* PUSH /stack[stackbase + 7LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 1LLU]; }/ SP + 1LLU = 8LLU */ }

		@@ -3911,7 +4029,7 @@
3911	4029	{/* PUSH /stack[stackbase + 15LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 9LLU]; }/ SP + 1LLU = 16LLU / }/ match-predicate */
3912	4030
3913	4031	if(/def_______/0x7E08400000000000LLU != stack[stackbase + 7LLU])
3914		-{ /* JUMP / fnaddr = 18446744073709551324LLU; break; } / skip match */
	4032	+{ /* JUMP / fnaddr = 18446744073709551311LLU; break; } / skip match */
3915	4033	/* match // predicate */
3916	4034
3917	4035	{/* PUSH /stack[stackbase + 16LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 17LLU */

		@@ -3919,21 +4037,21 @@
3919	4037	{
3920	4038	{/* PUSH /stack[stackbase + 16LLU] = stack[stackbase + 16LLU] == stack[stackbase + 17LLU]; }/ SP + 1LLU = 17LLU */ }
3921	4039	if(!/* SP - 1LLU = 16LLU // POP */stack[stackbase + 16LLU])
3922		-{ /* JUMP / fnaddr = 18446744073709551322LLU; break; } / skip consequent */
	4040	+{ /* JUMP / fnaddr = 18446744073709551309LLU; break; } / skip consequent */
3923	4041	/* consequent */
3924	4042	{/* PUSH /stack[stackbase + 16LLU] = 11720583592298938368LLU; }/ SP + 1LLU = 17LLU // SP + 1LLU = 18LLU // SP - 1LLU = 17LLU // SP = 16LLU // assign */
3925	4043	{ /* RESULT /stack[stackbase + 6LLU] = stack[stackbase + 16LLU]; }/ SP = 16LLU */
3926		-case 18446744073709551322LLU: /* alternative // SP = 16LLU // SP - 0LLU = 16LLU / / MATCH-RESULT // SP = 7LLU */
3927		-{ /* JUMP / fnaddr = 18446744073709551323LLU; break; } / skip other */
3928		-case 18446744073709551324LLU: /* other // SP = 7LLU // SP = 7LLU */
3929		-case 18446744073709551323LLU: /* skip to here */
	4044	+case 18446744073709551309LLU: /* alternative // SP = 16LLU // SP - 0LLU = 16LLU / / MATCH-RESULT // SP = 7LLU */
	4045	+{ /* JUMP / fnaddr = 18446744073709551310LLU; break; } / skip other */
	4046	+case 18446744073709551311LLU: /* other // SP = 7LLU // SP = 7LLU */
	4047	+case 18446744073709551310LLU: /* skip to here */
3930	4048	/* SP = 7LLU */
3931		-case 18446744073709551332LLU: /* skip to here */
	4049	+case 18446744073709551319LLU: /* skip to here */
3932	4050	/* SP = 7LLU */
3933	4051	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
3934		-{ /* JUMP / fnaddr = 18446744073709551335LLU; break; } / loop */
3935		-case 18446744073709551334LLU: /* skip to here // SP = 6LLU */
3936		-case 18446744073709551339LLU: /* skip to here */
	4052	+{ /* JUMP / fnaddr = 18446744073709551322LLU; break; } / loop */
	4053	+case 18446744073709551321LLU: /* skip to here // SP = 6LLU */
	4054	+case 18446744073709551326LLU: /* skip to here */
3937	4055
3938	4056	{/* PUSH /stack[stackbase + 6LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 7LLU */
3939	4057	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 8LLU */

		@@ -3951,23 +4069,23 @@
3951	4069	{/* PUSH /stack[stackbase + 4LLU] = 13784076749618806784LLU; }/ SP + 1LLU = 5LLU // SP + 2LLU = 7LLU // SPMAX = 7LLU // SP - 2LLU = 5LLU // SP + 1LLU = 6LLU // SP - 1LLU = 5LLU */
3952	4070	{/* PUSH /stack[stackbase + 5LLU] = 0LLU; }/ SP + 1LLU = 6LLU */
3953	4071	{/* PUSH /stack[stackbase + 6LLU] = 11720583387163918336LLU; }/ SP + 1LLU = 7LLU // SP + 1LLU = 8LLU // SPMAX = 8LLU // SP - 1LLU = 7LLU */
3954		-case 0xFFFFFFFFFFFFFED9LLU: /* loop to here // predicate: list non-empty? */
	4072	+case 0xFFFFFFFFFFFFFECCLLU: /* loop to here // predicate: list non-empty? */
3955	4073
3956	4074	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 8LLU */
3957	4075	if(!/* SP - 1LLU = 7LLU // POP */stack[stackbase + 7LLU])
3958		-{ /* JUMP / fnaddr = 18446744073709551320LLU; break; } / skip loop */
	4076	+{ /* JUMP / fnaddr = 18446744073709551307LLU; break; } / skip loop */
3959	4077	/* loop // parse data */
3960	4078
3961	4079	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 8LLU // match-predicate */
3962	4080
3963	4081	if(/modepar___/0xA2A7E0ADCB400000LLU != stack[stackbase + 7LLU])
3964		-{ /* JUMP / fnaddr = 18446744073709551319LLU; break; } / skip match */
	4082	+{ /* JUMP / fnaddr = 18446744073709551306LLU; break; } / skip match */
3965	4083	/* match */
3966		-case 0xFFFFFFFFFFFFFED5LLU: /* loop to here // predicate: list non-empty? */
	4084	+case 0xFFFFFFFFFFFFFEC8LLU: /* loop to here // predicate: list non-empty? */
3967	4085
3968	4086	{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 9LLU // SPMAX = 9LLU */
3969	4087	if(!/* SP - 1LLU = 8LLU // POP */stack[stackbase + 8LLU])
3970		-{ /* JUMP / fnaddr = 18446744073709551316LLU; break; } / skip loop */
	4088	+{ /* JUMP / fnaddr = 18446744073709551303LLU; break; } / skip loop */
3971	4089	/* loop // parse data */
3972	4090
3973	4091	{ /* LIST-READ */

		@@ -3990,33 +4108,34 @@
3990	4108	{/* PUSH /stack[stackbase + 16LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 9LLU]; }/ SP + 1LLU = 17LLU // SPMAX = 17LLU / }/ match-predicate */
3991	4109
3992	4110	if(/var_______/0xC5CB400000000000LLU != stack[stackbase + 8LLU])
3993		-{ /* JUMP / fnaddr = 18446744073709551315LLU; break; } / skip match */
	4111	+{ /* JUMP / fnaddr = 18446744073709551302LLU; break; } / skip match */
3994	4112	/* match */
3995	4113	{/* PUSH /stack[stackbase + 17LLU] = stack[stackbase + 9LLU]; }/ SP + 1LLU = 18LLU // SPMAX = 18LLU */
3996	4114	{/* PUSH /stack[stackbase + 18LLU] = stack[stackbase + 10LLU]; }/ SP + 1LLU = 19LLU // SPMAX = 19LLU */
3997	4115	{/* PUSH /stack[stackbase + 19LLU] = stack[stackbase + 11LLU]; }/ SP + 1LLU = 20LLU // SPMAX = 20LLU */
3998	4116	{/* PUSH /stack[stackbase + 20LLU] = stack[stackbase + 12LLU]; }/ SP + 1LLU = 21LLU // SPMAX = 21LLU */
3999		-{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 13LLU]; }/ SP + 1LLU = 22LLU // SPMAX = 22LLU // predicate */
	4117	+{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 13LLU]; }/ SP + 1LLU = 22LLU // SPMAX = 22LLU */
	4118	+{/* PUSH /stack[stackbase + 22LLU] = stack[stackbase + 14LLU]; }/ SP + 1LLU = 23LLU // SPMAX = 23LLU // predicate */
4000	4119
4001		-{/* PUSH /stack[stackbase + 22LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 23LLU // SPMAX = 23LLU */
4002		-{/* PUSH /stack[stackbase + 23LLU] = stack[stackbase + 17LLU]; }/ SP + 1LLU = 24LLU // SPMAX = 24LLU // SP = 22LLU */
	4120	+{/* PUSH /stack[stackbase + 23LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 24LLU // SPMAX = 24LLU */
	4121	+{/* PUSH /stack[stackbase + 24LLU] = stack[stackbase + 17LLU]; }/ SP + 1LLU = 25LLU // SPMAX = 25LLU // SP = 23LLU */
4003	4122	{
4004		-{/* PUSH /stack[stackbase + 22LLU] = stack[stackbase + 22LLU] == stack[stackbase + 23LLU]; }/ SP + 1LLU = 23LLU */ }
4005		-if(!/* SP - 1LLU = 22LLU // POP */stack[stackbase + 22LLU])
4006		-{ /* JUMP / fnaddr = 18446744073709551313LLU; break; } / skip consequent */
	4123	+{/* PUSH /stack[stackbase + 23LLU] = stack[stackbase + 23LLU] == stack[stackbase + 24LLU]; }/ SP + 1LLU = 24LLU */ }
	4124	+if(!/* SP - 1LLU = 23LLU // POP */stack[stackbase + 23LLU])
	4125	+{ /* JUMP / fnaddr = 18446744073709551300LLU; break; } / skip consequent */
4007	4126	/* consequent */
4008		-{/* PUSH /stack[stackbase + 22LLU] = stack[stackbase + 18LLU]; }/ SP + 1LLU = 23LLU // SP = 22LLU // assign */
4009		-{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 22LLU]; }
4010		-{/* PUSH /stack[stackbase + 22LLU] = stack[stackbase + 19LLU]; }/ SP + 1LLU = 23LLU */
4011		-{/* PUSH /stack[stackbase + 23LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 24LLU // SP = 22LLU // assign */
4012		-{ /* RESULT */stack[stackbase + 4LLU] = stack[stackbase + 22LLU]; }
4013		-{ /* RESULT */stack[stackbase + 5LLU] = stack[stackbase + 23LLU]; }
	4127	+{/* PUSH /stack[stackbase + 23LLU] = stack[stackbase + 18LLU]; }/ SP + 1LLU = 24LLU // SP = 23LLU // assign */
	4128	+{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 23LLU]; }
	4129	+{/* PUSH /stack[stackbase + 23LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 24LLU */
	4130	+{/* PUSH /stack[stackbase + 24LLU] = stack[stackbase + 21LLU]; }/ SP + 1LLU = 25LLU // SP = 23LLU // assign */
	4131	+{ /* RESULT */stack[stackbase + 4LLU] = stack[stackbase + 23LLU]; }
	4132	+{ /* RESULT */stack[stackbase + 5LLU] = stack[stackbase + 24LLU]; }
4014	4133	{stack[stackbase + 0LLU] = 0;}
4015		-{/* PUSH /stack[stackbase + 22LLU] = 11720583406751318016LLU; }/ SP + 1LLU = 23LLU // SP + 1LLU = 24LLU // SP - 1LLU = 23LLU // SP = 22LLU // assign */
4016		-{ /* RESULT /stack[stackbase + 6LLU] = stack[stackbase + 22LLU]; }/ SP = 22LLU */
4017		-case 18446744073709551313LLU: /* alternative // SP = 17LLU // SP - 0LLU = 17LLU / / MATCH-RESULT // SP = 8LLU */
4018		-{ /* JUMP / fnaddr = 18446744073709551314LLU; break; } / skip other */
4019		-case 18446744073709551315LLU: /* other // SP = 8LLU */
	4134	+{/* PUSH /stack[stackbase + 23LLU] = 11720583406751318016LLU; }/ SP + 1LLU = 24LLU // SP + 1LLU = 25LLU // SP - 1LLU = 24LLU // SP = 23LLU // assign */
	4135	+{ /* RESULT /stack[stackbase + 6LLU] = stack[stackbase + 23LLU]; }/ SP = 23LLU */
	4136	+case 18446744073709551300LLU: /* alternative // SP = 17LLU // SP - 0LLU = 17LLU / / MATCH-RESULT // SP = 8LLU */
	4137	+{ /* JUMP / fnaddr = 18446744073709551301LLU; break; } / skip other */
	4138	+case 18446744073709551302LLU: /* other // SP = 8LLU */
4020	4139	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("struct ", stderr);
4021	4140	{
4022	4141	/* CALLBEGIN */

		@@ -4028,12 +4147,12 @@
4028	4147	{
4029	4148	/CALLEND/
4030	4149	stackbase += 10LLU;
4031		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFED0LLU;
	4150	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC3LLU;
4032	4151	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
4033	4152	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
4034	4153	break;
4035	4154	}
4036		-case 0xFFFFFFFFFFFFFED0LLU:
	4155	+case 0xFFFFFFFFFFFFFEC3LLU:
4037	4156	/* SP = 8LLU */fputs(" has no element ", stderr);
4038	4157	{
4039	4158	/* CALLBEGIN */

		@@ -4045,22 +4164,22 @@
4045	4164	{
4046	4165	/CALLEND/
4047	4166	stackbase += 10LLU;
4048		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFECFLLU;
	4167	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC2LLU;
4049	4168	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
4050	4169	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
4051	4170	break;
4052	4171	}
4053		-case 0xFFFFFFFFFFFFFECFLLU:
	4172	+case 0xFFFFFFFFFFFFFEC2LLU:
4054	4173	/* SP = 8LLU */fputs("\n", stderr);
4055	4174	{/* set exit-value */stack[16LLU] = 255LLU; }
4056	4175	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 8LLU */
4057		-case 18446744073709551314LLU: /* skip to here */
	4176	+case 18446744073709551301LLU: /* skip to here */
4058	4177	/* SP = 8LLU */
4059	4178	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
4060		-{ /* JUMP / fnaddr = 18446744073709551317LLU; break; } / loop */
4061		-case 18446744073709551316LLU: /* skip to here // SP = 8LLU // SP - 0LLU = 8LLU / / MATCH-RESULT // SP = 7LLU */
4062		-{ /* JUMP / fnaddr = 18446744073709551318LLU; break; } / skip other */
4063		-case 18446744073709551319LLU: /* other // SP = 7LLU // parse data */
	4179	+{ /* JUMP / fnaddr = 18446744073709551304LLU; break; } / loop */
	4180	+case 18446744073709551303LLU: /* skip to here // SP = 8LLU // SP - 0LLU = 8LLU / / MATCH-RESULT // SP = 7LLU */
	4181	+{ /* JUMP / fnaddr = 18446744073709551305LLU; break; } / skip other */
	4182	+case 18446744073709551306LLU: /* other // SP = 7LLU // parse data */
4064	4183
4065	4184	{ /* LIST-READ */
4066	4185	{/* PUSH /stack[stackbase + 7LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 1LLU]; }/ SP + 1LLU = 8LLU */ }

		@@ -4082,7 +4201,7 @@
4082	4201	{/* PUSH /stack[stackbase + 15LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 9LLU]; }/ SP + 1LLU = 16LLU / }/ match-predicate */
4083	4202
4084	4203	if(/def_______/0x7E08400000000000LLU != stack[stackbase + 7LLU])
4085		-{ /* JUMP / fnaddr = 18446744073709551310LLU; break; } / skip match */
	4204	+{ /* JUMP / fnaddr = 18446744073709551297LLU; break; } / skip match */
4086	4205	/* match // predicate */
4087	4206
4088	4207	{/* PUSH /stack[stackbase + 16LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 17LLU */

		@@ -4090,25 +4209,25 @@
4090	4209	{
4091	4210	{/* PUSH /stack[stackbase + 16LLU] = stack[stackbase + 16LLU] == stack[stackbase + 17LLU]; }/ SP + 1LLU = 17LLU */ }
4092	4211	if(!/* SP - 1LLU = 16LLU // POP */stack[stackbase + 16LLU])
4093		-{ /* JUMP / fnaddr = 18446744073709551308LLU; break; } / skip consequent */
	4212	+{ /* JUMP / fnaddr = 18446744073709551295LLU; break; } / skip consequent */
4094	4213	/* consequent */
4095	4214	{/* PUSH /stack[stackbase + 16LLU] = 11720583592298938368LLU; }/ SP + 1LLU = 17LLU // SP + 1LLU = 18LLU // SP - 1LLU = 17LLU // SP = 16LLU // assign */
4096	4215	{ /* RESULT /stack[stackbase + 6LLU] = stack[stackbase + 16LLU]; }/ SP = 16LLU */
4097		-case 18446744073709551308LLU: /* alternative // SP = 16LLU // SP - 0LLU = 16LLU / / MATCH-RESULT // SP = 7LLU */
4098		-{ /* JUMP / fnaddr = 18446744073709551309LLU; break; } / skip other */
4099		-case 18446744073709551310LLU: /* other // SP = 7LLU // SP = 7LLU */
4100		-case 18446744073709551309LLU: /* skip to here */
	4216	+case 18446744073709551295LLU: /* alternative // SP = 16LLU // SP - 0LLU = 16LLU / / MATCH-RESULT // SP = 7LLU */
	4217	+{ /* JUMP / fnaddr = 18446744073709551296LLU; break; } / skip other */
	4218	+case 18446744073709551297LLU: /* other // SP = 7LLU // SP = 7LLU */
	4219	+case 18446744073709551296LLU: /* skip to here */
4101	4220	/* SP = 7LLU */
4102		-case 18446744073709551318LLU: /* skip to here */
	4221	+case 18446744073709551305LLU: /* skip to here */
4103	4222	/* SP = 7LLU */
4104	4223	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
4105		-{ /* JUMP / fnaddr = 18446744073709551321LLU; break; } / loop */
4106		-case 18446744073709551320LLU: /* skip to here // parse data */
	4224	+{ /* JUMP / fnaddr = 18446744073709551308LLU; break; } / loop */
	4225	+case 18446744073709551307LLU: /* skip to here // parse data */
4107	4226
4108	4227	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 8LLU // match-predicate */
4109	4228
4110	4229	if(/modedef___/0xA2A7E07E08400000LLU != stack[stackbase + 7LLU])
4111		-{ /* JUMP / fnaddr = 18446744073709551307LLU; break; } / skip match */
	4230	+{ /* JUMP / fnaddr = 18446744073709551294LLU; break; } / skip match */
4112	4231	/* match */
4113	4232	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("\ndefined functions\n", stderr);
4114	4233	{

		@@ -4121,12 +4240,12 @@
4121	4240	{
4122	4241	/CALLEND/
4123	4242	stackbase += 10LLU;
4124		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC9LLU;
	4243	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBCLLU;
4125	4244	fnaddr = /reportdefs/0xB60AEAB6F7E086E0LLU;/* SP = 0LLU */
4126	4245	{ if(stackbase + 27LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportdefs/\n"); exit(-1); } }
4127	4246	break;
4128	4247	}
4129		-case 0xFFFFFFFFFFFFFEC9LLU:
	4248	+case 0xFFFFFFFFFFFFFEBCLLU:
4130	4249	/* SP = 8LLU */fputs("\nundefined struct ", stderr);
4131	4250	{
4132	4251	/* CALLBEGIN */

		@@ -4138,22 +4257,22 @@
4138	4257	{
4139	4258	/CALLEND/
4140	4259	stackbase += 10LLU;
4141		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC8LLU;
	4260	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBBLLU;
4142	4261	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
4143	4262	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
4144	4263	break;
4145	4264	}
4146		-case 0xFFFFFFFFFFFFFEC8LLU:
	4265	+case 0xFFFFFFFFFFFFFEBBLLU:
4147	4266	/* SP = 8LLU */fputs("\n", stderr);
4148	4267	{/* set exit-value */stack[16LLU] = 255LLU; }
4149	4268	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 8LLU // SP - 0LLU = 8LLU / / MATCH-RESULT // SP = 7LLU */
4150		-{ /* JUMP / fnaddr = 18446744073709551306LLU; break; } / skip other */
4151		-case 18446744073709551307LLU: /* other // SP = 7LLU // parse data */
	4269	+{ /* JUMP / fnaddr = 18446744073709551293LLU; break; } / skip other */
	4270	+case 18446744073709551294LLU: /* other // SP = 7LLU // parse data */
4152	4271
4153	4272	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 8LLU // match-predicate */
4154	4273
4155	4274	if(/modepar___/0xA2A7E0ADCB400000LLU != stack[stackbase + 7LLU])
4156		-{ /* JUMP / fnaddr = 18446744073709551303LLU; break; } / skip match */
	4275	+{ /* JUMP / fnaddr = 18446744073709551290LLU; break; } / skip match */
4157	4276	/* match */
4158	4277	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("struct ", stderr);
4159	4278	{

		@@ -4166,12 +4285,12 @@
4166	4285	{
4167	4286	/CALLEND/
4168	4287	stackbase += 10LLU;
4169		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC5LLU;
	4288	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB8LLU;
4170	4289	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
4171	4290	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
4172	4291	break;
4173	4292	}
4174		-case 0xFFFFFFFFFFFFFEC5LLU:
	4293	+case 0xFFFFFFFFFFFFFEB8LLU:
4175	4294	/* SP = 8LLU */fputs(" has no element ", stderr);
4176	4295	{
4177	4296	/* CALLBEGIN */

		@@ -4183,20 +4302,20 @@
4183	4302	{
4184	4303	/CALLEND/
4185	4304	stackbase += 10LLU;
4186		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC4LLU;
	4305	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB7LLU;
4187	4306	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
4188	4307	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
4189	4308	break;
4190	4309	}
4191		-case 0xFFFFFFFFFFFFFEC4LLU:
	4310	+case 0xFFFFFFFFFFFFFEB7LLU:
4192	4311	/* SP = 8LLU */fputs("\n", stderr);
4193	4312	{/* set exit-value */stack[16LLU] = 255LLU; }
4194	4313	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 8LLU // SP - 0LLU = 8LLU / / MATCH-RESULT // SP = 7LLU */
4195		-{ /* JUMP / fnaddr = 18446744073709551302LLU; break; } / skip other */
4196		-case 18446744073709551303LLU: /* other // SP = 7LLU // SP = 7LLU */
4197		-case 18446744073709551302LLU: /* skip to here */
	4314	+{ /* JUMP / fnaddr = 18446744073709551289LLU; break; } / skip other */
	4315	+case 18446744073709551290LLU: /* other // SP = 7LLU // SP = 7LLU */
	4316	+case 18446744073709551289LLU: /* skip to here */
4198	4317
4199		-case 18446744073709551306LLU: /* skip to here */
	4318	+case 18446744073709551293LLU: /* skip to here */
4200	4319
4201	4320	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 8LLU */
4202	4321	{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 9LLU */

		@@ -4222,22 +4341,22 @@
4222	4341	{
4223	4342	/CALLEND/
4224	4343	stackbase += 6LLU;
4225		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEC1LLU;
	4344	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB4LLU;
4226	4345	fnaddr = /subtoid___/0xBB076FAA47C00000LLU;/* SP = 0LLU */
4227	4346	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subtoid___/\n"); exit(-1); } }
4228	4347	break;
4229	4348	}
4230		-case 0xFFFFFFFFFFFFFEC1LLU:
	4349	+case 0xFFFFFFFFFFFFFEB4LLU:
4231	4350	/* SP = 4LLU // SP = 2LLU */
4232	4351	{
4233	4352	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 2LLU] == stack[stackbase + 3LLU]; }/ SP + 1LLU = 3LLU */ }
4234	4353	if(!/* SP - 1LLU = 2LLU // POP */stack[stackbase + 2LLU])
4235		-{ /* JUMP / fnaddr = 18446744073709551299LLU; break; } / skip consequent */
	4354	+{ /* JUMP / fnaddr = 18446744073709551286LLU; break; } / skip consequent */
4236	4355	/* consequent */
4237	4356	{/* PUSH /stack[stackbase + 2LLU] = 0LLU; }/ SP + 1LLU = 3LLU // SP - 1LLU = 2LLU // RESULT */
4238	4357	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 2LLU]; }/ SP = 3LLU // SP = 2LLU */
4239		-{ /* JUMP / fnaddr = 18446744073709551298LLU; break; } / skip alternative */
4240		-case 18446744073709551299LLU: /* alternative // predicate */
	4358	+{ /* JUMP / fnaddr = 18446744073709551285LLU; break; } / skip alternative */
	4359	+case 18446744073709551286LLU: /* alternative // predicate */
4241	4360
4242	4361	{/* PUSH /stack[stackbase + 2LLU] = 14109355420086697984LLU; }/ SP + 1LLU = 3LLU */
4243	4362	{

		@@ -4250,29 +4369,29 @@
4250	4369	{
4251	4370	/CALLEND/
4252	4371	stackbase += 6LLU;
4253		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEBELLU;
	4372	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB1LLU;
4254	4373	fnaddr = /subtoid___/0xBB076FAA47C00000LLU;/* SP = 0LLU */
4255	4374	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subtoid___/\n"); exit(-1); } }
4256	4375	break;
4257	4376	}
4258		-case 0xFFFFFFFFFFFFFEBELLU:
	4377	+case 0xFFFFFFFFFFFFFEB1LLU:
4259	4378	/* SP = 4LLU // SP = 2LLU */
4260	4379	{
4261	4380	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 2LLU] == stack[stackbase + 3LLU]; }/ SP + 1LLU = 3LLU */ }
4262	4381	if(!/* SP - 1LLU = 2LLU // POP */stack[stackbase + 2LLU])
4263		-{ /* JUMP / fnaddr = 18446744073709551296LLU; break; } / skip consequent */
	4382	+{ /* JUMP / fnaddr = 18446744073709551283LLU; break; } / skip consequent */
4264	4383	/* consequent */
4265	4384	{/* PUSH /stack[stackbase + 2LLU] = 1LLU; }/ SP + 1LLU = 3LLU // SP - 1LLU = 2LLU // RESULT */
4266	4385	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 2LLU]; }/ SP = 3LLU // SP = 2LLU */
4267		-{ /* JUMP / fnaddr = 18446744073709551295LLU; break; } / skip alternative */
4268		-case 18446744073709551296LLU: /* alternative */
	4386	+{ /* JUMP / fnaddr = 18446744073709551282LLU; break; } / skip alternative */
	4387	+case 18446744073709551283LLU: /* alternative */
4269	4388	{/* PUSH /stack[stackbase + 2LLU] = 0LLU; }/ SP + 1LLU = 3LLU */
4270	4389	{/* PUSH /stack[stackbase + 3LLU] = 9640498710886481920LLU; }/ SP + 1LLU = 4LLU // SP + 1LLU = 5LLU // SP - 1LLU = 4LLU */
4271		-case 0xFFFFFFFFFFFFFEBDLLU: /* loop to here // predicate: list non-empty? */
	4390	+case 0xFFFFFFFFFFFFFEB0LLU: /* loop to here // predicate: list non-empty? */
4272	4391
4273	4392	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 5LLU */
4274	4393	if(!/* SP - 1LLU = 4LLU // POP */stack[stackbase + 4LLU])
4275		-{ /* JUMP / fnaddr = 18446744073709551292LLU; break; } / skip loop */
	4394	+{ /* JUMP / fnaddr = 18446744073709551279LLU; break; } / skip loop */
4276	4395	/* loop // parse data */
4277	4396
4278	4397	{ /* LIST-READ */

		@@ -4295,7 +4414,7 @@
4295	4414	{/* PUSH /stack[stackbase + 12LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 9LLU]; }/ SP + 1LLU = 13LLU // SPMAX = 13LLU / }/ match-predicate */
4296	4415
4297	4416	if(/def_______/0x7E08400000000000LLU != stack[stackbase + 4LLU])
4298		-{ /* JUMP / fnaddr = 18446744073709551291LLU; break; } / skip match */
	4417	+{ /* JUMP / fnaddr = 18446744073709551278LLU; break; } / skip match */
4299	4418	/* match // predicate */
4300	4419
4301	4420	{

		@@ -4308,18 +4427,18 @@
4308	4427	{
4309	4428	/CALLEND/
4310	4429	stackbase += 16LLU;
4311		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB8LLU;
	4430	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEABLLU;
4312	4431	fnaddr = /subtoid___/0xBB076FAA47C00000LLU;/* SP = 0LLU */
4313	4432	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subtoid___/\n"); exit(-1); } }
4314	4433	break;
4315	4434	}
4316		-case 0xFFFFFFFFFFFFFEB8LLU:
	4435	+case 0xFFFFFFFFFFFFFEABLLU:
4317	4436	/* SP = 14LLU */
4318	4437	{/* PUSH /stack[stackbase + 14LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 15LLU // SP = 13LLU */
4319	4438	{
4320	4439	{/* PUSH /stack[stackbase + 13LLU] = stack[stackbase + 13LLU] == stack[stackbase + 14LLU]; }/ SP + 1LLU = 14LLU */ }
4321	4440	if(!/* SP - 1LLU = 13LLU // POP */stack[stackbase + 13LLU])
4322		-{ /* JUMP / fnaddr = 18446744073709551289LLU; break; } / skip consequent */
	4441	+{ /* JUMP / fnaddr = 18446744073709551276LLU; break; } / skip consequent */
4323	4442	/* consequent // parse data */
4324	4443
4325	4444	{/* PUSH /stack[stackbase + 13LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 14LLU */

		@@ -4326,35 +4445,35 @@
4326	4445	{/* PUSH /stack[stackbase + 14LLU] = stack[stackbase + 7LLU]; }/ SP + 1LLU = 15LLU // match-predicate */
4327	4446
4328	4447	if(/some_u64__/0xBAAA20030F3A0000LLU != stack[stackbase + 13LLU])
4329		-{ /* JUMP / fnaddr = 18446744073709551287LLU; break; } / skip match */
	4448	+{ /* JUMP / fnaddr = 18446744073709551274LLU; break; } / skip match */
4330	4449	/* match */
4331	4450	{/* PUSH /stack[stackbase + 15LLU] = stack[stackbase + 14LLU]; }/ SP + 1LLU = 16LLU // SP - 1LLU = 15LLU / / MATCH-RESULT */
4332	4451	{ /* RESULT /stack[stackbase + 13LLU] = stack[stackbase + 15LLU]; }/ SP = 14LLU */
4333		-{ /* JUMP / fnaddr = 18446744073709551286LLU; break; } / skip other */
4334		-case 18446744073709551287LLU: /* other // SP = 13LLU */
	4452	+{ /* JUMP / fnaddr = 18446744073709551273LLU; break; } / skip other */
	4453	+case 18446744073709551274LLU: /* other // SP = 13LLU */
4335	4454	{/* PUSH /stack[stackbase + 13LLU] = 0LLU; }/ SP + 1LLU = 14LLU */
4336		-case 18446744073709551286LLU: /* skip to here */
	4455	+case 18446744073709551273LLU: /* skip to here */
4337	4456	/* SP = 13LLU // assign */
4338	4457	{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 13LLU]; }
4339	4458	{/* PUSH /stack[stackbase + 13LLU] = 13752902546454740992LLU; }/ SP + 1LLU = 14LLU // SP + 1LLU = 15LLU // SP - 1LLU = 14LLU // SP = 13LLU // assign */
4340	4459	{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 13LLU]; }
4341	4460	{stack[stackbase + 0LLU] = 0;}/* SP = 13LLU */
4342		-case 18446744073709551289LLU: /* alternative // SP = 13LLU // SP - 0LLU = 13LLU / / MATCH-RESULT // SP = 4LLU */
4343		-{ /* JUMP / fnaddr = 18446744073709551290LLU; break; } / skip other */
4344		-case 18446744073709551291LLU: /* other // SP = 4LLU // SP = 4LLU */
4345		-case 18446744073709551290LLU: /* skip to here */
	4461	+case 18446744073709551276LLU: /* alternative // SP = 13LLU // SP - 0LLU = 13LLU / / MATCH-RESULT // SP = 4LLU */
	4462	+{ /* JUMP / fnaddr = 18446744073709551277LLU; break; } / skip other */
	4463	+case 18446744073709551278LLU: /* other // SP = 4LLU // SP = 4LLU */
	4464	+case 18446744073709551277LLU: /* skip to here */
4346	4465	/* SP = 4LLU */
4347	4466	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
4348		-{ /* JUMP / fnaddr = 18446744073709551293LLU; break; } / loop */
4349		-case 18446744073709551292LLU: /* skip to here // parse data */
	4467	+{ /* JUMP / fnaddr = 18446744073709551280LLU; break; } / loop */
	4468	+case 18446744073709551279LLU: /* skip to here // parse data */
4350	4469
4351	4470	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 5LLU // match-predicate */
4352	4471
4353	4472	if(/true______/0xBEDC200000000000LLU != stack[stackbase + 4LLU])
4354		-{ /* JUMP / fnaddr = 18446744073709551285LLU; break; } / skip match */
	4473	+{ /* JUMP / fnaddr = 18446744073709551272LLU; break; } / skip match */
4355	4474	/* match // SP = 5LLU // SP - 0LLU = 5LLU / / MATCH-RESULT // SP = 4LLU */
4356		-{ /* JUMP / fnaddr = 18446744073709551284LLU; break; } / skip other */
4357		-case 18446744073709551285LLU: /* other // SP = 4LLU */
	4475	+{ /* JUMP / fnaddr = 18446744073709551271LLU; break; } / skip other */
	4476	+case 18446744073709551272LLU: /* other // SP = 4LLU */
4358	4477	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("\ndefined functions\n", stderr);
4359	4478	{
4360	4479	/* CALLBEGIN */

		@@ -4366,12 +4485,12 @@
4366	4485	{
4367	4486	/CALLEND/
4368	4487	stackbase += 6LLU;
4369		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB3LLU;
	4488	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA6LLU;
4370	4489	fnaddr = /reportdefs/0xB60AEAB6F7E086E0LLU;/* SP = 0LLU */
4371	4490	{ if(stackbase + 27LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportdefs/\n"); exit(-1); } }
4372	4491	break;
4373	4492	}
4374		-case 0xFFFFFFFFFFFFFEB3LLU:
	4493	+case 0xFFFFFFFFFFFFFEA6LLU:
4375	4494	/* SP = 4LLU */fputs("\nundefined struct ", stderr);
4376	4495	{
4377	4496	/* CALLBEGIN */

		@@ -4389,32 +4508,32 @@
4389	4508	{
4390	4509	/CALLEND/
4391	4510	stackbase += 9LLU;
4392		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB2LLU;
	4511	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA5LLU;
4393	4512	fnaddr = /subtoid___/0xBB076FAA47C00000LLU;/* SP = 0LLU */
4394	4513	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subtoid___/\n"); exit(-1); } }
4395	4514	break;
4396	4515	}
4397		-case 0xFFFFFFFFFFFFFEB2LLU:
	4516	+case 0xFFFFFFFFFFFFFEA5LLU:
4398	4517	/* SP = 7LLU */
4399	4518	{
4400	4519	/CALLEND/
4401	4520	stackbase += 6LLU;
4402		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEB1LLU;
	4521	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA4LLU;
4403	4522	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
4404	4523	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
4405	4524	break;
4406	4525	}
4407		-case 0xFFFFFFFFFFFFFEB1LLU:
	4526	+case 0xFFFFFFFFFFFFFEA4LLU:
4408	4527	/* SP = 4LLU */fputs("\n", stderr);
4409	4528	{/* set exit-value */stack[16LLU] = 255LLU; }
4410	4529	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 4LLU */
4411		-case 18446744073709551284LLU: /* skip to here */
	4530	+case 18446744073709551271LLU: /* skip to here */
4412	4531
4413	4532	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 5LLU // SP - 1LLU = 4LLU // RESULT */
4414	4533	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 4LLU]; }/ SP = 3LLU */
4415		-case 18446744073709551295LLU: /* skip to here */
	4534	+case 18446744073709551282LLU: /* skip to here */
4416	4535
4417		-case 18446744073709551298LLU: /* skip to here */
	4536	+case 18446744073709551285LLU: /* skip to here */
4418	4537	/* SP - 1LLU = 2LLU // RESULT */
4419	4538	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 2LLU]; }/ SP = 3LLU // SP - 1LLU = 2LLU // RESULT */
4420	4539	{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 2LLU]; }

		@@ -4426,7 +4545,7 @@
4426	4545	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 5LLU // SPMAX = 5LLU // match-predicate */
4427	4546
4428	4547	if(/typeval___/0xBF4AE0C5C9C00000LLU != stack[stackbase + 3LLU])
4429		-{ /* JUMP / fnaddr = 18446744073709551280LLU; break; } / skip match */
	4548	+{ /* JUMP / fnaddr = 18446744073709551267LLU; break; } / skip match */
4430	4549	/* match */
4431	4550	{
4432	4551	/* CALLBEGIN */

		@@ -4439,18 +4558,18 @@
4439	4558	{
4440	4559	/CALLEND/
4441	4560	stackbase += 8LLU;
4442		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEAELLU;
	4561	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA1LLU;
4443	4562	fnaddr = /subsize___/0xBB076E9358000000LLU;/* SP = 0LLU */
4444	4563	{ if(stackbase + 33LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subsize___/\n"); exit(-1); } }
4445	4564	break;
4446	4565	}
4447		-case 0xFFFFFFFFFFFFFEAELLU:
	4566	+case 0xFFFFFFFFFFFFFEA1LLU:
4448	4567	/* SP = 6LLU // SP - 1LLU = 5LLU / / MATCH-RESULT */
4449	4568	{ /* RESULT /stack[stackbase + 3LLU] = stack[stackbase + 5LLU]; }/ SP = 4LLU */
4450		-{ /* JUMP / fnaddr = 18446744073709551279LLU; break; } / skip other */
4451		-case 18446744073709551280LLU: /* other // SP = 3LLU */
	4569	+{ /* JUMP / fnaddr = 18446744073709551266LLU; break; } / skip other */
	4570	+case 18446744073709551267LLU: /* other // SP = 3LLU */
4452	4571	{/* PUSH /stack[stackbase + 3LLU] = 1LLU; }/ SP + 1LLU = 4LLU */
4453		-case 18446744073709551279LLU: /* skip to here */
	4572	+case 18446744073709551266LLU: /* skip to here */
4454	4573	/* SP - 1LLU = 3LLU // RESULT */
4455	4574	{ /* RESULT /stack[stackbase + 3LLU] = stack[stackbase + 3LLU]; }/ SP = 4LLU // SP - 1LLU = 3LLU // RESULT */
4456	4575	{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 3LLU]; }

		@@ -4458,11 +4577,11 @@
4458	4577	/* function requires 41LLU 64-bit chunks of memory (including 3LLU for parameters) */
4459	4578	case /reportvars/0xB60AEAB6FC5CB6E0LLU:/* SP = 1LLU // SPMAX = 1LLU */
4460	4579	{/* PUSH /stack[stackbase + 1LLU] = 0LLU; }/ SP + 1LLU = 2LLU // SPMAX = 2LLU */fputs("[", stderr);
4461		-case 0xFFFFFFFFFFFFFEADLLU: /* loop to here // predicate: list non-empty? */
	4580	+case 0xFFFFFFFFFFFFFEA0LLU: /* loop to here // predicate: list non-empty? */
4462	4581
4463	4582	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 3LLU // SPMAX = 3LLU */
4464	4583	if(!/* SP - 1LLU = 2LLU // POP */stack[stackbase + 2LLU])
4465		-{ /* JUMP / fnaddr = 18446744073709551276LLU; break; } / skip loop */
	4584	+{ /* JUMP / fnaddr = 18446744073709551263LLU; break; } / skip loop */
4466	4585	/* loop */
4467	4586	{
4468	4587	/* CALLBEGIN */

		@@ -4474,12 +4593,12 @@
4474	4593	{
4475	4594	/CALLEND/
4476	4595	stackbase += 4LLU;
4477		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEABLLU;
	4596	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9ELLU;
4478	4597	fnaddr = /reportnr__/0xB60AEAB6FA6D0000LLU;/* SP = 0LLU */
4479	4598	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportnr__/\n"); exit(-1); } }
4480	4599	break;
4481	4600	}
4482		-case 0xFFFFFFFFFFFFFEABLLU:
	4601	+case 0xFFFFFFFFFFFFFE9ELLU:
4483	4602	/* SP = 2LLU */fputs(" ", stderr);
4484	4603	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 3LLU */
4485	4604	{/* PUSH /stack[stackbase + 3LLU] = 1LLU; }/ SP + 1LLU = 4LLU // SP = 2LLU */

		@@ -4497,25 +4616,25 @@
4497	4616	{
4498	4617	/CALLEND/
4499	4618	stackbase += 4LLU;
4500		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEAALLU;
	4619	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9DLLU;
4501	4620	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
4502	4621	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
4503	4622	break;
4504	4623	}
4505		-case 0xFFFFFFFFFFFFFEAALLU:
	4624	+case 0xFFFFFFFFFFFFFE9DLLU:
4506	4625	/* SP = 2LLU /fputs(";", stderr); / SP = 2LLU */
4507	4626	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
4508		-{ /* JUMP / fnaddr = 18446744073709551277LLU; break; } / loop */
4509		-case 18446744073709551276LLU: /* skip to here /fputs("]\n", stderr); / SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
	4627	+{ /* JUMP / fnaddr = 18446744073709551264LLU; break; } / loop */
	4628	+case 18446744073709551263LLU: /* skip to here /fputs("]\n", stderr); / SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
4510	4629	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
4511	4630	/* function requires 18LLU 64-bit chunks of memory (including 1LLU for parameters) */
4512	4631	case /existsvar_/0x83392EBEEC5CB400LLU:/* SP = 2LLU // SPMAX = 2LLU */
4513	4632	{/* PUSH /stack[stackbase + 2LLU] = 0LLU; }/ SP + 1LLU = 3LLU // SPMAX = 3LLU */
4514		-case 0xFFFFFFFFFFFFFEA9LLU: /* loop to here // predicate: list non-empty? */
	4633	+case 0xFFFFFFFFFFFFFE9CLLU: /* loop to here // predicate: list non-empty? */
4515	4634
4516	4635	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 4LLU // SPMAX = 4LLU */
4517	4636	if(!/* SP - 1LLU = 3LLU // POP */stack[stackbase + 3LLU])
4518		-{ /* JUMP / fnaddr = 18446744073709551272LLU; break; } / skip loop */
	4637	+{ /* JUMP / fnaddr = 18446744073709551259LLU; break; } / skip loop */
4519	4638	/* loop // predicate */
4520	4639
4521	4640	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 4LLU */

		@@ -4524,142 +4643,149 @@
4524	4643	{
4525	4644	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 3LLU] == stack[stackbase + 4LLU]; }/ SP + 1LLU = 4LLU */ }
4526	4645	if(!/* SP - 1LLU = 3LLU // POP */stack[stackbase + 3LLU])
4527		-{ /* JUMP / fnaddr = 18446744073709551271LLU; break; } / skip consequent */
	4646	+{ /* JUMP / fnaddr = 18446744073709551258LLU; break; } / skip consequent */
4528	4647	/* consequent */
4529	4648	{/* PUSH /stack[stackbase + 3LLU] = 1LLU; }/ SP + 1LLU = 4LLU // SP = 3LLU // assign */
4530	4649	{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 3LLU]; }
4531	4650	{stack[stackbase + 0LLU] = 0;}/* SP = 3LLU */
4532		-case 18446744073709551271LLU: /* alternative // SP = 3LLU */
	4651	+case 18446744073709551258LLU: /* alternative // SP = 3LLU */
4533	4652	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
4534		-{ /* JUMP / fnaddr = 18446744073709551273LLU; break; } / loop */
4535		-case 18446744073709551272LLU: /* skip to here */
	4653	+{ /* JUMP / fnaddr = 18446744073709551260LLU; break; } / loop */
	4654	+case 18446744073709551259LLU: /* skip to here */
4536	4655	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 4LLU // SP - 1LLU = 3LLU // RESULT */
4537	4656	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 3LLU]; }/ SP = 3LLU // SP - 1LLU = 2LLU // RESULT */
4538	4657	{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 2LLU]; }
4539	4658	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
4540	4659	/* function requires 5LLU 64-bit chunks of memory (including 2LLU for parameters) */
4541		-case /findvar___/0x864A5FC5CB400000LLU:/* SP = 2LLU // SPMAX = 2LLU // SP + 5LLU = 7LLU // SPMAX = 7LLU // SP - 5LLU = 2LLU */
	4660	+case /findvar___/0x864A5FC5CB400000LLU:/* SP = 2LLU // SPMAX = 2LLU // SP + 6LLU = 8LLU // SPMAX = 8LLU // SP - 6LLU = 2LLU */
4542	4661	{/* PUSH /stack[stackbase + 2LLU] = 0LLU; }/ SP + 1LLU = 3LLU */
4543		-{/* PUSH /stack[stackbase + 3LLU] = 0LLU; }/ SP + 1LLU = 4LLU */
4544		-{/* PUSH /stack[stackbase + 4LLU] = 13784076749618806784LLU; }/ SP + 1LLU = 5LLU // SP + 2LLU = 7LLU // SP - 2LLU = 5LLU // SP + 1LLU = 6LLU // SP - 1LLU = 5LLU */
4545		-{/* PUSH /stack[stackbase + 5LLU] = 0LLU; }/ SP + 1LLU = 6LLU */
4546		-{/* PUSH /stack[stackbase + 6LLU] = 0LLU; }/ SP + 1LLU = 7LLU // predicate */
	4662	+{/* PUSH /stack[stackbase + 3LLU] = 0LLU; }/ SP + 1LLU = 4LLU // SP + 3LLU = 7LLU // SP - 3LLU = 4LLU */
	4663	+{/* PUSH /stack[stackbase + 4LLU] = 8838998972400926720LLU; }/ SP + 1LLU = 5LLU // SP + 1LLU = 6LLU // SP - 1LLU = 5LLU */
	4664	+{/* PUSH /stack[stackbase + 5LLU] = 13784076749618806784LLU; }/ SP + 1LLU = 6LLU // SP + 2LLU = 8LLU // SP - 2LLU = 6LLU // SP + 1LLU = 7LLU // SP - 1LLU = 6LLU */
	4665	+{/* PUSH /stack[stackbase + 6LLU] = 0LLU; }/ SP + 1LLU = 7LLU */
	4666	+{/* PUSH /stack[stackbase + 7LLU] = 0LLU; }/ SP + 1LLU = 8LLU // predicate */
4547	4667
4548	4668	{
4549	4669	/* CALLBEGIN */
4550		- /* reserve space for 1LLU returned values // SP + 1LLU = 8LLU // SPMAX = 8LLU */
4551		-{/* PUSH /stack[stackbase + 8LLU] = stackbase; }/ SP + 1LLU = 9LLU // SPMAX = 9LLU */
4552		- /* leave place for return addr // SP + 1LLU = 10LLU // SPMAX = 10LLU */
4553		- }/* SP + 5LLU = 15LLU // SPMAX = 15LLU // SP - 5LLU = 10LLU */
4554		-{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 11LLU */
4555		-{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 12LLU */
	4670	+ /* reserve space for 1LLU returned values // SP + 1LLU = 9LLU // SPMAX = 9LLU */
	4671	+{/* PUSH /stack[stackbase + 9LLU] = stackbase; }/ SP + 1LLU = 10LLU // SPMAX = 10LLU */
	4672	+ /* leave place for return addr // SP + 1LLU = 11LLU // SPMAX = 11LLU */
	4673	+ }/* SP + 5LLU = 16LLU // SPMAX = 16LLU // SP - 5LLU = 11LLU */
	4674	+{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 12LLU */
	4675	+{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 13LLU */
4556	4676	{
4557	4677	/CALLEND/
4558		- stackbase += 10LLU;
4559		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA4LLU;
	4678	+ stackbase += 11LLU;
	4679	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE97LLU;
4560	4680	fnaddr = /existsvar_/0x83392EBEEC5CB400LLU;/* SP = 0LLU */
4561	4681	{ if(stackbase + 5LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /existsvar_/\n"); exit(-1); } }
4562	4682	break;
4563	4683	}
4564		-case 0xFFFFFFFFFFFFFEA4LLU:
4565		-/* SP = 8LLU */
4566		-{ /* TOP /stack[stackbase + 7LLU] = !/ TOP */stack[stackbase + 7LLU]; }
4567		-if(!/* SP - 1LLU = 7LLU // POP */stack[stackbase + 7LLU])
4568		-{ /* JUMP / fnaddr = 18446744073709551270LLU; break; } / skip consequent */
	4684	+case 0xFFFFFFFFFFFFFE97LLU:
	4685	+/* SP = 9LLU */
	4686	+{ /* TOP /stack[stackbase + 8LLU] = !/ TOP */stack[stackbase + 8LLU]; }
	4687	+if(!/* SP - 1LLU = 8LLU // POP */stack[stackbase + 8LLU])
	4688	+{ /* JUMP / fnaddr = 18446744073709551257LLU; break; } / skip consequent */
4569	4689	/* consequent */
4570	4690	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("undefined variable ", stderr);
4571	4691	{
4572	4692	/* CALLBEGIN */
4573		- /* reserve space for 0LLU returned values // SP + 0LLU = 7LLU */
4574		-{/* PUSH /stack[stackbase + 7LLU] = stackbase; }/ SP + 1LLU = 8LLU */
4575		- /* leave place for return addr // SP + 1LLU = 9LLU */
4576		- }/* SP + 7LLU = 16LLU // SPMAX = 16LLU // SP - 7LLU = 9LLU */
4577		-{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 10LLU */
	4693	+ /* reserve space for 0LLU returned values // SP + 0LLU = 8LLU */
	4694	+{/* PUSH /stack[stackbase + 8LLU] = stackbase; }/ SP + 1LLU = 9LLU */
	4695	+ /* leave place for return addr // SP + 1LLU = 10LLU */
	4696	+ }/* SP + 7LLU = 17LLU // SPMAX = 17LLU // SP - 7LLU = 10LLU */
	4697	+{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 11LLU */
4578	4698	{
4579	4699	/CALLEND/
4580		- stackbase += 9LLU;
4581		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA3LLU;
	4700	+ stackbase += 10LLU;
	4701	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE96LLU;
4582	4702	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
4583	4703	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
4584	4704	break;
4585	4705	}
4586		-case 0xFFFFFFFFFFFFFEA3LLU:
4587		-/* SP = 7LLU */fputs("\n", stderr); fputs("defined variables\n", stderr);
	4706	+case 0xFFFFFFFFFFFFFE96LLU:
	4707	+/* SP = 8LLU */fputs("\n", stderr); fputs("defined variables\n", stderr);
4588	4708	{
4589	4709	/* CALLBEGIN */
4590		- /* reserve space for 0LLU returned values // SP + 0LLU = 7LLU */
4591		-{/* PUSH /stack[stackbase + 7LLU] = stackbase; }/ SP + 1LLU = 8LLU */
4592		- /* leave place for return addr // SP + 1LLU = 9LLU */
4593		- }/* SP + 18LLU = 27LLU // SPMAX = 27LLU // SP - 18LLU = 9LLU */
4594		-{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 10LLU */
	4710	+ /* reserve space for 0LLU returned values // SP + 0LLU = 8LLU */
	4711	+{/* PUSH /stack[stackbase + 8LLU] = stackbase; }/ SP + 1LLU = 9LLU */
	4712	+ /* leave place for return addr // SP + 1LLU = 10LLU */
	4713	+ }/* SP + 18LLU = 28LLU // SPMAX = 28LLU // SP - 18LLU = 10LLU */
	4714	+{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 11LLU */
4595	4715	{
4596	4716	/CALLEND/
4597		- stackbase += 9LLU;
4598		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFEA2LLU;
	4717	+ stackbase += 10LLU;
	4718	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE95LLU;
4599	4719	fnaddr = /reportvars/0xB60AEAB6FC5CB6E0LLU;/* SP = 0LLU */
4600	4720	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportvars/\n"); exit(-1); } }
4601	4721	break;
4602	4722	}
4603		-case 0xFFFFFFFFFFFFFEA2LLU:
4604		-/* SP = 7LLU */
	4723	+case 0xFFFFFFFFFFFFFE95LLU:
	4724	+/* SP = 8LLU */
4605	4725	{/* set exit-value */stack[16LLU] = 255LLU; }
4606		-{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 7LLU // SP = 7LLU */
4607		-{ /* JUMP / fnaddr = 18446744073709551269LLU; break; } / skip alternative */
4608		-case 18446744073709551270LLU: /* alternative */
4609		-case 0xFFFFFFFFFFFFFEA1LLU: /* loop to here // predicate: list non-empty? */
	4726	+{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 8LLU // SP = 8LLU */
	4727	+{ /* JUMP / fnaddr = 18446744073709551256LLU; break; } / skip alternative */
	4728	+case 18446744073709551257LLU: /* alternative */
	4729	+case 0xFFFFFFFFFFFFFE94LLU: /* loop to here // predicate: list non-empty? */
4610	4730
4611		-{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 8LLU */
4612		-if(!/* SP - 1LLU = 7LLU // POP */stack[stackbase + 7LLU])
4613		-{ /* JUMP / fnaddr = 18446744073709551264LLU; break; } / skip loop */
	4731	+{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 9LLU */
	4732	+if(!/* SP - 1LLU = 8LLU // POP */stack[stackbase + 8LLU])
	4733	+{ /* JUMP / fnaddr = 18446744073709551251LLU; break; } / skip loop */
4614	4734	/* loop // predicate */
4615	4735
4616		-{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 8LLU */
	4736	+{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 9LLU */
4617	4737	{
4618		-{/* PUSH /stack[stackbase + 8LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 1LLU]; }/ SP + 1LLU = 9LLU / }/ SP = 7LLU */
	4738	+{/* PUSH /stack[stackbase + 9LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 1LLU]; }/ SP + 1LLU = 10LLU / }/ SP = 8LLU */
4619	4739	{
4620		-{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 7LLU] == stack[stackbase + 8LLU]; }/ SP + 1LLU = 8LLU */ }
4621		-if(!/* SP - 1LLU = 7LLU // POP */stack[stackbase + 7LLU])
4622		-{ /* JUMP / fnaddr = 18446744073709551263LLU; break; } / skip consequent */
	4740	+{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 8LLU] == stack[stackbase + 9LLU]; }/ SP + 1LLU = 9LLU */ }
	4741	+if(!/* SP - 1LLU = 8LLU // POP */stack[stackbase + 8LLU])
	4742	+{ /* JUMP / fnaddr = 18446744073709551250LLU; break; } / skip consequent */
4623	4743	/* consequent */
4624	4744	{ /* LIST-READ */
4625		-{/* PUSH /stack[stackbase + 7LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 1LLU]; }/ SP + 1LLU = 8LLU */ }
	4745	+{/* PUSH /stack[stackbase + 8LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 1LLU]; }/ SP + 1LLU = 9LLU */ }
4626	4746	{ /* LIST-READ */
4627		-{/* PUSH /stack[stackbase + 8LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 2LLU]; }/ SP + 1LLU = 9LLU */ }
	4747	+{/* PUSH /stack[stackbase + 9LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 2LLU]; }/ SP + 1LLU = 10LLU */ }
4628	4748	{ /* LIST-READ */
4629		-{/* PUSH /stack[stackbase + 9LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 3LLU]; }/ SP + 1LLU = 10LLU */ }
	4749	+{/* PUSH /stack[stackbase + 10LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 3LLU]; }/ SP + 1LLU = 11LLU */ }
4630	4750	{ /* LIST-READ */
4631		-{/* PUSH /stack[stackbase + 10LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 4LLU]; }/ SP + 1LLU = 11LLU */ }
	4751	+{/* PUSH /stack[stackbase + 11LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 4LLU]; }/ SP + 1LLU = 12LLU */ }
4632	4752	{ /* LIST-READ */
4633		-{/* PUSH /stack[stackbase + 11LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 5LLU]; }/ SP + 1LLU = 12LLU / }/ SP = 7LLU // assign */
4634		-{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 7LLU]; }
4635		-{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 8LLU]; }
4636		-{ /* RESULT */stack[stackbase + 4LLU] = stack[stackbase + 9LLU]; }
4637		-{ /* RESULT */stack[stackbase + 5LLU] = stack[stackbase + 10LLU]; }
4638		-{ /* RESULT */stack[stackbase + 6LLU] = stack[stackbase + 11LLU]; }
4639		-{stack[stackbase + 0LLU] = 0;}/* SP = 7LLU */
4640		-case 18446744073709551263LLU: /* alternative // SP = 7LLU */
	4753	+{/* PUSH /stack[stackbase + 12LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 5LLU]; }/ SP + 1LLU = 13LLU */ }
	4754	+{ /* LIST-READ */
	4755	+{/* PUSH /stack[stackbase + 13LLU] = / DEREF-LIST / stack[stack[stackbase + 0LLU] + 6LLU]; }/ SP + 1LLU = 14LLU / }/ SP = 8LLU // assign */
	4756	+{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 8LLU]; }
	4757	+{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 9LLU]; }
	4758	+{ /* RESULT */stack[stackbase + 4LLU] = stack[stackbase + 10LLU]; }
	4759	+{ /* RESULT */stack[stackbase + 5LLU] = stack[stackbase + 11LLU]; }
	4760	+{ /* RESULT */stack[stackbase + 6LLU] = stack[stackbase + 12LLU]; }
	4761	+{ /* RESULT */stack[stackbase + 7LLU] = stack[stackbase + 13LLU]; }
	4762	+{stack[stackbase + 0LLU] = 0;}/* SP = 8LLU */
	4763	+case 18446744073709551250LLU: /* alternative // SP = 8LLU */
4641	4764	{ /* NEXT LIST ELEM */ if(stack[stackbase + 0LLU]) stack[stackbase + 0LLU] = stack[stack[stackbase + 0LLU]]; }
4642		-{ /* JUMP / fnaddr = 18446744073709551265LLU; break; } / loop */
4643		-case 18446744073709551264LLU: /* skip to here // SP = 7LLU */
4644		-case 18446744073709551269LLU: /* skip to here */
	4765	+{ /* JUMP / fnaddr = 18446744073709551252LLU; break; } / loop */
	4766	+case 18446744073709551251LLU: /* skip to here // SP = 8LLU */
	4767	+case 18446744073709551256LLU: /* skip to here */
4645	4768
4646		-{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 8LLU */
4647		-{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 9LLU */
4648		-{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 10LLU */
4649		-{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 11LLU */
4650		-{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 12LLU // SP - 5LLU = 7LLU // RESULT */
4651		-{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 7LLU]; }
4652		-{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 8LLU]; }
4653		-{ /* RESULT */stack[stackbase + 4LLU] = stack[stackbase + 9LLU]; }
4654		-{ /* RESULT */stack[stackbase + 5LLU] = stack[stackbase + 10LLU]; }
4655		-{ /* RESULT /stack[stackbase + 6LLU] = stack[stackbase + 11LLU]; }/ SP = 7LLU // SP - 5LLU = 2LLU // RESULT */
4656		-{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 6LLU]; }
4657		-{ /* RESULT */stack[stackbase + 18446744073709551612LLU] = stack[stackbase + 5LLU]; }
4658		-{ /* RESULT */stack[stackbase + 18446744073709551611LLU] = stack[stackbase + 4LLU]; }
4659		-{ /* RESULT */stack[stackbase + 18446744073709551610LLU] = stack[stackbase + 3LLU]; }
4660		-{ /* RESULT */stack[stackbase + 18446744073709551609LLU] = stack[stackbase + 2LLU]; }
	4769	+{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 9LLU */
	4770	+{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 10LLU */
	4771	+{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 11LLU */
	4772	+{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 12LLU */
	4773	+{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 13LLU */
	4774	+{/* PUSH /stack[stackbase + 13LLU] = stack[stackbase + 7LLU]; }/ SP + 1LLU = 14LLU // SP - 6LLU = 8LLU // RESULT */
	4775	+{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 8LLU]; }
	4776	+{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 9LLU]; }
	4777	+{ /* RESULT */stack[stackbase + 4LLU] = stack[stackbase + 10LLU]; }
	4778	+{ /* RESULT */stack[stackbase + 5LLU] = stack[stackbase + 11LLU]; }
	4779	+{ /* RESULT */stack[stackbase + 6LLU] = stack[stackbase + 12LLU]; }
	4780	+{ /* RESULT /stack[stackbase + 7LLU] = stack[stackbase + 13LLU]; }/ SP = 8LLU // SP - 6LLU = 2LLU // RESULT */
	4781	+{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 7LLU]; }
	4782	+{ /* RESULT */stack[stackbase + 18446744073709551612LLU] = stack[stackbase + 6LLU]; }
	4783	+{ /* RESULT */stack[stackbase + 18446744073709551611LLU] = stack[stackbase + 5LLU]; }
	4784	+{ /* RESULT */stack[stackbase + 18446744073709551610LLU] = stack[stackbase + 4LLU]; }
	4785	+{ /* RESULT */stack[stackbase + 18446744073709551609LLU] = stack[stackbase + 3LLU]; }
	4786	+{ /* RESULT */stack[stackbase + 18446744073709551608LLU] = stack[stackbase + 2LLU]; }
4661	4787	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
4662		-/* function requires 27LLU 64-bit chunks of memory (including 2LLU for parameters) */
	4788	+/* function requires 28LLU 64-bit chunks of memory (including 2LLU for parameters) */
4663	4789	case /GLOBMAXGET/0x1CC3C23416071540LLU:/* SP = 0LLU */
4664	4790	{/* PUSH /stack[stackbase + 0LLU] = stack[0LLU]; }/ SP + 1LLU = 1LLU // SPMAX = 1LLU // SP - 1LLU = 0LLU // RESULT */
4665	4791	{ /* RESULT /stack[stackbase + 0LLU] = stack[stackbase + 0LLU]; }/ SP = 1LLU // SP - 1LLU = 0LLU // RESULT */

		@@ -4724,12 +4850,12 @@
4724	4850	{
4725	4851	/CALLEND/
4726	4852	stackbase += 3LLU;
4727		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9ELLU;
	4853	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE91LLU;
4728	4854	fnaddr = /max_u64___/0xA1CCC0C3CE800000LLU;/* SP = 0LLU */
4729	4855	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /max_u64___/\n"); exit(-1); } }
4730	4856	break;
4731	4857	}
4732		-case 0xFFFFFFFFFFFFFE9ELLU:
	4858	+case 0xFFFFFFFFFFFFFE91LLU:
4733	4859	/* SP = 1LLU /stack[3LLU] = / SP - 1LLU = 0LLU // POP */stack[stackbase + 0LLU];
4734	4860	/* SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
4735	4861	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }

		@@ -4745,12 +4871,12 @@
4745	4871	{
4746	4872	/CALLEND/
4747	4873	stackbase += 3LLU;
4748		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9CLLU;
	4874	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8FLLU;
4749	4875	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
4750	4876	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
4751	4877	break;
4752	4878	}
4753		-case 0xFFFFFFFFFFFFFE9CLLU:
	4879	+case 0xFFFFFFFFFFFFFE8FLLU:
4754	4880	/* SP = 1LLU */
4755	4881	{
4756	4882	/* CALLBEGIN */

		@@ -4761,17 +4887,17 @@
4761	4887	{
4762	4888	/CALLEND/
4763	4889	stackbase += 4LLU;
4764		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9BLLU;
	4890	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8ELLU;
4765	4891	fnaddr = /SPMAX_GET_/0x4D03416001C55000LLU;/* SP = 0LLU */
4766	4892	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SPMAX_GET_/\n"); exit(-1); } }
4767	4893	break;
4768	4894	}
4769		-case 0xFFFFFFFFFFFFFE9BLLU:
	4895	+case 0xFFFFFFFFFFFFFE8ELLU:
4770	4896	/* SP = 2LLU // SP = 0LLU */
4771	4897	{
4772	4898	{/* PUSH /stack[stackbase + 0LLU] = stack[stackbase + 0LLU] > stack[stackbase + 1LLU]; }/ SP + 1LLU = 1LLU */ }
4773	4899	if(!/* SP - 1LLU = 0LLU // POP */stack[stackbase + 0LLU])
4774		-{ /* JUMP / fnaddr = 18446744073709551261LLU; break; } / skip consequent */
	4900	+{ /* JUMP / fnaddr = 18446744073709551248LLU; break; } / skip consequent */
4775	4901	/* consequent */
4776	4902	{/* PUSH /stack[stackbase + 0LLU] = stack[2LLU]; }/ SP + 1LLU = 1LLU /stack[3LLU] = / SP - 1LLU = 0LLU // POP */stack[stackbase + 0LLU];
4777	4903	fputs("/* SPMAX = ", stdout);

		@@ -4785,14 +4911,14 @@
4785	4911	{
4786	4912	/CALLEND/
4787	4913	stackbase += 2LLU;
4788		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE9ALLU;
	4914	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8DLLU;
4789	4915	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
4790	4916	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
4791	4917	break;
4792	4918	}
4793		-case 0xFFFFFFFFFFFFFE9ALLU:
	4919	+case 0xFFFFFFFFFFFFFE8DLLU:
4794	4920	/* SP = 0LLU /fputs(" /", stdout); /* SP = 0LLU */
4795		-case 18446744073709551261LLU: /* alternative // SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
	4921	+case 18446744073709551248LLU: /* alternative // SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
4796	4922	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
4797	4923	/* function requires 16LLU 64-bit chunks of memory (including 0LLU for parameters) */
4798	4924	case /SP_SET____/0x4D00131540000000LLU:/* SP = 1LLU // SPMAX = 1LLU */

		@@ -4808,12 +4934,12 @@
4808	4934	{
4809	4935	/CALLEND/
4810	4936	stackbase += 3LLU;
4811		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE99LLU;
	4937	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8CLLU;
4812	4938	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
4813	4939	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
4814	4940	break;
4815	4941	}
4816		-case 0xFFFFFFFFFFFFFE99LLU:
	4942	+case 0xFFFFFFFFFFFFFE8CLLU:
4817	4943	/* SP = 1LLU /fputs(" /", stdout);
4818	4944	{
4819	4945	/* CALLBEGIN */

		@@ -4824,12 +4950,12 @@
4824	4950	{
4825	4951	/CALLEND/
4826	4952	stackbase += 3LLU;
4827		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE98LLU;
	4953	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8BLLU;
4828	4954	fnaddr = /SPMAXCHECK/0x4D03416032050CB0LLU;/* SP = 0LLU */
4829	4955	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SPMAXCHECK/\n"); exit(-1); } }
4830	4956	break;
4831	4957	}
4832		-case 0xFFFFFFFFFFFFFE98LLU:
	4958	+case 0xFFFFFFFFFFFFFE8BLLU:
4833	4959	/* SP = 1LLU // SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
4834	4960	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
4835	4961	/* function requires 19LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -4849,12 +4975,12 @@
4849	4975	{
4850	4976	/CALLEND/
4851	4977	stackbase += 3LLU;
4852		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE97LLU;
	4978	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8ALLU;
4853	4979	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
4854	4980	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
4855	4981	break;
4856	4982	}
4857		-case 0xFFFFFFFFFFFFFE97LLU:
	4983	+case 0xFFFFFFFFFFFFFE8ALLU:
4858	4984	/* SP = 1LLU */fputs(" = ", stdout);
4859	4985	{
4860	4986	/* CALLBEGIN */

		@@ -4871,22 +4997,22 @@
4871	4997	{
4872	4998	/CALLEND/
4873	4999	stackbase += 6LLU;
4874		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE96LLU;
	5000	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE89LLU;
4875	5001	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
4876	5002	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
4877	5003	break;
4878	5004	}
4879		-case 0xFFFFFFFFFFFFFE96LLU:
	5005	+case 0xFFFFFFFFFFFFFE89LLU:
4880	5006	/* SP = 4LLU */
4881	5007	{
4882	5008	/CALLEND/
4883	5009	stackbase += 3LLU;
4884		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE95LLU;
	5010	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE88LLU;
4885	5011	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
4886	5012	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
4887	5013	break;
4888	5014	}
4889		-case 0xFFFFFFFFFFFFFE95LLU:
	5015	+case 0xFFFFFFFFFFFFFE88LLU:
4890	5016	/* SP = 1LLU /fputs(" /", stdout);
4891	5017	{
4892	5018	/* CALLBEGIN */

		@@ -4897,12 +5023,12 @@
4897	5023	{
4898	5024	/CALLEND/
4899	5025	stackbase += 3LLU;
4900		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE94LLU;
	5026	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE87LLU;
4901	5027	fnaddr = /SPMAXCHECK/0x4D03416032050CB0LLU;/* SP = 0LLU */
4902	5028	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SPMAXCHECK/\n"); exit(-1); } }
4903	5029	break;
4904	5030	}
4905		-case 0xFFFFFFFFFFFFFE94LLU:
	5031	+case 0xFFFFFFFFFFFFFE87LLU:
4906	5032	/* SP = 1LLU // SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
4907	5033	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
4908	5034	/* function requires 19LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -4922,12 +5048,12 @@
4922	5048	{
4923	5049	/CALLEND/
4924	5050	stackbase += 3LLU;
4925		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE93LLU;
	5051	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE86LLU;
4926	5052	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
4927	5053	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
4928	5054	break;
4929	5055	}
4930		-case 0xFFFFFFFFFFFFFE93LLU:
	5056	+case 0xFFFFFFFFFFFFFE86LLU:
4931	5057	/* SP = 1LLU */fputs(" = ", stdout);
4932	5058	{
4933	5059	/* CALLBEGIN */

		@@ -4944,22 +5070,22 @@
4944	5070	{
4945	5071	/CALLEND/
4946	5072	stackbase += 6LLU;
4947		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE92LLU;
	5073	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE85LLU;
4948	5074	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
4949	5075	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
4950	5076	break;
4951	5077	}
4952		-case 0xFFFFFFFFFFFFFE92LLU:
	5078	+case 0xFFFFFFFFFFFFFE85LLU:
4953	5079	/* SP = 4LLU */
4954	5080	{
4955	5081	/CALLEND/
4956	5082	stackbase += 3LLU;
4957		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE91LLU;
	5083	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE84LLU;
4958	5084	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
4959	5085	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
4960	5086	break;
4961	5087	}
4962		-case 0xFFFFFFFFFFFFFE91LLU:
	5088	+case 0xFFFFFFFFFFFFFE84LLU:
4963	5089	/* SP = 1LLU /fputs(" /", stdout); /* SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
4964	5090	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
4965	5091	/* function requires 17LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -4990,12 +5116,12 @@
4990	5116	{
4991	5117	/CALLEND/
4992	5118	stackbase += 3LLU;
4993		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE90LLU;
	5119	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE83LLU;
4994	5120	fnaddr = /DEREFSTART/0x1054851935014940LLU;/* SP = 0LLU */
4995	5121	{ if(stackbase + 0LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEREFSTART/\n"); exit(-1); } }
4996	5122	break;
4997	5123	}
4998		-case 0xFFFFFFFFFFFFFE90LLU:
	5124	+case 0xFFFFFFFFFFFFFE83LLU:
4999	5125	/* SP = 1LLU */
5000	5126	{
5001	5127	/* CALLBEGIN */

		@@ -5007,12 +5133,12 @@
5007	5133	{
5008	5134	/CALLEND/
5009	5135	stackbase += 3LLU;
5010		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8FLLU;
	5136	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE82LLU;
5011	5137	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
5012	5138	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
5013	5139	break;
5014	5140	}
5015		-case 0xFFFFFFFFFFFFFE8FLLU:
	5141	+case 0xFFFFFFFFFFFFFE82LLU:
5016	5142	/* SP = 1LLU */
5017	5143	{
5018	5144	/* CALLBEGIN */

		@@ -5023,12 +5149,12 @@
5023	5149	{
5024	5150	/CALLEND/
5025	5151	stackbase += 3LLU;
5026		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8ELLU;
	5152	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE81LLU;
5027	5153	fnaddr = /DEREFEND__/0x1054851853840000LLU;/* SP = 0LLU */
5028	5154	{ if(stackbase + 0LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEREFEND__/\n"); exit(-1); } }
5029	5155	break;
5030	5156	}
5031		-case 0xFFFFFFFFFFFFFE8ELLU:
	5157	+case 0xFFFFFFFFFFFFFE81LLU:
5032	5158	/* SP = 1LLU // SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
5033	5159	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5034	5160	/* function requires 17LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -5043,12 +5169,12 @@
5043	5169	{
5044	5170	/CALLEND/
5045	5171	stackbase += 3LLU;
5046		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8DLLU;
	5172	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE80LLU;
5047	5173	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
5048	5174	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
5049	5175	break;
5050	5176	}
5051		-case 0xFFFFFFFFFFFFFE8DLLU:
	5177	+case 0xFFFFFFFFFFFFFE80LLU:
5052	5178	/* SP = 1LLU /fputs("]", stdout); / SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
5053	5179	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5054	5180	/* function requires 17LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -5063,12 +5189,12 @@
5063	5189	{
5064	5190	/CALLEND/
5065	5191	stackbase += 3LLU;
5066		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8CLLU;
	5192	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7FLLU;
5067	5193	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
5068	5194	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
5069	5195	break;
5070	5196	}
5071		-case 0xFFFFFFFFFFFFFE8CLLU:
	5197	+case 0xFFFFFFFFFFFFFE7FLLU:
5072	5198	/* SP = 1LLU */fputs(") ", stdout);
5073	5199	{
5074	5200	/* CALLBEGIN */

		@@ -5080,12 +5206,12 @@
5080	5206	{
5081	5207	/CALLEND/
5082	5208	stackbase += 3LLU;
5083		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8BLLU;
	5209	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7ELLU;
5084	5210	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
5085	5211	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
5086	5212	break;
5087	5213	}
5088		-case 0xFFFFFFFFFFFFFE8BLLU:
	5214	+case 0xFFFFFFFFFFFFFE7ELLU:
5089	5215	/* SP = 1LLU */fputs(" = ", stdout);
5090	5216	{
5091	5217	/* CALLBEGIN */

		@@ -5096,12 +5222,12 @@
5096	5222	{
5097	5223	/CALLEND/
5098	5224	stackbase += 3LLU;
5099		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE8ALLU;
	5225	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7DLLU;
5100	5226	fnaddr = /DEREFSTART/0x1054851935014940LLU;/* SP = 0LLU */
5101	5227	{ if(stackbase + 0LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEREFSTART/\n"); exit(-1); } }
5102	5228	break;
5103	5229	}
5104		-case 0xFFFFFFFFFFFFFE8ALLU:
	5230	+case 0xFFFFFFFFFFFFFE7DLLU:
5105	5231	/* SP = 1LLU */
5106	5232	{
5107	5233	/* CALLBEGIN */

		@@ -5113,12 +5239,12 @@
5113	5239	{
5114	5240	/CALLEND/
5115	5241	stackbase += 3LLU;
5116		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE89LLU;
	5242	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7CLLU;
5117	5243	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
5118	5244	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
5119	5245	break;
5120	5246	}
5121		-case 0xFFFFFFFFFFFFFE89LLU:
	5247	+case 0xFFFFFFFFFFFFFE7CLLU:
5122	5248	/* SP = 1LLU */
5123	5249	{
5124	5250	/* CALLBEGIN */

		@@ -5129,12 +5255,12 @@
5129	5255	{
5130	5256	/CALLEND/
5131	5257	stackbase += 3LLU;
5132		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE88LLU;
	5258	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7BLLU;
5133	5259	fnaddr = /DEREFEND__/0x1054851853840000LLU;/* SP = 0LLU */
5134	5260	{ if(stackbase + 0LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEREFEND__/\n"); exit(-1); } }
5135	5261	break;
5136	5262	}
5137		-case 0xFFFFFFFFFFFFFE88LLU:
	5263	+case 0xFFFFFFFFFFFFFE7BLLU:
5138	5264	/* SP = 1LLU /fputs("; }", stdout); / SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
5139	5265	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5140	5266	/* function requires 20LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -5154,22 +5280,22 @@
5154	5280	{
5155	5281	/CALLEND/
5156	5282	stackbase += 5LLU;
5157		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE87LLU;
	5283	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7ALLU;
5158	5284	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
5159	5285	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
5160	5286	break;
5161	5287	}
5162		-case 0xFFFFFFFFFFFFFE87LLU:
	5288	+case 0xFFFFFFFFFFFFFE7ALLU:
5163	5289	/* SP = 3LLU */
5164	5290	{
5165	5291	/CALLEND/
5166	5292	stackbase += 2LLU;
5167		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE86LLU;
	5293	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE79LLU;
5168	5294	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
5169	5295	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
5170	5296	break;
5171	5297	}
5172		-case 0xFFFFFFFFFFFFFE86LLU:
	5298	+case 0xFFFFFFFFFFFFFE79LLU:
5173	5299	/* SP = 0LLU /fputs("] = ", stdout); / SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
5174	5300	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5175	5301	/* function requires 16LLU 64-bit chunks of memory (including 0LLU for parameters) */

		@@ -5184,12 +5310,12 @@
5184	5310	{
5185	5311	/CALLEND/
5186	5312	stackbase += 2LLU;
5187		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE85LLU;
	5313	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE78LLU;
5188	5314	fnaddr = /SP_ADD____/0x4D00011040000000LLU;/* SP = 0LLU */
5189	5315	{ if(stackbase + 19LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_ADD____/\n"); exit(-1); } }
5190	5316	break;
5191	5317	}
5192		-case 0xFFFFFFFFFFFFFE85LLU:
	5318	+case 0xFFFFFFFFFFFFFE78LLU:
5193	5319	/* SP = 0LLU // SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
5194	5320	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5195	5321	/* function requires 21LLU 64-bit chunks of memory (including 0LLU for parameters) */

		@@ -5203,12 +5329,12 @@
5203	5329	{
5204	5330	/CALLEND/
5205	5331	stackbase += 3LLU;
5206		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE84LLU;
	5332	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE77LLU;
5207	5333	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
5208	5334	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); } }
5209	5335	break;
5210	5336	}
5211		-case 0xFFFFFFFFFFFFFE84LLU:
	5337	+case 0xFFFFFFFFFFFFFE77LLU:
5212	5338	/* SP = 1LLU */
5213	5339	{
5214	5340	/* CALLBEGIN */

		@@ -5220,12 +5346,12 @@
5220	5346	{
5221	5347	/CALLEND/
5222	5348	stackbase += 3LLU;
5223		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE83LLU;
	5349	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE76LLU;
5224	5350	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
5225	5351	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
5226	5352	break;
5227	5353	}
5228		-case 0xFFFFFFFFFFFFFE83LLU:
	5354	+case 0xFFFFFFFFFFFFFE76LLU:
5229	5355	/* SP = 1LLU */
5230	5356	{
5231	5357	/* CALLBEGIN */

		@@ -5236,12 +5362,12 @@
5236	5362	{
5237	5363	/CALLEND/
5238	5364	stackbase += 3LLU;
5239		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE82LLU;
	5365	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE75LLU;
5240	5366	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
5241	5367	{ if(stackbase + 21LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); } }
5242	5368	break;
5243	5369	}
5244		-case 0xFFFFFFFFFFFFFE82LLU:
	5370	+case 0xFFFFFFFFFFFFFE75LLU:
5245	5371	/* SP = 1LLU // SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
5246	5372	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5247	5373	/* function requires 24LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -5256,12 +5382,12 @@
5256	5382	{
5257	5383	/CALLEND/
5258	5384	stackbase += 2LLU;
5259		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE81LLU;
	5385	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE74LLU;
5260	5386	fnaddr = /SP_SUB____/0x4D00135420000000LLU;/* SP = 0LLU */
5261	5387	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SUB____/\n"); exit(-1); } }
5262	5388	break;
5263	5389	}
5264		-case 0xFFFFFFFFFFFFFE81LLU:
	5390	+case 0xFFFFFFFFFFFFFE74LLU:
5265	5391	/* SP = 0LLU /fputs("/ POP */stack[stackbase + ", stdout);
5266	5392	{
5267	5393	/* CALLBEGIN */

		@@ -5278,22 +5404,22 @@
5278	5404	{
5279	5405	/CALLEND/
5280	5406	stackbase += 5LLU;
5281		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE80LLU;
	5407	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE73LLU;
5282	5408	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
5283	5409	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
5284	5410	break;
5285	5411	}
5286		-case 0xFFFFFFFFFFFFFE80LLU:
	5412	+case 0xFFFFFFFFFFFFFE73LLU:
5287	5413	/* SP = 3LLU */
5288	5414	{
5289	5415	/CALLEND/
5290	5416	stackbase += 2LLU;
5291		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7FLLU;
	5417	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE72LLU;
5292	5418	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
5293	5419	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
5294	5420	break;
5295	5421	}
5296		-case 0xFFFFFFFFFFFFFE7FLLU:
	5422	+case 0xFFFFFFFFFFFFFE72LLU:
5297	5423	/* SP = 0LLU /fputs("]", stdout); / SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
5298	5424	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5299	5425	/* function requires 19LLU 64-bit chunks of memory (including 0LLU for parameters) */

		@@ -5310,12 +5436,12 @@
5310	5436	{
5311	5437	/CALLEND/
5312	5438	stackbase += 2LLU;
5313		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7ELLU;
	5439	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE71LLU;
5314	5440	fnaddr = /POP_START_/0x40F4004D40525000LLU;/* SP = 0LLU */
5315	5441	{ if(stackbase + 19LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_START_/\n"); exit(-1); } }
5316	5442	break;
5317	5443	}
5318		-case 0xFFFFFFFFFFFFFE7ELLU:
	5444	+case 0xFFFFFFFFFFFFFE71LLU:
5319	5445	/* SP = 0LLU */
5320	5446	{
5321	5447	/* CALLBEGIN */

		@@ -5326,12 +5452,12 @@
5326	5452	{
5327	5453	/CALLEND/
5328	5454	stackbase += 2LLU;
5329		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7DLLU;
	5455	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE70LLU;
5330	5456	fnaddr = /POP_END___/0x40F40014E1000000LLU;/* SP = 0LLU */
5331	5457	{ if(stackbase + 0LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_END___/\n"); exit(-1); } }
5332	5458	break;
5333	5459	}
5334		-case 0xFFFFFFFFFFFFFE7DLLU:
	5460	+case 0xFFFFFFFFFFFFFE70LLU:
5335	5461	/* SP = 0LLU // SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
5336	5462	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5337	5463	/* function requires 21LLU 64-bit chunks of memory (including 0LLU for parameters) */

		@@ -5351,12 +5477,12 @@
5351	5477	{
5352	5478	/CALLEND/
5353	5479	stackbase += 5LLU;
5354		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7CLLU;
	5480	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6FLLU;
5355	5481	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
5356	5482	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
5357	5483	break;
5358	5484	}
5359		-case 0xFFFFFFFFFFFFFE7CLLU:
	5485	+case 0xFFFFFFFFFFFFFE6FLLU:
5360	5486	/* SP = 3LLU */
5361	5487	{/* PUSH /stack[stackbase + 3LLU] = 1LLU; }/ SP + 1LLU = 4LLU // SP = 2LLU */
5362	5488	{

		@@ -5364,12 +5490,12 @@
5364	5490	{
5365	5491	/CALLEND/
5366	5492	stackbase += 2LLU;
5367		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7BLLU;
	5493	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6ELLU;
5368	5494	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
5369	5495	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
5370	5496	break;
5371	5497	}
5372		-case 0xFFFFFFFFFFFFFE7BLLU:
	5498	+case 0xFFFFFFFFFFFFFE6ELLU:
5373	5499	/* SP = 0LLU /fputs("]", stdout); / SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
5374	5500	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5375	5501	/* function requires 16LLU 64-bit chunks of memory (including 0LLU for parameters) */

		@@ -5386,12 +5512,12 @@
5386	5512	{
5387	5513	/CALLEND/
5388	5514	stackbase += 2LLU;
5389		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE7ALLU;
	5515	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6DLLU;
5390	5516	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
5391	5517	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
5392	5518	break;
5393	5519	}
5394		-case 0xFFFFFFFFFFFFFE7ALLU:
	5520	+case 0xFFFFFFFFFFFFFE6DLLU:
5395	5521	/* SP = 0LLU */
5396	5522	{
5397	5523	/* CALLBEGIN */

		@@ -5402,12 +5528,12 @@
5402	5528	{
5403	5529	/CALLEND/
5404	5530	stackbase += 2LLU;
5405		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE79LLU;
	5531	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6CLLU;
5406	5532	fnaddr = /TOP_END___/0x50F40014E1000000LLU;/* SP = 0LLU */
5407	5533	{ if(stackbase + 0LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_END___/\n"); exit(-1); } }
5408	5534	break;
5409	5535	}
5410		-case 0xFFFFFFFFFFFFFE79LLU:
	5536	+case 0xFFFFFFFFFFFFFE6CLLU:
5411	5537	/* SP = 0LLU // SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
5412	5538	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5413	5539	/* function requires 18LLU 64-bit chunks of memory (including 0LLU for parameters) */

		@@ -5421,12 +5547,12 @@
5421	5547	{
5422	5548	/CALLEND/
5423	5549	stackbase += 3LLU;
5424		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE78LLU;
	5550	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6BLLU;
5425	5551	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
5426	5552	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
5427	5553	break;
5428	5554	}
5429		-case 0xFFFFFFFFFFFFFE78LLU:
	5555	+case 0xFFFFFFFFFFFFFE6BLLU:
5430	5556	/* SP = 1LLU */fputs(" = ", stdout);
5431	5557	{
5432	5558	/* CALLBEGIN */

		@@ -5438,12 +5564,12 @@
5438	5564	{
5439	5565	/CALLEND/
5440	5566	stackbase += 3LLU;
5441		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE77LLU;
	5567	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6ALLU;
5442	5568	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
5443	5569	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
5444	5570	break;
5445	5571	}
5446		-case 0xFFFFFFFFFFFFFE77LLU:
	5572	+case 0xFFFFFFFFFFFFFE6ALLU:
5447	5573	/* SP = 1LLU */
5448	5574	{
5449	5575	/* CALLBEGIN */

		@@ -5454,12 +5580,12 @@
5454	5580	{
5455	5581	/CALLEND/
5456	5582	stackbase += 3LLU;
5457		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE76LLU;
	5583	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE69LLU;
5458	5584	fnaddr = /TOP_END___/0x50F40014E1000000LLU;/* SP = 0LLU */
5459	5585	{ if(stackbase + 0LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_END___/\n"); exit(-1); } }
5460	5586	break;
5461	5587	}
5462		-case 0xFFFFFFFFFFFFFE76LLU:
	5588	+case 0xFFFFFFFFFFFFFE69LLU:
5463	5589	/* SP = 1LLU // SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
5464	5590	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5465	5591	/* function requires 19LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -5474,12 +5600,12 @@
5474	5600	{
5475	5601	/CALLEND/
5476	5602	stackbase += 4LLU;
5477		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE75LLU;
	5603	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE68LLU;
5478	5604	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
5479	5605	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
5480	5606	break;
5481	5607	}
5482		-case 0xFFFFFFFFFFFFFE75LLU:
	5608	+case 0xFFFFFFFFFFFFFE68LLU:
5483	5609	/* SP = 2LLU */fputs(" >= ", stdout);
5484	5610	{
5485	5611	/* CALLBEGIN */

		@@ -5496,22 +5622,22 @@
5496	5622	{
5497	5623	/CALLEND/
5498	5624	stackbase += 7LLU;
5499		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE74LLU;
	5625	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE67LLU;
5500	5626	fnaddr = /MEMSIZEGET/0x34535325A1471540LLU;/* SP = 0LLU */
5501	5627	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /MEMSIZEGET/\n"); exit(-1); } }
5502	5628	break;
5503	5629	}
5504		-case 0xFFFFFFFFFFFFFE74LLU:
	5630	+case 0xFFFFFFFFFFFFFE67LLU:
5505	5631	/* SP = 5LLU */
5506	5632	{
5507	5633	/CALLEND/
5508	5634	stackbase += 4LLU;
5509		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE73LLU;
	5635	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE66LLU;
5510	5636	fnaddr = /printhexnr/0xAED929BE3833A6D0LLU;/* SP = 0LLU */
5511	5637	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printhexnr/\n"); exit(-1); } }
5512	5638	break;
5513	5639	}
5514		-case 0xFFFFFFFFFFFFFE73LLU:
	5640	+case 0xFFFFFFFFFFFFFE66LLU:
5515	5641	/* SP = 2LLU */fputs(") { fprintf(stderr, \"STACKOVERFLOW calling ", stdout);
5516	5642	{
5517	5643	/* CALLBEGIN */

		@@ -5523,12 +5649,12 @@
5523	5649	{
5524	5650	/CALLEND/
5525	5651	stackbase += 4LLU;
5526		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE72LLU;
	5652	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE65LLU;
5527	5653	fnaddr = /commentid_/0x7AAA28829BE47C00LLU;/* SP = 0LLU */
5528	5654	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /commentid_/\n"); exit(-1); } }
5529	5655	break;
5530	5656	}
5531		-case 0xFFFFFFFFFFFFFE72LLU:
	5657	+case 0xFFFFFFFFFFFFFE65LLU:
5532	5658	/* SP = 2LLU /fputs("\\n\"); exit(-1); } }", stdout); / SP = 2LLU // SP - 0LLU = 2LLU // RESULT */
5533	5659	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5534	5660	/* function requires 18LLU 64-bit chunks of memory (including 2LLU for parameters) */

		@@ -5543,12 +5669,12 @@
5543	5669	{
5544	5670	/CALLEND/
5545	5671	stackbase += 5LLU;
5546		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE70LLU;
	5672	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE63LLU;
5547	5673	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
5548	5674	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
5549	5675	break;
5550	5676	}
5551		-case 0xFFFFFFFFFFFFFE70LLU:
	5677	+case 0xFFFFFFFFFFFFFE63LLU:
5552	5678	/* SP = 3LLU */
5553	5679	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 4LLU */
5554	5680	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 5LLU // SP = 3LLU */

		@@ -5557,16 +5683,16 @@
5557	5683	{
5558	5684	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 2LLU] < stack[stackbase + 3LLU]; }/ SP + 1LLU = 3LLU */ }
5559	5685	if(!/* SP - 1LLU = 2LLU // POP */stack[stackbase + 2LLU])
5560		-{ /* JUMP / fnaddr = 18446744073709551217LLU; break; } / skip consequent */
	5686	+{ /* JUMP / fnaddr = 18446744073709551204LLU; break; } / skip consequent */
5561	5687	/* consequent */fputs("INTERNAL ERROR: OVERLAP IN PUSH_MULTI\n", stderr);
5562	5688	{/* set exit-value */stack[16LLU] = 255LLU; }
5563	5689	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 2LLU */
5564		-case 18446744073709551217LLU: /* alternative */
	5690	+case 18446744073709551204LLU: /* alternative */
5565	5691	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 3LLU */
5566		-case 0xFFFFFFFFFFFFFE6FLLU: /* loop to here // predicate: counter > 0? */
	5692	+case 0xFFFFFFFFFFFFFE62LLU: /* loop to here // predicate: counter > 0? */
5567	5693
5568	5694	if(!stack[stackbase + 2LLU]--)
5569		-{ /* JUMP / fnaddr = 18446744073709551214LLU; break; } / skip loop */
	5695	+{ /* JUMP / fnaddr = 18446744073709551201LLU; break; } / skip loop */
5570	5696	/* loop */
5571	5697	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 4LLU */
5572	5698	{/* PUSH /stack[stackbase + 4LLU] = 1LLU; }/ SP + 1LLU = 5LLU // SP = 3LLU */

		@@ -5582,12 +5708,12 @@
5582	5708	{
5583	5709	/CALLEND/
5584	5710	stackbase += 5LLU;
5585		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6DLLU;
	5711	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE60LLU;
5586	5712	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
5587	5713	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); } }
5588	5714	break;
5589	5715	}
5590		-case 0xFFFFFFFFFFFFFE6DLLU:
	5716	+case 0xFFFFFFFFFFFFFE60LLU:
5591	5717	/* SP = 3LLU */
5592	5718	{
5593	5719	/* CALLBEGIN */

		@@ -5599,12 +5725,12 @@
5599	5725	{
5600	5726	/CALLEND/
5601	5727	stackbase += 5LLU;
5602		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6CLLU;
	5728	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5FLLU;
5603	5729	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
5604	5730	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
5605	5731	break;
5606	5732	}
5607		-case 0xFFFFFFFFFFFFFE6CLLU:
	5733	+case 0xFFFFFFFFFFFFFE5FLLU:
5608	5734	/* SP = 3LLU */
5609	5735	{
5610	5736	/* CALLBEGIN */

		@@ -5615,12 +5741,12 @@
5615	5741	{
5616	5742	/CALLEND/
5617	5743	stackbase += 5LLU;
5618		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE6BLLU;
	5744	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5ELLU;
5619	5745	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
5620	5746	{ if(stackbase + 21LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); } }
5621	5747	break;
5622	5748	}
5623		-case 0xFFFFFFFFFFFFFE6BLLU:
	5749	+case 0xFFFFFFFFFFFFFE5ELLU:
5624	5750	/* SP = 3LLU */
5625	5751	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 4LLU */
5626	5752	{/* PUSH /stack[stackbase + 4LLU] = 1LLU; }/ SP + 1LLU = 5LLU // SP = 3LLU */

		@@ -5627,8 +5753,8 @@
5627	5753	{
5628	5754	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 3LLU] + stack[stackbase + 4LLU]; }/ SP + 1LLU = 4LLU / }/ SP = 3LLU // assign */
5629	5755	{ /* RESULT /stack[stackbase + 0LLU] = stack[stackbase + 3LLU]; }/ SP = 3LLU */
5630		-{ /* JUMP / fnaddr = 18446744073709551215LLU; break; } / loop */
5631		-case 18446744073709551214LLU: /* skip to here // SP = 2LLU // SP - 0LLU = 2LLU // RESULT */
	5756	+{ /* JUMP / fnaddr = 18446744073709551202LLU; break; } / loop */
	5757	+case 18446744073709551201LLU: /* skip to here // SP = 2LLU // SP - 0LLU = 2LLU // RESULT */
5632	5758	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5633	5759	/* function requires 26LLU 64-bit chunks of memory (including 2LLU for parameters) */
5634	5760	case /STACK_COPY/0x4D40432C00CF4190LLU:/* SP = 3LLU // SPMAX = 3LLU // predicate */

		@@ -5638,13 +5764,13 @@
5638	5764	{
5639	5765	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 3LLU] < stack[stackbase + 4LLU]; }/ SP + 1LLU = 4LLU */ }
5640	5766	if(!/* SP - 1LLU = 3LLU // POP */stack[stackbase + 3LLU])
5641		-{ /* JUMP / fnaddr = 18446744073709551210LLU; break; } / skip consequent */
	5767	+{ /* JUMP / fnaddr = 18446744073709551197LLU; break; } / skip consequent */
5642	5768	/* consequent */
5643	5769	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 4LLU */
5644		-case 0xFFFFFFFFFFFFFE68LLU: /* loop to here // predicate: counter > 0? */
	5770	+case 0xFFFFFFFFFFFFFE5BLLU: /* loop to here // predicate: counter > 0? */
5645	5771
5646	5772	if(!stack[stackbase + 3LLU]--)
5647		-{ /* JUMP / fnaddr = 18446744073709551207LLU; break; } / skip loop */
	5773	+{ /* JUMP / fnaddr = 18446744073709551194LLU; break; } / skip loop */
5648	5774	/* loop */
5649	5775	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 5LLU */
5650	5776	{/* PUSH /stack[stackbase + 5LLU] = 1LLU; }/ SP + 1LLU = 6LLU // SPMAX = 6LLU // SP = 4LLU */

		@@ -5664,12 +5790,12 @@
5664	5790	{
5665	5791	/CALLEND/
5666	5792	stackbase += 6LLU;
5667		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE66LLU;
	5793	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE59LLU;
5668	5794	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
5669	5795	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
5670	5796	break;
5671	5797	}
5672		-case 0xFFFFFFFFFFFFFE66LLU:
	5798	+case 0xFFFFFFFFFFFFFE59LLU:
5673	5799	/* SP = 4LLU */fputs(" = ", stdout);
5674	5800	{
5675	5801	/* CALLBEGIN */

		@@ -5684,23 +5810,23 @@
5684	5810	{
5685	5811	/CALLEND/
5686	5812	stackbase += 6LLU;
5687		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE65LLU;
	5813	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE58LLU;
5688	5814	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
5689	5815	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
5690	5816	break;
5691	5817	}
5692		-case 0xFFFFFFFFFFFFFE65LLU:
	5818	+case 0xFFFFFFFFFFFFFE58LLU:
5693	5819	/* SP = 4LLU /fputs("; }", stdout); / SP = 4LLU */
5694		-{ /* JUMP / fnaddr = 18446744073709551208LLU; break; } / loop */
5695		-case 18446744073709551207LLU: /* skip to here // SP = 3LLU // SP = 3LLU */
5696		-{ /* JUMP / fnaddr = 18446744073709551209LLU; break; } / skip alternative */
5697		-case 18446744073709551210LLU: /* alternative */
	5820	+{ /* JUMP / fnaddr = 18446744073709551195LLU; break; } / loop */
	5821	+case 18446744073709551194LLU: /* skip to here // SP = 3LLU // SP = 3LLU */
	5822	+{ /* JUMP / fnaddr = 18446744073709551196LLU; break; } / skip alternative */
	5823	+case 18446744073709551197LLU: /* alternative */
5698	5824	{/* PUSH /stack[stackbase + 3LLU] = 0LLU; }/ SP + 1LLU = 4LLU */
5699	5825	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 5LLU */
5700		-case 0xFFFFFFFFFFFFFE64LLU: /* loop to here // predicate: counter > 0? */
	5826	+case 0xFFFFFFFFFFFFFE57LLU: /* loop to here // predicate: counter > 0? */
5701	5827
5702	5828	if(!stack[stackbase + 4LLU]--)
5703		-{ /* JUMP / fnaddr = 18446744073709551203LLU; break; } / skip loop */
	5829	+{ /* JUMP / fnaddr = 18446744073709551190LLU; break; } / skip loop */
5704	5830	/* loop /fputs("\n{ / RESULT */", stdout);
5705	5831	{
5706	5832	/* CALLBEGIN */

		@@ -5715,12 +5841,12 @@
5715	5841	{
5716	5842	/CALLEND/
5717	5843	stackbase += 7LLU;
5718		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE62LLU;
	5844	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE55LLU;
5719	5845	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
5720	5846	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
5721	5847	break;
5722	5848	}
5723		-case 0xFFFFFFFFFFFFFE62LLU:
	5849	+case 0xFFFFFFFFFFFFFE55LLU:
5724	5850	/* SP = 5LLU */fputs(" = ", stdout);
5725	5851	{
5726	5852	/* CALLBEGIN */

		@@ -5735,12 +5861,12 @@
5735	5861	{
5736	5862	/CALLEND/
5737	5863	stackbase += 7LLU;
5738		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE61LLU;
	5864	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE54LLU;
5739	5865	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
5740	5866	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
5741	5867	break;
5742	5868	}
5743		-case 0xFFFFFFFFFFFFFE61LLU:
	5869	+case 0xFFFFFFFFFFFFFE54LLU:
5744	5870	/* SP = 5LLU */fputs("; }", stdout);
5745	5871	{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 6LLU */
5746	5872	{/* PUSH /stack[stackbase + 6LLU] = 1LLU; }/ SP + 1LLU = 7LLU // SP = 5LLU */

		@@ -5747,9 +5873,9 @@
5747	5873	{
5748	5874	{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 5LLU] + stack[stackbase + 6LLU]; }/ SP + 1LLU = 6LLU / }/ SP = 5LLU // assign */
5749	5875	{ /* RESULT /stack[stackbase + 3LLU] = stack[stackbase + 5LLU]; }/ SP = 5LLU */
5750		-{ /* JUMP / fnaddr = 18446744073709551204LLU; break; } / loop */
5751		-case 18446744073709551203LLU: /* skip to here // SP = 3LLU */
5752		-case 18446744073709551209LLU: /* skip to here */
	5876	+{ /* JUMP / fnaddr = 18446744073709551191LLU; break; } / loop */
	5877	+case 18446744073709551190LLU: /* skip to here // SP = 3LLU */
	5878	+case 18446744073709551196LLU: /* skip to here */
5753	5879	/* SP = 3LLU // SP - 0LLU = 3LLU // RESULT */
5754	5880	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
5755	5881	/* function requires 24LLU 64-bit chunks of memory (including 3LLU for parameters) */

		@@ -5764,12 +5890,12 @@
5764	5890	{
5765	5891	/CALLEND/
5766	5892	stackbase += 3LLU;
5767		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE60LLU;
	5893	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE53LLU;
5768	5894	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
5769	5895	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
5770	5896	break;
5771	5897	}
5772		-case 0xFFFFFFFFFFFFFE60LLU:
	5898	+case 0xFFFFFFFFFFFFFE53LLU:
5773	5899	/* SP = 1LLU /fputs(" returned values /", stdout);
5774	5900	{
5775	5901	/* CALLBEGIN */

		@@ -5781,12 +5907,12 @@
5781	5907	{
5782	5908	/CALLEND/
5783	5909	stackbase += 3LLU;
5784		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5FLLU;
	5910	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE52LLU;
5785	5911	fnaddr = /SP_ADD____/0x4D00011040000000LLU;/* SP = 0LLU */
5786	5912	{ if(stackbase + 19LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_ADD____/\n"); exit(-1); } }
5787	5913	break;
5788	5914	}
5789		-case 0xFFFFFFFFFFFFFE5FLLU:
	5915	+case 0xFFFFFFFFFFFFFE52LLU:
5790	5916	/* SP = 1LLU */
5791	5917	{
5792	5918	/* CALLBEGIN */

		@@ -5797,12 +5923,12 @@
5797	5923	{
5798	5924	/CALLEND/
5799	5925	stackbase += 4LLU;
5800		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5ELLU;
	5926	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE51LLU;
5801	5927	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
5802	5928	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
5803	5929	break;
5804	5930	}
5805		-case 0xFFFFFFFFFFFFFE5ELLU:
	5931	+case 0xFFFFFFFFFFFFFE51LLU:
5806	5932	/* SP = 2LLU */
5807	5933	{
5808	5934	/* CALLBEGIN */

		@@ -5813,12 +5939,12 @@
5813	5939	{
5814	5940	/CALLEND/
5815	5941	stackbase += 4LLU;
5816		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5DLLU;
	5942	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE50LLU;
5817	5943	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
5818	5944	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); } }
5819	5945	break;
5820	5946	}
5821		-case 0xFFFFFFFFFFFFFE5DLLU:
	5947	+case 0xFFFFFFFFFFFFFE50LLU:
5822	5948	/* SP = 2LLU */fputs("stackbase", stdout);
5823	5949	{
5824	5950	/* CALLBEGIN */

		@@ -5829,12 +5955,12 @@
5829	5955	{
5830	5956	/CALLEND/
5831	5957	stackbase += 4LLU;
5832		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5CLLU;
	5958	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4FLLU;
5833	5959	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
5834	5960	{ if(stackbase + 21LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); } }
5835	5961	break;
5836	5962	}
5837		-case 0xFFFFFFFFFFFFFE5CLLU:
	5963	+case 0xFFFFFFFFFFFFFE4FLLU:
5838	5964	/* SP = 2LLU /fputs("\n / leave place for return addr */", stdout);
5839	5965	{
5840	5966	/* CALLBEGIN */

		@@ -5846,12 +5972,12 @@
5846	5972	{
5847	5973	/CALLEND/
5848	5974	stackbase += 4LLU;
5849		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5BLLU;
	5975	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4ELLU;
5850	5976	fnaddr = /SP_ADD____/0x4D00011040000000LLU;/* SP = 0LLU */
5851	5977	{ if(stackbase + 19LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_ADD____/\n"); exit(-1); } }
5852	5978	break;
5853	5979	}
5854		-case 0xFFFFFFFFFFFFFE5BLLU:
	5980	+case 0xFFFFFFFFFFFFFE4ELLU:
5855	5981	/* SP = 2LLU */fputs("\n }", stdout);
5856	5982	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 3LLU // SP - 1LLU = 2LLU // RESULT */
5857	5983	{ /* RESULT /stack[stackbase + 1LLU] = stack[stackbase + 2LLU]; }/ SP = 2LLU // SP - 1LLU = 1LLU // RESULT */

		@@ -5874,12 +6000,12 @@
5874	6000	{
5875	6001	/CALLEND/
5876	6002	stackbase += 9LLU;
5877		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE5ALLU;
	6003	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4DLLU;
5878	6004	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
5879	6005	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
5880	6006	break;
5881	6007	}
5882		-case 0xFFFFFFFFFFFFFE5ALLU:
	6008	+case 0xFFFFFFFFFFFFFE4DLLU:
5883	6009	/* SP = 7LLU */
5884	6010	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 8LLU // SP = 6LLU */
5885	6011	{

		@@ -5887,12 +6013,12 @@
5887	6013	{
5888	6014	/CALLEND/
5889	6015	stackbase += 6LLU;
5890		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE59LLU;
	6016	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4CLLU;
5891	6017	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
5892	6018	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
5893	6019	break;
5894	6020	}
5895		-case 0xFFFFFFFFFFFFFE59LLU:
	6021	+case 0xFFFFFFFFFFFFFE4CLLU:
5896	6022	/* SP = 4LLU */fputs(";", stdout); fputs("\n stack[stackbase - 1] = ", stdout);
5897	6023	{
5898	6024	/* CALLBEGIN */

		@@ -5909,12 +6035,12 @@
5909	6035	{
5910	6036	/CALLEND/
5911	6037	stackbase += 9LLU;
5912		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE58LLU;
	6038	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4BLLU;
5913	6039	fnaddr = /ADDRGET___/0x0441121C55000000LLU;/* SP = 0LLU */
5914	6040	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ADDRGET___/\n"); exit(-1); } }
5915	6041	break;
5916	6042	}
5917		-case 0xFFFFFFFFFFFFFE58LLU:
	6043	+case 0xFFFFFFFFFFFFFE4BLLU:
5918	6044	/* SP = 7LLU */
5919	6045	{/* PUSH /stack[stackbase + 7LLU] = 1LLU; }/ SP + 1LLU = 8LLU // SP = 6LLU */
5920	6046	{

		@@ -5922,12 +6048,12 @@
5922	6048	{
5923	6049	/CALLEND/
5924	6050	stackbase += 6LLU;
5925		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE57LLU;
	6051	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4ALLU;
5926	6052	fnaddr = /printhexnr/0xAED929BE3833A6D0LLU;/* SP = 0LLU */
5927	6053	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printhexnr/\n"); exit(-1); } }
5928	6054	break;
5929	6055	}
5930		-case 0xFFFFFFFFFFFFFE57LLU:
	6056	+case 0xFFFFFFFFFFFFFE4ALLU:
5931	6057	/* SP = 4LLU */fputs(";", stdout); fputs("\n fnaddr = ", stdout);
5932	6058	{
5933	6059	/* CALLBEGIN */

		@@ -5939,12 +6065,12 @@
5939	6065	{
5940	6066	/CALLEND/
5941	6067	stackbase += 6LLU;
5942		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE56LLU;
	6068	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE49LLU;
5943	6069	fnaddr = /printid___/0xAED929BE47C00000LLU;/* SP = 0LLU */
5944	6070	{ if(stackbase + 10LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printid___/\n"); exit(-1); } }
5945	6071	break;
5946	6072	}
5947		-case 0xFFFFFFFFFFFFFE56LLU:
	6073	+case 0xFFFFFFFFFFFFFE49LLU:
5948	6074	/* SP = 4LLU */fputs(";", stdout);
5949	6075	{
5950	6076	/* CALLBEGIN */

		@@ -5956,12 +6082,12 @@
5956	6082	{
5957	6083	/CALLEND/
5958	6084	stackbase += 6LLU;
5959		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE55LLU;
	6085	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE48LLU;
5960	6086	fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
5961	6087	{ if(stackbase + 19LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); } }
5962	6088	break;
5963	6089	}
5964		-case 0xFFFFFFFFFFFFFE55LLU:
	6090	+case 0xFFFFFFFFFFFFFE48LLU:
5965	6091	/* SP = 4LLU */
5966	6092	{
5967	6093	/* CALLBEGIN */

		@@ -5974,12 +6100,12 @@
5974	6100	{
5975	6101	/CALLEND/
5976	6102	stackbase += 6LLU;
5977		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE54LLU;
	6103	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE47LLU;
5978	6104	fnaddr = /STACKCHECK/0x4D40432C32050CB0LLU;/* SP = 0LLU */
5979	6105	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /STACKCHECK/\n"); exit(-1); } }
5980	6106	break;
5981	6107	}
5982		-case 0xFFFFFFFFFFFFFE54LLU:
	6108	+case 0xFFFFFFFFFFFFFE47LLU:
5983	6109	/* SP = 4LLU */fputs("\n break;", stdout); fputs("\n }", stdout); fputs("\ncase ", stdout);
5984	6110	{
5985	6111	/* CALLBEGIN */

		@@ -5996,22 +6122,22 @@
5996	6122	{
5997	6123	/CALLEND/
5998	6124	stackbase += 9LLU;
5999		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE53LLU;
	6125	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE46LLU;
6000	6126	fnaddr = /ADDRNEXT__/0x0441123856140000LLU;/* SP = 0LLU */
6001	6127	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ADDRNEXT__/\n"); exit(-1); } }
6002	6128	break;
6003	6129	}
6004		-case 0xFFFFFFFFFFFFFE53LLU:
	6130	+case 0xFFFFFFFFFFFFFE46LLU:
6005	6131	/* SP = 7LLU */
6006	6132	{
6007	6133	/CALLEND/
6008	6134	stackbase += 6LLU;
6009		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE52LLU;
	6135	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE45LLU;
6010	6136	fnaddr = /printhexnr/0xAED929BE3833A6D0LLU;/* SP = 0LLU */
6011	6137	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printhexnr/\n"); exit(-1); } }
6012	6138	break;
6013	6139	}
6014		-case 0xFFFFFFFFFFFFFE52LLU:
	6140	+case 0xFFFFFFFFFFFFFE45LLU:
6015	6141	/* SP = 4LLU */fputs(":\n", stdout);
6016	6142	{
6017	6143	/* CALLBEGIN */

		@@ -6023,12 +6149,12 @@
6023	6149	{
6024	6150	/CALLEND/
6025	6151	stackbase += 6LLU;
6026		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE51LLU;
	6152	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE44LLU;
6027	6153	fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
6028	6154	{ if(stackbase + 19LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); } }
6029	6155	break;
6030	6156	}
6031		-case 0xFFFFFFFFFFFFFE51LLU:
	6157	+case 0xFFFFFFFFFFFFFE44LLU:
6032	6158	/* SP = 4LLU // SP = 4LLU // SP - 0LLU = 4LLU // RESULT */
6033	6159	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6034	6160	/* function requires 25LLU 64-bit chunks of memory (including 4LLU for parameters) */

		@@ -6046,12 +6172,12 @@
6046	6172	{
6047	6173	/CALLEND/
6048	6174	stackbase += 3LLU;
6049		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE50LLU;
	6175	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE43LLU;
6050	6176	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
6051	6177	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
6052	6178	break;
6053	6179	}
6054		-case 0xFFFFFFFFFFFFFE50LLU:
	6180	+case 0xFFFFFFFFFFFFFE43LLU:
6055	6181	/* SP = 1LLU /fputs("; break; }", stdout); / SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
6056	6182	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6057	6183	/* function requires 17LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -6071,22 +6197,22 @@
6071	6197	{
6072	6198	/CALLEND/
6073	6199	stackbase += 5LLU;
6074		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4FLLU;
	6200	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE42LLU;
6075	6201	fnaddr = /parsenr___/0xADCB6E829B400000LLU;/* SP = 0LLU */
6076	6202	{ if(stackbase + 12LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsenr___/\n"); exit(-1); } }
6077	6203	break;
6078	6204	}
6079		-case 0xFFFFFFFFFFFFFE4FLLU:
	6205	+case 0xFFFFFFFFFFFFFE42LLU:
6080	6206	/* SP = 3LLU */
6081	6207	{
6082	6208	/CALLEND/
6083	6209	stackbase += 2LLU;
6084		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4ELLU;
	6210	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE41LLU;
6085	6211	fnaddr = /DEREF_____/0x1054851800000000LLU;/* SP = 0LLU */
6086	6212	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /DEREF_____/\n"); exit(-1); } }
6087	6213	break;
6088	6214	}
6089		-case 0xFFFFFFFFFFFFFE4ELLU:
	6215	+case 0xFFFFFFFFFFFFFE41LLU:
6090	6216	/* SP = 0LLU // SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
6091	6217	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6092	6218	/* function requires 19LLU 64-bit chunks of memory (including 0LLU for parameters) */

		@@ -6100,12 +6226,12 @@
6100	6226	{
6101	6227	/CALLEND/
6102	6228	stackbase += 2LLU;
6103		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4DLLU;
	6229	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE40LLU;
6104	6230	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
6105	6231	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); } }
6106	6232	break;
6107	6233	}
6108		-case 0xFFFFFFFFFFFFFE4DLLU:
	6234	+case 0xFFFFFFFFFFFFFE40LLU:
6109	6235	/* SP = 0LLU */
6110	6236	{
6111	6237	/* CALLBEGIN */

		@@ -6116,12 +6242,12 @@
6116	6242	{
6117	6243	/CALLEND/
6118	6244	stackbase += 2LLU;
6119		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4CLLU;
	6245	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3FLLU;
6120	6246	fnaddr = /parseglob_/0xADCB6E8229EA7400LLU;/* SP = 0LLU */
6121	6247	{ if(stackbase + 19LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseglob_/\n"); exit(-1); } }
6122	6248	break;
6123	6249	}
6124		-case 0xFFFFFFFFFFFFFE4CLLU:
	6250	+case 0xFFFFFFFFFFFFFE3FLLU:
6125	6251	/* SP = 0LLU */
6126	6252	{
6127	6253	/* CALLBEGIN */

		@@ -6132,12 +6258,12 @@
6132	6258	{
6133	6259	/CALLEND/
6134	6260	stackbase += 2LLU;
6135		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE4BLLU;
	6261	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3ELLU;
6136	6262	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
6137	6263	{ if(stackbase + 21LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); } }
6138	6264	break;
6139	6265	}
6140		-case 0xFFFFFFFFFFFFFE4BLLU:
	6266	+case 0xFFFFFFFFFFFFFE3ELLU:
6141	6267	/* SP = 0LLU // SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
6142	6268	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6143	6269	/* function requires 23LLU 64-bit chunks of memory (including 0LLU for parameters) */

		@@ -6152,12 +6278,12 @@
6152	6278	{
6153	6279	/CALLEND/
6154	6280	stackbase += 8LLU;
6155		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE49LLU;
	6281	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3CLLU;
6156	6282	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
6157	6283	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
6158	6284	break;
6159	6285	}
6160		-case 0xFFFFFFFFFFFFFE49LLU:
	6286	+case 0xFFFFFFFFFFFFFE3CLLU:
6161	6287	/* SP = 6LLU */
6162	6288	{/* PUSH /stack[stackbase + 6LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 7LLU */
6163	6289	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 8LLU // SP - 4LLU = 4LLU */

		@@ -6176,12 +6302,12 @@
6176	6302	{
6177	6303	/CALLEND/
6178	6304	stackbase += 9LLU;
6179		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE48LLU;
	6305	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3BLLU;
6180	6306	fnaddr = /typeislist/0xBF4AE092E9E4BAF0LLU;/* SP = 0LLU */
6181	6307	{ if(stackbase + 5LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeislist/\n"); exit(-1); } }
6182	6308	break;
6183	6309	}
6184		-case 0xFFFFFFFFFFFFFE48LLU:
	6310	+case 0xFFFFFFFFFFFFFE3BLLU:
6185	6311	/* SP = 7LLU */
6186	6312	{ /* TOP /stack[stackbase + 6LLU] = !/ TOP /stack[stackbase + 6LLU]; }/ SP = 5LLU */
6187	6313	{

		@@ -6189,7 +6315,7 @@
6189	6315	{
6190	6316	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 4LLU] && stack[stackbase + 5LLU]; }/ SP + 1LLU = 5LLU */ }
6191	6317	if(!/* SP - 1LLU = 4LLU // POP */stack[stackbase + 4LLU])
6192		-{ /* JUMP / fnaddr = 18446744073709551178LLU; break; } / skip consequent */
	6318	+{ /* JUMP / fnaddr = 18446744073709551165LLU; break; } / skip consequent */
6193	6319	/* consequent */
6194	6320	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("expected type u64, but found type ", stderr);
6195	6321	{

		@@ -6203,12 +6329,12 @@
6203	6329	{
6204	6330	/CALLEND/
6205	6331	stackbase += 6LLU;
6206		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE47LLU;
	6332	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3ALLU;
6207	6333	fnaddr = /reporttype/0xB60AEAB6FBF4AE00LLU;/* SP = 0LLU */
6208	6334	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reporttype/\n"); exit(-1); } }
6209	6335	break;
6210	6336	}
6211		-case 0xFFFFFFFFFFFFFE47LLU:
	6337	+case 0xFFFFFFFFFFFFFE3ALLU:
6212	6338	/* SP = 4LLU */fputs(" - can't assign non-zero value ", stderr);
6213	6339	{
6214	6340	/* CALLBEGIN */

		@@ -6220,16 +6346,16 @@
6220	6346	{
6221	6347	/CALLEND/
6222	6348	stackbase += 6LLU;
6223		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE46LLU;
	6349	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE39LLU;
6224	6350	fnaddr = /reportnr__/0xB60AEAB6FA6D0000LLU;/* SP = 0LLU */
6225	6351	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportnr__/\n"); exit(-1); } }
6226	6352	break;
6227	6353	}
6228		-case 0xFFFFFFFFFFFFFE46LLU:
	6354	+case 0xFFFFFFFFFFFFFE39LLU:
6229	6355	/* SP = 4LLU */
6230	6356	{/* set exit-value */stack[16LLU] = 255LLU; }
6231	6357	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 4LLU */
6232		-case 18446744073709551178LLU: /* alternative */
	6358	+case 18446744073709551165LLU: /* alternative */
6233	6359	{
6234	6360	/* CALLBEGIN */
6235	6361	/* reserve space for 1LLU returned values // SP + 1LLU = 5LLU */

		@@ -6242,18 +6368,18 @@
6242	6368	{
6243	6369	/CALLEND/
6244	6370	stackbase += 7LLU;
6245		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE45LLU;
	6371	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE38LLU;
6246	6372	fnaddr = /typesize__/0xBF4AE0BA4D600000LLU;/* SP = 0LLU */
6247	6373	{ if(stackbase + 41LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typesize__/\n"); exit(-1); } }
6248	6374	break;
6249	6375	}
6250		-case 0xFFFFFFFFFFFFFE45LLU:
	6376	+case 0xFFFFFFFFFFFFFE38LLU:
6251	6377	/* SP = 5LLU */
6252	6378	{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 6LLU */
6253		-case 0xFFFFFFFFFFFFFE44LLU: /* loop to here // predicate: counter > 0? */
	6379	+case 0xFFFFFFFFFFFFFE37LLU: /* loop to here // predicate: counter > 0? */
6254	6380
6255	6381	if(!stack[stackbase + 5LLU]--)
6256		-{ /* JUMP / fnaddr = 18446744073709551171LLU; break; } / skip loop */
	6382	+{ /* JUMP / fnaddr = 18446744073709551158LLU; break; } / skip loop */
6257	6383	/* loop */
6258	6384	{/* PUSH /stack[stackbase + 6LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 7LLU */
6259	6385	{/* PUSH /stack[stackbase + 7LLU] = 1LLU; }/ SP + 1LLU = 8LLU // SP = 6LLU */

		@@ -6270,19 +6396,19 @@
6270	6396	{
6271	6397	/CALLEND/
6272	6398	stackbase += 8LLU;
6273		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE42LLU;
	6399	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE35LLU;
6274	6400	fnaddr = /PUSH______/0x4154C80000000000LLU;/* SP = 0LLU */
6275	6401	{ if(stackbase + 24LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH______/\n"); exit(-1); } }
6276	6402	break;
6277	6403	}
6278		-case 0xFFFFFFFFFFFFFE42LLU:
	6404	+case 0xFFFFFFFFFFFFFE35LLU:
6279	6405	/* SP = 6LLU // SP = 6LLU */
6280		-{ /* JUMP / fnaddr = 18446744073709551172LLU; break; } / loop */
6281		-case 18446744073709551171LLU: /* skip to here // SP = 4LLU // SP - 0LLU = 4LLU // RESULT */
	6406	+{ /* JUMP / fnaddr = 18446744073709551159LLU; break; } / loop */
	6407	+case 18446744073709551158LLU: /* skip to here // SP = 4LLU // SP - 0LLU = 4LLU // RESULT */
6282	6408	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6283	6409	/* function requires 48LLU 64-bit chunks of memory (including 4LLU for parameters) */
6284	6410	case /verbatim__/0xC60B5D72F9280000LLU:/* SP = 0LLU */
6285		-case 0xFFFFFFFFFFFFFE41LLU: /* loop to here // predicate */
	6411	+case 0xFFFFFFFFFFFFFE34LLU: /* loop to here // predicate */
6286	6412
6287	6413	{
6288	6414	/* CALLBEGIN */

		@@ -6293,12 +6419,12 @@
6293	6419	{
6294	6420	/CALLEND/
6295	6421	stackbase += 3LLU;
6296		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE40LLU;
	6422	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE33LLU;
6297	6423	fnaddr = /get_______/0x8A0BC00000000000LLU;/* SP = 0LLU */
6298	6424	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /get_______/\n"); exit(-1); } }
6299	6425	break;
6300	6426	}
6301		-case 0xFFFFFFFFFFFFFE40LLU:
	6427	+case 0xFFFFFFFFFFFFFE33LLU:
6302	6428	/* SP = 1LLU // predicate */
6303	6429
6304	6430	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU */

		@@ -6306,12 +6432,12 @@
6306	6432	{
6307	6433	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 1LLU] > stack[stackbase + 2LLU]; }/ SP + 1LLU = 2LLU */ }
6308	6434	if(!/* SP - 1LLU = 1LLU // POP */stack[stackbase + 1LLU])
6309		-{ /* JUMP / fnaddr = 18446744073709551167LLU; break; } / skip consequent */
	6435	+{ /* JUMP / fnaddr = 18446744073709551154LLU; break; } / skip consequent */
6310	6436	/* consequent */
6311	6437	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("EOF in verbatim\n", stderr);
6312	6438	{/* set exit-value */stack[16LLU] = 255LLU; }
6313	6439	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 1LLU */
6314		-case 18446744073709551167LLU: /* alternative // predicate */
	6440	+case 18446744073709551154LLU: /* alternative // predicate */
6315	6441
6316	6442	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU */
6317	6443	{/* PUSH /stack[stackbase + 2LLU] = 96LLU; }/ SP + 1LLU = 3LLU // SP = 1LLU */

		@@ -6318,23 +6444,92 @@
6318	6444	{
6319	6445	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 1LLU] != stack[stackbase + 2LLU]; }/ SP + 1LLU = 2LLU */ }
6320	6446	if(!/* SP - 1LLU = 1LLU // POP */stack[stackbase + 1LLU])
6321		-{ /* JUMP / fnaddr = 18446744073709551166LLU; break; } / skip consequent */
	6447	+{ /* JUMP / fnaddr = 18446744073709551153LLU; break; } / skip consequent */
6322	6448	/* consequent */
6323	6449	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU */
6324	6450	{ fputc(/* TOP */stack[stackbase + 1LLU], stdout); }
6325	6451	{/* PUSH /stack[stackbase + 2LLU] = 1LLU; }/ SP + 1LLU = 3LLU // SP - 1LLU = 2LLU // RESULT */
6326	6452	{ /* RESULT /stack[stackbase + 1LLU] = stack[stackbase + 2LLU]; }/ SP = 2LLU // SP = 1LLU */
6327		-{ /* JUMP / fnaddr = 18446744073709551165LLU; break; } / skip alternative */
6328		-case 18446744073709551166LLU: /* alternative */
	6453	+{ /* JUMP / fnaddr = 18446744073709551152LLU; break; } / skip alternative */
	6454	+case 18446744073709551153LLU: /* alternative */
6329	6455	{/* PUSH /stack[stackbase + 1LLU] = 0LLU; }/ SP + 1LLU = 2LLU // SP - 1LLU = 1LLU // RESULT */
6330	6456	{ /* RESULT /stack[stackbase + 1LLU] = stack[stackbase + 1LLU]; }/ SP = 2LLU */
6331		-case 18446744073709551165LLU: /* skip to here */
	6457	+case 18446744073709551152LLU: /* skip to here */
6332	6458	/* SP - 1LLU = 1LLU // RESULT */
6333	6459	{ /* RESULT /stack[stackbase + 0LLU] = stack[stackbase + 1LLU]; }/ SP = 1LLU */
6334	6460	if(/* SP - 1LLU = 0LLU // POP */stack[stackbase + 0LLU])
6335		-{ /* JUMP / fnaddr = 18446744073709551169LLU; break; } / loop // SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
	6461	+{ /* JUMP / fnaddr = 18446744073709551156LLU; break; } / loop // SP = 0LLU // SP - 0LLU = 0LLU // RESULT */
6336	6462	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6337	6463	/* function requires 5LLU 64-bit chunks of memory (including 0LLU for parameters) */
	6464	+case /parsetoken/0xADCB6E82FAA68290LLU:/* SP = 0LLU */
	6465	+ {
	6466	+ /* CALLBEGIN */
	6467	+ /* reserve space for 0LLU returned values // SP + 0LLU = 0LLU */
	6468	+{/* PUSH /stack[stackbase + 0LLU] = stackbase; }/ SP + 1LLU = 1LLU // SPMAX = 1LLU */
	6469	+ /* leave place for return addr // SP + 1LLU = 2LLU // SPMAX = 2LLU */
	6470	+ }/* SP + 13LLU = 15LLU // SPMAX = 15LLU // SP - 13LLU = 2LLU */
	6471	+ {
	6472	+ /CALLEND/
	6473	+ stackbase += 2LLU;
	6474	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2FLLU;
	6475	+ fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
	6476	+{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
	6477	+ break;
	6478	+ }
	6479	+case 0xFFFFFFFFFFFFFE2FLLU:
	6480	+/* SP = 0LLU */
	6481	+ {
	6482	+ /* CALLBEGIN */
	6483	+ /* reserve space for 1LLU returned values // SP + 1LLU = 1LLU */
	6484	+{/* PUSH /stack[stackbase + 1LLU] = stackbase; }/ SP + 1LLU = 2LLU */
	6485	+ /* leave place for return addr // SP + 1LLU = 3LLU */
	6486	+ }/* SP + 2LLU = 5LLU // SP - 2LLU = 3LLU */
	6487	+ {
	6488	+ /CALLEND/
	6489	+ stackbase += 3LLU;
	6490	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2ELLU;
	6491	+ fnaddr = /get_______/0x8A0BC00000000000LLU;/* SP = 0LLU */
	6492	+{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /get_______/\n"); exit(-1); } }
	6493	+ break;
	6494	+ }
	6495	+case 0xFFFFFFFFFFFFFE2ELLU:
	6496	+/* SP = 1LLU // predicate */
	6497	+
	6498	+{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU */
	6499	+{ /* TOP /stack[stackbase + 1LLU] = isalpha(/ TOP */stack[stackbase + 1LLU]); }
	6500	+if(!/* SP - 1LLU = 1LLU // POP */stack[stackbase + 1LLU])
	6501	+{ /* JUMP / fnaddr = 18446744073709551149LLU; break; } / skip consequent */
	6502	+/* consequent */
	6503	+{/* PUSH /stack[stackbase + 1LLU] = 13738688774299189248LLU; }/ SP + 1LLU = 2LLU // SP + 2LLU = 4LLU // SP - 2LLU = 2LLU */
	6504	+ {
	6505	+ /* CALLBEGIN */
	6506	+ /* reserve space for 1LLU returned values // SP + 1LLU = 3LLU */
	6507	+{/* PUSH /stack[stackbase + 3LLU] = stackbase; }/ SP + 1LLU = 4LLU */
	6508	+ /* leave place for return addr // SP + 1LLU = 5LLU */
	6509	+ }/* SP + 13LLU = 18LLU // SPMAX = 18LLU // SP - 13LLU = 5LLU */
	6510	+{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 6LLU */
	6511	+ {
	6512	+ /CALLEND/
	6513	+ stackbase += 5LLU;
	6514	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2BLLU;
	6515	+ fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
	6516	+{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); } }
	6517	+ break;
	6518	+ }
	6519	+case 0xFFFFFFFFFFFFFE2BLLU:
	6520	+/* SP = 3LLU // SP = 1LLU */
	6521	+{ /* JUMP / fnaddr = 18446744073709551148LLU; break; } / skip alternative */
	6522	+case 18446744073709551149LLU: /* alternative */
	6523	+{/* PUSH /stack[stackbase + 1LLU] = 13738688775979238096LLU; }/ SP + 1LLU = 2LLU // SP + 2LLU = 4LLU // SP - 2LLU = 2LLU */
	6524	+{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 3LLU */
	6525	+case 18446744073709551148LLU: /* skip to here */
	6526	+/* SP - 2LLU = 1LLU // RESULT */
	6527	+{ /* RESULT */stack[stackbase + 0LLU] = stack[stackbase + 1LLU]; }
	6528	+{ /* RESULT /stack[stackbase + 1LLU] = stack[stackbase + 2LLU]; }/ SP = 2LLU // SP - 2LLU = 0LLU // RESULT */
	6529	+{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 1LLU]; }
	6530	+{ /* RESULT */stack[stackbase + 18446744073709551612LLU] = stack[stackbase + 0LLU]; }
	6531	+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
	6532	+/* function requires 18LLU 64-bit chunks of memory (including 0LLU for parameters) */
6338	6533	case /parsestype/0xADCB6E82EBF4AE00LLU:/* SP = 1LLU // SPMAX = 1LLU */
6339	6534	{
6340	6535	/* CALLBEGIN */

		@@ -6346,73 +6541,81 @@
6346	6541	{
6347	6542	/CALLEND/
6348	6543	stackbase += 4LLU;
6349		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3CLLU;
	6544	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2ALLU;
6350	6545	fnaddr = /idtosub___/0x91FBEABB07400000LLU;/* SP = 0LLU */
6351	6546	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /idtosub___/\n"); exit(-1); } }
6352	6547	break;
6353	6548	}
6354		-case 0xFFFFFFFFFFFFFE3CLLU:
	6549	+case 0xFFFFFFFFFFFFFE2ALLU:
6355	6550	/* SP = 2LLU // SP - 1LLU = 1LLU // RESULT */
6356	6551	{ /* RESULT /stack[stackbase + 1LLU] = stack[stackbase + 1LLU]; }/ SP = 2LLU // SP - 1LLU = 1LLU // RESULT */
6357	6552	{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 1LLU]; }
6358	6553	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6359	6554	/* function requires 6LLU 64-bit chunks of memory (including 1LLU for parameters) */
6360		-case /parsetype_/0xADCB6E82FD2B8000LLU:/* SP = 0LLU */
6361		-{/* PUSH /stack[stackbase + 0LLU] = 13784076749618806784LLU; }/ SP + 1LLU = 1LLU // SPMAX = 1LLU // SP + 2LLU = 3LLU // SPMAX = 3LLU // SP - 2LLU = 1LLU // SP + 1LLU = 2LLU // SP - 1LLU = 1LLU */
6362		-{/* PUSH /stack[stackbase + 1LLU] = 0LLU; }/ SP + 1LLU = 2LLU */
	6555	+case /parsetype_/0xADCB6E82FD2B8000LLU:/* SP = 2LLU // SPMAX = 2LLU */
	6556	+{/* PUSH /stack[stackbase + 2LLU] = 13784076749618806784LLU; }/ SP + 1LLU = 3LLU // SPMAX = 3LLU // SP + 2LLU = 5LLU // SPMAX = 5LLU // SP - 2LLU = 3LLU // SP + 1LLU = 4LLU // SP - 1LLU = 3LLU */
	6557	+{/* PUSH /stack[stackbase + 3LLU] = 0LLU; }/ SP + 1LLU = 4LLU // parse data */
	6558	+
	6559	+{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 5LLU */
	6560	+{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 6LLU // SPMAX = 6LLU // match-predicate */
	6561	+
	6562	+if(/tokenid___/0xBEA9A0A647C00000LLU != stack[stackbase + 4LLU])
	6563	+{ /* JUMP / fnaddr = 18446744073709551145LLU; break; } / skip match */
	6564	+/* match */
	6565	+{/* PUSH /stack[stackbase + 6LLU] = 13784076749618806784LLU; }/ SP + 1LLU = 7LLU // SPMAX = 7LLU // SP + 2LLU = 9LLU // SPMAX = 9LLU // SP - 2LLU = 7LLU */
6363	6566	{
6364	6567	/* CALLBEGIN */
6365		- /* reserve space for 1LLU returned values // SP + 1LLU = 3LLU */
6366		-{/* PUSH /stack[stackbase + 3LLU] = stackbase; }/ SP + 1LLU = 4LLU // SPMAX = 4LLU */
6367		- /* leave place for return addr // SP + 1LLU = 5LLU // SPMAX = 5LLU */
6368		- }/* SP + 13LLU = 18LLU // SPMAX = 18LLU // SP - 13LLU = 5LLU */
	6568	+ /* reserve space for 1LLU returned values // SP + 1LLU = 8LLU */
	6569	+{/* PUSH /stack[stackbase + 8LLU] = stackbase; }/ SP + 1LLU = 9LLU */
	6570	+ /* leave place for return addr // SP + 1LLU = 10LLU // SPMAX = 10LLU */
	6571	+ }/* SP + 6LLU = 16LLU // SPMAX = 16LLU // SP - 6LLU = 10LLU */
	6572	+{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 11LLU */
6369	6573	{
	6574	+ /CALLEND/
	6575	+ stackbase += 10LLU;
	6576	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE27LLU;
	6577	+ fnaddr = /parsestype/0xADCB6E82EBF4AE00LLU;/* SP = 0LLU */
	6578	+{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestype/\n"); exit(-1); } }
	6579	+ break;
	6580	+ }
	6581	+case 0xFFFFFFFFFFFFFE27LLU:
	6582	+/* SP = 8LLU // SP = 6LLU // assign */
	6583	+{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 6LLU]; }
	6584	+{ /* RESULT /stack[stackbase + 3LLU] = stack[stackbase + 7LLU]; }/ SP = 6LLU // SP - 0LLU = 6LLU / / MATCH-RESULT // SP = 4LLU */
	6585	+{ /* JUMP / fnaddr = 18446744073709551144LLU; break; } / skip other */
	6586	+case 18446744073709551145LLU: /* other // SP = 4LLU // parse data */
	6587	+
	6588	+{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 5LLU */
	6589	+{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 6LLU // match-predicate */
	6590	+
	6591	+if(/tokenother/0xBEA9A0A6ABE382D0LLU != stack[stackbase + 4LLU])
	6592	+{ /* JUMP / fnaddr = 18446744073709551142LLU; break; } / skip match */
	6593	+/* match */
	6594	+ {
6370	6595	/* CALLBEGIN */
6371		- /* reserve space for 1LLU returned values // SP + 1LLU = 6LLU */
	6596	+ /* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */
6372	6597	{/* PUSH /stack[stackbase + 6LLU] = stackbase; }/ SP + 1LLU = 7LLU */
6373	6598	/* leave place for return addr // SP + 1LLU = 8LLU */
6374		- }/* SP + 2LLU = 10LLU // SP - 2LLU = 8LLU */
	6599	+ }/* SP + 6LLU = 14LLU // SP - 6LLU = 8LLU */
	6600	+{/* PUSH /stack[stackbase + 8LLU] = 91LLU; }/ SP + 1LLU = 9LLU */
	6601	+{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 10LLU */
6375	6602	{
6376	6603	/CALLEND/
6377	6604	stackbase += 8LLU;
6378		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3BLLU;
6379		- fnaddr = /get_______/0x8A0BC00000000000LLU;/* SP = 0LLU */
6380		-{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /get_______/\n"); exit(-1); } }
	6605	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE24LLU;
	6606	+ fnaddr = /MATCH_____/0x3415032000000000LLU;/* SP = 0LLU */
	6607	+{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /MATCH_____/\n"); exit(-1); } }
6381	6608	break;
6382	6609	}
6383		-case 0xFFFFFFFFFFFFFE3BLLU:
	6610	+case 0xFFFFFFFFFFFFFE24LLU:
6384	6611	/* SP = 6LLU */
	6612	+{/* PUSH /stack[stackbase + 6LLU] = 13784076580000038912LLU; }/ SP + 1LLU = 7LLU // SP + 2LLU = 9LLU // SP - 2LLU = 7LLU */
6385	6613	{
6386		- /CALLEND/
6387		- stackbase += 5LLU;
6388		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE3ALLU;
6389		- fnaddr = /SKIPCMNTS_/0x4CB2500CD3944C00LLU;/* SP = 0LLU */
6390		-{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SKIPCMNTS_/\n"); exit(-1); } }
6391		- break;
6392		- }
6393		-case 0xFFFFFFFFFFFFFE3ALLU:
6394		-/* SP = 3LLU // predicate */
6395		-
6396		-{/* PUSH /stack[stackbase + 3LLU] = 91LLU; }/ SP + 1LLU = 4LLU */
6397		-{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 5LLU // SP = 3LLU */
6398		-{
6399		-{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 3LLU] == stack[stackbase + 4LLU]; }/ SP + 1LLU = 4LLU */ }
6400		-if(!/* SP - 1LLU = 3LLU // POP */stack[stackbase + 3LLU])
6401		-{ /* JUMP / fnaddr = 18446744073709551161LLU; break; } / skip consequent */
6402		-/* consequent */
6403		-{/* PUSH /stack[stackbase + 3LLU] = 13784076580000038912LLU; }/ SP + 1LLU = 4LLU // SP + 2LLU = 6LLU // SP - 2LLU = 4LLU */
6404		- {
6405	6614	/* CALLBEGIN */
6406		- /* reserve space for 1LLU returned values // SP + 1LLU = 5LLU */
6407		-{/* PUSH /stack[stackbase + 5LLU] = stackbase; }/ SP + 1LLU = 6LLU */
6408		- /* leave place for return addr // SP + 1LLU = 7LLU */
6409		- }/* SP + 6LLU = 13LLU // SP - 6LLU = 7LLU */
6410		- {
6411		- /* CALLBEGIN */
6412	6615	/* reserve space for 1LLU returned values // SP + 1LLU = 8LLU */
6413	6616	{/* PUSH /stack[stackbase + 8LLU] = stackbase; }/ SP + 1LLU = 9LLU */
6414	6617	/* leave place for return addr // SP + 1LLU = 10LLU */
6415		- }/* SP + 13LLU = 23LLU // SPMAX = 23LLU // SP - 13LLU = 10LLU */
	6618	+ }/* SP + 6LLU = 16LLU // SP - 6LLU = 10LLU */
6416	6619	{
6417	6620	/* CALLBEGIN */
6418	6621	/* reserve space for 1LLU returned values // SP + 1LLU = 11LLU */

		@@ -6424,146 +6627,225 @@
6424	6627	/* reserve space for 1LLU returned values // SP + 1LLU = 14LLU */
6425	6628	{/* PUSH /stack[stackbase + 14LLU] = stackbase; }/ SP + 1LLU = 15LLU */
6426	6629	/* leave place for return addr // SP + 1LLU = 16LLU */
6427		- }/* SP + 2LLU = 18LLU // SP - 2LLU = 16LLU */
	6630	+ }/* SP + 13LLU = 29LLU // SPMAX = 29LLU // SP - 13LLU = 16LLU */
6428	6631	{
	6632	+ /* CALLBEGIN */
	6633	+ /* reserve space for 1LLU returned values // SP + 1LLU = 17LLU */
	6634	+{/* PUSH /stack[stackbase + 17LLU] = stackbase; }/ SP + 1LLU = 18LLU */
	6635	+ /* leave place for return addr // SP + 1LLU = 19LLU */
	6636	+ }/* SP + 2LLU = 21LLU // SP - 2LLU = 19LLU */
	6637	+ {
6429	6638	/CALLEND/
6430		- stackbase += 16LLU;
6431		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE37LLU;
	6639	+ stackbase += 19LLU;
	6640	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE23LLU;
6432	6641	fnaddr = /get_______/0x8A0BC00000000000LLU;/* SP = 0LLU */
6433	6642	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /get_______/\n"); exit(-1); } }
6434	6643	break;
6435	6644	}
6436		-case 0xFFFFFFFFFFFFFE37LLU:
6437		-/* SP = 14LLU */
	6645	+case 0xFFFFFFFFFFFFFE23LLU:
	6646	+/* SP = 17LLU */
6438	6647	{
6439	6648	/CALLEND/
6440		- stackbase += 13LLU;
6441		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE36LLU;
	6649	+ stackbase += 16LLU;
	6650	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE22LLU;
6442	6651	fnaddr = /SKIPCMNTS_/0x4CB2500CD3944C00LLU;/* SP = 0LLU */
6443	6652	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SKIPCMNTS_/\n"); exit(-1); } }
6444	6653	break;
6445	6654	}
6446		-case 0xFFFFFFFFFFFFFE36LLU:
6447		-/* SP = 11LLU */
	6655	+case 0xFFFFFFFFFFFFFE22LLU:
	6656	+/* SP = 14LLU */
6448	6657	{
6449	6658	/CALLEND/
6450		- stackbase += 10LLU;
6451		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE35LLU;
	6659	+ stackbase += 13LLU;
	6660	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE21LLU;
6452	6661	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
6453	6662	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); } }
6454	6663	break;
6455	6664	}
6456		-case 0xFFFFFFFFFFFFFE35LLU:
6457		-/* SP = 8LLU */
	6665	+case 0xFFFFFFFFFFFFFE21LLU:
	6666	+/* SP = 11LLU */
6458	6667	{
6459	6668	/CALLEND/
6460		- stackbase += 7LLU;
6461		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE34LLU;
	6669	+ stackbase += 10LLU;
	6670	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE20LLU;
6462	6671	fnaddr = /parsestype/0xADCB6E82EBF4AE00LLU;/* SP = 0LLU */
6463	6672	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestype/\n"); exit(-1); } }
6464	6673	break;
6465	6674	}
6466		-case 0xFFFFFFFFFFFFFE34LLU:
6467		-/* SP = 5LLU // SP = 3LLU // assign */
6468		-{ /* RESULT */stack[stackbase + 0LLU] = stack[stackbase + 3LLU]; }
6469		-{ /* RESULT */stack[stackbase + 1LLU] = stack[stackbase + 4LLU]; }
	6675	+case 0xFFFFFFFFFFFFFE20LLU:
	6676	+/* SP = 8LLU // SP = 6LLU // assign */
	6677	+{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 6LLU]; }
	6678	+{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 7LLU]; }
6470	6679	{
6471	6680	/* CALLBEGIN */
6472		- /* reserve space for 0LLU returned values // SP + 0LLU = 3LLU */
6473		-{/* PUSH /stack[stackbase + 3LLU] = stackbase; }/ SP + 1LLU = 4LLU */
6474		- /* leave place for return addr // SP + 1LLU = 5LLU */
6475		- }/* SP + 13LLU = 18LLU // SP - 13LLU = 5LLU */
	6681	+ /* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */
	6682	+{/* PUSH /stack[stackbase + 6LLU] = stackbase; }/ SP + 1LLU = 7LLU */
	6683	+ /* leave place for return addr // SP + 1LLU = 8LLU */
	6684	+ }/* SP + 13LLU = 21LLU // SP - 13LLU = 8LLU */
6476	6685	{
6477	6686	/CALLEND/
6478		- stackbase += 5LLU;
6479		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE33LLU;
	6687	+ stackbase += 8LLU;
	6688	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1FLLU;
6480	6689	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
6481	6690	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
6482	6691	break;
6483	6692	}
6484		-case 0xFFFFFFFFFFFFFE33LLU:
6485		-/* SP = 3LLU */
	6693	+case 0xFFFFFFFFFFFFFE1FLLU:
	6694	+/* SP = 6LLU */
6486	6695	{
6487	6696	/* CALLBEGIN */
6488		- /* reserve space for 0LLU returned values // SP + 0LLU = 3LLU */
6489		-{/* PUSH /stack[stackbase + 3LLU] = stackbase; }/ SP + 1LLU = 4LLU */
6490		- /* leave place for return addr // SP + 1LLU = 5LLU */
6491		- }/* SP + 9LLU = 14LLU // SP - 9LLU = 5LLU */
6492		-{/* PUSH /stack[stackbase + 5LLU] = 93LLU; }/ SP + 1LLU = 6LLU */
	6697	+ /* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */
	6698	+{/* PUSH /stack[stackbase + 6LLU] = stackbase; }/ SP + 1LLU = 7LLU */
	6699	+ /* leave place for return addr // SP + 1LLU = 8LLU */
	6700	+ }/* SP + 9LLU = 17LLU // SP - 9LLU = 8LLU */
	6701	+{/* PUSH /stack[stackbase + 8LLU] = 93LLU; }/ SP + 1LLU = 9LLU */
6493	6702	{
6494	6703	/CALLEND/
6495		- stackbase += 5LLU;
6496		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE32LLU;
	6704	+ stackbase += 8LLU;
	6705	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1ELLU;
6497	6706	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
6498	6707	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
6499	6708	break;
6500	6709	}
6501		-case 0xFFFFFFFFFFFFFE32LLU:
6502		-/* SP = 3LLU // SP = 3LLU // SP = 3LLU */
6503		-{ /* JUMP / fnaddr = 18446744073709551160LLU; break; } / skip alternative */
6504		-case 18446744073709551161LLU: /* alternative */
6505		-{/* PUSH /stack[stackbase + 3LLU] = 13784076749618806784LLU; }/ SP + 1LLU = 4LLU // SP + 2LLU = 6LLU // SP - 2LLU = 4LLU */
	6710	+case 0xFFFFFFFFFFFFFE1ELLU:
	6711	+/* SP = 6LLU // SP = 6LLU // SP - 0LLU = 6LLU / / MATCH-RESULT // SP = 4LLU */
	6712	+{ /* JUMP / fnaddr = 18446744073709551141LLU; break; } / skip other */
	6713	+case 18446744073709551142LLU: /* other // SP = 4LLU // SP = 4LLU */
	6714	+case 18446744073709551141LLU: /* skip to here */
	6715	+
	6716	+case 18446744073709551144LLU: /* skip to here */
	6717	+
	6718	+{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 5LLU */
	6719	+{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 6LLU // SP - 2LLU = 4LLU // RESULT */
	6720	+{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 4LLU]; }
	6721	+{ /* RESULT /stack[stackbase + 3LLU] = stack[stackbase + 5LLU]; }/ SP = 4LLU // SP - 2LLU = 2LLU // RESULT */
	6722	+{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 3LLU]; }
	6723	+{ /* RESULT */stack[stackbase + 18446744073709551612LLU] = stack[stackbase + 2LLU]; }
	6724	+{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
	6725	+/* function requires 29LLU 64-bit chunks of memory (including 2LLU for parameters) */
	6726	+case /parseqtype/0xADCB6E82CBF4AE00LLU:/* SP = 2LLU // SPMAX = 2LLU // parse data */
	6727	+
	6728	+{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 3LLU // SPMAX = 3LLU */
	6729	+{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 4LLU // SPMAX = 4LLU // match-predicate */
	6730	+
	6731	+if(/tokenid___/0xBEA9A0A647C00000LLU != stack[stackbase + 2LLU])
	6732	+{ /* JUMP / fnaddr = 18446744073709551133LLU; break; } / skip match */
	6733	+/* match // predicate */
	6734	+
	6735	+{/* PUSH /stack[stackbase + 4LLU] = 11748695159158603776LLU; }/ SP + 1LLU = 5LLU // SPMAX = 5LLU */
	6736	+{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 6LLU // SPMAX = 6LLU // SP = 4LLU */
	6737	+{
	6738	+{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 4LLU] == stack[stackbase + 5LLU]; }/ SP + 1LLU = 5LLU */ }
	6739	+if(!/* SP - 1LLU = 4LLU // POP */stack[stackbase + 4LLU])
	6740	+{ /* JUMP / fnaddr = 18446744073709551131LLU; break; } / skip consequent */
	6741	+/* consequent // SP + 3LLU = 7LLU // SPMAX = 7LLU // SP - 3LLU = 4LLU */
	6742	+{/* PUSH /stack[stackbase + 4LLU] = 11748726454303588352LLU; }/ SP + 1LLU = 5LLU // SP + 1LLU = 6LLU // SP - 1LLU = 5LLU */
6506	6743	{
6507	6744	/* CALLBEGIN */
6508		- /* reserve space for 1LLU returned values // SP + 1LLU = 5LLU */
6509		-{/* PUSH /stack[stackbase + 5LLU] = stackbase; }/ SP + 1LLU = 6LLU */
6510		- /* leave place for return addr // SP + 1LLU = 7LLU */
6511		- }/* SP + 6LLU = 13LLU // SP - 6LLU = 7LLU */
	6745	+ /* reserve space for 2LLU returned values // SP + 2LLU = 7LLU */
	6746	+{/* PUSH /stack[stackbase + 7LLU] = stackbase; }/ SP + 1LLU = 8LLU // SPMAX = 8LLU */
	6747	+ /* leave place for return addr // SP + 1LLU = 9LLU // SPMAX = 9LLU */
	6748	+ }/* SP + 29LLU = 38LLU // SPMAX = 38LLU // SP - 29LLU = 9LLU */
6512	6749	{
6513	6750	/* CALLBEGIN */
6514		- /* reserve space for 1LLU returned values // SP + 1LLU = 8LLU */
6515		-{/* PUSH /stack[stackbase + 8LLU] = stackbase; }/ SP + 1LLU = 9LLU */
6516		- /* leave place for return addr // SP + 1LLU = 10LLU */
6517		- }/* SP + 13LLU = 23LLU // SP - 13LLU = 10LLU */
6518		- {
6519		- /* CALLBEGIN */
6520		- /* reserve space for 1LLU returned values // SP + 1LLU = 11LLU */
	6751	+ /* reserve space for 2LLU returned values // SP + 2LLU = 11LLU */
6521	6752	{/* PUSH /stack[stackbase + 11LLU] = stackbase; }/ SP + 1LLU = 12LLU */
6522	6753	/* leave place for return addr // SP + 1LLU = 13LLU */
6523		- }/* SP + 13LLU = 26LLU // SP - 13LLU = 13LLU */
6524		-{/* PUSH /stack[stackbase + 13LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 14LLU */
	6754	+ }/* SP + 18LLU = 31LLU // SP - 18LLU = 13LLU */
6525	6755	{
6526	6756	/CALLEND/
6527	6757	stackbase += 13LLU;
6528		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE31LLU;
6529		- fnaddr = /SKIPCMNTS_/0x4CB2500CD3944C00LLU;/* SP = 0LLU */
6530		-{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SKIPCMNTS_/\n"); exit(-1); } }
	6758	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE19LLU;
	6759	+ fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
	6760	+{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
6531	6761	break;
6532	6762	}
6533		-case 0xFFFFFFFFFFFFFE31LLU:
	6763	+case 0xFFFFFFFFFFFFFE19LLU:
6534	6764	/* SP = 11LLU */
6535	6765	{
6536	6766	/CALLEND/
6537		- stackbase += 10LLU;
6538		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE30LLU;
6539		- fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
6540		-{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); } }
	6767	+ stackbase += 9LLU;
	6768	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE18LLU;
	6769	+ fnaddr = /parsetype_/0xADCB6E82FD2B8000LLU;/* SP = 0LLU */
	6770	+{ if(stackbase + 29LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetype_/\n"); exit(-1); } }
6541	6771	break;
6542	6772	}
6543		-case 0xFFFFFFFFFFFFFE30LLU:
6544		-/* SP = 8LLU */
	6773	+case 0xFFFFFFFFFFFFFE18LLU:
	6774	+/* SP = 7LLU // SP = 4LLU */
	6775	+{ /* JUMP / fnaddr = 18446744073709551130LLU; break; } / skip alternative */
	6776	+case 18446744073709551131LLU: /* alternative // SP + 3LLU = 7LLU // SP - 3LLU = 4LLU */
	6777	+{/* PUSH /stack[stackbase + 4LLU] = 8838998972400926720LLU; }/ SP + 1LLU = 5LLU // SP + 1LLU = 6LLU // SP - 1LLU = 5LLU */
6545	6778	{
	6779	+ /* CALLBEGIN */
	6780	+ /* reserve space for 2LLU returned values // SP + 2LLU = 7LLU */
	6781	+{/* PUSH /stack[stackbase + 7LLU] = stackbase; }/ SP + 1LLU = 8LLU */
	6782	+ /* leave place for return addr // SP + 1LLU = 9LLU */
	6783	+ }/* SP + 29LLU = 38LLU // SP - 29LLU = 9LLU */
	6784	+{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 10LLU */
	6785	+{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 11LLU */
	6786	+ {
6546	6787	/CALLEND/
6547		- stackbase += 7LLU;
6548		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2FLLU;
6549		- fnaddr = /parsestype/0xADCB6E82EBF4AE00LLU;/* SP = 0LLU */
6550		-{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestype/\n"); exit(-1); } }
	6788	+ stackbase += 9LLU;
	6789	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE17LLU;
	6790	+ fnaddr = /parsetype_/0xADCB6E82FD2B8000LLU;/* SP = 0LLU */
	6791	+{ if(stackbase + 29LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetype_/\n"); exit(-1); } }
6551	6792	break;
6552	6793	}
6553		-case 0xFFFFFFFFFFFFFE2FLLU:
6554		-/* SP = 5LLU // SP = 3LLU // assign */
6555		-{ /* RESULT */stack[stackbase + 0LLU] = stack[stackbase + 3LLU]; }
6556		-{ /* RESULT /stack[stackbase + 1LLU] = stack[stackbase + 4LLU]; }/ SP = 3LLU */
6557		-case 18446744073709551160LLU: /* skip to here */
	6794	+case 0xFFFFFFFFFFFFFE17LLU:
	6795	+/* SP = 7LLU */
	6796	+case 18446744073709551130LLU: /* skip to here */
	6797	+/* SP - 3LLU = 4LLU / / MATCH-RESULT */
	6798	+{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 4LLU]; }
	6799	+{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 5LLU]; }
	6800	+{ /* RESULT /stack[stackbase + 4LLU] = stack[stackbase + 6LLU]; }/ SP = 5LLU */
	6801	+{ /* JUMP / fnaddr = 18446744073709551132LLU; break; } / skip other */
	6802	+case 18446744073709551133LLU: /* other // SP = 2LLU // parse data */
6558	6803
6559		-{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 4LLU */
6560		-{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 5LLU // SP - 2LLU = 3LLU // RESULT */
6561		-{ /* RESULT */stack[stackbase + 0LLU] = stack[stackbase + 3LLU]; }
6562		-{ /* RESULT /stack[stackbase + 1LLU] = stack[stackbase + 4LLU]; }/ SP = 2LLU // SP - 2LLU = 0LLU // RESULT */
6563		-{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 1LLU]; }
6564		-{ /* RESULT */stack[stackbase + 18446744073709551612LLU] = stack[stackbase + 0LLU]; }
	6804	+{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 3LLU */
	6805	+{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 4LLU // match-predicate */
	6806	+
	6807	+if(/tokenother/0xBEA9A0A6ABE382D0LLU != stack[stackbase + 2LLU])
	6808	+{ /* JUMP / fnaddr = 18446744073709551126LLU; break; } / skip match */
	6809	+/* match // SP + 3LLU = 7LLU // SP - 3LLU = 4LLU */
	6810	+{/* PUSH /stack[stackbase + 4LLU] = 8838998972400926720LLU; }/ SP + 1LLU = 5LLU // SP + 1LLU = 6LLU // SP - 1LLU = 5LLU */
	6811	+ {
	6812	+ /* CALLBEGIN */
	6813	+ /* reserve space for 2LLU returned values // SP + 2LLU = 7LLU */
	6814	+{/* PUSH /stack[stackbase + 7LLU] = stackbase; }/ SP + 1LLU = 8LLU */
	6815	+ /* leave place for return addr // SP + 1LLU = 9LLU */
	6816	+ }/* SP + 29LLU = 38LLU // SP - 29LLU = 9LLU */
	6817	+{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 10LLU */
	6818	+{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 11LLU */
	6819	+ {
	6820	+ /CALLEND/
	6821	+ stackbase += 9LLU;
	6822	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE14LLU;
	6823	+ fnaddr = /parsetype_/0xADCB6E82FD2B8000LLU;/* SP = 0LLU */
	6824	+{ if(stackbase + 29LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetype_/\n"); exit(-1); } }
	6825	+ break;
	6826	+ }
	6827	+case 0xFFFFFFFFFFFFFE14LLU:
	6828	+/* SP = 7LLU // SP - 3LLU = 4LLU / / MATCH-RESULT */
	6829	+{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 4LLU]; }
	6830	+{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 5LLU]; }
	6831	+{ /* RESULT /stack[stackbase + 4LLU] = stack[stackbase + 6LLU]; }/ SP = 5LLU */
	6832	+{ /* JUMP / fnaddr = 18446744073709551125LLU; break; } / skip other */
	6833	+case 18446744073709551126LLU: /* other // SP = 2LLU // SP + 3LLU = 5LLU // SP - 3LLU = 2LLU */
	6834	+{/* PUSH /stack[stackbase + 2LLU] = 8838998972400926720LLU; }/ SP + 1LLU = 3LLU // SP + 1LLU = 4LLU // SP - 1LLU = 3LLU */
	6835	+{/* PUSH /stack[stackbase + 3LLU] = 13784076749618806784LLU; }/ SP + 1LLU = 4LLU // SP + 2LLU = 6LLU // SP - 2LLU = 4LLU // SP + 1LLU = 5LLU // SP - 1LLU = 4LLU */
	6836	+{/* PUSH /stack[stackbase + 4LLU] = 0LLU; }/ SP + 1LLU = 5LLU */
	6837	+case 18446744073709551125LLU: /* skip to here */
	6838	+
	6839	+case 18446744073709551132LLU: /* skip to here */
	6840	+/* SP - 3LLU = 2LLU // RESULT */
	6841	+{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 2LLU]; }
	6842	+{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 3LLU]; }
	6843	+{ /* RESULT /stack[stackbase + 4LLU] = stack[stackbase + 4LLU]; }/ SP = 5LLU // SP - 3LLU = 2LLU // RESULT */
	6844	+{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 4LLU]; }
	6845	+{ /* RESULT */stack[stackbase + 18446744073709551612LLU] = stack[stackbase + 3LLU]; }
	6846	+{ /* RESULT */stack[stackbase + 18446744073709551611LLU] = stack[stackbase + 2LLU]; }
6565	6847	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6566		-/* function requires 26LLU 64-bit chunks of memory (including 0LLU for parameters) */
	6848	+/* function requires 38LLU 64-bit chunks of memory (including 2LLU for parameters) */
6567	6849	case /typescheck/0xBF4AE0B9E8E07A60LLU:/* SP = 2LLU // SPMAX = 2LLU // predicate */
6568	6850
6569	6851	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 3LLU // SPMAX = 3LLU */

		@@ -6572,7 +6854,7 @@
6572	6854	{/* PUSH /stack[stackbase + 2LLU] = (stack[stackbase + 2LLU] == stack[stackbase + 3LLU]); }/ SP + 1LLU = 3LLU */}
6573	6855	{ /* TOP /stack[stackbase + 2LLU] = !/ TOP */stack[stackbase + 2LLU]; }
6574	6856	if(!/* SP - 1LLU = 2LLU // POP */stack[stackbase + 2LLU])
6575		-{ /* JUMP / fnaddr = 18446744073709551150LLU; break; } / skip consequent */
	6857	+{ /* JUMP / fnaddr = 18446744073709551123LLU; break; } / skip consequent */
6576	6858	/* consequent */
6577	6859	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("want type ", stderr);
6578	6860	{

		@@ -6585,12 +6867,12 @@
6585	6867	{
6586	6868	/CALLEND/
6587	6869	stackbase += 4LLU;
6588		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2DLLU;
	6870	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE12LLU;
6589	6871	fnaddr = /reportstyp/0xB60AEAB6FBAFD2B0LLU;/* SP = 0LLU */
6590	6872	{ if(stackbase + 10LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportstyp/\n"); exit(-1); } }
6591	6873	break;
6592	6874	}
6593		-case 0xFFFFFFFFFFFFFE2DLLU:
	6875	+case 0xFFFFFFFFFFFFFE12LLU:
6594	6876	/* SP = 2LLU */fputs(" but have type ", stderr);
6595	6877	{
6596	6878	/* CALLBEGIN */

		@@ -6602,16 +6884,16 @@
6602	6884	{
6603	6885	/CALLEND/
6604	6886	stackbase += 4LLU;
6605		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2CLLU;
	6887	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE11LLU;
6606	6888	fnaddr = /reportstyp/0xB60AEAB6FBAFD2B0LLU;/* SP = 0LLU */
6607	6889	{ if(stackbase + 10LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportstyp/\n"); exit(-1); } }
6608	6890	break;
6609	6891	}
6610		-case 0xFFFFFFFFFFFFFE2CLLU:
	6892	+case 0xFFFFFFFFFFFFFE11LLU:
6611	6893	/* SP = 2LLU */fputs("\n", stderr);
6612	6894	{/* set exit-value */stack[16LLU] = 255LLU; }
6613	6895	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 2LLU */
6614		-case 18446744073709551150LLU: /* alternative // SP = 2LLU // SP - 0LLU = 2LLU // RESULT */
	6896	+case 18446744073709551123LLU: /* alternative // SP = 2LLU // SP - 0LLU = 2LLU // RESULT */
6615	6897	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6616	6898	/* function requires 14LLU 64-bit chunks of memory (including 2LLU for parameters) */
6617	6899	case /typecheck_/0xBF4AE07A381E9800LLU:/* SP = 4LLU // SPMAX = 4LLU // predicate */

		@@ -6624,7 +6906,7 @@
6624	6906	{/* PUSH /stack[stackbase + 4LLU] = (stack[stackbase + 4LLU] == stack[stackbase + 6LLU]) && (stack[stackbase + 5LLU] == stack[stackbase + 7LLU]); }/ SP + 1LLU = 5LLU */}
6625	6907	{ /* TOP /stack[stackbase + 4LLU] = !/ TOP */stack[stackbase + 4LLU]; }
6626	6908	if(!/* SP - 1LLU = 4LLU // POP */stack[stackbase + 4LLU])
6627		-{ /* JUMP / fnaddr = 18446744073709551147LLU; break; } / skip consequent */
	6909	+{ /* JUMP / fnaddr = 18446744073709551120LLU; break; } / skip consequent */
6628	6910	/* consequent */
6629	6911	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("want type ", stderr);
6630	6912	{

		@@ -6638,12 +6920,12 @@
6638	6920	{
6639	6921	/CALLEND/
6640	6922	stackbase += 6LLU;
6641		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE2ALLU;
	6923	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0FLLU;
6642	6924	fnaddr = /reporttype/0xB60AEAB6FBF4AE00LLU;/* SP = 0LLU */
6643	6925	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reporttype/\n"); exit(-1); } }
6644	6926	break;
6645	6927	}
6646		-case 0xFFFFFFFFFFFFFE2ALLU:
	6928	+case 0xFFFFFFFFFFFFFE0FLLU:
6647	6929	/* SP = 4LLU */fputs(" but have type ", stderr);
6648	6930	{
6649	6931	/* CALLBEGIN */

		@@ -6656,16 +6938,16 @@
6656	6938	{
6657	6939	/CALLEND/
6658	6940	stackbase += 6LLU;
6659		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE29LLU;
	6941	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0ELLU;
6660	6942	fnaddr = /reporttype/0xB60AEAB6FBF4AE00LLU;/* SP = 0LLU */
6661	6943	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reporttype/\n"); exit(-1); } }
6662	6944	break;
6663	6945	}
6664		-case 0xFFFFFFFFFFFFFE29LLU:
	6946	+case 0xFFFFFFFFFFFFFE0ELLU:
6665	6947	/* SP = 4LLU */fputs("\n", stderr);
6666	6948	{/* set exit-value */stack[16LLU] = 255LLU; }
6667	6949	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 4LLU */
6668		-case 18446744073709551147LLU: /* alternative // SP = 4LLU // SP - 0LLU = 4LLU // RESULT */
	6950	+case 18446744073709551120LLU: /* alternative // SP = 4LLU // SP - 0LLU = 4LLU // RESULT */
6669	6951	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6670	6952	/* function requires 20LLU 64-bit chunks of memory (including 4LLU for parameters) */
6671	6953	case /typecheckV/0xBF4AE07A381E9960LLU:/* SP = 5LLU // SPMAX = 5LLU // predicate */

		@@ -6678,7 +6960,7 @@
6678	6960	{/* PUSH /stack[stackbase + 5LLU] = (stack[stackbase + 5LLU] == stack[stackbase + 7LLU]) && (stack[stackbase + 6LLU] == stack[stackbase + 8LLU]); }/ SP + 1LLU = 6LLU */}
6679	6961	{ /* TOP /stack[stackbase + 5LLU] = !/ TOP */stack[stackbase + 5LLU]; }
6680	6962	if(!/* SP - 1LLU = 5LLU // POP */stack[stackbase + 5LLU])
6681		-{ /* JUMP / fnaddr = 18446744073709551144LLU; break; } / skip consequent */
	6963	+{ /* JUMP / fnaddr = 18446744073709551117LLU; break; } / skip consequent */
6682	6964	/* consequent */
6683	6965	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("expected type ", stderr);
6684	6966	{

		@@ -6692,12 +6974,12 @@
6692	6974	{
6693	6975	/CALLEND/
6694	6976	stackbase += 7LLU;
6695		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE27LLU;
	6977	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0CLLU;
6696	6978	fnaddr = /reporttype/0xB60AEAB6FBF4AE00LLU;/* SP = 0LLU */
6697	6979	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reporttype/\n"); exit(-1); } }
6698	6980	break;
6699	6981	}
6700		-case 0xFFFFFFFFFFFFFE27LLU:
	6982	+case 0xFFFFFFFFFFFFFE0CLLU:
6701	6983	/* SP = 5LLU */fputs(" but variable ", stderr);
6702	6984	{
6703	6985	/* CALLBEGIN */

		@@ -6709,12 +6991,12 @@
6709	6991	{
6710	6992	/CALLEND/
6711	6993	stackbase += 7LLU;
6712		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE26LLU;
	6994	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0BLLU;
6713	6995	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
6714	6996	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
6715	6997	break;
6716	6998	}
6717		-case 0xFFFFFFFFFFFFFE26LLU:
	6999	+case 0xFFFFFFFFFFFFFE0BLLU:
6718	7000	/* SP = 5LLU */fputs(" has type ", stderr);
6719	7001	{
6720	7002	/* CALLBEGIN */

		@@ -6727,16 +7009,16 @@
6727	7009	{
6728	7010	/CALLEND/
6729	7011	stackbase += 7LLU;
6730		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE25LLU;
	7012	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0ALLU;
6731	7013	fnaddr = /reporttype/0xB60AEAB6FBF4AE00LLU;/* SP = 0LLU */
6732	7014	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reporttype/\n"); exit(-1); } }
6733	7015	break;
6734	7016	}
6735		-case 0xFFFFFFFFFFFFFE25LLU:
	7017	+case 0xFFFFFFFFFFFFFE0ALLU:
6736	7018	/* SP = 5LLU */fputs("\n", stderr);
6737	7019	{/* set exit-value */stack[16LLU] = 255LLU; }
6738	7020	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 5LLU */
6739		-case 18446744073709551144LLU: /* alternative // SP = 5LLU // SP - 0LLU = 5LLU // RESULT */
	7021	+case 18446744073709551117LLU: /* alternative // SP = 5LLU // SP - 0LLU = 5LLU // RESULT */
6740	7022	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
6741	7023	/* function requires 21LLU 64-bit chunks of memory (including 5LLU for parameters) */
6742	7024	case /emitbitequ/0x82892F764BE0B300LLU:/* SP = 3LLU // SPMAX = 3LLU */

		@@ -6749,12 +7031,12 @@
6749	7031	{
6750	7032	/CALLEND/
6751	7033	stackbase += 5LLU;
6752		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE24LLU;
	7034	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE09LLU;
6753	7035	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
6754	7036	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
6755	7037	break;
6756	7038	}
6757		-case 0xFFFFFFFFFFFFFE24LLU:
	7039	+case 0xFFFFFFFFFFFFFE09LLU:
6758	7040	/* SP = 3LLU */
6759	7041	{
6760	7042	/* CALLBEGIN */

		@@ -6766,12 +7048,12 @@
6766	7048	{
6767	7049	/CALLEND/
6768	7050	stackbase += 5LLU;
6769		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE23LLU;
	7051	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE08LLU;
6770	7052	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
6771	7053	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
6772	7054	break;
6773	7055	}
6774		-case 0xFFFFFFFFFFFFFE23LLU:
	7056	+case 0xFFFFFFFFFFFFFE08LLU:
6775	7057	/* SP = 3LLU // parse data */
6776	7058
6777	7059	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 4LLU */

		@@ -6778,7 +7060,7 @@
6778	7060	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 5LLU // match-predicate */
6779	7061
6780	7062	if(/typelist__/0xBF4AE09E4BAF0000LLU != stack[stackbase + 3LLU])
6781		-{ /* JUMP / fnaddr = 18446744073709551138LLU; break; } / skip match */
	7063	+{ /* JUMP / fnaddr = 18446744073709551111LLU; break; } / skip match */
6782	7064	/* match /fputs("\n{/list-compare*/", stdout);
6783	7065	{
6784	7066	/* CALLBEGIN */

		@@ -6791,12 +7073,12 @@
6791	7073	{
6792	7074	/CALLEND/
6793	7075	stackbase += 8LLU;
6794		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE20LLU;
	7076	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE05LLU;
6795	7077	fnaddr = /subsize___/0xBB076E9358000000LLU;/* SP = 0LLU */
6796	7078	{ if(stackbase + 33LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subsize___/\n"); exit(-1); } }
6797	7079	break;
6798	7080	}
6799		-case 0xFFFFFFFFFFFFFE20LLU:
	7081	+case 0xFFFFFFFFFFFFFE05LLU:
6800	7082	/* SP = 6LLU */
6801	7083	{
6802	7084	/* CALLBEGIN */

		@@ -6807,12 +7089,12 @@
6807	7089	{
6808	7090	/CALLEND/
6809	7091	stackbase += 9LLU;
6810		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1FLLU;
	7092	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE04LLU;
6811	7093	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
6812	7094	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
6813	7095	break;
6814	7096	}
6815		-case 0xFFFFFFFFFFFFFE1FLLU:
	7097	+case 0xFFFFFFFFFFFFFE04LLU:
6816	7098	/* SP = 7LLU */
6817	7099	{/* PUSH /stack[stackbase + 7LLU] = 2LLU; }/ SP + 1LLU = 8LLU // SP = 6LLU */
6818	7100	{

		@@ -6826,12 +7108,12 @@
6826	7108	{
6827	7109	/CALLEND/
6828	7110	stackbase += 10LLU;
6829		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1ELLU;
	7111	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE03LLU;
6830	7112	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
6831	7113	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
6832	7114	break;
6833	7115	}
6834		-case 0xFFFFFFFFFFFFFE1ELLU:
	7116	+case 0xFFFFFFFFFFFFFE03LLU:
6835	7117	/* SP = 8LLU */
6836	7118	{/* PUSH /stack[stackbase + 8LLU] = 1LLU; }/ SP + 1LLU = 9LLU // SP = 7LLU */
6837	7119	{

		@@ -6845,12 +7127,12 @@
6845	7127	{
6846	7128	/CALLEND/
6847	7129	stackbase += 11LLU;
6848		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1DLLU;
	7130	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE02LLU;
6849	7131	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
6850	7132	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
6851	7133	break;
6852	7134	}
6853		-case 0xFFFFFFFFFFFFFE1DLLU:
	7135	+case 0xFFFFFFFFFFFFFE02LLU:
6854	7136	/* SP = 9LLU */
6855	7137	{/* PUSH /stack[stackbase + 9LLU] = 0LLU; }/ SP + 1LLU = 10LLU // SP = 8LLU */
6856	7138	{

		@@ -6864,12 +7146,12 @@
6864	7146	{
6865	7147	/CALLEND/
6866	7148	stackbase += 11LLU;
6867		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1CLLU;
	7149	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE01LLU;
6868	7150	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
6869	7151	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); } }
6870	7152	break;
6871	7153	}
6872		-case 0xFFFFFFFFFFFFFE1CLLU:
	7154	+case 0xFFFFFFFFFFFFFE01LLU:
6873	7155	/* SP = 9LLU */
6874	7156	{
6875	7157	/* CALLBEGIN */

		@@ -6886,12 +7168,12 @@
6886	7168	{
6887	7169	/CALLEND/
6888	7170	stackbase += 14LLU;
6889		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1BLLU;
	7171	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFE00LLU;
6890	7172	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
6891	7173	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
6892	7174	break;
6893	7175	}
6894		-case 0xFFFFFFFFFFFFFE1BLLU:
	7176	+case 0xFFFFFFFFFFFFFE00LLU:
6895	7177	/* SP = 12LLU */
6896	7178	{/* PUSH /stack[stackbase + 12LLU] = 2LLU; }/ SP + 1LLU = 13LLU // SP = 11LLU */
6897	7179	{

		@@ -6899,12 +7181,12 @@
6899	7181	{
6900	7182	/CALLEND/
6901	7183	stackbase += 11LLU;
6902		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE1ALLU;
	7184	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFFLLU;
6903	7185	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
6904	7186	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
6905	7187	break;
6906	7188	}
6907		-case 0xFFFFFFFFFFFFFE1ALLU:
	7189	+case 0xFFFFFFFFFFFFFDFFLLU:
6908	7190	/* SP = 9LLU */
6909	7191	{
6910	7192	/* CALLBEGIN */

		@@ -6915,12 +7197,12 @@
6915	7197	{
6916	7198	/CALLEND/
6917	7199	stackbase += 11LLU;
6918		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE19LLU;
	7200	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFELLU;
6919	7201	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
6920	7202	{ if(stackbase + 21LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); } }
6921	7203	break;
6922	7204	}
6923		-case 0xFFFFFFFFFFFFFE19LLU:
	7205	+case 0xFFFFFFFFFFFFFDFELLU:
6924	7206	/* SP = 9LLU */fputs("\n ", stdout);
6925	7207	{
6926	7208	/* CALLBEGIN */

		@@ -6932,12 +7214,12 @@
6932	7214	{
6933	7215	/CALLEND/
6934	7216	stackbase += 11LLU;
6935		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE18LLU;
	7217	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFDLLU;
6936	7218	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
6937	7219	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
6938	7220	break;
6939	7221	}
6940		-case 0xFFFFFFFFFFFFFE18LLU:
	7222	+case 0xFFFFFFFFFFFFFDFDLLU:
6941	7223	/* SP = 9LLU */fputs(" = 1;", stdout); fputs("\n while(", stdout);
6942	7224	{
6943	7225	/* CALLBEGIN */

		@@ -6949,12 +7231,12 @@
6949	7231	{
6950	7232	/CALLEND/
6951	7233	stackbase += 11LLU;
6952		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE17LLU;
	7234	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFCLLU;
6953	7235	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
6954	7236	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
6955	7237	break;
6956	7238	}
6957		-case 0xFFFFFFFFFFFFFE17LLU:
	7239	+case 0xFFFFFFFFFFFFFDFCLLU:
6958	7240	/* SP = 9LLU */fputs(" \|\| ", stdout);
6959	7241	{
6960	7242	/* CALLBEGIN */

		@@ -6966,12 +7248,12 @@
6966	7248	{
6967	7249	/CALLEND/
6968	7250	stackbase += 11LLU;
6969		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE16LLU;
	7251	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFBLLU;
6970	7252	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
6971	7253	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
6972	7254	break;
6973	7255	}
6974		-case 0xFFFFFFFFFFFFFE16LLU:
	7256	+case 0xFFFFFFFFFFFFFDFBLLU:
6975	7257	/* SP = 9LLU */fputs(")", stdout); fputs("\n {", stdout); fputs("\n if(", stdout); fputs("(!stack[", stdout);
6976	7258	{
6977	7259	/* CALLBEGIN */

		@@ -6983,12 +7265,12 @@
6983	7265	{
6984	7266	/CALLEND/
6985	7267	stackbase += 11LLU;
6986		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE15LLU;
	7268	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFALLU;
6987	7269	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
6988	7270	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
6989	7271	break;
6990	7272	}
6991		-case 0xFFFFFFFFFFFFFE15LLU:
	7273	+case 0xFFFFFFFFFFFFFDFALLU:
6992	7274	/* SP = 9LLU */fputs("] != !stack[", stdout);
6993	7275	{
6994	7276	/* CALLBEGIN */

		@@ -7000,19 +7282,19 @@
7000	7282	{
7001	7283	/CALLEND/
7002	7284	stackbase += 11LLU;
7003		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE14LLU;
	7285	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF9LLU;
7004	7286	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
7005	7287	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
7006	7288	break;
7007	7289	}
7008		-case 0xFFFFFFFFFFFFFE14LLU:
	7290	+case 0xFFFFFFFFFFFFFDF9LLU:
7009	7291	/* SP = 9LLU */fputs("])", stdout);
7010	7292	{/* PUSH /stack[stackbase + 9LLU] = 0LLU; }/ SP + 1LLU = 10LLU */
7011	7293	{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 11LLU */
7012		-case 0xFFFFFFFFFFFFFE13LLU: /* loop to here // predicate: counter > 0? */
	7294	+case 0xFFFFFFFFFFFFFDF8LLU: /* loop to here // predicate: counter > 0? */
7013	7295
7014	7296	if(!stack[stackbase + 10LLU]--)
7015		-{ /* JUMP / fnaddr = 18446744073709551122LLU; break; } / skip loop */
	7297	+{ /* JUMP / fnaddr = 18446744073709551095LLU; break; } / skip loop */
7016	7298	/* loop */
7017	7299	{/* PUSH /stack[stackbase + 11LLU] = 1LLU; }/ SP + 1LLU = 12LLU */
7018	7300	{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 9LLU]; }/ SP + 1LLU = 13LLU // SP = 11LLU */

		@@ -7029,12 +7311,12 @@
7029	7311	{
7030	7312	/CALLEND/
7031	7313	stackbase += 13LLU;
7032		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE11LLU;
	7314	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF6LLU;
7033	7315	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
7034	7316	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
7035	7317	break;
7036	7318	}
7037		-case 0xFFFFFFFFFFFFFE11LLU:
	7319	+case 0xFFFFFFFFFFFFFDF6LLU:
7038	7320	/* SP = 11LLU */fputs(" + ", stdout);
7039	7321	{
7040	7322	/* CALLBEGIN */

		@@ -7046,12 +7328,12 @@
7046	7328	{
7047	7329	/CALLEND/
7048	7330	stackbase += 13LLU;
7049		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE10LLU;
	7331	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF5LLU;
7050	7332	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
7051	7333	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
7052	7334	break;
7053	7335	}
7054		-case 0xFFFFFFFFFFFFFE10LLU:
	7336	+case 0xFFFFFFFFFFFFFDF5LLU:
7055	7337	/* SP = 11LLU */fputs("] != stack[", stdout);
7056	7338	{
7057	7339	/* CALLBEGIN */

		@@ -7063,12 +7345,12 @@
7063	7345	{
7064	7346	/CALLEND/
7065	7347	stackbase += 13LLU;
7066		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0FLLU;
	7348	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF4LLU;
7067	7349	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
7068	7350	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
7069	7351	break;
7070	7352	}
7071		-case 0xFFFFFFFFFFFFFE0FLLU:
	7353	+case 0xFFFFFFFFFFFFFDF4LLU:
7072	7354	/* SP = 11LLU */fputs(" + ", stdout);
7073	7355	{
7074	7356	/* CALLBEGIN */

		@@ -7080,15 +7362,15 @@
7080	7362	{
7081	7363	/CALLEND/
7082	7364	stackbase += 13LLU;
7083		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0ELLU;
	7365	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF3LLU;
7084	7366	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
7085	7367	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
7086	7368	break;
7087	7369	}
7088		-case 0xFFFFFFFFFFFFFE0ELLU:
	7370	+case 0xFFFFFFFFFFFFFDF3LLU:
7089	7371	/* SP = 11LLU /fputs("])", stdout); / SP = 11LLU */
7090		-{ /* JUMP / fnaddr = 18446744073709551123LLU; break; } / loop */
7091		-case 18446744073709551122LLU: /* skip to here */fputs(")", stdout); fputs("\n {", stdout); fputs("\n ", stdout);
	7372	+{ /* JUMP / fnaddr = 18446744073709551096LLU; break; } / loop */
	7373	+case 18446744073709551095LLU: /* skip to here */fputs(")", stdout); fputs("\n {", stdout); fputs("\n ", stdout);
7092	7374	{
7093	7375	/* CALLBEGIN */
7094	7376	/* reserve space for 0LLU returned values // SP + 0LLU = 11LLU */

		@@ -7099,12 +7381,12 @@
7099	7381	{
7100	7382	/CALLEND/
7101	7383	stackbase += 13LLU;
7102		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0DLLU;
	7384	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF2LLU;
7103	7385	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
7104	7386	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
7105	7387	break;
7106	7388	}
7107		-case 0xFFFFFFFFFFFFFE0DLLU:
	7389	+case 0xFFFFFFFFFFFFFDF2LLU:
7108	7390	/* SP = 11LLU */fputs(" = 0;", stdout); fputs("\n break;", stdout); fputs("\n }", stdout); fputs("\n ", stdout);
7109	7391	{
7110	7392	/* CALLBEGIN */

		@@ -7116,12 +7398,12 @@
7116	7398	{
7117	7399	/CALLEND/
7118	7400	stackbase += 13LLU;
7119		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0CLLU;
	7401	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF1LLU;
7120	7402	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
7121	7403	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
7122	7404	break;
7123	7405	}
7124		-case 0xFFFFFFFFFFFFFE0CLLU:
	7406	+case 0xFFFFFFFFFFFFFDF1LLU:
7125	7407	/* SP = 11LLU */fputs(" = stack[", stdout);
7126	7408	{
7127	7409	/* CALLBEGIN */

		@@ -7133,12 +7415,12 @@
7133	7415	{
7134	7416	/CALLEND/
7135	7417	stackbase += 13LLU;
7136		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0BLLU;
	7418	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF0LLU;
7137	7419	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
7138	7420	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
7139	7421	break;
7140	7422	}
7141		-case 0xFFFFFFFFFFFFFE0BLLU:
	7423	+case 0xFFFFFFFFFFFFFDF0LLU:
7142	7424	/* SP = 11LLU */fputs("];", stdout); fputs("\n ", stdout);
7143	7425	{
7144	7426	/* CALLBEGIN */

		@@ -7150,12 +7432,12 @@
7150	7432	{
7151	7433	/CALLEND/
7152	7434	stackbase += 13LLU;
7153		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE0ALLU;
	7435	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEFLLU;
7154	7436	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
7155	7437	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
7156	7438	break;
7157	7439	}
7158		-case 0xFFFFFFFFFFFFFE0ALLU:
	7440	+case 0xFFFFFFFFFFFFFDEFLLU:
7159	7441	/* SP = 11LLU */fputs(" = stack[", stdout);
7160	7442	{
7161	7443	/* CALLBEGIN */

		@@ -7167,12 +7449,12 @@
7167	7449	{
7168	7450	/CALLEND/
7169	7451	stackbase += 13LLU;
7170		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE09LLU;
	7452	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEELLU;
7171	7453	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
7172	7454	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
7173	7455	break;
7174	7456	}
7175		-case 0xFFFFFFFFFFFFFE09LLU:
	7457	+case 0xFFFFFFFFFFFFFDEELLU:
7176	7458	/* SP = 11LLU */fputs("];", stdout); fputs("\n }", stdout);
7177	7459	{
7178	7460	/* CALLBEGIN */

		@@ -7184,21 +7466,21 @@
7184	7466	{
7185	7467	/CALLEND/
7186	7468	stackbase += 13LLU;
7187		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE08LLU;
	7469	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEDLLU;
7188	7470	fnaddr = /SP_SUB____/0x4D00135420000000LLU;/* SP = 0LLU */
7189	7471	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SUB____/\n"); exit(-1); } }
7190	7472	break;
7191	7473	}
7192		-case 0xFFFFFFFFFFFFFE08LLU:
	7474	+case 0xFFFFFFFFFFFFFDEDLLU:
7193	7475	/* SP = 11LLU /fputs("\n}", stdout); / SP = 5LLU // SP - 0LLU = 5LLU / / MATCH-RESULT // SP = 3LLU */
7194		-{ /* JUMP / fnaddr = 18446744073709551137LLU; break; } / skip other */
7195		-case 18446744073709551138LLU: /* other // SP = 3LLU // parse data */
	7476	+{ /* JUMP / fnaddr = 18446744073709551110LLU; break; } / skip other */
	7477	+case 18446744073709551111LLU: /* other // SP = 3LLU // parse data */
7196	7478
7197	7479	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 4LLU */
7198	7480	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 5LLU // match-predicate */
7199	7481
7200	7482	if(/typeval___/0xBF4AE0C5C9C00000LLU != stack[stackbase + 3LLU])
7201		-{ /* JUMP / fnaddr = 18446744073709551111LLU; break; } / skip match */
	7483	+{ /* JUMP / fnaddr = 18446744073709551084LLU; break; } / skip match */
7202	7484	/* match */
7203	7485	{
7204	7486	/* CALLBEGIN */

		@@ -7211,12 +7493,12 @@
7211	7493	{
7212	7494	/CALLEND/
7213	7495	stackbase += 8LLU;
7214		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE05LLU;
	7496	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDEALLU;
7215	7497	fnaddr = /subsize___/0xBB076E9358000000LLU;/* SP = 0LLU */
7216	7498	{ if(stackbase + 33LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subsize___/\n"); exit(-1); } }
7217	7499	break;
7218	7500	}
7219		-case 0xFFFFFFFFFFFFFE05LLU:
	7501	+case 0xFFFFFFFFFFFFFDEALLU:
7220	7502	/* SP = 6LLU */
7221	7503	{
7222	7504	/* CALLBEGIN */

		@@ -7231,12 +7513,12 @@
7231	7513	{
7232	7514	/CALLEND/
7233	7515	stackbase += 8LLU;
7234		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE04LLU;
	7516	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE9LLU;
7235	7517	fnaddr = /SP_SUB____/0x4D00135420000000LLU;/* SP = 0LLU */
7236	7518	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SUB____/\n"); exit(-1); } }
7237	7519	break;
7238	7520	}
7239		-case 0xFFFFFFFFFFFFFE04LLU:
	7521	+case 0xFFFFFFFFFFFFFDE9LLU:
7240	7522	/* SP = 6LLU */fputs("\n{", stdout);
7241	7523	{
7242	7524	/* CALLBEGIN */

		@@ -7247,19 +7529,19 @@
7247	7529	{
7248	7530	/CALLEND/
7249	7531	stackbase += 8LLU;
7250		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFE03LLU;
	7532	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE8LLU;
7251	7533	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
7252	7534	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); } }
7253	7535	break;
7254	7536	}
7255		-case 0xFFFFFFFFFFFFFE03LLU:
	7537	+case 0xFFFFFFFFFFFFFDE8LLU:
7256	7538	/* SP = 6LLU */
7257	7539	{/* PUSH /stack[stackbase + 6LLU] = 0LLU; }/ SP + 1LLU = 7LLU */
7258	7540	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 8LLU */
7259		-case 0xFFFFFFFFFFFFFE02LLU: /* loop to here // predicate: counter > 0? */
	7541	+case 0xFFFFFFFFFFFFFDE7LLU: /* loop to here // predicate: counter > 0? */
7260	7542
7261	7543	if(!stack[stackbase + 7LLU]--)
7262		-{ /* JUMP / fnaddr = 18446744073709551105LLU; break; } / skip loop */
	7544	+{ /* JUMP / fnaddr = 18446744073709551078LLU; break; } / skip loop */
7263	7545	/* loop // predicate */
7264	7546
7265	7547	{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 9LLU */

		@@ -7267,9 +7549,9 @@
7267	7549	{
7268	7550	{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 8LLU] > stack[stackbase + 9LLU]; }/ SP + 1LLU = 9LLU */ }
7269	7551	if(!/* SP - 1LLU = 8LLU // POP */stack[stackbase + 8LLU])
7270		-{ /* JUMP / fnaddr = 18446744073709551104LLU; break; } / skip consequent */
	7552	+{ /* JUMP / fnaddr = 18446744073709551077LLU; break; } / skip consequent */
7271	7553	/* consequent /fputs(" && ", stdout); / SP = 8LLU */
7272		-case 18446744073709551104LLU: /* alternative */fputs("(", stdout);
	7554	+case 18446744073709551077LLU: /* alternative */fputs("(", stdout);
7273	7555	{
7274	7556	/* CALLBEGIN */
7275	7557	/* reserve space for 0LLU returned values // SP + 0LLU = 8LLU */

		@@ -7285,12 +7567,12 @@
7285	7567	{
7286	7568	/CALLEND/
7287	7569	stackbase += 13LLU;
7288		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFFLLU;
	7570	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE4LLU;
7289	7571	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
7290	7572	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
7291	7573	break;
7292	7574	}
7293		-case 0xFFFFFFFFFFFFFDFFLLU:
	7575	+case 0xFFFFFFFFFFFFFDE4LLU:
7294	7576	/* SP = 11LLU */
7295	7577	{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 12LLU // SP = 10LLU */
7296	7578	{

		@@ -7298,12 +7580,12 @@
7298	7580	{
7299	7581	/CALLEND/
7300	7582	stackbase += 10LLU;
7301		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFELLU;
	7583	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE3LLU;
7302	7584	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
7303	7585	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
7304	7586	break;
7305	7587	}
7306		-case 0xFFFFFFFFFFFFFDFELLU:
	7588	+case 0xFFFFFFFFFFFFFDE3LLU:
7307	7589	/* SP = 8LLU */fputs(" == ", stdout);
7308	7590	{
7309	7591	/* CALLBEGIN */

		@@ -7320,12 +7602,12 @@
7320	7602	{
7321	7603	/CALLEND/
7322	7604	stackbase += 13LLU;
7323		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFDLLU;
	7605	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE2LLU;
7324	7606	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
7325	7607	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
7326	7608	break;
7327	7609	}
7328		-case 0xFFFFFFFFFFFFFDFDLLU:
	7610	+case 0xFFFFFFFFFFFFFDE2LLU:
7329	7611	/* SP = 11LLU */
7330	7612	{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 12LLU */
7331	7613	{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 13LLU // SP = 11LLU */

		@@ -7336,12 +7618,12 @@
7336	7618	{
7337	7619	/CALLEND/
7338	7620	stackbase += 10LLU;
7339		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFCLLU;
	7621	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE1LLU;
7340	7622	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
7341	7623	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
7342	7624	break;
7343	7625	}
7344		-case 0xFFFFFFFFFFFFFDFCLLU:
	7626	+case 0xFFFFFFFFFFFFFDE1LLU:
7345	7627	/* SP = 8LLU */fputs(")", stdout);
7346	7628	{/* PUSH /stack[stackbase + 8LLU] = 1LLU; }/ SP + 1LLU = 9LLU */
7347	7629	{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 10LLU // SP = 8LLU */

		@@ -7348,8 +7630,8 @@
7348	7630	{
7349	7631	{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 8LLU] + stack[stackbase + 9LLU]; }/ SP + 1LLU = 9LLU / }/ SP = 8LLU // assign */
7350	7632	{ /* RESULT /stack[stackbase + 6LLU] = stack[stackbase + 8LLU]; }/ SP = 8LLU */
7351		-{ /* JUMP / fnaddr = 18446744073709551106LLU; break; } / loop */
7352		-case 18446744073709551105LLU: /* skip to here */
	7633	+{ /* JUMP / fnaddr = 18446744073709551079LLU; break; } / loop */
	7634	+case 18446744073709551078LLU: /* skip to here */
7353	7635	{
7354	7636	/* CALLBEGIN */
7355	7637	/* reserve space for 0LLU returned values // SP + 0LLU = 8LLU */

		@@ -7359,21 +7641,21 @@
7359	7641	{
7360	7642	/CALLEND/
7361	7643	stackbase += 10LLU;
7362		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDFBLLU;
	7644	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE0LLU;
7363	7645	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
7364	7646	{ if(stackbase + 21LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); } }
7365	7647	break;
7366	7648	}
7367		-case 0xFFFFFFFFFFFFFDFBLLU:
	7649	+case 0xFFFFFFFFFFFFFDE0LLU:
7368	7650	/* SP = 8LLU /fputs("}", stdout); / SP = 5LLU // SP - 0LLU = 5LLU / / MATCH-RESULT // SP = 3LLU */
7369		-{ /* JUMP / fnaddr = 18446744073709551110LLU; break; } / skip other */
7370		-case 18446744073709551111LLU: /* other // SP = 3LLU */
	7651	+{ /* JUMP / fnaddr = 18446744073709551083LLU; break; } / skip other */
	7652	+case 18446744073709551084LLU: /* other // SP = 3LLU */
7371	7653	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("\nINTERNAL ERROR IN emitbitequ\n", stderr);
7372	7654	{/* set exit-value */stack[16LLU] = 255LLU; }
7373	7655	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 3LLU */
	7656	+case 18446744073709551083LLU: /* skip to here */
	7657	+
7374	7658	case 18446744073709551110LLU: /* skip to here */
7375		-
7376		-case 18446744073709551137LLU: /* skip to here */
7377	7659	/* SP = 3LLU // SP - 0LLU = 3LLU // RESULT */
7378	7660	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
7379	7661	/* function requires 41LLU 64-bit chunks of memory (including 3LLU for parameters) */

		@@ -7384,13 +7666,13 @@
7384	7666	{
7385	7667	{/* PUSH /stack[stackbase + 0LLU] = stack[stackbase + 0LLU] == stack[stackbase + 1LLU]; }/ SP + 1LLU = 1LLU */ }
7386	7668	if(!/* SP - 1LLU = 0LLU // POP */stack[stackbase + 0LLU])
7387		-{ /* JUMP / fnaddr = 18446744073709551098LLU; break; } / skip consequent */
	7669	+{ /* JUMP / fnaddr = 18446744073709551071LLU; break; } / skip consequent */
7388	7670	/* consequent */
7389	7671	{/* PUSH /stack[stackbase + 0LLU] = 13752902546454740992LLU; }/ SP + 1LLU = 1LLU // SP + 1LLU = 2LLU // SP - 1LLU = 1LLU // SP = 0LLU */
7390		-{ /* JUMP / fnaddr = 18446744073709551097LLU; break; } / skip alternative */
7391		-case 18446744073709551098LLU: /* alternative */
	7672	+{ /* JUMP / fnaddr = 18446744073709551070LLU; break; } / skip alternative */
	7673	+case 18446744073709551071LLU: /* alternative */
7392	7674	{/* PUSH /stack[stackbase + 0LLU] = 9640498710886481920LLU; }/ SP + 1LLU = 1LLU // SP + 1LLU = 2LLU // SP - 1LLU = 1LLU */
7393		-case 18446744073709551097LLU: /* skip to here */
	7675	+case 18446744073709551070LLU: /* skip to here */
7394	7676	/* SP - 1LLU = 0LLU // RESULT */
7395	7677	{ /* RESULT /stack[stackbase + 0LLU] = stack[stackbase + 0LLU]; }/ SP = 1LLU // SP - 1LLU = 0LLU // RESULT */
7396	7678	{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 0LLU]; }

		@@ -7407,12 +7689,12 @@
7407	7689	{
7408	7690	/CALLEND/
7409	7691	stackbase += 2LLU;
7410		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF8LLU;
	7692	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDDLLU;
7411	7693	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
7412	7694	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
7413	7695	break;
7414	7696	}
7415		-case 0xFFFFFFFFFFFFFDF8LLU:
	7697	+case 0xFFFFFFFFFFFFFDDDLLU:
7416	7698	/* SP = 0LLU */
7417	7699	{
7418	7700	/* CALLBEGIN */

		@@ -7419,16 +7701,32 @@
7419	7701	/* reserve space for 2LLU returned values // SP + 2LLU = 2LLU */
7420	7702	{/* PUSH /stack[stackbase + 2LLU] = stackbase; }/ SP + 1LLU = 3LLU */
7421	7703	/* leave place for return addr // SP + 1LLU = 4LLU */
7422		- }/* SP + 26LLU = 30LLU // SPMAX = 30LLU // SP - 26LLU = 4LLU */
	7704	+ }/* SP + 29LLU = 33LLU // SPMAX = 33LLU // SP - 29LLU = 4LLU */
7423	7705	{
	7706	+ /* CALLBEGIN */
	7707	+ /* reserve space for 2LLU returned values // SP + 2LLU = 6LLU */
	7708	+{/* PUSH /stack[stackbase + 6LLU] = stackbase; }/ SP + 1LLU = 7LLU */
	7709	+ /* leave place for return addr // SP + 1LLU = 8LLU */
	7710	+ }/* SP + 18LLU = 26LLU // SP - 18LLU = 8LLU */
	7711	+ {
7424	7712	/CALLEND/
	7713	+ stackbase += 8LLU;
	7714	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDCLLU;
	7715	+ fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
	7716	+{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
	7717	+ break;
	7718	+ }
	7719	+case 0xFFFFFFFFFFFFFDDCLLU:
	7720	+/* SP = 6LLU */
	7721	+ {
	7722	+ /CALLEND/
7425	7723	stackbase += 4LLU;
7426		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF7LLU;
	7724	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDBLLU;
7427	7725	fnaddr = /parsetype_/0xADCB6E82FD2B8000LLU;/* SP = 0LLU */
7428		-{ if(stackbase + 26LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetype_/\n"); exit(-1); } }
	7726	+{ if(stackbase + 29LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetype_/\n"); exit(-1); } }
7429	7727	break;
7430	7728	}
7431		-case 0xFFFFFFFFFFFFFDF7LLU:
	7729	+case 0xFFFFFFFFFFFFFDDBLLU:
7432	7730	/* SP = 2LLU */
7433	7731	{
7434	7732	/* CALLBEGIN */

		@@ -7440,12 +7738,12 @@
7440	7738	{
7441	7739	/CALLEND/
7442	7740	stackbase += 4LLU;
7443		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF6LLU;
	7741	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDALLU;
7444	7742	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
7445	7743	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
7446	7744	break;
7447	7745	}
7448		-case 0xFFFFFFFFFFFFFDF6LLU:
	7746	+case 0xFFFFFFFFFFFFFDDALLU:
7449	7747	/* SP = 2LLU */
7450	7748	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 3LLU */
7451	7749	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 4LLU // SP - 2LLU = 2LLU // RESULT */

		@@ -7454,7 +7752,7 @@
7454	7752	{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 1LLU]; }
7455	7753	{ /* RESULT */stack[stackbase + 18446744073709551612LLU] = stack[stackbase + 0LLU]; }
7456	7754	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
7457		-/* function requires 30LLU 64-bit chunks of memory (including 0LLU for parameters) */
	7755	+/* function requires 33LLU 64-bit chunks of memory (including 0LLU for parameters) */
7458	7756	case /checklevel/0x7A381E9A78318270LLU:/* SP = 1LLU // SPMAX = 1LLU // predicate */
7459	7757
7460	7758	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU // SPMAX = 2LLU */

		@@ -7467,17 +7765,17 @@
7467	7765	{
7468	7766	/CALLEND/
7469	7767	stackbase += 5LLU;
7470		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF4LLU;
	7768	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD8LLU;
7471	7769	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
7472	7770	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
7473	7771	break;
7474	7772	}
7475		-case 0xFFFFFFFFFFFFFDF4LLU:
	7773	+case 0xFFFFFFFFFFFFFDD8LLU:
7476	7774	/* SP = 3LLU // SP = 1LLU */
7477	7775	{
7478	7776	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 1LLU] != stack[stackbase + 2LLU]; }/ SP + 1LLU = 2LLU */ }
7479	7777	if(!/* SP - 1LLU = 1LLU // POP */stack[stackbase + 1LLU])
7480		-{ /* JUMP / fnaddr = 18446744073709551093LLU; break; } / skip consequent */
	7778	+{ /* JUMP / fnaddr = 18446744073709551065LLU; break; } / skip consequent */
7481	7779	/* consequent */
7482	7780	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("LEVEL ", stderr);
7483	7781	{

		@@ -7490,12 +7788,12 @@
7490	7788	{
7491	7789	/CALLEND/
7492	7790	stackbase += 3LLU;
7493		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF3LLU;
	7791	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD7LLU;
7494	7792	fnaddr = /reportnr__/0xB60AEAB6FA6D0000LLU;/* SP = 0LLU */
7495	7793	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportnr__/\n"); exit(-1); } }
7496	7794	break;
7497	7795	}
7498		-case 0xFFFFFFFFFFFFFDF3LLU:
	7796	+case 0xFFFFFFFFFFFFFDD7LLU:
7499	7797	/* SP = 1LLU */fputs(" != ", stderr);
7500	7798	{
7501	7799	/* CALLBEGIN */

		@@ -7512,26 +7810,26 @@
7512	7810	{
7513	7811	/CALLEND/
7514	7812	stackbase += 6LLU;
7515		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF2LLU;
	7813	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD6LLU;
7516	7814	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
7517	7815	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
7518	7816	break;
7519	7817	}
7520		-case 0xFFFFFFFFFFFFFDF2LLU:
	7818	+case 0xFFFFFFFFFFFFFDD6LLU:
7521	7819	/* SP = 4LLU */
7522	7820	{
7523	7821	/CALLEND/
7524	7822	stackbase += 3LLU;
7525		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDF1LLU;
	7823	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD5LLU;
7526	7824	fnaddr = /reportnr__/0xB60AEAB6FA6D0000LLU;/* SP = 0LLU */
7527	7825	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportnr__/\n"); exit(-1); } }
7528	7826	break;
7529	7827	}
7530		-case 0xFFFFFFFFFFFFFDF1LLU:
	7828	+case 0xFFFFFFFFFFFFFDD5LLU:
7531	7829	/* SP = 1LLU */fputs(" SP\n", stderr);
7532	7830	{/* set exit-value */stack[16LLU] = 255LLU; }
7533	7831	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 1LLU */
7534		-case 18446744073709551093LLU: /* alternative // SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
	7832	+case 18446744073709551065LLU: /* alternative // SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
7535	7833	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
7536	7834	/* function requires 17LLU 64-bit chunks of memory (including 1LLU for parameters) */
7537	7835	case /reportloop/0xB60AEAB6F9EAAAB0LLU:/* SP = 2LLU // SPMAX = 2LLU // parse data */

		@@ -7540,21 +7838,21 @@
7540	7838	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 4LLU // SPMAX = 4LLU // match-predicate */
7541	7839
7542	7840	if(/loopsafe__/0x9EAAABB9C8600000LLU != stack[stackbase + 2LLU])
7543		-{ /* JUMP / fnaddr = 18446744073709551088LLU; break; } / skip match */
	7841	+{ /* JUMP / fnaddr = 18446744073709551060LLU; break; } / skip match */
7544	7842	/* match // parse data */
7545	7843
7546	7844	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 5LLU // SPMAX = 5LLU // match-predicate */
7547	7845
7548	7846	if(/reduce____/0xB607F07A00000000LLU != stack[stackbase + 4LLU])
7549		-{ /* JUMP / fnaddr = 18446744073709551086LLU; break; } / skip match */
	7847	+{ /* JUMP / fnaddr = 18446744073709551058LLU; break; } / skip match */
7550	7848	/* match /fputs("loopsafe.reduce", stderr); / SP - 0LLU = 5LLU / / MATCH-RESULT // SP = 4LLU */
7551		-{ /* JUMP / fnaddr = 18446744073709551085LLU; break; } / skip other */
7552		-case 18446744073709551086LLU: /* other // SP = 4LLU */fputs("loopsafe", stderr);
7553		-case 18446744073709551085LLU: /* skip to here */
	7849	+{ /* JUMP / fnaddr = 18446744073709551057LLU; break; } / skip other */
	7850	+case 18446744073709551058LLU: /* other // SP = 4LLU */fputs("loopsafe", stderr);
	7851	+case 18446744073709551057LLU: /* skip to here */
7554	7852	/* SP = 4LLU // SP - 0LLU = 4LLU / / MATCH-RESULT // SP = 2LLU */
7555		-{ /* JUMP / fnaddr = 18446744073709551087LLU; break; } / skip other */
7556		-case 18446744073709551088LLU: /* other // SP = 2LLU /fputs("loopunsafe", stderr); / SP = 2LLU */
7557		-case 18446744073709551087LLU: /* skip to here */
	7853	+{ /* JUMP / fnaddr = 18446744073709551059LLU; break; } / skip other */
	7854	+case 18446744073709551060LLU: /* other // SP = 2LLU /fputs("loopunsafe", stderr); / SP = 2LLU */
	7855	+case 18446744073709551059LLU: /* skip to here */
7558	7856	/* SP = 2LLU // SP - 0LLU = 2LLU // RESULT */
7559	7857	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
7560	7858	/* function requires 5LLU 64-bit chunks of memory (including 2LLU for parameters) */

		@@ -7563,26 +7861,26 @@
7563	7861	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 3LLU // SPMAX = 3LLU // match-predicate */
7564	7862
7565	7863	if(/reduce____/0xB607F07A00000000LLU != stack[stackbase + 2LLU])
7566		-{ /* JUMP / fnaddr = 18446744073709551084LLU; break; } / skip match */
	7864	+{ /* JUMP / fnaddr = 18446744073709551056LLU; break; } / skip match */
7567	7865	/* match */
7568	7866	{/* PUSH /stack[stackbase + 3LLU] = 13116716846516535296LLU; }/ SP + 1LLU = 4LLU // SPMAX = 4LLU // SP + 1LLU = 5LLU // SPMAX = 5LLU // SP - 1LLU = 4LLU // SP - 1LLU = 3LLU / / MATCH-RESULT */
7569	7867	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 3LLU]; }/ SP = 3LLU */
7570		-{ /* JUMP / fnaddr = 18446744073709551083LLU; break; } / skip other */
7571		-case 18446744073709551084LLU: /* other // SP = 2LLU // parse data */
	7868	+{ /* JUMP / fnaddr = 18446744073709551055LLU; break; } / skip other */
	7869	+case 18446744073709551056LLU: /* other // SP = 2LLU // parse data */
7572	7870
7573	7871	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 3LLU // match-predicate */
7574	7872
7575	7873	if(/reduce____/0xB607F07A00000000LLU != stack[stackbase + 2LLU])
7576		-{ /* JUMP / fnaddr = 18446744073709551082LLU; break; } / skip match */
	7874	+{ /* JUMP / fnaddr = 18446744073709551054LLU; break; } / skip match */
7577	7875	/* match */
7578	7876	{/* PUSH /stack[stackbase + 3LLU] = 13116716846516535296LLU; }/ SP + 1LLU = 4LLU // SP + 1LLU = 5LLU // SP - 1LLU = 4LLU // SP - 1LLU = 3LLU / / MATCH-RESULT */
7579	7877	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 3LLU]; }/ SP = 3LLU */
7580		-{ /* JUMP / fnaddr = 18446744073709551081LLU; break; } / skip other */
7581		-case 18446744073709551082LLU: /* other // SP = 2LLU */
	7878	+{ /* JUMP / fnaddr = 18446744073709551053LLU; break; } / skip other */
	7879	+case 18446744073709551054LLU: /* other // SP = 2LLU */
7582	7880	{/* PUSH /stack[stackbase + 2LLU] = 12009798930018598912LLU; }/ SP + 1LLU = 3LLU // SP + 1LLU = 4LLU // SP - 1LLU = 3LLU */
7583		-case 18446744073709551081LLU: /* skip to here */
	7881	+case 18446744073709551053LLU: /* skip to here */
7584	7882
7585		-case 18446744073709551083LLU: /* skip to here */
	7883	+case 18446744073709551055LLU: /* skip to here */
7586	7884	/* SP - 1LLU = 2LLU // RESULT */
7587	7885	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 2LLU]; }/ SP = 3LLU // SP - 1LLU = 2LLU // RESULT */
7588	7886	{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 2LLU]; }

		@@ -7593,26 +7891,26 @@
7593	7891	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 3LLU // SPMAX = 3LLU // match-predicate */
7594	7892
7595	7893	if(/noreduce__/0xA6AB607F07A00000LLU != stack[stackbase + 2LLU])
7596		-{ /* JUMP / fnaddr = 18446744073709551080LLU; break; } / skip match */
	7894	+{ /* JUMP / fnaddr = 18446744073709551052LLU; break; } / skip match */
7597	7895	/* match */
7598	7896	{/* PUSH /stack[stackbase + 3LLU] = 12009798930018598912LLU; }/ SP + 1LLU = 4LLU // SPMAX = 4LLU // SP + 1LLU = 5LLU // SPMAX = 5LLU // SP - 1LLU = 4LLU // SP - 1LLU = 3LLU / / MATCH-RESULT */
7599	7897	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 3LLU]; }/ SP = 3LLU */
7600		-{ /* JUMP / fnaddr = 18446744073709551079LLU; break; } / skip other */
7601		-case 18446744073709551080LLU: /* other // SP = 2LLU // parse data */
	7898	+{ /* JUMP / fnaddr = 18446744073709551051LLU; break; } / skip other */
	7899	+case 18446744073709551052LLU: /* other // SP = 2LLU // parse data */
7602	7900
7603	7901	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 3LLU // match-predicate */
7604	7902
7605	7903	if(/noreduce__/0xA6AB607F07A00000LLU != stack[stackbase + 2LLU])
7606		-{ /* JUMP / fnaddr = 18446744073709551078LLU; break; } / skip match */
	7904	+{ /* JUMP / fnaddr = 18446744073709551050LLU; break; } / skip match */
7607	7905	/* match */
7608	7906	{/* PUSH /stack[stackbase + 3LLU] = 12009798930018598912LLU; }/ SP + 1LLU = 4LLU // SP + 1LLU = 5LLU // SP - 1LLU = 4LLU // SP - 1LLU = 3LLU / / MATCH-RESULT */
7609	7907	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 3LLU]; }/ SP = 3LLU */
7610		-{ /* JUMP / fnaddr = 18446744073709551077LLU; break; } / skip other */
7611		-case 18446744073709551078LLU: /* other // SP = 2LLU */
	7908	+{ /* JUMP / fnaddr = 18446744073709551049LLU; break; } / skip other */
	7909	+case 18446744073709551050LLU: /* other // SP = 2LLU */
7612	7910	{/* PUSH /stack[stackbase + 2LLU] = 13116716846516535296LLU; }/ SP + 1LLU = 3LLU // SP + 1LLU = 4LLU // SP - 1LLU = 3LLU */
7613		-case 18446744073709551077LLU: /* skip to here */
	7911	+case 18446744073709551049LLU: /* skip to here */
7614	7912
7615		-case 18446744073709551079LLU: /* skip to here */
	7913	+case 18446744073709551051LLU: /* skip to here */
7616	7914	/* SP - 1LLU = 2LLU // RESULT */
7617	7915	{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 2LLU]; }/ SP = 3LLU // SP - 1LLU = 2LLU // RESULT */
7618	7916	{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 2LLU]; }

		@@ -7630,12 +7928,12 @@
7630	7928	{
7631	7929	/CALLEND/
7632	7930	stackbase += 4LLU;
7633		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE4LLU;
	7931	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC8LLU;
7634	7932	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
7635	7933	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
7636	7934	break;
7637	7935	}
7638		-case 0xFFFFFFFFFFFFFDE4LLU:
	7936	+case 0xFFFFFFFFFFFFFDC8LLU:
7639	7937	/* SP = 2LLU /fputs(" requires completeness, ", stderr); fputs("but ", stderr); / predicate */
7640	7938
7641	7939	{/* PUSH /stack[stackbase + 2LLU] = 0LLU; }/ SP + 1LLU = 3LLU */

		@@ -7643,7 +7941,7 @@
7643	7941	{
7644	7942	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 2LLU] != stack[stackbase + 3LLU]; }/ SP + 1LLU = 3LLU */ }
7645	7943	if(!/* SP - 1LLU = 2LLU // POP */stack[stackbase + 2LLU])
7646		-{ /* JUMP / fnaddr = 18446744073709551075LLU; break; } / skip consequent */
	7944	+{ /* JUMP / fnaddr = 18446744073709551047LLU; break; } / skip consequent */
7647	7945	/* consequent */fputs("callee ", stderr);
7648	7946	{
7649	7947	/* CALLBEGIN */

		@@ -7655,16 +7953,16 @@
7655	7953	{
7656	7954	/CALLEND/
7657	7955	stackbase += 4LLU;
7658		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDE1LLU;
	7956	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC5LLU;
7659	7957	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
7660	7958	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
7661	7959	break;
7662	7960	}
7663		-case 0xFFFFFFFFFFFFFDE1LLU:
	7961	+case 0xFFFFFFFFFFFFFDC5LLU:
7664	7962	/* SP = 2LLU // SP = 2LLU // SP = 2LLU */
7665		-{ /* JUMP / fnaddr = 18446744073709551074LLU; break; } / skip alternative */
7666		-case 18446744073709551075LLU: /* alternative /fputs("expression", stderr); / SP = 2LLU */
7667		-case 18446744073709551074LLU: /* skip to here */
	7963	+{ /* JUMP / fnaddr = 18446744073709551046LLU; break; } / skip alternative */
	7964	+case 18446744073709551047LLU: /* alternative /fputs("expression", stderr); / SP = 2LLU */
	7965	+case 18446744073709551046LLU: /* skip to here */
7668	7966	fputs(" is incomplete\n", stderr);
7669	7967	{/* set exit-value */stack[16LLU] = 255LLU; }
7670	7968	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 2LLU // SP - 0LLU = 2LLU // RESULT */

		@@ -7675,13 +7973,13 @@
7675	7973	{/* PUSH /stack[stackbase + 4LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 5LLU // SPMAX = 5LLU // match-predicate */
7676	7974
7677	7975	if(/incomplete/0x9297AAA2B9E0BE00LLU != stack[stackbase + 4LLU])
7678		-{ /* JUMP / fnaddr = 18446744073709551072LLU; break; } / skip match */
	7976	+{ /* JUMP / fnaddr = 18446744073709551044LLU; break; } / skip match */
7679	7977	/* match // parse data */
7680	7978
7681	7979	{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 6LLU // SPMAX = 6LLU // match-predicate */
7682	7980
7683	7981	if(/complete__/0x7AAA2B9E0BE00000LLU != stack[stackbase + 5LLU])
7684		-{ /* JUMP / fnaddr = 18446744073709551070LLU; break; } / skip match */
	7982	+{ /* JUMP / fnaddr = 18446744073709551042LLU; break; } / skip match */
7685	7983	/* match */
7686	7984	{
7687	7985	/* CALLBEGIN */

		@@ -7694,20 +7992,20 @@
7694	7992	{
7695	7993	/CALLEND/
7696	7994	stackbase += 8LLU;
7697		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDCLLU;
	7995	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC0LLU;
7698	7996	fnaddr = /refutecomp/0xB60870BE07AAA2B0LLU;/* SP = 0LLU */
7699	7997	{ if(stackbase + 11LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /refutecomp/\n"); exit(-1); } }
7700	7998	break;
7701	7999	}
7702		-case 0xFFFFFFFFFFFFFDDCLLU:
	8000	+case 0xFFFFFFFFFFFFFDC0LLU:
7703	8001	/* SP = 6LLU // SP = 6LLU // SP - 0LLU = 6LLU / / MATCH-RESULT // SP = 5LLU */
7704		-{ /* JUMP / fnaddr = 18446744073709551069LLU; break; } / skip other */
7705		-case 18446744073709551070LLU: /* other // SP = 5LLU // SP = 5LLU */
7706		-case 18446744073709551069LLU: /* skip to here */
	8002	+{ /* JUMP / fnaddr = 18446744073709551041LLU; break; } / skip other */
	8003	+case 18446744073709551042LLU: /* other // SP = 5LLU // SP = 5LLU */
	8004	+case 18446744073709551041LLU: /* skip to here */
7707	8005	/* SP = 5LLU // SP - 0LLU = 5LLU / / MATCH-RESULT // SP = 4LLU */
7708		-{ /* JUMP / fnaddr = 18446744073709551071LLU; break; } / skip other */
7709		-case 18446744073709551072LLU: /* other // SP = 4LLU // SP = 4LLU */
7710		-case 18446744073709551071LLU: /* skip to here */
	8006	+{ /* JUMP / fnaddr = 18446744073709551043LLU; break; } / skip other */
	8007	+case 18446744073709551044LLU: /* other // SP = 4LLU // SP = 4LLU */
	8008	+case 18446744073709551043LLU: /* skip to here */
7711	8009	/* SP = 4LLU // SP - 0LLU = 4LLU // RESULT */
7712	8010	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
7713	8011	/* function requires 19LLU 64-bit chunks of memory (including 4LLU for parameters) */

		@@ -7723,12 +8021,12 @@
7723	8021	{
7724	8022	/CALLEND/
7725	8023	stackbase += 4LLU;
7726		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDDBLLU;
	8024	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBFLLU;
7727	8025	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
7728	8026	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
7729	8027	break;
7730	8028	}
7731		-case 0xFFFFFFFFFFFFFDDBLLU:
	8029	+case 0xFFFFFFFFFFFFFDBFLLU:
7732	8030	/* SP = 2LLU /fputs(" requires finiteness, ", stderr); fputs("but ", stderr); / predicate */
7733	8031
7734	8032	{/* PUSH /stack[stackbase + 2LLU] = 0LLU; }/ SP + 1LLU = 3LLU */

		@@ -7736,7 +8034,7 @@
7736	8034	{
7737	8035	{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 2LLU] != stack[stackbase + 3LLU]; }/ SP + 1LLU = 3LLU */ }
7738	8036	if(!/* SP - 1LLU = 2LLU // POP */stack[stackbase + 2LLU])
7739		-{ /* JUMP / fnaddr = 18446744073709551066LLU; break; } / skip consequent */
	8037	+{ /* JUMP / fnaddr = 18446744073709551038LLU; break; } / skip consequent */
7740	8038	/* consequent */fputs("callee ", stderr);
7741	8039	{
7742	8040	/* CALLBEGIN */

		@@ -7748,16 +8046,16 @@
7748	8046	{
7749	8047	/CALLEND/
7750	8048	stackbase += 4LLU;
7751		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD8LLU;
	8049	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBCLLU;
7752	8050	fnaddr = /reportid__/0xB60AEAB6F91F0000LLU;/* SP = 0LLU */
7753	8051	{ if(stackbase + 7LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /reportid__/\n"); exit(-1); } }
7754	8052	break;
7755	8053	}
7756		-case 0xFFFFFFFFFFFFFDD8LLU:
	8054	+case 0xFFFFFFFFFFFFFDBCLLU:
7757	8055	/* SP = 2LLU // SP = 2LLU // SP = 2LLU */
7758		-{ /* JUMP / fnaddr = 18446744073709551065LLU; break; } / skip alternative */
7759		-case 18446744073709551066LLU: /* alternative /fputs("expression", stderr); / SP = 2LLU */
7760		-case 18446744073709551065LLU: /* skip to here */
	8056	+{ /* JUMP / fnaddr = 18446744073709551037LLU; break; } / skip alternative */
	8057	+case 18446744073709551038LLU: /* alternative /fputs("expression", stderr); / SP = 2LLU */
	8058	+case 18446744073709551037LLU: /* skip to here */
7761	8059	fputs(" is infinite\n", stderr);
7762	8060	{/* set exit-value */stack[16LLU] = 255LLU; }
7763	8061	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 2LLU // SP - 0LLU = 2LLU // RESULT */

		@@ -7769,7 +8067,7 @@
7769	8067	{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 8LLU // SPMAX = 8LLU // match-predicate */
7770	8068
7771	8069	if(/loopunsafe/0x9EAAABC29B9C8600LLU != stack[stackbase + 6LLU])
7772		-{ /* JUMP / fnaddr = 18446744073709551063LLU; break; } / skip match */
	8070	+{ /* JUMP / fnaddr = 18446744073709551035LLU; break; } / skip match */
7773	8071	/* match // parse data */
7774	8072
7775	8073	{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 9LLU // SPMAX = 9LLU */

		@@ -7776,7 +8074,7 @@
7776	8074	{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 10LLU // SPMAX = 10LLU // match-predicate */
7777	8075
7778	8076	if(/loopsafe__/0x9EAAABB9C8600000LLU != stack[stackbase + 8LLU])
7779		-{ /* JUMP / fnaddr = 18446744073709551061LLU; break; } / skip match */
	8077	+{ /* JUMP / fnaddr = 18446744073709551033LLU; break; } / skip match */
7780	8078	/* match */
7781	8079	{
7782	8080	/* CALLBEGIN */

		@@ -7789,20 +8087,20 @@
7789	8087	{
7790	8088	/CALLEND/
7791	8089	stackbase += 12LLU;
7792		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD3LLU;
	8090	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB7LLU;
7793	8091	fnaddr = /refutehalt/0xB60870BE08DC9EF0LLU;/* SP = 0LLU */
7794	8092	{ if(stackbase + 11LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /refutehalt/\n"); exit(-1); } }
7795	8093	break;
7796	8094	}
7797		-case 0xFFFFFFFFFFFFFDD3LLU:
	8095	+case 0xFFFFFFFFFFFFFDB7LLU:
7798	8096	/* SP = 10LLU // SP = 10LLU // SP - 0LLU = 10LLU / / MATCH-RESULT // SP = 8LLU */
7799		-{ /* JUMP / fnaddr = 18446744073709551060LLU; break; } / skip other */
7800		-case 18446744073709551061LLU: /* other // SP = 8LLU // SP = 8LLU */
7801		-case 18446744073709551060LLU: /* skip to here */
	8097	+{ /* JUMP / fnaddr = 18446744073709551032LLU; break; } / skip other */
	8098	+case 18446744073709551033LLU: /* other // SP = 8LLU // SP = 8LLU */
	8099	+case 18446744073709551032LLU: /* skip to here */
7802	8100	/* SP = 8LLU // SP - 0LLU = 8LLU / / MATCH-RESULT // SP = 6LLU */
7803		-{ /* JUMP / fnaddr = 18446744073709551062LLU; break; } / skip other */
7804		-case 18446744073709551063LLU: /* other // SP = 6LLU // SP = 6LLU */
7805		-case 18446744073709551062LLU: /* skip to here */
	8101	+{ /* JUMP / fnaddr = 18446744073709551034LLU; break; } / skip other */
	8102	+case 18446744073709551035LLU: /* other // SP = 6LLU // SP = 6LLU */
	8103	+case 18446744073709551034LLU: /* skip to here */
7806	8104	/* SP = 6LLU // SP - 0LLU = 6LLU // RESULT */
7807	8105	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
7808	8106	/* function requires 23LLU 64-bit chunks of memory (including 6LLU for parameters) */

		@@ -7820,12 +8118,12 @@
7820	8118	{
7821	8119	/CALLEND/
7822	8120	stackbase += 10LLU;
7823		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD2LLU;
	8121	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB6LLU;
7824	8122	fnaddr = /verifycomp/0xC60B648747AAA2B0LLU;/* SP = 0LLU */
7825	8123	{ if(stackbase + 19LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /verifycomp/\n"); exit(-1); } }
7826	8124	break;
7827	8125	}
7828		-case 0xFFFFFFFFFFFFFDD2LLU:
	8126	+case 0xFFFFFFFFFFFFFDB6LLU:
7829	8127	/* SP = 8LLU */
7830	8128	{
7831	8129	/* CALLBEGIN */

		@@ -7842,12 +8140,12 @@
7842	8140	{
7843	8141	/CALLEND/
7844	8142	stackbase += 10LLU;
7845		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD1LLU;
	8143	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB5LLU;
7846	8144	fnaddr = /verifyhalt/0xC60B648748DC9EF0LLU;/* SP = 0LLU */
7847	8145	{ if(stackbase + 23LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /verifyhalt/\n"); exit(-1); } }
7848	8146	break;
7849	8147	}
7850		-case 0xFFFFFFFFFFFFFDD1LLU:
	8148	+case 0xFFFFFFFFFFFFFDB5LLU:
7851	8149	/* SP = 8LLU // SP = 8LLU // SP - 0LLU = 8LLU // RESULT */
7852	8150	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
7853	8151	/* function requires 33LLU 64-bit chunks of memory (including 8LLU for parameters) */

		@@ -7861,12 +8159,12 @@
7861	8159	{
7862	8160	/CALLEND/
7863	8161	stackbase += 3LLU;
7864		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDD0LLU;
	8162	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB4LLU;
7865	8163	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
7866	8164	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
7867	8165	break;
7868	8166	}
7869		-case 0xFFFFFFFFFFFFFDD0LLU:
	8167	+case 0xFFFFFFFFFFFFFDB4LLU:
7870	8168	/* SP = 1LLU */
7871	8169	{
7872	8170	/* CALLBEGIN */

		@@ -7878,12 +8176,12 @@
7878	8176	{
7879	8177	/CALLEND/
7880	8178	stackbase += 3LLU;
7881		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCFLLU;
	8179	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB3LLU;
7882	8180	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
7883	8181	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
7884	8182	break;
7885	8183	}
7886		-case 0xFFFFFFFFFFFFFDCFLLU:
	8184	+case 0xFFFFFFFFFFFFFDB3LLU:
7887	8185	/* SP = 1LLU */fputs("\n{ ", stdout);
7888	8186	{
7889	8187	/* CALLBEGIN */

		@@ -7894,12 +8192,12 @@
7894	8192	{
7895	8193	/CALLEND/
7896	8194	stackbase += 3LLU;
7897		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCELLU;
	8195	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB2LLU;
7898	8196	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
7899	8197	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
7900	8198	break;
7901	8199	}
7902		-case 0xFFFFFFFFFFFFFDCELLU:
	8200	+case 0xFFFFFFFFFFFFFDB2LLU:
7903	8201	/* SP = 1LLU */fputs(" = ", stdout);
7904	8202	{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU */
7905	8203	{ fputc(/* TOP */stack[stackbase + 1LLU], stdout); }

		@@ -7912,12 +8210,12 @@
7912	8210	{
7913	8211	/CALLEND/
7914	8212	stackbase += 4LLU;
7915		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCDLLU;
	8213	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB1LLU;
7916	8214	fnaddr = /TOP_GET___/0x50F4001C55000000LLU;/* SP = 0LLU */
7917	8215	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_GET___/\n"); exit(-1); } }
7918	8216	break;
7919	8217	}
7920		-case 0xFFFFFFFFFFFFFDCDLLU:
	8218	+case 0xFFFFFFFFFFFFFDB1LLU:
7921	8219	/* SP = 2LLU /fputs(" }", stdout); / SP = 1LLU // SP - 0LLU = 1LLU // RESULT */
7922	8220	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
7923	8221	/* function requires 22LLU 64-bit chunks of memory (including 1LLU for parameters) */

		@@ -7931,12 +8229,12 @@
7931	8229	{
7932	8230	/CALLEND/
7933	8231	stackbase += 5LLU;
7934		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCCLLU;
	8232	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB0LLU;
7935	8233	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
7936	8234	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
7937	8235	break;
7938	8236	}
7939		-case 0xFFFFFFFFFFFFFDCCLLU:
	8237	+case 0xFFFFFFFFFFFFFDB0LLU:
7940	8238	/* SP = 3LLU */
7941	8239	{
7942	8240	/* CALLBEGIN */

		@@ -7948,12 +8246,12 @@
7948	8246	{
7949	8247	/CALLEND/
7950	8248	stackbase += 5LLU;
7951		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCBLLU;
	8249	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAFLLU;
7952	8250	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
7953	8251	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
7954	8252	break;
7955	8253	}
7956		-case 0xFFFFFFFFFFFFFDCBLLU:
	8254	+case 0xFFFFFFFFFFFFFDAFLLU:
7957	8255	/* SP = 3LLU */
7958	8256	{
7959	8257	/* CALLBEGIN */

		@@ -7965,12 +8263,12 @@
7965	8263	{
7966	8264	/CALLEND/
7967	8265	stackbase += 5LLU;
7968		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDCALLU;
	8266	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAELLU;
7969	8267	fnaddr = /SP_SET____/0x4D00131540000000LLU;/* SP = 0LLU */
7970	8268	{ if(stackbase + 19LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_SET____/\n"); exit(-1); } }
7971	8269	break;
7972	8270	}
7973		-case 0xFFFFFFFFFFFFFDCALLU:
	8271	+case 0xFFFFFFFFFFFFFDAELLU:
7974	8272	/* SP = 3LLU */fputs("\n{ ", stdout);
7975	8273	{
7976	8274	/* CALLBEGIN */

		@@ -7981,12 +8279,12 @@
7981	8279	{
7982	8280	/CALLEND/
7983	8281	stackbase += 5LLU;
7984		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC9LLU;
	8282	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDADLLU;
7985	8283	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
7986	8284	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); } }
7987	8285	break;
7988	8286	}
7989		-case 0xFFFFFFFFFFFFFDC9LLU:
	8287	+case 0xFFFFFFFFFFFFFDADLLU:
7990	8288	/* SP = 3LLU */
7991	8289	{
7992	8290	/* CALLBEGIN */

		@@ -7998,12 +8296,12 @@
7998	8296	{
7999	8297	/CALLEND/
8000	8298	stackbase += 5LLU;
8001		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC8LLU;
	8299	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDACLLU;
8002	8300	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
8003	8301	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
8004	8302	break;
8005	8303	}
8006		-case 0xFFFFFFFFFFFFFDC8LLU:
	8304	+case 0xFFFFFFFFFFFFFDACLLU:
8007	8305	/* SP = 3LLU */fputs(" ", stdout);
8008	8306	{/* PUSH /stack[stackbase + 3LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 4LLU */
8009	8307	{ fputc(/* TOP */stack[stackbase + 3LLU], stdout); }

		@@ -8022,12 +8320,12 @@
8022	8320	{
8023	8321	/CALLEND/
8024	8322	stackbase += 7LLU;
8025		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC7LLU;
	8323	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDABLLU;
8026	8324	fnaddr = /ACCESSVAR_/0x0430C54D35814800LLU;/* SP = 0LLU */
8027	8325	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /ACCESSVAR_/\n"); exit(-1); } }
8028	8326	break;
8029	8327	}
8030		-case 0xFFFFFFFFFFFFFDC7LLU:
	8328	+case 0xFFFFFFFFFFFFFDABLLU:
8031	8329	/* SP = 5LLU */
8032	8330	{
8033	8331	/* CALLBEGIN */

		@@ -8038,260 +8336,212 @@
8038	8336	{
8039	8337	/CALLEND/
8040	8338	stackbase += 7LLU;
8041		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC6LLU;
	8339	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAALLU;
8042	8340	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
8043	8341	{ if(stackbase + 21LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); } }
8044	8342	break;
8045	8343	}
8046		-case 0xFFFFFFFFFFFFFDC6LLU:
	8344	+case 0xFFFFFFFFFFFFFDAALLU:
8047	8345	/* SP = 5LLU /fputs(" }", stdout); / SP = 3LLU // SP - 0LLU = 3LLU // RESULT */
8048	8346	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
8049	8347	/* function requires 28LLU 64-bit chunks of memory (including 3LLU for parameters) */
8050		-case /elemaccess/0x82782871E7A0BAE0LLU:/* SP = 6LLU // SPMAX = 6LLU */
	8348	+case /elemaccess/0x82782871E7A0BAE0LLU:/* SP = 7LLU // SPMAX = 7LLU */
8051	8349	{
8052	8350	/* CALLBEGIN */
8053		- /* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */
8054		-{/* PUSH /stack[stackbase + 6LLU] = stackbase; }/ SP + 1LLU = 7LLU // SPMAX = 7LLU */
8055		- /* leave place for return addr // SP + 1LLU = 8LLU // SPMAX = 8LLU */
8056		- }/* SP + 13LLU = 21LLU // SPMAX = 21LLU // SP - 13LLU = 8LLU */
	8351	+ /* reserve space for 0LLU returned values // SP + 0LLU = 7LLU */
	8352	+{/* PUSH /stack[stackbase + 7LLU] = stackbase; }/ SP + 1LLU = 8LLU // SPMAX = 8LLU */
	8353	+ /* leave place for return addr // SP + 1LLU = 9LLU // SPMAX = 9LLU */
	8354	+ }/* SP + 13LLU = 22LLU // SPMAX = 22LLU // SP - 13LLU = 9LLU */
8057	8355	{
8058	8356	/CALLEND/
8059		- stackbase += 8LLU;
8060		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC5LLU;
	8357	+ stackbase += 9LLU;
	8358	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA9LLU;
8061	8359	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8062	8360	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8063	8361	break;
8064	8362	}
8065		-case 0xFFFFFFFFFFFFFDC5LLU:
8066		-/* SP = 6LLU // predicate */
	8363	+case 0xFFFFFFFFFFFFFDA9LLU:
	8364	+/* SP = 7LLU // predicate */
8067	8365
8068		-{/* PUSH /stack[stackbase + 6LLU] = 46LLU; }/ SP + 1LLU = 7LLU */
8069		-{/* PUSH /stack[stackbase + 7LLU] = ungetc(fgetc(stdin), stdin); }/ SP + 1LLU = 8LLU // SP = 6LLU */
	8366	+{/* PUSH /stack[stackbase + 7LLU] = 46LLU; }/ SP + 1LLU = 8LLU */
	8367	+{/* PUSH /stack[stackbase + 8LLU] = ungetc(fgetc(stdin), stdin); }/ SP + 1LLU = 9LLU // SP = 7LLU */
8070	8368	{
8071		-{/* PUSH /stack[stackbase + 6LLU] = stack[stackbase + 6LLU] == stack[stackbase + 7LLU]; }/ SP + 1LLU = 7LLU */ }
8072		-if(!/* SP - 1LLU = 6LLU // POP */stack[stackbase + 6LLU])
8073		-{ /* JUMP / fnaddr = 18446744073709551044LLU; break; } / skip consequent */
	8369	+{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 7LLU] == stack[stackbase + 8LLU]; }/ SP + 1LLU = 8LLU */ }
	8370	+if(!/* SP - 1LLU = 7LLU // POP */stack[stackbase + 7LLU])
	8371	+{ /* JUMP / fnaddr = 18446744073709551016LLU; break; } / skip consequent */
8074	8372	/* consequent */
8075		-case 0xFFFFFFFFFFFFFDC3LLU: /* loop to here // predicate */
	8373	+case 0xFFFFFFFFFFFFFDA7LLU: /* loop to here // predicate */
8076	8374
8077	8375	{
8078	8376	/* CALLBEGIN */
8079		- /* reserve space for 0LLU returned values // SP + 0LLU = 6LLU */
8080		-{/* PUSH /stack[stackbase + 6LLU] = stackbase; }/ SP + 1LLU = 7LLU */
8081		- /* leave place for return addr // SP + 1LLU = 8LLU */
8082		- }/* SP + 5LLU = 13LLU // SP - 5LLU = 8LLU */
	8377	+ /* reserve space for 0LLU returned values // SP + 0LLU = 7LLU */
	8378	+{/* PUSH /stack[stackbase + 7LLU] = stackbase; }/ SP + 1LLU = 8LLU */
	8379	+ /* leave place for return addr // SP + 1LLU = 9LLU */
	8380	+ }/* SP + 5LLU = 14LLU // SP - 5LLU = 9LLU */
8083	8381	{
8084	8382	/CALLEND/
8085		- stackbase += 8LLU;
8086		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC2LLU;
	8383	+ stackbase += 9LLU;
	8384	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA6LLU;
8087	8385	fnaddr = /skip______/0xBA692B0000000000LLU;/* SP = 0LLU */
8088	8386	{ if(stackbase + 5LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skip______/\n"); exit(-1); } }
8089	8387	break;
8090	8388	}
8091		-case 0xFFFFFFFFFFFFFDC2LLU:
8092		-/* SP = 6LLU */
	8389	+case 0xFFFFFFFFFFFFFDA6LLU:
	8390	+/* SP = 7LLU */
8093	8391	{
8094	8392	/* CALLBEGIN */
8095		- /* reserve space for 3LLU returned values // SP + 3LLU = 9LLU */
8096		-{/* PUSH /stack[stackbase + 9LLU] = stackbase; }/ SP + 1LLU = 10LLU */
8097		- /* leave place for return addr // SP + 1LLU = 11LLU */
8098		- }/* SP + 37LLU = 48LLU // SPMAX = 48LLU // SP - 37LLU = 11LLU */
8099		-{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 12LLU */
	8393	+ /* reserve space for 3LLU returned values // SP + 3LLU = 10LLU */
	8394	+{/* PUSH /stack[stackbase + 10LLU] = stackbase; }/ SP + 1LLU = 11LLU */
	8395	+ /* leave place for return addr // SP + 1LLU = 12LLU */
	8396	+ }/* SP + 37LLU = 49LLU // SPMAX = 49LLU // SP - 37LLU = 12LLU */
	8397	+{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 13LLU */
8100	8398	{
8101	8399	/* CALLBEGIN */
8102		- /* reserve space for 1LLU returned values // SP + 1LLU = 13LLU */
8103		-{/* PUSH /stack[stackbase + 13LLU] = stackbase; }/ SP + 1LLU = 14LLU */
8104		- /* leave place for return addr // SP + 1LLU = 15LLU */
8105		- }/* SP + 2LLU = 17LLU // SP - 2LLU = 15LLU */
	8400	+ /* reserve space for 1LLU returned values // SP + 1LLU = 14LLU */
	8401	+{/* PUSH /stack[stackbase + 14LLU] = stackbase; }/ SP + 1LLU = 15LLU */
	8402	+ /* leave place for return addr // SP + 1LLU = 16LLU */
	8403	+ }/* SP + 2LLU = 18LLU // SP - 2LLU = 16LLU */
8106	8404	{
8107	8405	/* CALLBEGIN */
8108		- /* reserve space for 1LLU returned values // SP + 1LLU = 16LLU */
8109		-{/* PUSH /stack[stackbase + 16LLU] = stackbase; }/ SP + 1LLU = 17LLU */
8110		- /* leave place for return addr // SP + 1LLU = 18LLU */
8111		- }/* SP + 5LLU = 23LLU // SP - 5LLU = 18LLU */
8112		-{/* PUSH /stack[stackbase + 18LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 19LLU */
	8406	+ /* reserve space for 1LLU returned values // SP + 1LLU = 17LLU */
	8407	+{/* PUSH /stack[stackbase + 17LLU] = stackbase; }/ SP + 1LLU = 18LLU */
	8408	+ /* leave place for return addr // SP + 1LLU = 19LLU */
	8409	+ }/* SP + 5LLU = 24LLU // SP - 5LLU = 19LLU */
8113	8410	{/* PUSH /stack[stackbase + 19LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 20LLU */
	8411	+{/* PUSH /stack[stackbase + 20LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 21LLU */
8114	8412	{
8115	8413	/CALLEND/
8116		- stackbase += 18LLU;
8117		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC1LLU;
	8414	+ stackbase += 19LLU;
	8415	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA5LLU;
8118	8416	fnaddr = /typetosub_/0xBF4AE0BEABB07400LLU;/* SP = 0LLU */
8119	8417	{ if(stackbase + 5LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typetosub_/\n"); exit(-1); } }
8120	8418	break;
8121	8419	}
8122		-case 0xFFFFFFFFFFFFFDC1LLU:
8123		-/* SP = 16LLU */
	8420	+case 0xFFFFFFFFFFFFFDA5LLU:
	8421	+/* SP = 17LLU */
8124	8422	{
8125	8423	/CALLEND/
8126		- stackbase += 15LLU;
8127		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDC0LLU;
	8424	+ stackbase += 16LLU;
	8425	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA4LLU;
8128	8426	fnaddr = /subtoid___/0xBB076FAA47C00000LLU;/* SP = 0LLU */
8129	8427	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /subtoid___/\n"); exit(-1); } }
8130	8428	break;
8131	8429	}
8132		-case 0xFFFFFFFFFFFFFDC0LLU:
8133		-/* SP = 13LLU */
	8430	+case 0xFFFFFFFFFFFFFDA4LLU:
	8431	+/* SP = 14LLU */
8134	8432	{
8135	8433	/* CALLBEGIN */
8136		- /* reserve space for 1LLU returned values // SP + 1LLU = 14LLU */
8137		-{/* PUSH /stack[stackbase + 14LLU] = stackbase; }/ SP + 1LLU = 15LLU */
8138		- /* leave place for return addr // SP + 1LLU = 16LLU */
8139		- }/* SP + 13LLU = 29LLU // SP - 13LLU = 16LLU */
	8434	+ /* reserve space for 1LLU returned values // SP + 1LLU = 15LLU */
	8435	+{/* PUSH /stack[stackbase + 15LLU] = stackbase; }/ SP + 1LLU = 16LLU */
	8436	+ /* leave place for return addr // SP + 1LLU = 17LLU */
	8437	+ }/* SP + 13LLU = 30LLU // SP - 13LLU = 17LLU */
8140	8438	{
8141	8439	/* CALLBEGIN */
8142		- /* reserve space for 1LLU returned values // SP + 1LLU = 17LLU */
8143		-{/* PUSH /stack[stackbase + 17LLU] = stackbase; }/ SP + 1LLU = 18LLU */
8144		- /* leave place for return addr // SP + 1LLU = 19LLU */
8145		- }/* SP + 13LLU = 32LLU // SP - 13LLU = 19LLU */
	8440	+ /* reserve space for 1LLU returned values // SP + 1LLU = 18LLU */
	8441	+{/* PUSH /stack[stackbase + 18LLU] = stackbase; }/ SP + 1LLU = 19LLU */
	8442	+ /* leave place for return addr // SP + 1LLU = 20LLU */
	8443	+ }/* SP + 13LLU = 33LLU // SP - 13LLU = 20LLU */
8146	8444	{
8147	8445	/* CALLBEGIN */
8148		- /* reserve space for 1LLU returned values // SP + 1LLU = 20LLU */
8149		-{/* PUSH /stack[stackbase + 20LLU] = stackbase; }/ SP + 1LLU = 21LLU */
8150		- /* leave place for return addr // SP + 1LLU = 22LLU */
8151		- }/* SP + 2LLU = 24LLU // SP - 2LLU = 22LLU */
	8446	+ /* reserve space for 1LLU returned values // SP + 1LLU = 21LLU */
	8447	+{/* PUSH /stack[stackbase + 21LLU] = stackbase; }/ SP + 1LLU = 22LLU */
	8448	+ /* leave place for return addr // SP + 1LLU = 23LLU */
	8449	+ }/* SP + 2LLU = 25LLU // SP - 2LLU = 23LLU */
8152	8450	{
8153	8451	/CALLEND/
8154		- stackbase += 22LLU;
8155		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBFLLU;
	8452	+ stackbase += 23LLU;
	8453	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA3LLU;
8156	8454	fnaddr = /get_______/0x8A0BC00000000000LLU;/* SP = 0LLU */
8157	8455	{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /get_______/\n"); exit(-1); } }
8158	8456	break;
8159	8457	}
8160		-case 0xFFFFFFFFFFFFFDBFLLU:
8161		-/* SP = 20LLU */
	8458	+case 0xFFFFFFFFFFFFFDA3LLU:
	8459	+/* SP = 21LLU */
8162	8460	{
8163	8461	/CALLEND/
8164		- stackbase += 19LLU;
8165		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBELLU;
	8462	+ stackbase += 20LLU;
	8463	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA2LLU;
8166	8464	fnaddr = /SKIPCMNTS_/0x4CB2500CD3944C00LLU;/* SP = 0LLU */
8167	8465	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SKIPCMNTS_/\n"); exit(-1); } }
8168	8466	break;
8169	8467	}
8170		-case 0xFFFFFFFFFFFFFDBELLU:
8171		-/* SP = 17LLU */
	8468	+case 0xFFFFFFFFFFFFFDA2LLU:
	8469	+/* SP = 18LLU */
8172	8470	{
8173	8471	/CALLEND/
8174		- stackbase += 16LLU;
8175		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBDLLU;
	8472	+ stackbase += 17LLU;
	8473	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA1LLU;
8176	8474	fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
8177	8475	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); } }
8178	8476	break;
8179	8477	}
8180		-case 0xFFFFFFFFFFFFFDBDLLU:
8181		-/* SP = 14LLU */
	8478	+case 0xFFFFFFFFFFFFFDA1LLU:
	8479	+/* SP = 15LLU */
8182	8480	{
8183	8481	/CALLEND/
8184		- stackbase += 11LLU;
8185		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBCLLU;
	8482	+ stackbase += 12LLU;
	8483	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA0LLU;
8186	8484	fnaddr = /getdefelem/0x8A0BDF8218278280LLU;/* SP = 0LLU */
8187	8485	{ if(stackbase + 37LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /getdefelem/\n"); exit(-1); } }
8188	8486	break;
8189	8487	}
8190		-case 0xFFFFFFFFFFFFFDBCLLU:
8191		-/* SP = 9LLU */
8192		-{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 10LLU */
8193		-{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 11LLU // SP = 9LLU */
	8488	+case 0xFFFFFFFFFFFFFDA0LLU:
	8489	+/* SP = 10LLU */
	8490	+{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 11LLU */
	8491	+{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 7LLU]; }/ SP + 1LLU = 12LLU // SP = 10LLU */
8194	8492	{
8195		-{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 9LLU] + stack[stackbase + 10LLU]; }/ SP + 1LLU = 10LLU / }/ SP = 9LLU // assign */
8196		-{ /* RESULT */stack[stackbase + 2LLU] = stack[stackbase + 9LLU]; }
8197		-{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 7LLU]; }/ SP + 1LLU = 10LLU */
8198		-{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 8LLU]; }/ SP + 1LLU = 11LLU // SP = 9LLU // assign */
8199		-{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 9LLU]; }
8200		-{ /* RESULT */stack[stackbase + 4LLU] = stack[stackbase + 10LLU]; }
	8493	+{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 10LLU] + stack[stackbase + 11LLU]; }/ SP + 1LLU = 11LLU / }/ SP = 10LLU // assign */
	8494	+{ /* RESULT /stack[stackbase + 2LLU] = stack[stackbase + 10LLU]; }/ SP + 3LLU = 13LLU // SP - 3LLU = 10LLU */
	8495	+{/* PUSH /stack[stackbase + 10LLU] = 11748726454303588352LLU; }/ SP + 1LLU = 11LLU // SP + 1LLU = 12LLU // SP - 1LLU = 11LLU */
	8496	+{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 8LLU]; }/ SP + 1LLU = 12LLU */
	8497	+{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 9LLU]; }/ SP + 1LLU = 13LLU // SP = 10LLU // assign */
	8498	+{ /* RESULT */stack[stackbase + 3LLU] = stack[stackbase + 10LLU]; }
	8499	+{ /* RESULT */stack[stackbase + 4LLU] = stack[stackbase + 11LLU]; }
	8500	+{ /* RESULT */stack[stackbase + 5LLU] = stack[stackbase + 12LLU]; }
8201	8501	{
8202	8502	/* CALLBEGIN */
8203		- /* reserve space for 0LLU returned values // SP + 0LLU = 9LLU */
8204		-{/* PUSH /stack[stackbase + 9LLU] = stackbase; }/ SP + 1LLU = 10LLU */
8205		- /* leave place for return addr // SP + 1LLU = 11LLU */
8206		- }/* SP + 13LLU = 24LLU // SP - 13LLU = 11LLU */
	8503	+ /* reserve space for 0LLU returned values // SP + 0LLU = 10LLU */
	8504	+{/* PUSH /stack[stackbase + 10LLU] = stackbase; }/ SP + 1LLU = 11LLU */
	8505	+ /* leave place for return addr // SP + 1LLU = 12LLU */
	8506	+ }/* SP + 13LLU = 25LLU // SP - 13LLU = 12LLU */
8207	8507	{
8208	8508	/CALLEND/
8209		- stackbase += 11LLU;
8210		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBBLLU;
	8509	+ stackbase += 12LLU;
	8510	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9FLLU;
8211	8511	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8212	8512	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8213	8513	break;
8214	8514	}
8215		-case 0xFFFFFFFFFFFFFDBBLLU:
8216		-/* SP = 9LLU */
8217		-{/* PUSH /stack[stackbase + 9LLU] = 46LLU; }/ SP + 1LLU = 10LLU */
8218		-{/* PUSH /stack[stackbase + 10LLU] = ungetc(fgetc(stdin), stdin); }/ SP + 1LLU = 11LLU // SP = 9LLU */
	8515	+case 0xFFFFFFFFFFFFFD9FLLU:
	8516	+/* SP = 10LLU */
	8517	+{/* PUSH /stack[stackbase + 10LLU] = 46LLU; }/ SP + 1LLU = 11LLU */
	8518	+{/* PUSH /stack[stackbase + 11LLU] = ungetc(fgetc(stdin), stdin); }/ SP + 1LLU = 12LLU // SP = 10LLU */
8219	8519	{
8220		-{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 9LLU] == stack[stackbase + 10LLU]; }/ SP + 1LLU = 10LLU / }/ SP - 1LLU = 9LLU // RESULT */
8221		-{ /* RESULT /stack[stackbase + 6LLU] = stack[stackbase + 9LLU]; }/ SP = 7LLU */
8222		-if(/* SP - 1LLU = 6LLU // POP */stack[stackbase + 6LLU])
8223		-{ /* JUMP / fnaddr = 18446744073709551043LLU; break; } / loop // SP = 6LLU */
8224		-case 18446744073709551044LLU: /* alternative */
8225		-{/* PUSH /stack[stackbase + 6LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 7LLU */
8226		-{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 8LLU */
8227		-{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 9LLU */
8228		-{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 10LLU */
8229		-{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 11LLU // SP - 5LLU = 6LLU // RESULT */
8230		-{ /* RESULT */stack[stackbase + 6LLU] = stack[stackbase + 6LLU]; }
	8520	+{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 10LLU] == stack[stackbase + 11LLU]; }/ SP + 1LLU = 11LLU / }/ SP - 1LLU = 10LLU // RESULT */
	8521	+{ /* RESULT /stack[stackbase + 7LLU] = stack[stackbase + 10LLU]; }/ SP = 8LLU */
	8522	+if(/* SP - 1LLU = 7LLU // POP */stack[stackbase + 7LLU])
	8523	+{ /* JUMP / fnaddr = 18446744073709551015LLU; break; } / loop // SP = 7LLU */
	8524	+case 18446744073709551016LLU: /* alternative */
	8525	+{/* PUSH /stack[stackbase + 7LLU] = stack[stackbase + 1LLU]; }/ SP + 1LLU = 8LLU */
	8526	+{/* PUSH /stack[stackbase + 8LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 9LLU */
	8527	+{/* PUSH /stack[stackbase + 9LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 10LLU */
	8528	+{/* PUSH /stack[stackbase + 10LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 11LLU */
	8529	+{/* PUSH /stack[stackbase + 11LLU] = stack[stackbase + 5LLU]; }/ SP + 1LLU = 12LLU */
	8530	+{/* PUSH /stack[stackbase + 12LLU] = stack[stackbase + 6LLU]; }/ SP + 1LLU = 13LLU // SP - 6LLU = 7LLU // RESULT */
8231	8531	{ /* RESULT */stack[stackbase + 7LLU] = stack[stackbase + 7LLU]; }
8232	8532	{ /* RESULT */stack[stackbase + 8LLU] = stack[stackbase + 8LLU]; }
8233	8533	{ /* RESULT */stack[stackbase + 9LLU] = stack[stackbase + 9LLU]; }
8234		-{ /* RESULT /stack[stackbase + 10LLU] = stack[stackbase + 10LLU]; }/ SP = 11LLU // SP - 5LLU = 6LLU // RESULT */
8235		-{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 10LLU]; }
8236		-{ /* RESULT */stack[stackbase + 18446744073709551612LLU] = stack[stackbase + 9LLU]; }
8237		-{ /* RESULT */stack[stackbase + 18446744073709551611LLU] = stack[stackbase + 8LLU]; }
8238		-{ /* RESULT */stack[stackbase + 18446744073709551610LLU] = stack[stackbase + 7LLU]; }
8239		-{ /* RESULT */stack[stackbase + 18446744073709551609LLU] = stack[stackbase + 6LLU]; }
	8534	+{ /* RESULT */stack[stackbase + 10LLU] = stack[stackbase + 10LLU]; }
	8535	+{ /* RESULT */stack[stackbase + 11LLU] = stack[stackbase + 11LLU]; }
	8536	+{ /* RESULT /stack[stackbase + 12LLU] = stack[stackbase + 12LLU]; }/ SP = 13LLU // SP - 6LLU = 7LLU // RESULT */
	8537	+{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 12LLU]; }
	8538	+{ /* RESULT */stack[stackbase + 18446744073709551612LLU] = stack[stackbase + 11LLU]; }
	8539	+{ /* RESULT */stack[stackbase + 18446744073709551611LLU] = stack[stackbase + 10LLU]; }
	8540	+{ /* RESULT */stack[stackbase + 18446744073709551610LLU] = stack[stackbase + 9LLU]; }
	8541	+{ /* RESULT */stack[stackbase + 18446744073709551609LLU] = stack[stackbase + 8LLU]; }
	8542	+{ /* RESULT */stack[stackbase + 18446744073709551608LLU] = stack[stackbase + 7LLU]; }
8240	8543	{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
8241		-/* function requires 48LLU 64-bit chunks of memory (including 6LLU for parameters) */
8242		-case /parsetoken/0xADCB6E82FAA68290LLU:/* SP = 0LLU */
8243		- {
8244		- /* CALLBEGIN */
8245		- /* reserve space for 1LLU returned values // SP + 1LLU = 1LLU // SPMAX = 1LLU */
8246		-{/* PUSH /stack[stackbase + 1LLU] = stackbase; }/ SP + 1LLU = 2LLU // SPMAX = 2LLU */
8247		- /* leave place for return addr // SP + 1LLU = 3LLU // SPMAX = 3LLU */
8248		- }/* SP + 2LLU = 5LLU // SPMAX = 5LLU // SP - 2LLU = 3LLU */
8249		- {
8250		- /CALLEND/
8251		- stackbase += 3LLU;
8252		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDBALLU;
8253		- fnaddr = /get_______/0x8A0BC00000000000LLU;/* SP = 0LLU */
8254		-{ if(stackbase + 2LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /get_______/\n"); exit(-1); } }
8255		- break;
8256		- }
8257		-case 0xFFFFFFFFFFFFFDBALLU:
8258		-/* SP = 1LLU // predicate */
8259		-
8260		-{/* PUSH /stack[stackbase + 1LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 2LLU */
8261		-{ /* TOP /stack[stackbase + 1LLU] = isalpha(/ TOP */stack[stackbase + 1LLU]); }
8262		-if(!/* SP - 1LLU = 1LLU // POP */stack[stackbase + 1LLU])
8263		-{ /* JUMP / fnaddr = 18446744073709551033LLU; break; } / skip consequent */
8264		-/* consequent */
8265		-{/* PUSH /stack[stackbase + 1LLU] = 13738688774299189248LLU; }/ SP + 1LLU = 2LLU // SP + 2LLU = 4LLU // SP - 2LLU = 2LLU */
8266		- {
8267		- /* CALLBEGIN */
8268		- /* reserve space for 1LLU returned values // SP + 1LLU = 3LLU */
8269		-{/* PUSH /stack[stackbase + 3LLU] = stackbase; }/ SP + 1LLU = 4LLU */
8270		- /* leave place for return addr // SP + 1LLU = 5LLU */
8271		- }/* SP + 13LLU = 18LLU // SPMAX = 18LLU // SP - 13LLU = 5LLU */
8272		-{/* PUSH /stack[stackbase + 5LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 6LLU */
8273		- {
8274		- /CALLEND/
8275		- stackbase += 5LLU;
8276		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB7LLU;
8277		- fnaddr = /parseid___/0xADCB6E8247C00000LLU;/* SP = 0LLU */
8278		-{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parseid___/\n"); exit(-1); } }
8279		- break;
8280		- }
8281		-case 0xFFFFFFFFFFFFFDB7LLU:
8282		-/* SP = 3LLU // SP = 1LLU */
8283		-{ /* JUMP / fnaddr = 18446744073709551032LLU; break; } / skip alternative */
8284		-case 18446744073709551033LLU: /* alternative */
8285		-{/* PUSH /stack[stackbase + 1LLU] = 13738688775979238096LLU; }/ SP + 1LLU = 2LLU // SP + 2LLU = 4LLU // SP - 2LLU = 2LLU */
8286		-{/* PUSH /stack[stackbase + 2LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 3LLU */
8287		-case 18446744073709551032LLU: /* skip to here */
8288		-/* SP - 2LLU = 1LLU // RESULT */
8289		-{ /* RESULT */stack[stackbase + 0LLU] = stack[stackbase + 1LLU]; }
8290		-{ /* RESULT /stack[stackbase + 1LLU] = stack[stackbase + 2LLU]; }/ SP = 2LLU // SP - 2LLU = 0LLU // RESULT */
8291		-{ /* RESULT */stack[stackbase + 18446744073709551613LLU] = stack[stackbase + 1LLU]; }
8292		-{ /* RESULT */stack[stackbase + 18446744073709551612LLU] = stack[stackbase + 0LLU]; }
8293		-{ /* RET */fnaddr = stack[--stackbase]; stackbase = stack[stackbase - 1]; break; }
8294		-/* function requires 18LLU 64-bit chunks of memory (including 0LLU for parameters) */
	8544	+/* function requires 49LLU 64-bit chunks of memory (including 7LLU for parameters) */
8295	8545	case /parsestep_/0xADCB6E82EBE0AC00LLU:/* SP = 16LLU // SPMAX = 16LLU // parse data */
8296	8546
8297	8547	{/* PUSH /stack[stackbase + 16LLU] = stack[stackbase + 0LLU]; }/ SP + 1LLU = 17LLU // SPMAX = 17LLU */

		@@ -8299,7 +8549,7 @@
8299	8549	{/* PUSH /stack[stackbase + 18LLU] = stack[stackbase + 2LLU]; }/ SP + 1LLU = 19LLU // SPMAX = 19LLU // match-predicate */
8300	8550
8301	8551	if(/parseexpr_/0xADCB6E820CEBB400LLU != stack[stackbase + 16LLU])
8302		-{ /* JUMP / fnaddr = 18446744073709551030LLU; break; } / skip match */
	8552	+{ /* JUMP / fnaddr = 18446744073709551006LLU; break; } / skip match */
8303	8553	/* match // parse data */
8304	8554
8305	8555	{/* PUSH /stack[stackbase + 19LLU] = stack[stackbase + 17LLU]; }/ SP + 1LLU = 20LLU // SPMAX = 20LLU */

		@@ -8306,7 +8556,7 @@
8306	8556	{/* PUSH /stack[stackbase + 20LLU] = stack[stackbase + 18LLU]; }/ SP + 1LLU = 21LLU // SPMAX = 21LLU // match-predicate */
8307	8557
8308	8558	if(/tokenid___/0xBEA9A0A647C00000LLU != stack[stackbase + 19LLU])
8309		-{ /* JUMP / fnaddr = 18446744073709551028LLU; break; } / skip match */
	8559	+{ /* JUMP / fnaddr = 18446744073709551004LLU; break; } / skip match */
8310	8560	/* match */
8311	8561	{
8312	8562	/* CALLBEGIN */

		@@ -8317,12 +8567,12 @@
8317	8567	{
8318	8568	/CALLEND/
8319	8569	stackbase += 23LLU;
8320		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDB2LLU;
	8570	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9ALLU;
8321	8571	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8322	8572	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8323	8573	break;
8324	8574	}
8325		-case 0xFFFFFFFFFFFFFDB2LLU:
	8575	+case 0xFFFFFFFFFFFFFD9ALLU:
8326	8576	/* SP = 21LLU // predicate */
8327	8577
8328	8578	{/* PUSH /stack[stackbase + 21LLU] = ungetc(fgetc(stdin), stdin); }/ SP + 1LLU = 22LLU */

		@@ -8330,7 +8580,7 @@
8330	8580	{
8331	8581	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
8332	8582	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
8333		-{ /* JUMP / fnaddr = 18446744073709551025LLU; break; } / skip consequent */
	8583	+{ /* JUMP / fnaddr = 18446744073709551001LLU; break; } / skip consequent */
8334	8584	/* consequent */
8335	8585	{
8336	8586	/* CALLBEGIN */

		@@ -8337,16 +8587,16 @@
8337	8587	/* reserve space for 2LLU returned values // SP + 2LLU = 23LLU */
8338	8588	{/* PUSH /stack[stackbase + 23LLU] = stackbase; }/ SP + 1LLU = 24LLU */
8339	8589	/* leave place for return addr // SP + 1LLU = 25LLU */
8340		- }/* SP + 30LLU = 55LLU // SPMAX = 55LLU // SP - 30LLU = 25LLU */
	8590	+ }/* SP + 33LLU = 58LLU // SPMAX = 58LLU // SP - 33LLU = 25LLU */
8341	8591	{
8342	8592	/CALLEND/
8343	8593	stackbase += 25LLU;
8344		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAFLLU;
	8594	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD97LLU;
8345	8595	fnaddr = /gettypearg/0x8A0BEFD2B81CB620LLU;/* SP = 0LLU */
8346		-{ if(stackbase + 30LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /gettypearg/\n"); exit(-1); } }
	8596	+{ if(stackbase + 33LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /gettypearg/\n"); exit(-1); } }
8347	8597	break;
8348	8598	}
8349		-case 0xFFFFFFFFFFFFFDAFLLU:
	8599	+case 0xFFFFFFFFFFFFFD97LLU:
8350	8600	/* SP = 23LLU */
8351	8601	{
8352	8602	/* CALLBEGIN */

		@@ -8357,12 +8607,12 @@
8357	8607	{
8358	8608	/CALLEND/
8359	8609	stackbase += 25LLU;
8360		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAELLU;
	8610	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD96LLU;
8361	8611	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8362	8612	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8363	8613	break;
8364	8614	}
8365		-case 0xFFFFFFFFFFFFFDAELLU:
	8615	+case 0xFFFFFFFFFFFFFD96LLU:
8366	8616	/* SP = 23LLU */
8367	8617	{
8368	8618	/* CALLBEGIN */

		@@ -8374,12 +8624,12 @@
8374	8624	{
8375	8625	/CALLEND/
8376	8626	stackbase += 25LLU;
8377		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDADLLU;
	8627	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD95LLU;
8378	8628	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
8379	8629	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
8380	8630	break;
8381	8631	}
8382		-case 0xFFFFFFFFFFFFFDADLLU:
	8632	+case 0xFFFFFFFFFFFFFD95LLU:
8383	8633	/* SP = 23LLU // predicate */
8384	8634
8385	8635	{/* PUSH /stack[stackbase + 23LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 24LLU */

		@@ -8387,7 +8637,7 @@
8387	8637	{
8388	8638	{/* PUSH /stack[stackbase + 23LLU] = stack[stackbase + 23LLU] == stack[stackbase + 24LLU]; }/ SP + 1LLU = 24LLU */ }
8389	8639	if(!/* SP - 1LLU = 23LLU // POP */stack[stackbase + 23LLU])
8390		-{ /* JUMP / fnaddr = 18446744073709551020LLU; break; } / skip consequent */
	8640	+{ /* JUMP / fnaddr = 18446744073709550996LLU; break; } / skip consequent */
8391	8641	/* consequent */
8392	8642	{
8393	8643	/* CALLBEGIN */

		@@ -8406,22 +8656,22 @@
8406	8656	{
8407	8657	/CALLEND/
8408	8658	stackbase += 31LLU;
8409		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDAALLU;
	8659	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD92LLU;
8410	8660	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
8411	8661	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
8412	8662	break;
8413	8663	}
8414		-case 0xFFFFFFFFFFFFFDAALLU:
	8664	+case 0xFFFFFFFFFFFFFD92LLU:
8415	8665	/* SP = 29LLU */
8416	8666	{
8417	8667	/CALLEND/
8418	8668	stackbase += 25LLU;
8419		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA9LLU;
	8669	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD91LLU;
8420	8670	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
8421	8671	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
8422	8672	break;
8423	8673	}
8424		-case 0xFFFFFFFFFFFFFDA9LLU:
	8674	+case 0xFFFFFFFFFFFFFD91LLU:
8425	8675	/* SP = 23LLU */
8426	8676	{
8427	8677	/* CALLBEGIN */

		@@ -8432,12 +8682,12 @@
8432	8682	{
8433	8683	/CALLEND/
8434	8684	stackbase += 25LLU;
8435		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA8LLU;
	8685	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD90LLU;
8436	8686	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8437	8687	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8438	8688	break;
8439	8689	}
8440		-case 0xFFFFFFFFFFFFFDA8LLU:
	8690	+case 0xFFFFFFFFFFFFFD90LLU:
8441	8691	/* SP = 23LLU */
8442	8692	{
8443	8693	/* CALLBEGIN */

		@@ -8455,12 +8705,12 @@
8455	8705	{
8456	8706	/CALLEND/
8457	8707	stackbase += 31LLU;
8458		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA7LLU;
	8708	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8FLLU;
8459	8709	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
8460	8710	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
8461	8711	break;
8462	8712	}
8463		-case 0xFFFFFFFFFFFFFDA7LLU:
	8713	+case 0xFFFFFFFFFFFFFD8FLLU:
8464	8714	/* SP = 29LLU */
8465	8715	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 30LLU */
8466	8716	{/* PUSH /stack[stackbase + 30LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 31LLU */

		@@ -8478,12 +8728,12 @@
8478	8728	{
8479	8729	/CALLEND/
8480	8730	stackbase += 26LLU;
8481		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA6LLU;
	8731	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8ELLU;
8482	8732	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
8483		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	8733	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
8484	8734	break;
8485	8735	}
8486		-case 0xFFFFFFFFFFFFFDA6LLU:
	8736	+case 0xFFFFFFFFFFFFFD8ELLU:
8487	8737	/* SP = 24LLU // SP = 23LLU // assign */
8488	8738	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 23LLU]; }
8489	8739	{

		@@ -8495,12 +8745,12 @@
8495	8745	{
8496	8746	/CALLEND/
8497	8747	stackbase += 25LLU;
8498		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA5LLU;
	8748	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8DLLU;
8499	8749	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8500	8750	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8501	8751	break;
8502	8752	}
8503		-case 0xFFFFFFFFFFFFFDA5LLU:
	8753	+case 0xFFFFFFFFFFFFFD8DLLU:
8504	8754	/* SP = 23LLU */
8505	8755	{
8506	8756	/* CALLBEGIN */

		@@ -8512,12 +8762,12 @@
8512	8762	{
8513	8763	/CALLEND/
8514	8764	stackbase += 25LLU;
8515		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA4LLU;
	8765	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8CLLU;
8516	8766	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
8517	8767	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
8518	8768	break;
8519	8769	}
8520		-case 0xFFFFFFFFFFFFFDA4LLU:
	8770	+case 0xFFFFFFFFFFFFFD8CLLU:
8521	8771	/* SP = 23LLU */
8522	8772	{
8523	8773	/* CALLBEGIN */

		@@ -8528,12 +8778,12 @@
8528	8778	{
8529	8779	/CALLEND/
8530	8780	stackbase += 25LLU;
8531		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA3LLU;
	8781	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8BLLU;
8532	8782	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8533	8783	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8534	8784	break;
8535	8785	}
8536		-case 0xFFFFFFFFFFFFFDA3LLU:
	8786	+case 0xFFFFFFFFFFFFFD8BLLU:
8537	8787	/* SP = 23LLU */
8538	8788	{
8539	8789	/* CALLBEGIN */

		@@ -8551,12 +8801,12 @@
8551	8801	{
8552	8802	/CALLEND/
8553	8803	stackbase += 31LLU;
8554		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA2LLU;
	8804	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8ALLU;
8555	8805	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
8556	8806	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
8557	8807	break;
8558	8808	}
8559		-case 0xFFFFFFFFFFFFFDA2LLU:
	8809	+case 0xFFFFFFFFFFFFFD8ALLU:
8560	8810	/* SP = 29LLU */
8561	8811	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 30LLU */
8562	8812	{/* PUSH /stack[stackbase + 30LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 31LLU */

		@@ -8574,12 +8824,12 @@
8574	8824	{
8575	8825	/CALLEND/
8576	8826	stackbase += 26LLU;
8577		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA1LLU;
	8827	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD89LLU;
8578	8828	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
8579		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	8829	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
8580	8830	break;
8581	8831	}
8582		-case 0xFFFFFFFFFFFFFDA1LLU:
	8832	+case 0xFFFFFFFFFFFFFD89LLU:
8583	8833	/* SP = 24LLU // SP = 23LLU // assign */
8584	8834	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 23LLU]; }
8585	8835	{

		@@ -8594,22 +8844,22 @@
8594	8844	{
8595	8845	/CALLEND/
8596	8846	stackbase += 25LLU;
8597		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFDA0LLU;
	8847	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD88LLU;
8598	8848	fnaddr = /emitbitequ/0x82892F764BE0B300LLU;/* SP = 0LLU */
8599	8849	{ if(stackbase + 41LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitbitequ/\n"); exit(-1); } }
8600	8850	break;
8601	8851	}
8602		-case 0xFFFFFFFFFFFFFDA0LLU:
	8852	+case 0xFFFFFFFFFFFFFD88LLU:
8603	8853	/* SP = 23LLU // SP = 23LLU // SP = 23LLU */
8604		-{ /* JUMP / fnaddr = 18446744073709551019LLU; break; } / skip alternative */
8605		-case 18446744073709551020LLU: /* alternative */
	8854	+{ /* JUMP / fnaddr = 18446744073709550995LLU; break; } / skip alternative */
	8855	+case 18446744073709550996LLU: /* alternative */
8606	8856	fprintf(stderr, "[line %llu]", (long long unsigned int)stack[4]);fputs("can't process type-argument\n", stderr);
8607	8857	{/* set exit-value */stack[16LLU] = 255LLU; }
8608	8858	{ /* JUMP / fnaddr = 0LLU; break; }/ SP = 23LLU */
8609		-case 18446744073709551019LLU: /* skip to here */
	8859	+case 18446744073709550995LLU: /* skip to here */
8610	8860	/* SP = 21LLU // SP = 21LLU */
8611		-{ /* JUMP / fnaddr = 18446744073709551024LLU; break; } / skip alternative */
8612		-case 18446744073709551025LLU: /* alternative // predicate */
	8861	+{ /* JUMP / fnaddr = 18446744073709551000LLU; break; } / skip alternative */
	8862	+case 18446744073709551001LLU: /* alternative // predicate */
8613	8863
8614	8864	{/* PUSH /stack[stackbase + 21LLU] = ungetc(fgetc(stdin), stdin); }/ SP + 1LLU = 22LLU */
8615	8865	{/* PUSH /stack[stackbase + 22LLU] = 40LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -8616,7 +8866,7 @@
8616	8866	{
8617	8867	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
8618	8868	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
8619		-{ /* JUMP / fnaddr = 18446744073709551007LLU; break; } / skip consequent */
	8869	+{ /* JUMP / fnaddr = 18446744073709550983LLU; break; } / skip consequent */
8620	8870	/* consequent */
8621	8871	{
8622	8872	/* CALLBEGIN */

		@@ -8627,12 +8877,12 @@
8627	8877	{
8628	8878	/CALLEND/
8629	8879	stackbase += 23LLU;
8630		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9DLLU;
	8880	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD85LLU;
8631	8881	fnaddr = /skip______/0xBA692B0000000000LLU;/* SP = 0LLU */
8632	8882	{ if(stackbase + 5LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skip______/\n"); exit(-1); } }
8633	8883	break;
8634	8884	}
8635		-case 0xFFFFFFFFFFFFFD9DLLU:
	8885	+case 0xFFFFFFFFFFFFFD85LLU:
8636	8886	/* SP = 21LLU */
8637	8887	{
8638	8888	/* CALLBEGIN */

		@@ -8643,12 +8893,12 @@
8643	8893	{
8644	8894	/CALLEND/
8645	8895	stackbase += 23LLU;
8646		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD9CLLU;
	8896	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD84LLU;
8647	8897	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8648	8898	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8649	8899	break;
8650	8900	}
8651		-case 0xFFFFFFFFFFFFFD9CLLU:
	8901	+case 0xFFFFFFFFFFFFFD84LLU:
8652	8902	/* SP = 21LLU // predicate */
8653	8903
8654	8904	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */

		@@ -8656,7 +8906,7 @@
8656	8906	{
8657	8907	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
8658	8908	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
8659		-{ /* JUMP / fnaddr = 18446744073709551003LLU; break; } / skip consequent */
	8909	+{ /* JUMP / fnaddr = 18446744073709550979LLU; break; } / skip consequent */
8660	8910	/* consequent */
8661	8911	{
8662	8912	/* CALLBEGIN */

		@@ -8675,22 +8925,22 @@
8675	8925	{
8676	8926	/CALLEND/
8677	8927	stackbase += 29LLU;
8678		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD99LLU;
	8928	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD81LLU;
8679	8929	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
8680	8930	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
8681	8931	break;
8682	8932	}
8683		-case 0xFFFFFFFFFFFFFD99LLU:
	8933	+case 0xFFFFFFFFFFFFFD81LLU:
8684	8934	/* SP = 27LLU */
8685	8935	{
8686	8936	/CALLEND/
8687	8937	stackbase += 23LLU;
8688		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD98LLU;
	8938	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD80LLU;
8689	8939	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
8690	8940	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
8691	8941	break;
8692	8942	}
8693		-case 0xFFFFFFFFFFFFFD98LLU:
	8943	+case 0xFFFFFFFFFFFFFD80LLU:
8694	8944	/* SP = 21LLU */
8695	8945	{
8696	8946	/* CALLBEGIN */

		@@ -8701,12 +8951,12 @@
8701	8951	{
8702	8952	/CALLEND/
8703	8953	stackbase += 24LLU;
8704		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD97LLU;
	8954	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7FLLU;
8705	8955	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
8706	8956	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
8707	8957	break;
8708	8958	}
8709		-case 0xFFFFFFFFFFFFFD97LLU:
	8959	+case 0xFFFFFFFFFFFFFD7FLLU:
8710	8960	/* SP = 22LLU */
8711	8961	{
8712	8962	/* CALLBEGIN */

		@@ -8717,12 +8967,12 @@
8717	8967	{
8718	8968	/CALLEND/
8719	8969	stackbase += 24LLU;
8720		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD96LLU;
	8970	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7ELLU;
8721	8971	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8722	8972	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8723	8973	break;
8724	8974	}
8725		-case 0xFFFFFFFFFFFFFD96LLU:
	8975	+case 0xFFFFFFFFFFFFFD7ELLU:
8726	8976	/* SP = 22LLU */
8727	8977	{
8728	8978	/* CALLBEGIN */

		@@ -8740,12 +8990,12 @@
8740	8990	{
8741	8991	/CALLEND/
8742	8992	stackbase += 30LLU;
8743		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD95LLU;
	8993	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7DLLU;
8744	8994	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
8745	8995	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
8746	8996	break;
8747	8997	}
8748		-case 0xFFFFFFFFFFFFFD95LLU:
	8998	+case 0xFFFFFFFFFFFFFD7DLLU:
8749	8999	/* SP = 28LLU */
8750	9000	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
8751	9001	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -8766,23 +9016,23 @@
8766	9016	{
8767	9017	/CALLEND/
8768	9018	stackbase += 42LLU;
8769		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD94LLU;
	9019	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7CLLU;
8770	9020	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
8771	9021	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
8772	9022	break;
8773	9023	}
8774		-case 0xFFFFFFFFFFFFFD94LLU:
	9024	+case 0xFFFFFFFFFFFFFD7CLLU:
8775	9025	/* SP = 40LLU */
8776	9026	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
8777	9027	{
8778	9028	/CALLEND/
8779	9029	stackbase += 25LLU;
8780		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD93LLU;
	9030	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7BLLU;
8781	9031	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
8782		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	9032	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
8783	9033	break;
8784	9034	}
8785		-case 0xFFFFFFFFFFFFFD93LLU:
	9035	+case 0xFFFFFFFFFFFFFD7BLLU:
8786	9036	/* SP = 23LLU // SP = 22LLU // assign */
8787	9037	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
8788	9038	{

		@@ -8794,12 +9044,12 @@
8794	9044	{
8795	9045	/CALLEND/
8796	9046	stackbase += 24LLU;
8797		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD92LLU;
	9047	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7ALLU;
8798	9048	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8799	9049	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8800	9050	break;
8801	9051	}
8802		-case 0xFFFFFFFFFFFFFD92LLU:
	9052	+case 0xFFFFFFFFFFFFFD7ALLU:
8803	9053	/* SP = 22LLU */
8804	9054	{
8805	9055	/* CALLBEGIN */

		@@ -8811,12 +9061,12 @@
8811	9061	{
8812	9062	/CALLEND/
8813	9063	stackbase += 24LLU;
8814		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD91LLU;
	9064	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD79LLU;
8815	9065	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
8816	9066	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
8817	9067	break;
8818	9068	}
8819		-case 0xFFFFFFFFFFFFFD91LLU:
	9069	+case 0xFFFFFFFFFFFFFD79LLU:
8820	9070	/* SP = 22LLU */
8821	9071	{
8822	9072	/* CALLBEGIN */

		@@ -8827,12 +9077,12 @@
8827	9077	{
8828	9078	/CALLEND/
8829	9079	stackbase += 24LLU;
8830		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD90LLU;
	9080	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD78LLU;
8831	9081	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8832	9082	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8833	9083	break;
8834	9084	}
8835		-case 0xFFFFFFFFFFFFFD90LLU:
	9085	+case 0xFFFFFFFFFFFFFD78LLU:
8836	9086	/* SP = 22LLU */
8837	9087	{
8838	9088	/* CALLBEGIN */

		@@ -8850,12 +9100,12 @@
8850	9100	{
8851	9101	/CALLEND/
8852	9102	stackbase += 30LLU;
8853		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8FLLU;
	9103	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD77LLU;
8854	9104	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
8855	9105	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
8856	9106	break;
8857	9107	}
8858		-case 0xFFFFFFFFFFFFFD8FLLU:
	9108	+case 0xFFFFFFFFFFFFFD77LLU:
8859	9109	/* SP = 28LLU */
8860	9110	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
8861	9111	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -8876,23 +9126,23 @@
8876	9126	{
8877	9127	/CALLEND/
8878	9128	stackbase += 42LLU;
8879		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8ELLU;
	9129	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD76LLU;
8880	9130	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
8881	9131	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
8882	9132	break;
8883	9133	}
8884		-case 0xFFFFFFFFFFFFFD8ELLU:
	9134	+case 0xFFFFFFFFFFFFFD76LLU:
8885	9135	/* SP = 40LLU */
8886	9136	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
8887	9137	{
8888	9138	/CALLEND/
8889	9139	stackbase += 25LLU;
8890		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8DLLU;
	9140	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD75LLU;
8891	9141	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
8892		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	9142	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
8893	9143	break;
8894	9144	}
8895		-case 0xFFFFFFFFFFFFFD8DLLU:
	9145	+case 0xFFFFFFFFFFFFFD75LLU:
8896	9146	/* SP = 23LLU // SP = 22LLU // assign */
8897	9147	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
8898	9148	{

		@@ -8907,15 +9157,15 @@
8907	9157	{
8908	9158	/CALLEND/
8909	9159	stackbase += 24LLU;
8910		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD8CLLU;
	9160	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD74LLU;
8911	9161	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
8912	9162	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
8913	9163	break;
8914	9164	}
8915		-case 0xFFFFFFFFFFFFFD8CLLU:
	9165	+case 0xFFFFFFFFFFFFFD74LLU:
8916	9166	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
8917		-{ /* JUMP / fnaddr = 18446744073709551002LLU; break; } / skip alternative */
8918		-case 18446744073709551003LLU: /* alternative // predicate */
	9167	+{ /* JUMP / fnaddr = 18446744073709550978LLU; break; } / skip alternative */
	9168	+case 18446744073709550979LLU: /* alternative // predicate */
8919	9169
8920	9170	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
8921	9171	{/* PUSH /stack[stackbase + 22LLU] = 9947044201977872384LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -8922,7 +9172,7 @@
8922	9172	{
8923	9173	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
8924	9174	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
8925		-{ /* JUMP / fnaddr = 18446744073709550987LLU; break; } / skip consequent */
	9175	+{ /* JUMP / fnaddr = 18446744073709550963LLU; break; } / skip consequent */
8926	9176	/* consequent */
8927	9177	{
8928	9178	/* CALLBEGIN */

		@@ -8941,22 +9191,22 @@
8941	9191	{
8942	9192	/CALLEND/
8943	9193	stackbase += 29LLU;
8944		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD89LLU;
	9194	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD71LLU;
8945	9195	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
8946	9196	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
8947	9197	break;
8948	9198	}
8949		-case 0xFFFFFFFFFFFFFD89LLU:
	9199	+case 0xFFFFFFFFFFFFFD71LLU:
8950	9200	/* SP = 27LLU */
8951	9201	{
8952	9202	/CALLEND/
8953	9203	stackbase += 23LLU;
8954		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD88LLU;
	9204	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD70LLU;
8955	9205	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
8956	9206	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
8957	9207	break;
8958	9208	}
8959		-case 0xFFFFFFFFFFFFFD88LLU:
	9209	+case 0xFFFFFFFFFFFFFD70LLU:
8960	9210	/* SP = 21LLU */
8961	9211	{
8962	9212	/* CALLBEGIN */

		@@ -8967,12 +9217,12 @@
8967	9217	{
8968	9218	/CALLEND/
8969	9219	stackbase += 24LLU;
8970		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD87LLU;
	9220	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6FLLU;
8971	9221	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
8972	9222	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
8973	9223	break;
8974	9224	}
8975		-case 0xFFFFFFFFFFFFFD87LLU:
	9225	+case 0xFFFFFFFFFFFFFD6FLLU:
8976	9226	/* SP = 22LLU */
8977	9227	{
8978	9228	/* CALLBEGIN */

		@@ -8983,12 +9233,12 @@
8983	9233	{
8984	9234	/CALLEND/
8985	9235	stackbase += 24LLU;
8986		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD86LLU;
	9236	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6ELLU;
8987	9237	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
8988	9238	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
8989	9239	break;
8990	9240	}
8991		-case 0xFFFFFFFFFFFFFD86LLU:
	9241	+case 0xFFFFFFFFFFFFFD6ELLU:
8992	9242	/* SP = 22LLU */
8993	9243	{
8994	9244	/* CALLBEGIN */

		@@ -9006,12 +9256,12 @@
9006	9256	{
9007	9257	/CALLEND/
9008	9258	stackbase += 30LLU;
9009		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD85LLU;
	9259	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6DLLU;
9010	9260	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
9011	9261	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
9012	9262	break;
9013	9263	}
9014		-case 0xFFFFFFFFFFFFFD85LLU:
	9264	+case 0xFFFFFFFFFFFFFD6DLLU:
9015	9265	/* SP = 28LLU */
9016	9266	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
9017	9267	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -9032,23 +9282,23 @@
9032	9282	{
9033	9283	/CALLEND/
9034	9284	stackbase += 42LLU;
9035		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD84LLU;
	9285	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6CLLU;
9036	9286	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
9037	9287	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
9038	9288	break;
9039	9289	}
9040		-case 0xFFFFFFFFFFFFFD84LLU:
	9290	+case 0xFFFFFFFFFFFFFD6CLLU:
9041	9291	/* SP = 40LLU */
9042	9292	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
9043	9293	{
9044	9294	/CALLEND/
9045	9295	stackbase += 25LLU;
9046		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD83LLU;
	9296	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6BLLU;
9047	9297	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
9048		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	9298	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
9049	9299	break;
9050	9300	}
9051		-case 0xFFFFFFFFFFFFFD83LLU:
	9301	+case 0xFFFFFFFFFFFFFD6BLLU:
9052	9302	/* SP = 23LLU // SP = 22LLU // assign */
9053	9303	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
9054	9304	{

		@@ -9060,12 +9310,12 @@
9060	9310	{
9061	9311	/CALLEND/
9062	9312	stackbase += 24LLU;
9063		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD82LLU;
	9313	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6ALLU;
9064	9314	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9065	9315	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
9066	9316	break;
9067	9317	}
9068		-case 0xFFFFFFFFFFFFFD82LLU:
	9318	+case 0xFFFFFFFFFFFFFD6ALLU:
9069	9319	/* SP = 22LLU */
9070	9320	{
9071	9321	/* CALLBEGIN */

		@@ -9077,12 +9327,12 @@
9077	9327	{
9078	9328	/CALLEND/
9079	9329	stackbase += 24LLU;
9080		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD81LLU;
	9330	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD69LLU;
9081	9331	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
9082	9332	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
9083	9333	break;
9084	9334	}
9085		-case 0xFFFFFFFFFFFFFD81LLU:
	9335	+case 0xFFFFFFFFFFFFFD69LLU:
9086	9336	/* SP = 22LLU */
9087	9337	{
9088	9338	/* CALLBEGIN */

		@@ -9093,12 +9343,12 @@
9093	9343	{
9094	9344	/CALLEND/
9095	9345	stackbase += 24LLU;
9096		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD80LLU;
	9346	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD68LLU;
9097	9347	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9098	9348	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
9099	9349	break;
9100	9350	}
9101		-case 0xFFFFFFFFFFFFFD80LLU:
	9351	+case 0xFFFFFFFFFFFFFD68LLU:
9102	9352	/* SP = 22LLU */
9103	9353	{
9104	9354	/* CALLBEGIN */

		@@ -9116,12 +9366,12 @@
9116	9366	{
9117	9367	/CALLEND/
9118	9368	stackbase += 30LLU;
9119		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7FLLU;
	9369	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD67LLU;
9120	9370	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
9121	9371	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
9122	9372	break;
9123	9373	}
9124		-case 0xFFFFFFFFFFFFFD7FLLU:
	9374	+case 0xFFFFFFFFFFFFFD67LLU:
9125	9375	/* SP = 28LLU */
9126	9376	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
9127	9377	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -9142,23 +9392,23 @@
9142	9392	{
9143	9393	/CALLEND/
9144	9394	stackbase += 42LLU;
9145		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7ELLU;
	9395	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD66LLU;
9146	9396	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
9147	9397	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
9148	9398	break;
9149	9399	}
9150		-case 0xFFFFFFFFFFFFFD7ELLU:
	9400	+case 0xFFFFFFFFFFFFFD66LLU:
9151	9401	/* SP = 40LLU */
9152	9402	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
9153	9403	{
9154	9404	/CALLEND/
9155	9405	stackbase += 25LLU;
9156		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7DLLU;
	9406	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD65LLU;
9157	9407	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
9158		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	9408	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
9159	9409	break;
9160	9410	}
9161		-case 0xFFFFFFFFFFFFFD7DLLU:
	9411	+case 0xFFFFFFFFFFFFFD65LLU:
9162	9412	/* SP = 23LLU // SP = 22LLU // assign */
9163	9413	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
9164	9414	{

		@@ -9173,15 +9423,15 @@
9173	9423	{
9174	9424	/CALLEND/
9175	9425	stackbase += 24LLU;
9176		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD7CLLU;
	9426	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD64LLU;
9177	9427	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
9178	9428	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
9179	9429	break;
9180	9430	}
9181		-case 0xFFFFFFFFFFFFFD7CLLU:
	9431	+case 0xFFFFFFFFFFFFFD64LLU:
9182	9432	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
9183		-{ /* JUMP / fnaddr = 18446744073709550986LLU; break; } / skip alternative */
9184		-case 18446744073709550987LLU: /* alternative // predicate */
	9433	+{ /* JUMP / fnaddr = 18446744073709550962LLU; break; } / skip alternative */
	9434	+case 18446744073709550963LLU: /* alternative // predicate */
9185	9435
9186	9436	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
9187	9437	{/* PUSH /stack[stackbase + 22LLU] = 10014668565132607488LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -9188,7 +9438,7 @@
9188	9438	{
9189	9439	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
9190	9440	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
9191		-{ /* JUMP / fnaddr = 18446744073709550971LLU; break; } / skip consequent */
	9441	+{ /* JUMP / fnaddr = 18446744073709550947LLU; break; } / skip consequent */
9192	9442	/* consequent */
9193	9443	{
9194	9444	/* CALLBEGIN */

		@@ -9207,22 +9457,22 @@
9207	9457	{
9208	9458	/CALLEND/
9209	9459	stackbase += 29LLU;
9210		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD79LLU;
	9460	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD61LLU;
9211	9461	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
9212	9462	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
9213	9463	break;
9214	9464	}
9215		-case 0xFFFFFFFFFFFFFD79LLU:
	9465	+case 0xFFFFFFFFFFFFFD61LLU:
9216	9466	/* SP = 27LLU */
9217	9467	{
9218	9468	/CALLEND/
9219	9469	stackbase += 23LLU;
9220		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD78LLU;
	9470	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD60LLU;
9221	9471	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
9222	9472	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
9223	9473	break;
9224	9474	}
9225		-case 0xFFFFFFFFFFFFFD78LLU:
	9475	+case 0xFFFFFFFFFFFFFD60LLU:
9226	9476	/* SP = 21LLU */
9227	9477	{
9228	9478	/* CALLBEGIN */

		@@ -9233,12 +9483,12 @@
9233	9483	{
9234	9484	/CALLEND/
9235	9485	stackbase += 24LLU;
9236		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD77LLU;
	9486	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5FLLU;
9237	9487	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
9238	9488	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
9239	9489	break;
9240	9490	}
9241		-case 0xFFFFFFFFFFFFFD77LLU:
	9491	+case 0xFFFFFFFFFFFFFD5FLLU:
9242	9492	/* SP = 22LLU */
9243	9493	{
9244	9494	/* CALLBEGIN */

		@@ -9249,12 +9499,12 @@
9249	9499	{
9250	9500	/CALLEND/
9251	9501	stackbase += 24LLU;
9252		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD76LLU;
	9502	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5ELLU;
9253	9503	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9254	9504	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
9255	9505	break;
9256	9506	}
9257		-case 0xFFFFFFFFFFFFFD76LLU:
	9507	+case 0xFFFFFFFFFFFFFD5ELLU:
9258	9508	/* SP = 22LLU */
9259	9509	{
9260	9510	/* CALLBEGIN */

		@@ -9272,12 +9522,12 @@
9272	9522	{
9273	9523	/CALLEND/
9274	9524	stackbase += 30LLU;
9275		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD75LLU;
	9525	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5DLLU;
9276	9526	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
9277	9527	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
9278	9528	break;
9279	9529	}
9280		-case 0xFFFFFFFFFFFFFD75LLU:
	9530	+case 0xFFFFFFFFFFFFFD5DLLU:
9281	9531	/* SP = 28LLU */
9282	9532	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
9283	9533	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -9298,23 +9548,23 @@
9298	9548	{
9299	9549	/CALLEND/
9300	9550	stackbase += 42LLU;
9301		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD74LLU;
	9551	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5CLLU;
9302	9552	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
9303	9553	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
9304	9554	break;
9305	9555	}
9306		-case 0xFFFFFFFFFFFFFD74LLU:
	9556	+case 0xFFFFFFFFFFFFFD5CLLU:
9307	9557	/* SP = 40LLU */
9308	9558	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
9309	9559	{
9310	9560	/CALLEND/
9311	9561	stackbase += 25LLU;
9312		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD73LLU;
	9562	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5BLLU;
9313	9563	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
9314		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	9564	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
9315	9565	break;
9316	9566	}
9317		-case 0xFFFFFFFFFFFFFD73LLU:
	9567	+case 0xFFFFFFFFFFFFFD5BLLU:
9318	9568	/* SP = 23LLU // SP = 22LLU // assign */
9319	9569	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
9320	9570	{

		@@ -9326,12 +9576,12 @@
9326	9576	{
9327	9577	/CALLEND/
9328	9578	stackbase += 24LLU;
9329		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD72LLU;
	9579	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5ALLU;
9330	9580	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9331	9581	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
9332	9582	break;
9333	9583	}
9334		-case 0xFFFFFFFFFFFFFD72LLU:
	9584	+case 0xFFFFFFFFFFFFFD5ALLU:
9335	9585	/* SP = 22LLU */
9336	9586	{
9337	9587	/* CALLBEGIN */

		@@ -9343,12 +9593,12 @@
9343	9593	{
9344	9594	/CALLEND/
9345	9595	stackbase += 24LLU;
9346		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD71LLU;
	9596	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD59LLU;
9347	9597	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
9348	9598	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
9349	9599	break;
9350	9600	}
9351		-case 0xFFFFFFFFFFFFFD71LLU:
	9601	+case 0xFFFFFFFFFFFFFD59LLU:
9352	9602	/* SP = 22LLU */
9353	9603	{
9354	9604	/* CALLBEGIN */

		@@ -9359,12 +9609,12 @@
9359	9609	{
9360	9610	/CALLEND/
9361	9611	stackbase += 24LLU;
9362		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD70LLU;
	9612	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD58LLU;
9363	9613	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9364	9614	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
9365	9615	break;
9366	9616	}
9367		-case 0xFFFFFFFFFFFFFD70LLU:
	9617	+case 0xFFFFFFFFFFFFFD58LLU:
9368	9618	/* SP = 22LLU */
9369	9619	{
9370	9620	/* CALLBEGIN */

		@@ -9382,12 +9632,12 @@
9382	9632	{
9383	9633	/CALLEND/
9384	9634	stackbase += 30LLU;
9385		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6FLLU;
	9635	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD57LLU;
9386	9636	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
9387	9637	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
9388	9638	break;
9389	9639	}
9390		-case 0xFFFFFFFFFFFFFD6FLLU:
	9640	+case 0xFFFFFFFFFFFFFD57LLU:
9391	9641	/* SP = 28LLU */
9392	9642	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
9393	9643	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -9408,23 +9658,23 @@
9408	9658	{
9409	9659	/CALLEND/
9410	9660	stackbase += 42LLU;
9411		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6ELLU;
	9661	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD56LLU;
9412	9662	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
9413	9663	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
9414	9664	break;
9415	9665	}
9416		-case 0xFFFFFFFFFFFFFD6ELLU:
	9666	+case 0xFFFFFFFFFFFFFD56LLU:
9417	9667	/* SP = 40LLU */
9418	9668	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
9419	9669	{
9420	9670	/CALLEND/
9421	9671	stackbase += 25LLU;
9422		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6DLLU;
	9672	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD55LLU;
9423	9673	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
9424		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	9674	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
9425	9675	break;
9426	9676	}
9427		-case 0xFFFFFFFFFFFFFD6DLLU:
	9677	+case 0xFFFFFFFFFFFFFD55LLU:
9428	9678	/* SP = 23LLU // SP = 22LLU // assign */
9429	9679	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
9430	9680	{

		@@ -9439,15 +9689,15 @@
9439	9689	{
9440	9690	/CALLEND/
9441	9691	stackbase += 24LLU;
9442		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD6CLLU;
	9692	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD54LLU;
9443	9693	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
9444	9694	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
9445	9695	break;
9446	9696	}
9447		-case 0xFFFFFFFFFFFFFD6CLLU:
	9697	+case 0xFFFFFFFFFFFFFD54LLU:
9448	9698	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
9449		-{ /* JUMP / fnaddr = 18446744073709550970LLU; break; } / skip alternative */
9450		-case 18446744073709550971LLU: /* alternative // predicate */
	9699	+{ /* JUMP / fnaddr = 18446744073709550946LLU; break; } / skip alternative */
	9700	+case 18446744073709550947LLU: /* alternative // predicate */
9451	9701
9452	9702	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
9453	9703	{/* PUSH /stack[stackbase + 22LLU] = 11388196082736431104LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -9454,7 +9704,7 @@
9454	9704	{
9455	9705	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
9456	9706	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
9457		-{ /* JUMP / fnaddr = 18446744073709550955LLU; break; } / skip consequent */
	9707	+{ /* JUMP / fnaddr = 18446744073709550931LLU; break; } / skip consequent */
9458	9708	/* consequent */
9459	9709	{
9460	9710	/* CALLBEGIN */

		@@ -9473,22 +9723,22 @@
9473	9723	{
9474	9724	/CALLEND/
9475	9725	stackbase += 29LLU;
9476		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD69LLU;
	9726	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD51LLU;
9477	9727	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
9478	9728	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
9479	9729	break;
9480	9730	}
9481		-case 0xFFFFFFFFFFFFFD69LLU:
	9731	+case 0xFFFFFFFFFFFFFD51LLU:
9482	9732	/* SP = 27LLU */
9483	9733	{
9484	9734	/CALLEND/
9485	9735	stackbase += 23LLU;
9486		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD68LLU;
	9736	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD50LLU;
9487	9737	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
9488	9738	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
9489	9739	break;
9490	9740	}
9491		-case 0xFFFFFFFFFFFFFD68LLU:
	9741	+case 0xFFFFFFFFFFFFFD50LLU:
9492	9742	/* SP = 21LLU */
9493	9743	{
9494	9744	/* CALLBEGIN */

		@@ -9499,12 +9749,12 @@
9499	9749	{
9500	9750	/CALLEND/
9501	9751	stackbase += 24LLU;
9502		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD67LLU;
	9752	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4FLLU;
9503	9753	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
9504	9754	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
9505	9755	break;
9506	9756	}
9507		-case 0xFFFFFFFFFFFFFD67LLU:
	9757	+case 0xFFFFFFFFFFFFFD4FLLU:
9508	9758	/* SP = 22LLU */
9509	9759	{
9510	9760	/* CALLBEGIN */

		@@ -9515,12 +9765,12 @@
9515	9765	{
9516	9766	/CALLEND/
9517	9767	stackbase += 24LLU;
9518		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD66LLU;
	9768	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4ELLU;
9519	9769	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9520	9770	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
9521	9771	break;
9522	9772	}
9523		-case 0xFFFFFFFFFFFFFD66LLU:
	9773	+case 0xFFFFFFFFFFFFFD4ELLU:
9524	9774	/* SP = 22LLU */
9525	9775	{
9526	9776	/* CALLBEGIN */

		@@ -9538,12 +9788,12 @@
9538	9788	{
9539	9789	/CALLEND/
9540	9790	stackbase += 30LLU;
9541		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD65LLU;
	9791	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4DLLU;
9542	9792	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
9543	9793	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
9544	9794	break;
9545	9795	}
9546		-case 0xFFFFFFFFFFFFFD65LLU:
	9796	+case 0xFFFFFFFFFFFFFD4DLLU:
9547	9797	/* SP = 28LLU */
9548	9798	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
9549	9799	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -9564,23 +9814,23 @@
9564	9814	{
9565	9815	/CALLEND/
9566	9816	stackbase += 42LLU;
9567		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD64LLU;
	9817	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4CLLU;
9568	9818	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
9569	9819	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
9570	9820	break;
9571	9821	}
9572		-case 0xFFFFFFFFFFFFFD64LLU:
	9822	+case 0xFFFFFFFFFFFFFD4CLLU:
9573	9823	/* SP = 40LLU */
9574	9824	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
9575	9825	{
9576	9826	/CALLEND/
9577	9827	stackbase += 25LLU;
9578		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD63LLU;
	9828	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4BLLU;
9579	9829	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
9580		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	9830	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
9581	9831	break;
9582	9832	}
9583		-case 0xFFFFFFFFFFFFFD63LLU:
	9833	+case 0xFFFFFFFFFFFFFD4BLLU:
9584	9834	/* SP = 23LLU // SP = 22LLU // assign */
9585	9835	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
9586	9836	{

		@@ -9592,12 +9842,12 @@
9592	9842	{
9593	9843	/CALLEND/
9594	9844	stackbase += 24LLU;
9595		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD62LLU;
	9845	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4ALLU;
9596	9846	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9597	9847	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
9598	9848	break;
9599	9849	}
9600		-case 0xFFFFFFFFFFFFFD62LLU:
	9850	+case 0xFFFFFFFFFFFFFD4ALLU:
9601	9851	/* SP = 22LLU */
9602	9852	{
9603	9853	/* CALLBEGIN */

		@@ -9609,12 +9859,12 @@
9609	9859	{
9610	9860	/CALLEND/
9611	9861	stackbase += 24LLU;
9612		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD61LLU;
	9862	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD49LLU;
9613	9863	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
9614	9864	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
9615	9865	break;
9616	9866	}
9617		-case 0xFFFFFFFFFFFFFD61LLU:
	9867	+case 0xFFFFFFFFFFFFFD49LLU:
9618	9868	/* SP = 22LLU */
9619	9869	{
9620	9870	/* CALLBEGIN */

		@@ -9625,12 +9875,12 @@
9625	9875	{
9626	9876	/CALLEND/
9627	9877	stackbase += 24LLU;
9628		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD60LLU;
	9878	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD48LLU;
9629	9879	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9630	9880	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
9631	9881	break;
9632	9882	}
9633		-case 0xFFFFFFFFFFFFFD60LLU:
	9883	+case 0xFFFFFFFFFFFFFD48LLU:
9634	9884	/* SP = 22LLU */
9635	9885	{
9636	9886	/* CALLBEGIN */

		@@ -9648,12 +9898,12 @@
9648	9898	{
9649	9899	/CALLEND/
9650	9900	stackbase += 30LLU;
9651		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5FLLU;
	9901	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD47LLU;
9652	9902	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
9653	9903	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
9654	9904	break;
9655	9905	}
9656		-case 0xFFFFFFFFFFFFFD5FLLU:
	9906	+case 0xFFFFFFFFFFFFFD47LLU:
9657	9907	/* SP = 28LLU */
9658	9908	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
9659	9909	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -9674,23 +9924,23 @@
9674	9924	{
9675	9925	/CALLEND/
9676	9926	stackbase += 42LLU;
9677		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5ELLU;
	9927	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD46LLU;
9678	9928	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
9679	9929	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
9680	9930	break;
9681	9931	}
9682		-case 0xFFFFFFFFFFFFFD5ELLU:
	9932	+case 0xFFFFFFFFFFFFFD46LLU:
9683	9933	/* SP = 40LLU */
9684	9934	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
9685	9935	{
9686	9936	/CALLEND/
9687	9937	stackbase += 25LLU;
9688		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5DLLU;
	9938	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD45LLU;
9689	9939	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
9690		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	9940	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
9691	9941	break;
9692	9942	}
9693		-case 0xFFFFFFFFFFFFFD5DLLU:
	9943	+case 0xFFFFFFFFFFFFFD45LLU:
9694	9944	/* SP = 23LLU // SP = 22LLU // assign */
9695	9945	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
9696	9946	{

		@@ -9705,15 +9955,15 @@
9705	9955	{
9706	9956	/CALLEND/
9707	9957	stackbase += 24LLU;
9708		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD5CLLU;
	9958	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD44LLU;
9709	9959	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
9710	9960	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
9711	9961	break;
9712	9962	}
9713		-case 0xFFFFFFFFFFFFFD5CLLU:
	9963	+case 0xFFFFFFFFFFFFFD44LLU:
9714	9964	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
9715		-{ /* JUMP / fnaddr = 18446744073709550954LLU; break; } / skip alternative */
9716		-case 18446744073709550955LLU: /* alternative // predicate */
	9965	+{ /* JUMP / fnaddr = 18446744073709550930LLU; break; } / skip alternative */
	9966	+case 18446744073709550931LLU: /* alternative // predicate */
9717	9967
9718	9968	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
9719	9969	{/* PUSH /stack[stackbase + 22LLU] = 11451387215007973376LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -9720,7 +9970,7 @@
9720	9970	{
9721	9971	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
9722	9972	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
9723		-{ /* JUMP / fnaddr = 18446744073709550939LLU; break; } / skip consequent */
	9973	+{ /* JUMP / fnaddr = 18446744073709550915LLU; break; } / skip consequent */
9724	9974	/* consequent */
9725	9975	{
9726	9976	/* CALLBEGIN */

		@@ -9739,22 +9989,22 @@
9739	9989	{
9740	9990	/CALLEND/
9741	9991	stackbase += 29LLU;
9742		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD59LLU;
	9992	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD41LLU;
9743	9993	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
9744	9994	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
9745	9995	break;
9746	9996	}
9747		-case 0xFFFFFFFFFFFFFD59LLU:
	9997	+case 0xFFFFFFFFFFFFFD41LLU:
9748	9998	/* SP = 27LLU */
9749	9999	{
9750	10000	/CALLEND/
9751	10001	stackbase += 23LLU;
9752		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD58LLU;
	10002	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD40LLU;
9753	10003	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
9754	10004	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
9755	10005	break;
9756	10006	}
9757		-case 0xFFFFFFFFFFFFFD58LLU:
	10007	+case 0xFFFFFFFFFFFFFD40LLU:
9758	10008	/* SP = 21LLU */
9759	10009	{
9760	10010	/* CALLBEGIN */

		@@ -9765,12 +10015,12 @@
9765	10015	{
9766	10016	/CALLEND/
9767	10017	stackbase += 24LLU;
9768		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD57LLU;
	10018	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3FLLU;
9769	10019	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
9770	10020	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
9771	10021	break;
9772	10022	}
9773		-case 0xFFFFFFFFFFFFFD57LLU:
	10023	+case 0xFFFFFFFFFFFFFD3FLLU:
9774	10024	/* SP = 22LLU */
9775	10025	{
9776	10026	/* CALLBEGIN */

		@@ -9781,12 +10031,12 @@
9781	10031	{
9782	10032	/CALLEND/
9783	10033	stackbase += 24LLU;
9784		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD56LLU;
	10034	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3ELLU;
9785	10035	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9786	10036	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
9787	10037	break;
9788	10038	}
9789		-case 0xFFFFFFFFFFFFFD56LLU:
	10039	+case 0xFFFFFFFFFFFFFD3ELLU:
9790	10040	/* SP = 22LLU */
9791	10041	{
9792	10042	/* CALLBEGIN */

		@@ -9804,12 +10054,12 @@
9804	10054	{
9805	10055	/CALLEND/
9806	10056	stackbase += 30LLU;
9807		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD55LLU;
	10057	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3DLLU;
9808	10058	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
9809	10059	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
9810	10060	break;
9811	10061	}
9812		-case 0xFFFFFFFFFFFFFD55LLU:
	10062	+case 0xFFFFFFFFFFFFFD3DLLU:
9813	10063	/* SP = 28LLU */
9814	10064	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
9815	10065	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -9830,23 +10080,23 @@
9830	10080	{
9831	10081	/CALLEND/
9832	10082	stackbase += 42LLU;
9833		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD54LLU;
	10083	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3CLLU;
9834	10084	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
9835	10085	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
9836	10086	break;
9837	10087	}
9838		-case 0xFFFFFFFFFFFFFD54LLU:
	10088	+case 0xFFFFFFFFFFFFFD3CLLU:
9839	10089	/* SP = 40LLU */
9840	10090	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
9841	10091	{
9842	10092	/CALLEND/
9843	10093	stackbase += 25LLU;
9844		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD53LLU;
	10094	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3BLLU;
9845	10095	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
9846		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	10096	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
9847	10097	break;
9848	10098	}
9849		-case 0xFFFFFFFFFFFFFD53LLU:
	10099	+case 0xFFFFFFFFFFFFFD3BLLU:
9850	10100	/* SP = 23LLU // SP = 22LLU // assign */
9851	10101	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
9852	10102	{

		@@ -9858,12 +10108,12 @@
9858	10108	{
9859	10109	/CALLEND/
9860	10110	stackbase += 24LLU;
9861		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD52LLU;
	10111	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3ALLU;
9862	10112	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9863	10113	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
9864	10114	break;
9865	10115	}
9866		-case 0xFFFFFFFFFFFFFD52LLU:
	10116	+case 0xFFFFFFFFFFFFFD3ALLU:
9867	10117	/* SP = 22LLU */
9868	10118	{
9869	10119	/* CALLBEGIN */

		@@ -9875,12 +10125,12 @@
9875	10125	{
9876	10126	/CALLEND/
9877	10127	stackbase += 24LLU;
9878		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD51LLU;
	10128	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD39LLU;
9879	10129	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
9880	10130	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
9881	10131	break;
9882	10132	}
9883		-case 0xFFFFFFFFFFFFFD51LLU:
	10133	+case 0xFFFFFFFFFFFFFD39LLU:
9884	10134	/* SP = 22LLU */
9885	10135	{
9886	10136	/* CALLBEGIN */

		@@ -9891,12 +10141,12 @@
9891	10141	{
9892	10142	/CALLEND/
9893	10143	stackbase += 24LLU;
9894		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD50LLU;
	10144	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD38LLU;
9895	10145	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
9896	10146	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
9897	10147	break;
9898	10148	}
9899		-case 0xFFFFFFFFFFFFFD50LLU:
	10149	+case 0xFFFFFFFFFFFFFD38LLU:
9900	10150	/* SP = 22LLU */
9901	10151	{
9902	10152	/* CALLBEGIN */

		@@ -9914,12 +10164,12 @@
9914	10164	{
9915	10165	/CALLEND/
9916	10166	stackbase += 30LLU;
9917		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4FLLU;
	10167	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD37LLU;
9918	10168	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
9919	10169	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
9920	10170	break;
9921	10171	}
9922		-case 0xFFFFFFFFFFFFFD4FLLU:
	10172	+case 0xFFFFFFFFFFFFFD37LLU:
9923	10173	/* SP = 28LLU */
9924	10174	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
9925	10175	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -9940,23 +10190,23 @@
9940	10190	{
9941	10191	/CALLEND/
9942	10192	stackbase += 42LLU;
9943		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4ELLU;
	10193	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD36LLU;
9944	10194	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
9945	10195	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
9946	10196	break;
9947	10197	}
9948		-case 0xFFFFFFFFFFFFFD4ELLU:
	10198	+case 0xFFFFFFFFFFFFFD36LLU:
9949	10199	/* SP = 40LLU */
9950	10200	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
9951	10201	{
9952	10202	/CALLEND/
9953	10203	stackbase += 25LLU;
9954		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4DLLU;
	10204	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD35LLU;
9955	10205	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
9956		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	10206	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
9957	10207	break;
9958	10208	}
9959		-case 0xFFFFFFFFFFFFFD4DLLU:
	10209	+case 0xFFFFFFFFFFFFFD35LLU:
9960	10210	/* SP = 23LLU // SP = 22LLU // assign */
9961	10211	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
9962	10212	{

		@@ -9971,15 +10221,15 @@
9971	10221	{
9972	10222	/CALLEND/
9973	10223	stackbase += 24LLU;
9974		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD4CLLU;
	10224	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD34LLU;
9975	10225	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
9976	10226	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
9977	10227	break;
9978	10228	}
9979		-case 0xFFFFFFFFFFFFFD4CLLU:
	10229	+case 0xFFFFFFFFFFFFFD34LLU:
9980	10230	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
9981		-{ /* JUMP / fnaddr = 18446744073709550938LLU; break; } / skip alternative */
9982		-case 18446744073709550939LLU: /* alternative // predicate */
	10231	+{ /* JUMP / fnaddr = 18446744073709550914LLU; break; } / skip alternative */
	10232	+case 18446744073709550915LLU: /* alternative // predicate */
9983	10233
9984	10234	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
9985	10235	{/* PUSH /stack[stackbase + 22LLU] = 11964656835039854592LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -9986,7 +10236,7 @@
9986	10236	{
9987	10237	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
9988	10238	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
9989		-{ /* JUMP / fnaddr = 18446744073709550923LLU; break; } / skip consequent */
	10239	+{ /* JUMP / fnaddr = 18446744073709550899LLU; break; } / skip consequent */
9990	10240	/* consequent */
9991	10241	{
9992	10242	/* CALLBEGIN */

		@@ -10005,22 +10255,22 @@
10005	10255	{
10006	10256	/CALLEND/
10007	10257	stackbase += 29LLU;
10008		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD49LLU;
	10258	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD31LLU;
10009	10259	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
10010	10260	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
10011	10261	break;
10012	10262	}
10013		-case 0xFFFFFFFFFFFFFD49LLU:
	10263	+case 0xFFFFFFFFFFFFFD31LLU:
10014	10264	/* SP = 27LLU */
10015	10265	{
10016	10266	/CALLEND/
10017	10267	stackbase += 23LLU;
10018		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD48LLU;
	10268	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD30LLU;
10019	10269	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
10020	10270	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
10021	10271	break;
10022	10272	}
10023		-case 0xFFFFFFFFFFFFFD48LLU:
	10273	+case 0xFFFFFFFFFFFFFD30LLU:
10024	10274	/* SP = 21LLU */
10025	10275	{
10026	10276	/* CALLBEGIN */

		@@ -10031,12 +10281,12 @@
10031	10281	{
10032	10282	/CALLEND/
10033	10283	stackbase += 24LLU;
10034		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD47LLU;
	10284	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2FLLU;
10035	10285	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
10036	10286	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
10037	10287	break;
10038	10288	}
10039		-case 0xFFFFFFFFFFFFFD47LLU:
	10289	+case 0xFFFFFFFFFFFFFD2FLLU:
10040	10290	/* SP = 22LLU */
10041	10291	{
10042	10292	/* CALLBEGIN */

		@@ -10047,12 +10297,12 @@
10047	10297	{
10048	10298	/CALLEND/
10049	10299	stackbase += 24LLU;
10050		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD46LLU;
	10300	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2ELLU;
10051	10301	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
10052	10302	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
10053	10303	break;
10054	10304	}
10055		-case 0xFFFFFFFFFFFFFD46LLU:
	10305	+case 0xFFFFFFFFFFFFFD2ELLU:
10056	10306	/* SP = 22LLU */
10057	10307	{
10058	10308	/* CALLBEGIN */

		@@ -10070,12 +10320,12 @@
10070	10320	{
10071	10321	/CALLEND/
10072	10322	stackbase += 30LLU;
10073		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD45LLU;
	10323	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2DLLU;
10074	10324	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
10075	10325	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
10076	10326	break;
10077	10327	}
10078		-case 0xFFFFFFFFFFFFFD45LLU:
	10328	+case 0xFFFFFFFFFFFFFD2DLLU:
10079	10329	/* SP = 28LLU */
10080	10330	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
10081	10331	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -10096,23 +10346,23 @@
10096	10346	{
10097	10347	/CALLEND/
10098	10348	stackbase += 42LLU;
10099		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD44LLU;
	10349	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2CLLU;
10100	10350	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
10101	10351	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
10102	10352	break;
10103	10353	}
10104		-case 0xFFFFFFFFFFFFFD44LLU:
	10354	+case 0xFFFFFFFFFFFFFD2CLLU:
10105	10355	/* SP = 40LLU */
10106	10356	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
10107	10357	{
10108	10358	/CALLEND/
10109	10359	stackbase += 25LLU;
10110		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD43LLU;
	10360	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2BLLU;
10111	10361	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
10112		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	10362	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
10113	10363	break;
10114	10364	}
10115		-case 0xFFFFFFFFFFFFFD43LLU:
	10365	+case 0xFFFFFFFFFFFFFD2BLLU:
10116	10366	/* SP = 23LLU // SP = 22LLU // assign */
10117	10367	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
10118	10368	{

		@@ -10124,12 +10374,12 @@
10124	10374	{
10125	10375	/CALLEND/
10126	10376	stackbase += 24LLU;
10127		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD42LLU;
	10377	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2ALLU;
10128	10378	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
10129	10379	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
10130	10380	break;
10131	10381	}
10132		-case 0xFFFFFFFFFFFFFD42LLU:
	10382	+case 0xFFFFFFFFFFFFFD2ALLU:
10133	10383	/* SP = 22LLU */
10134	10384	{
10135	10385	/* CALLBEGIN */

		@@ -10141,12 +10391,12 @@
10141	10391	{
10142	10392	/CALLEND/
10143	10393	stackbase += 24LLU;
10144		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD41LLU;
	10394	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD29LLU;
10145	10395	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
10146	10396	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
10147	10397	break;
10148	10398	}
10149		-case 0xFFFFFFFFFFFFFD41LLU:
	10399	+case 0xFFFFFFFFFFFFFD29LLU:
10150	10400	/* SP = 22LLU */
10151	10401	{
10152	10402	/* CALLBEGIN */

		@@ -10157,12 +10407,12 @@
10157	10407	{
10158	10408	/CALLEND/
10159	10409	stackbase += 24LLU;
10160		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD40LLU;
	10410	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD28LLU;
10161	10411	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
10162	10412	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
10163	10413	break;
10164	10414	}
10165		-case 0xFFFFFFFFFFFFFD40LLU:
	10415	+case 0xFFFFFFFFFFFFFD28LLU:
10166	10416	/* SP = 22LLU */
10167	10417	{
10168	10418	/* CALLBEGIN */

		@@ -10180,12 +10430,12 @@
10180	10430	{
10181	10431	/CALLEND/
10182	10432	stackbase += 30LLU;
10183		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3FLLU;
	10433	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD27LLU;
10184	10434	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
10185	10435	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
10186	10436	break;
10187	10437	}
10188		-case 0xFFFFFFFFFFFFFD3FLLU:
	10438	+case 0xFFFFFFFFFFFFFD27LLU:
10189	10439	/* SP = 28LLU */
10190	10440	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
10191	10441	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -10206,23 +10456,23 @@
10206	10456	{
10207	10457	/CALLEND/
10208	10458	stackbase += 42LLU;
10209		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3ELLU;
	10459	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD26LLU;
10210	10460	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
10211	10461	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
10212	10462	break;
10213	10463	}
10214		-case 0xFFFFFFFFFFFFFD3ELLU:
	10464	+case 0xFFFFFFFFFFFFFD26LLU:
10215	10465	/* SP = 40LLU */
10216	10466	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
10217	10467	{
10218	10468	/CALLEND/
10219	10469	stackbase += 25LLU;
10220		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3DLLU;
	10470	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD25LLU;
10221	10471	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
10222		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	10472	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
10223	10473	break;
10224	10474	}
10225		-case 0xFFFFFFFFFFFFFD3DLLU:
	10475	+case 0xFFFFFFFFFFFFFD25LLU:
10226	10476	/* SP = 23LLU // SP = 22LLU // assign */
10227	10477	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
10228	10478	{

		@@ -10237,15 +10487,15 @@
10237	10487	{
10238	10488	/CALLEND/
10239	10489	stackbase += 24LLU;
10240		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD3CLLU;
	10490	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD24LLU;
10241	10491	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
10242	10492	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
10243	10493	break;
10244	10494	}
10245		-case 0xFFFFFFFFFFFFFD3CLLU:
	10495	+case 0xFFFFFFFFFFFFFD24LLU:
10246	10496	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
10247		-{ /* JUMP / fnaddr = 18446744073709550922LLU; break; } / skip alternative */
10248		-case 18446744073709550923LLU: /* alternative // predicate */
	10497	+{ /* JUMP / fnaddr = 18446744073709550898LLU; break; } / skip alternative */
	10498	+case 18446744073709550899LLU: /* alternative // predicate */
10249	10499
10250	10500	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
10251	10501	{/* PUSH /stack[stackbase + 22LLU] = 9455640569687572480LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -10252,7 +10502,7 @@
10252	10502	{
10253	10503	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
10254	10504	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
10255		-{ /* JUMP / fnaddr = 18446744073709550907LLU; break; } / skip consequent */
	10505	+{ /* JUMP / fnaddr = 18446744073709550883LLU; break; } / skip consequent */
10256	10506	/* consequent */
10257	10507	{
10258	10508	/* CALLBEGIN */

		@@ -10274,22 +10524,22 @@
10274	10524	{
10275	10525	/CALLEND/
10276	10526	stackbase += 33LLU;
10277		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD39LLU;
	10527	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD21LLU;
10278	10528	fnaddr = /termprops_/0xBE0B68AEDAABB800LLU;/* SP = 0LLU */
10279	10529	{ if(stackbase + 4LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /termprops_/\n"); exit(-1); } }
10280	10530	break;
10281	10531	}
10282		-case 0xFFFFFFFFFFFFFD39LLU:
	10532	+case 0xFFFFFFFFFFFFFD21LLU:
10283	10533	/* SP = 31LLU */
10284	10534	{
10285	10535	/CALLEND/
10286	10536	stackbase += 23LLU;
10287		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD38LLU;
	10537	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD20LLU;
10288	10538	fnaddr = /verifyprop/0xC60B64874AEDAAB0LLU;/* SP = 0LLU */
10289	10539	{ if(stackbase + 33LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /verifyprop/\n"); exit(-1); } }
10290	10540	break;
10291	10541	}
10292		-case 0xFFFFFFFFFFFFFD38LLU:
	10542	+case 0xFFFFFFFFFFFFFD20LLU:
10293	10543	/* SP = 21LLU */
10294	10544	{
10295	10545	/* CALLBEGIN */

		@@ -10300,12 +10550,12 @@
10300	10550	{
10301	10551	/CALLEND/
10302	10552	stackbase += 23LLU;
10303		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD37LLU;
	10553	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1FLLU;
10304	10554	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
10305	10555	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
10306	10556	break;
10307	10557	}
10308		-case 0xFFFFFFFFFFFFFD37LLU:
	10558	+case 0xFFFFFFFFFFFFFD1FLLU:
10309	10559	/* SP = 21LLU /fputs("\n{/ set exit-value */stack[", stdout);
10310	10560	{
10311	10561	/* CALLBEGIN */

		@@ -10322,22 +10572,22 @@
10322	10572	{
10323	10573	/CALLEND/
10324	10574	stackbase += 26LLU;
10325		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD36LLU;
	10575	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1ELLU;
10326	10576	fnaddr = /GLOBMAXGET/0x1CC3C23416071540LLU;/* SP = 0LLU */
10327	10577	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /GLOBMAXGET/\n"); exit(-1); } }
10328	10578	break;
10329	10579	}
10330		-case 0xFFFFFFFFFFFFFD36LLU:
	10580	+case 0xFFFFFFFFFFFFFD1ELLU:
10331	10581	/* SP = 24LLU */
10332	10582	{
10333	10583	/CALLEND/
10334	10584	stackbase += 23LLU;
10335		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD35LLU;
	10585	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1DLLU;
10336	10586	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
10337	10587	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
10338	10588	break;
10339	10589	}
10340		-case 0xFFFFFFFFFFFFFD35LLU:
	10590	+case 0xFFFFFFFFFFFFFD1DLLU:
10341	10591	/* SP = 21LLU */fputs("] = ", stdout);
10342	10592	{
10343	10593	/* CALLBEGIN */

		@@ -10354,22 +10604,22 @@
10354	10604	{
10355	10605	/CALLEND/
10356	10606	stackbase += 26LLU;
10357		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD34LLU;
	10607	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1CLLU;
10358	10608	fnaddr = /parsenr___/0xADCB6E829B400000LLU;/* SP = 0LLU */
10359	10609	{ if(stackbase + 12LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsenr___/\n"); exit(-1); } }
10360	10610	break;
10361	10611	}
10362		-case 0xFFFFFFFFFFFFFD34LLU:
	10612	+case 0xFFFFFFFFFFFFFD1CLLU:
10363	10613	/* SP = 24LLU */
10364	10614	{
10365	10615	/CALLEND/
10366	10616	stackbase += 23LLU;
10367		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD33LLU;
	10617	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1BLLU;
10368	10618	fnaddr = /printnr___/0xAED929BE9B400000LLU;/* SP = 0LLU */
10369	10619	{ if(stackbase + 14LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /printnr___/\n"); exit(-1); } }
10370	10620	break;
10371	10621	}
10372		-case 0xFFFFFFFFFFFFFD33LLU:
	10622	+case 0xFFFFFFFFFFFFFD1BLLU:
10373	10623	/* SP = 21LLU */fputs("; }", stdout);
10374	10624	{
10375	10625	/* CALLBEGIN */

		@@ -10380,12 +10630,12 @@
10380	10630	{
10381	10631	/CALLEND/
10382	10632	stackbase += 23LLU;
10383		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD32LLU;
	10633	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1ALLU;
10384	10634	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
10385	10635	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
10386	10636	break;
10387	10637	}
10388		-case 0xFFFFFFFFFFFFFD32LLU:
	10638	+case 0xFFFFFFFFFFFFFD1ALLU:
10389	10639	/* SP = 21LLU */
10390	10640	{
10391	10641	/* CALLBEGIN */

		@@ -10397,12 +10647,12 @@
10397	10647	{
10398	10648	/CALLEND/
10399	10649	stackbase += 23LLU;
10400		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD31LLU;
	10650	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD19LLU;
10401	10651	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
10402	10652	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
10403	10653	break;
10404	10654	}
10405		-case 0xFFFFFFFFFFFFFD31LLU:
	10655	+case 0xFFFFFFFFFFFFFD19LLU:
10406	10656	/* SP = 21LLU */
10407	10657	{
10408	10658	/* CALLBEGIN */

		@@ -10414,17 +10664,17 @@
10414	10664	{
10415	10665	/CALLEND/
10416	10666	stackbase += 23LLU;
10417		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD30LLU;
	10667	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD18LLU;
10418	10668	fnaddr = /JUMP______/0x2953500000000000LLU;/* SP = 0LLU */
10419	10669	{ if(stackbase + 17LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /JUMP______/\n"); exit(-1); } }
10420	10670	break;
10421	10671	}
10422		-case 0xFFFFFFFFFFFFFD30LLU:
	10672	+case 0xFFFFFFFFFFFFFD18LLU:
10423	10673	/* SP = 21LLU */
10424	10674	{/* PUSH /stack[stackbase + 21LLU] = 13116716846516535296LLU; }/ SP + 1LLU = 22LLU // SP + 1LLU = 23LLU // SP - 1LLU = 22LLU // SP = 21LLU // assign */
10425	10675	{ /* RESULT /stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }/ SP = 21LLU // SP = 21LLU */
10426		-{ /* JUMP / fnaddr = 18446744073709550906LLU; break; } / skip alternative */
10427		-case 18446744073709550907LLU: /* alternative // predicate */
	10676	+{ /* JUMP / fnaddr = 18446744073709550882LLU; break; } / skip alternative */
	10677	+case 18446744073709550883LLU: /* alternative // predicate */
10428	10678
10429	10679	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
10430	10680	{/* PUSH /stack[stackbase + 22LLU] = 2041538006082387968LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -10431,7 +10681,7 @@
10431	10681	{
10432	10682	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
10433	10683	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
10434		-{ /* JUMP / fnaddr = 18446744073709550895LLU; break; } / skip consequent */
	10684	+{ /* JUMP / fnaddr = 18446744073709550871LLU; break; } / skip consequent */
10435	10685	/* consequent */
10436	10686	{/* PUSH /stack[stackbase + 21LLU] = 13116716846516535296LLU; }/ SP + 1LLU = 22LLU // SP + 1LLU = 23LLU // SP - 1LLU = 22LLU // SP = 21LLU // assign */
10437	10687	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }

		@@ -10452,22 +10702,22 @@
10452	10702	{
10453	10703	/CALLEND/
10454	10704	stackbase += 29LLU;
10455		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2DLLU;
	10705	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD15LLU;
10456	10706	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
10457	10707	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
10458	10708	break;
10459	10709	}
10460		-case 0xFFFFFFFFFFFFFD2DLLU:
	10710	+case 0xFFFFFFFFFFFFFD15LLU:
10461	10711	/* SP = 27LLU */
10462	10712	{
10463	10713	/CALLEND/
10464	10714	stackbase += 23LLU;
10465		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2CLLU;
	10715	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD14LLU;
10466	10716	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
10467	10717	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
10468	10718	break;
10469	10719	}
10470		-case 0xFFFFFFFFFFFFFD2CLLU:
	10720	+case 0xFFFFFFFFFFFFFD14LLU:
10471	10721	/* SP = 21LLU */
10472	10722	{
10473	10723	/* CALLBEGIN */

		@@ -10479,12 +10729,12 @@
10479	10729	{
10480	10730	/CALLEND/
10481	10731	stackbase += 23LLU;
10482		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2BLLU;
	10732	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD13LLU;
10483	10733	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
10484	10734	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
10485	10735	break;
10486	10736	}
10487		-case 0xFFFFFFFFFFFFFD2BLLU:
	10737	+case 0xFFFFFFFFFFFFFD13LLU:
10488	10738	/* SP = 21LLU */
10489	10739	{
10490	10740	/* CALLBEGIN */

		@@ -10495,12 +10745,12 @@
10495	10745	{
10496	10746	/CALLEND/
10497	10747	stackbase += 23LLU;
10498		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD2ALLU;
	10748	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD12LLU;
10499	10749	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
10500	10750	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); } }
10501	10751	break;
10502	10752	}
10503		-case 0xFFFFFFFFFFFFFD2ALLU:
	10753	+case 0xFFFFFFFFFFFFFD12LLU:
10504	10754	/* SP = 21LLU */fputs("fgetc(stdin)", stdout);
10505	10755	{
10506	10756	/* CALLBEGIN */

		@@ -10511,15 +10761,15 @@
10511	10761	{
10512	10762	/CALLEND/
10513	10763	stackbase += 23LLU;
10514		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD29LLU;
	10764	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD11LLU;
10515	10765	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
10516	10766	{ if(stackbase + 21LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); } }
10517	10767	break;
10518	10768	}
10519		-case 0xFFFFFFFFFFFFFD29LLU:
	10769	+case 0xFFFFFFFFFFFFFD11LLU:
10520	10770	/* SP = 21LLU // SP = 21LLU // SP = 21LLU */
10521		-{ /* JUMP / fnaddr = 18446744073709550894LLU; break; } / skip alternative */
10522		-case 18446744073709550895LLU: /* alternative // predicate */
	10771	+{ /* JUMP / fnaddr = 18446744073709550870LLU; break; } / skip alternative */
	10772	+case 18446744073709550871LLU: /* alternative // predicate */
10523	10773
10524	10774	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
10525	10775	{/* PUSH /stack[stackbase + 22LLU] = 12009903937546092544LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -10526,7 +10776,7 @@
10526	10776	{
10527	10777	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
10528	10778	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
10529		-{ /* JUMP / fnaddr = 18446744073709550888LLU; break; } / skip consequent */
	10779	+{ /* JUMP / fnaddr = 18446744073709550864LLU; break; } / skip consequent */
10530	10780	/* consequent */
10531	10781	{
10532	10782	/* CALLBEGIN */

		@@ -10545,22 +10795,22 @@
10545	10795	{
10546	10796	/CALLEND/
10547	10797	stackbase += 29LLU;
10548		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD26LLU;
	10798	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0ELLU;
10549	10799	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
10550	10800	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
10551	10801	break;
10552	10802	}
10553		-case 0xFFFFFFFFFFFFFD26LLU:
	10803	+case 0xFFFFFFFFFFFFFD0ELLU:
10554	10804	/* SP = 27LLU */
10555	10805	{
10556	10806	/CALLEND/
10557	10807	stackbase += 23LLU;
10558		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD25LLU;
	10808	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0DLLU;
10559	10809	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
10560	10810	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
10561	10811	break;
10562	10812	}
10563		-case 0xFFFFFFFFFFFFFD25LLU:
	10813	+case 0xFFFFFFFFFFFFFD0DLLU:
10564	10814	/* SP = 21LLU */
10565	10815	{
10566	10816	/* CALLBEGIN */

		@@ -10571,12 +10821,12 @@
10571	10821	{
10572	10822	/CALLEND/
10573	10823	stackbase += 23LLU;
10574		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD24LLU;
	10824	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0CLLU;
10575	10825	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
10576	10826	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
10577	10827	break;
10578	10828	}
10579		-case 0xFFFFFFFFFFFFFD24LLU:
	10829	+case 0xFFFFFFFFFFFFFD0CLLU:
10580	10830	/* SP = 21LLU */
10581	10831	{
10582	10832	/* CALLBEGIN */

		@@ -10594,12 +10844,12 @@
10594	10844	{
10595	10845	/CALLEND/
10596	10846	stackbase += 29LLU;
10597		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD23LLU;
	10847	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0BLLU;
10598	10848	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
10599	10849	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
10600	10850	break;
10601	10851	}
10602		-case 0xFFFFFFFFFFFFFD23LLU:
	10852	+case 0xFFFFFFFFFFFFFD0BLLU:
10603	10853	/* SP = 27LLU */
10604	10854	{/* PUSH /stack[stackbase + 27LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 28LLU */
10605	10855	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 29LLU */

		@@ -10620,23 +10870,23 @@
10620	10870	{
10621	10871	/CALLEND/
10622	10872	stackbase += 41LLU;
10623		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD22LLU;
	10873	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0ALLU;
10624	10874	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
10625	10875	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
10626	10876	break;
10627	10877	}
10628		-case 0xFFFFFFFFFFFFFD22LLU:
	10878	+case 0xFFFFFFFFFFFFFD0ALLU:
10629	10879	/* SP = 39LLU */
10630	10880	{/* PUSH /stack[stackbase + 39LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 40LLU */
10631	10881	{
10632	10882	/CALLEND/
10633	10883	stackbase += 24LLU;
10634		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD21LLU;
	10884	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD09LLU;
10635	10885	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
10636		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	10886	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
10637	10887	break;
10638	10888	}
10639		-case 0xFFFFFFFFFFFFFD21LLU:
	10889	+case 0xFFFFFFFFFFFFFD09LLU:
10640	10890	/* SP = 22LLU // SP = 21LLU // assign */
10641	10891	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }
10642	10892	{

		@@ -10649,15 +10899,15 @@
10649	10899	{
10650	10900	/CALLEND/
10651	10901	stackbase += 23LLU;
10652		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD20LLU;
	10902	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD08LLU;
10653	10903	fnaddr = /emitprefix/0x82892FAED8219330LLU;/* SP = 0LLU */
10654	10904	{ if(stackbase + 22LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitprefix/\n"); exit(-1); } }
10655	10905	break;
10656	10906	}
10657		-case 0xFFFFFFFFFFFFFD20LLU:
	10907	+case 0xFFFFFFFFFFFFFD08LLU:
10658	10908	/* SP = 21LLU // SP = 21LLU // SP = 21LLU */
10659		-{ /* JUMP / fnaddr = 18446744073709550887LLU; break; } / skip alternative */
10660		-case 18446744073709550888LLU: /* alternative // predicate */
	10909	+{ /* JUMP / fnaddr = 18446744073709550863LLU; break; } / skip alternative */
	10910	+case 18446744073709550864LLU: /* alternative // predicate */
10661	10911
10662	10912	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
10663	10913	{/* PUSH /stack[stackbase + 22LLU] = 8257279548039626752LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -10664,7 +10914,7 @@
10664	10914	{
10665	10915	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
10666	10916	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
10667		-{ /* JUMP / fnaddr = 18446744073709550879LLU; break; } / skip consequent */
	10917	+{ /* JUMP / fnaddr = 18446744073709550855LLU; break; } / skip consequent */
10668	10918	/* consequent */
10669	10919	{
10670	10920	/* CALLBEGIN */

		@@ -10683,22 +10933,22 @@
10683	10933	{
10684	10934	/CALLEND/
10685	10935	stackbase += 29LLU;
10686		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1DLLU;
	10936	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD05LLU;
10687	10937	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
10688	10938	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
10689	10939	break;
10690	10940	}
10691		-case 0xFFFFFFFFFFFFFD1DLLU:
	10941	+case 0xFFFFFFFFFFFFFD05LLU:
10692	10942	/* SP = 27LLU */
10693	10943	{
10694	10944	/CALLEND/
10695	10945	stackbase += 23LLU;
10696		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1CLLU;
	10946	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD04LLU;
10697	10947	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
10698	10948	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
10699	10949	break;
10700	10950	}
10701		-case 0xFFFFFFFFFFFFFD1CLLU:
	10951	+case 0xFFFFFFFFFFFFFD04LLU:
10702	10952	/* SP = 21LLU */
10703	10953	{
10704	10954	/* CALLBEGIN */

		@@ -10709,12 +10959,12 @@
10709	10959	{
10710	10960	/CALLEND/
10711	10961	stackbase += 24LLU;
10712		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1BLLU;
	10962	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD03LLU;
10713	10963	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
10714	10964	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
10715	10965	break;
10716	10966	}
10717		-case 0xFFFFFFFFFFFFFD1BLLU:
	10967	+case 0xFFFFFFFFFFFFFD03LLU:
10718	10968	/* SP = 22LLU */
10719	10969	{
10720	10970	/* CALLBEGIN */

		@@ -10725,12 +10975,12 @@
10725	10975	{
10726	10976	/CALLEND/
10727	10977	stackbase += 24LLU;
10728		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD1ALLU;
	10978	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD02LLU;
10729	10979	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
10730	10980	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
10731	10981	break;
10732	10982	}
10733		-case 0xFFFFFFFFFFFFFD1ALLU:
	10983	+case 0xFFFFFFFFFFFFFD02LLU:
10734	10984	/* SP = 22LLU */
10735	10985	{
10736	10986	/* CALLBEGIN */

		@@ -10748,12 +10998,12 @@
10748	10998	{
10749	10999	/CALLEND/
10750	11000	stackbase += 30LLU;
10751		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD19LLU;
	11001	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD01LLU;
10752	11002	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
10753	11003	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
10754	11004	break;
10755	11005	}
10756		-case 0xFFFFFFFFFFFFFD19LLU:
	11006	+case 0xFFFFFFFFFFFFFD01LLU:
10757	11007	/* SP = 28LLU */
10758	11008	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
10759	11009	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -10774,23 +11024,23 @@
10774	11024	{
10775	11025	/CALLEND/
10776	11026	stackbase += 42LLU;
10777		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD18LLU;
	11027	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFD00LLU;
10778	11028	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
10779	11029	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
10780	11030	break;
10781	11031	}
10782		-case 0xFFFFFFFFFFFFFD18LLU:
	11032	+case 0xFFFFFFFFFFFFFD00LLU:
10783	11033	/* SP = 40LLU */
10784	11034	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
10785	11035	{
10786	11036	/CALLEND/
10787	11037	stackbase += 25LLU;
10788		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD17LLU;
	11038	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFFLLU;
10789	11039	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
10790		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	11040	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
10791	11041	break;
10792	11042	}
10793		-case 0xFFFFFFFFFFFFFD17LLU:
	11043	+case 0xFFFFFFFFFFFFFCFFLLU:
10794	11044	/* SP = 23LLU // SP = 22LLU // assign */
10795	11045	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
10796	11046	{

		@@ -10802,12 +11052,12 @@
10802	11052	{
10803	11053	/CALLEND/
10804	11054	stackbase += 24LLU;
10805		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD16LLU;
	11055	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFELLU;
10806	11056	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
10807	11057	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
10808	11058	break;
10809	11059	}
10810		-case 0xFFFFFFFFFFFFFD16LLU:
	11060	+case 0xFFFFFFFFFFFFFCFELLU:
10811	11061	/* SP = 22LLU */
10812	11062	{
10813	11063	/* CALLBEGIN */

		@@ -10819,12 +11069,12 @@
10819	11069	{
10820	11070	/CALLEND/
10821	11071	stackbase += 24LLU;
10822		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD15LLU;
	11072	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFDLLU;
10823	11073	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
10824	11074	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
10825	11075	break;
10826	11076	}
10827		-case 0xFFFFFFFFFFFFFD15LLU:
	11077	+case 0xFFFFFFFFFFFFFCFDLLU:
10828	11078	/* SP = 22LLU */
10829	11079	{
10830	11080	/* CALLBEGIN */

		@@ -10835,12 +11085,12 @@
10835	11085	{
10836	11086	/CALLEND/
10837	11087	stackbase += 24LLU;
10838		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD14LLU;
	11088	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFCLLU;
10839	11089	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
10840	11090	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
10841	11091	break;
10842	11092	}
10843		-case 0xFFFFFFFFFFFFFD14LLU:
	11093	+case 0xFFFFFFFFFFFFFCFCLLU:
10844	11094	/* SP = 22LLU */
10845	11095	{
10846	11096	/* CALLBEGIN */

		@@ -10858,12 +11108,12 @@
10858	11108	{
10859	11109	/CALLEND/
10860	11110	stackbase += 30LLU;
10861		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD13LLU;
	11111	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFBLLU;
10862	11112	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
10863	11113	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
10864	11114	break;
10865	11115	}
10866		-case 0xFFFFFFFFFFFFFD13LLU:
	11116	+case 0xFFFFFFFFFFFFFCFBLLU:
10867	11117	/* SP = 28LLU */
10868	11118	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
10869	11119	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -10884,23 +11134,23 @@
10884	11134	{
10885	11135	/CALLEND/
10886	11136	stackbase += 42LLU;
10887		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD12LLU;
	11137	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFALLU;
10888	11138	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
10889	11139	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
10890	11140	break;
10891	11141	}
10892		-case 0xFFFFFFFFFFFFFD12LLU:
	11142	+case 0xFFFFFFFFFFFFFCFALLU:
10893	11143	/* SP = 40LLU */
10894	11144	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
10895	11145	{
10896	11146	/CALLEND/
10897	11147	stackbase += 25LLU;
10898		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD11LLU;
	11148	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF9LLU;
10899	11149	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
10900		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	11150	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
10901	11151	break;
10902	11152	}
10903		-case 0xFFFFFFFFFFFFFD11LLU:
	11153	+case 0xFFFFFFFFFFFFFCF9LLU:
10904	11154	/* SP = 23LLU // SP = 22LLU // assign */
10905	11155	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
10906	11156	{

		@@ -10915,15 +11165,15 @@
10915	11165	{
10916	11166	/CALLEND/
10917	11167	stackbase += 24LLU;
10918		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD10LLU;
	11168	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF8LLU;
10919	11169	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
10920	11170	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
10921	11171	break;
10922	11172	}
10923		-case 0xFFFFFFFFFFFFFD10LLU:
	11173	+case 0xFFFFFFFFFFFFFCF8LLU:
10924	11174	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
10925		-{ /* JUMP / fnaddr = 18446744073709550878LLU; break; } / skip alternative */
10926		-case 18446744073709550879LLU: /* alternative // predicate */
	11175	+{ /* JUMP / fnaddr = 18446744073709550854LLU; break; } / skip alternative */
	11176	+case 18446744073709550855LLU: /* alternative // predicate */
10927	11177
10928	11178	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
10929	11179	{/* PUSH /stack[stackbase + 22LLU] = 12308337781603565568LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -10930,7 +11180,7 @@
10930	11180	{
10931	11181	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
10932	11182	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
10933		-{ /* JUMP / fnaddr = 18446744073709550863LLU; break; } / skip consequent */
	11183	+{ /* JUMP / fnaddr = 18446744073709550839LLU; break; } / skip consequent */
10934	11184	/* consequent */
10935	11185	{
10936	11186	/* CALLBEGIN */

		@@ -10949,22 +11199,22 @@
10949	11199	{
10950	11200	/CALLEND/
10951	11201	stackbase += 29LLU;
10952		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0DLLU;
	11202	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF5LLU;
10953	11203	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
10954	11204	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
10955	11205	break;
10956	11206	}
10957		-case 0xFFFFFFFFFFFFFD0DLLU:
	11207	+case 0xFFFFFFFFFFFFFCF5LLU:
10958	11208	/* SP = 27LLU */
10959	11209	{
10960	11210	/CALLEND/
10961	11211	stackbase += 23LLU;
10962		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0CLLU;
	11212	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF4LLU;
10963	11213	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
10964	11214	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
10965	11215	break;
10966	11216	}
10967		-case 0xFFFFFFFFFFFFFD0CLLU:
	11217	+case 0xFFFFFFFFFFFFFCF4LLU:
10968	11218	/* SP = 21LLU */
10969	11219	{
10970	11220	/* CALLBEGIN */

		@@ -10975,12 +11225,12 @@
10975	11225	{
10976	11226	/CALLEND/
10977	11227	stackbase += 24LLU;
10978		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0BLLU;
	11228	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF3LLU;
10979	11229	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
10980	11230	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
10981	11231	break;
10982	11232	}
10983		-case 0xFFFFFFFFFFFFFD0BLLU:
	11233	+case 0xFFFFFFFFFFFFFCF3LLU:
10984	11234	/* SP = 22LLU */
10985	11235	{
10986	11236	/* CALLBEGIN */

		@@ -10991,12 +11241,12 @@
10991	11241	{
10992	11242	/CALLEND/
10993	11243	stackbase += 24LLU;
10994		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD0ALLU;
	11244	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF2LLU;
10995	11245	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
10996	11246	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
10997	11247	break;
10998	11248	}
10999		-case 0xFFFFFFFFFFFFFD0ALLU:
	11249	+case 0xFFFFFFFFFFFFFCF2LLU:
11000	11250	/* SP = 22LLU */
11001	11251	{
11002	11252	/* CALLBEGIN */

		@@ -11014,12 +11264,12 @@
11014	11264	{
11015	11265	/CALLEND/
11016	11266	stackbase += 30LLU;
11017		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD09LLU;
	11267	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF1LLU;
11018	11268	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
11019	11269	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
11020	11270	break;
11021	11271	}
11022		-case 0xFFFFFFFFFFFFFD09LLU:
	11272	+case 0xFFFFFFFFFFFFFCF1LLU:
11023	11273	/* SP = 28LLU */
11024	11274	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
11025	11275	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -11040,23 +11290,23 @@
11040	11290	{
11041	11291	/CALLEND/
11042	11292	stackbase += 42LLU;
11043		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD08LLU;
	11293	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF0LLU;
11044	11294	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11045	11295	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11046	11296	break;
11047	11297	}
11048		-case 0xFFFFFFFFFFFFFD08LLU:
	11298	+case 0xFFFFFFFFFFFFFCF0LLU:
11049	11299	/* SP = 40LLU */
11050	11300	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
11051	11301	{
11052	11302	/CALLEND/
11053	11303	stackbase += 25LLU;
11054		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD07LLU;
	11304	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCEFLLU;
11055	11305	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
11056		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	11306	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
11057	11307	break;
11058	11308	}
11059		-case 0xFFFFFFFFFFFFFD07LLU:
	11309	+case 0xFFFFFFFFFFFFFCEFLLU:
11060	11310	/* SP = 23LLU // SP = 22LLU // assign */
11061	11311	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
11062	11312	{

		@@ -11068,12 +11318,12 @@
11068	11318	{
11069	11319	/CALLEND/
11070	11320	stackbase += 24LLU;
11071		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD06LLU;
	11321	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCEELLU;
11072	11322	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11073	11323	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
11074	11324	break;
11075	11325	}
11076		-case 0xFFFFFFFFFFFFFD06LLU:
	11326	+case 0xFFFFFFFFFFFFFCEELLU:
11077	11327	/* SP = 22LLU */
11078	11328	{
11079	11329	/* CALLBEGIN */

		@@ -11085,12 +11335,12 @@
11085	11335	{
11086	11336	/CALLEND/
11087	11337	stackbase += 24LLU;
11088		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD05LLU;
	11338	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCEDLLU;
11089	11339	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
11090	11340	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
11091	11341	break;
11092	11342	}
11093		-case 0xFFFFFFFFFFFFFD05LLU:
	11343	+case 0xFFFFFFFFFFFFFCEDLLU:
11094	11344	/* SP = 22LLU */
11095	11345	{
11096	11346	/* CALLBEGIN */

		@@ -11101,12 +11351,12 @@
11101	11351	{
11102	11352	/CALLEND/
11103	11353	stackbase += 24LLU;
11104		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD04LLU;
	11354	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCECLLU;
11105	11355	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11106	11356	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
11107	11357	break;
11108	11358	}
11109		-case 0xFFFFFFFFFFFFFD04LLU:
	11359	+case 0xFFFFFFFFFFFFFCECLLU:
11110	11360	/* SP = 22LLU */
11111	11361	{
11112	11362	/* CALLBEGIN */

		@@ -11124,12 +11374,12 @@
11124	11374	{
11125	11375	/CALLEND/
11126	11376	stackbase += 30LLU;
11127		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD03LLU;
	11377	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCEBLLU;
11128	11378	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
11129	11379	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
11130	11380	break;
11131	11381	}
11132		-case 0xFFFFFFFFFFFFFD03LLU:
	11382	+case 0xFFFFFFFFFFFFFCEBLLU:
11133	11383	/* SP = 28LLU */
11134	11384	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
11135	11385	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -11150,23 +11400,23 @@
11150	11400	{
11151	11401	/CALLEND/
11152	11402	stackbase += 42LLU;
11153		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD02LLU;
	11403	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCEALLU;
11154	11404	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11155	11405	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11156	11406	break;
11157	11407	}
11158		-case 0xFFFFFFFFFFFFFD02LLU:
	11408	+case 0xFFFFFFFFFFFFFCEALLU:
11159	11409	/* SP = 40LLU */
11160	11410	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
11161	11411	{
11162	11412	/CALLEND/
11163	11413	stackbase += 25LLU;
11164		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD01LLU;
	11414	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE9LLU;
11165	11415	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
11166		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	11416	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
11167	11417	break;
11168	11418	}
11169		-case 0xFFFFFFFFFFFFFD01LLU:
	11419	+case 0xFFFFFFFFFFFFFCE9LLU:
11170	11420	/* SP = 23LLU // SP = 22LLU // assign */
11171	11421	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
11172	11422	{

		@@ -11181,15 +11431,15 @@
11181	11431	{
11182	11432	/CALLEND/
11183	11433	stackbase += 24LLU;
11184		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFD00LLU;
	11434	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE8LLU;
11185	11435	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
11186	11436	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
11187	11437	break;
11188	11438	}
11189		-case 0xFFFFFFFFFFFFFD00LLU:
	11439	+case 0xFFFFFFFFFFFFFCE8LLU:
11190	11440	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
11191		-{ /* JUMP / fnaddr = 18446744073709550862LLU; break; } / skip alternative */
11192		-case 18446744073709550863LLU: /* alternative // predicate */
	11441	+{ /* JUMP / fnaddr = 18446744073709550838LLU; break; } / skip alternative */
	11442	+case 18446744073709550839LLU: /* alternative // predicate */
11193	11443
11194	11444	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
11195	11445	{/* PUSH /stack[stackbase + 22LLU] = 8524163640109039616LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -11196,7 +11446,7 @@
11196	11446	{
11197	11447	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
11198	11448	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
11199		-{ /* JUMP / fnaddr = 18446744073709550847LLU; break; } / skip consequent */
	11449	+{ /* JUMP / fnaddr = 18446744073709550823LLU; break; } / skip consequent */
11200	11450	/* consequent */
11201	11451	{
11202	11452	/* CALLBEGIN */

		@@ -11215,22 +11465,22 @@
11215	11465	{
11216	11466	/CALLEND/
11217	11467	stackbase += 29LLU;
11218		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFDLLU;
	11468	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE5LLU;
11219	11469	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11220	11470	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11221	11471	break;
11222	11472	}
11223		-case 0xFFFFFFFFFFFFFCFDLLU:
	11473	+case 0xFFFFFFFFFFFFFCE5LLU:
11224	11474	/* SP = 27LLU */
11225	11475	{
11226	11476	/CALLEND/
11227	11477	stackbase += 23LLU;
11228		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFCLLU;
	11478	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE4LLU;
11229	11479	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
11230	11480	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
11231	11481	break;
11232	11482	}
11233		-case 0xFFFFFFFFFFFFFCFCLLU:
	11483	+case 0xFFFFFFFFFFFFFCE4LLU:
11234	11484	/* SP = 21LLU */
11235	11485	{
11236	11486	/* CALLBEGIN */

		@@ -11241,12 +11491,12 @@
11241	11491	{
11242	11492	/CALLEND/
11243	11493	stackbase += 23LLU;
11244		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFBLLU;
	11494	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE3LLU;
11245	11495	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11246	11496	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
11247	11497	break;
11248	11498	}
11249		-case 0xFFFFFFFFFFFFFCFBLLU:
	11499	+case 0xFFFFFFFFFFFFFCE3LLU:
11250	11500	/* SP = 21LLU */
11251	11501	{
11252	11502	/* CALLBEGIN */

		@@ -11264,12 +11514,12 @@
11264	11514	{
11265	11515	/CALLEND/
11266	11516	stackbase += 29LLU;
11267		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCFALLU;
	11517	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE2LLU;
11268	11518	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
11269	11519	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
11270	11520	break;
11271	11521	}
11272		-case 0xFFFFFFFFFFFFFCFALLU:
	11522	+case 0xFFFFFFFFFFFFFCE2LLU:
11273	11523	/* SP = 27LLU */
11274	11524	{/* PUSH /stack[stackbase + 27LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 28LLU */
11275	11525	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 29LLU */

		@@ -11290,23 +11540,23 @@
11290	11540	{
11291	11541	/CALLEND/
11292	11542	stackbase += 41LLU;
11293		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF9LLU;
	11543	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE1LLU;
11294	11544	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11295	11545	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11296	11546	break;
11297	11547	}
11298		-case 0xFFFFFFFFFFFFFCF9LLU:
	11548	+case 0xFFFFFFFFFFFFFCE1LLU:
11299	11549	/* SP = 39LLU */
11300	11550	{/* PUSH /stack[stackbase + 39LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 40LLU */
11301	11551	{
11302	11552	/CALLEND/
11303	11553	stackbase += 24LLU;
11304		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF8LLU;
	11554	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE0LLU;
11305	11555	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
11306		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	11556	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
11307	11557	break;
11308	11558	}
11309		-case 0xFFFFFFFFFFFFFCF8LLU:
	11559	+case 0xFFFFFFFFFFFFFCE0LLU:
11310	11560	/* SP = 22LLU // SP = 21LLU // assign */
11311	11561	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }
11312	11562	{

		@@ -11319,15 +11569,15 @@
11319	11569	{
11320	11570	/CALLEND/
11321	11571	stackbase += 23LLU;
11322		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF7LLU;
	11572	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCDFLLU;
11323	11573	fnaddr = /emitprefix/0x82892FAED8219330LLU;/* SP = 0LLU */
11324	11574	{ if(stackbase + 22LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitprefix/\n"); exit(-1); } }
11325	11575	break;
11326	11576	}
11327		-case 0xFFFFFFFFFFFFFCF7LLU:
	11577	+case 0xFFFFFFFFFFFFFCDFLLU:
11328	11578	/* SP = 21LLU // SP = 21LLU // SP = 21LLU */
11329		-{ /* JUMP / fnaddr = 18446744073709550846LLU; break; } / skip alternative */
11330		-case 18446744073709550847LLU: /* alternative // predicate */
	11579	+{ /* JUMP / fnaddr = 18446744073709550822LLU; break; } / skip alternative */
	11580	+case 18446744073709550823LLU: /* alternative // predicate */
11331	11581
11332	11582	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
11333	11583	{/* PUSH /stack[stackbase + 22LLU] = 8524149324983042048LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -11334,7 +11584,7 @@
11334	11584	{
11335	11585	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
11336	11586	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
11337		-{ /* JUMP / fnaddr = 18446744073709550838LLU; break; } / skip consequent */
	11587	+{ /* JUMP / fnaddr = 18446744073709550814LLU; break; } / skip consequent */
11338	11588	/* consequent */
11339	11589	{
11340	11590	/* CALLBEGIN */

		@@ -11353,22 +11603,22 @@
11353	11603	{
11354	11604	/CALLEND/
11355	11605	stackbase += 29LLU;
11356		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF4LLU;
	11606	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCDCLLU;
11357	11607	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11358	11608	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11359	11609	break;
11360	11610	}
11361		-case 0xFFFFFFFFFFFFFCF4LLU:
	11611	+case 0xFFFFFFFFFFFFFCDCLLU:
11362	11612	/* SP = 27LLU */
11363	11613	{
11364	11614	/CALLEND/
11365	11615	stackbase += 23LLU;
11366		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF3LLU;
	11616	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCDBLLU;
11367	11617	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
11368	11618	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
11369	11619	break;
11370	11620	}
11371		-case 0xFFFFFFFFFFFFFCF3LLU:
	11621	+case 0xFFFFFFFFFFFFFCDBLLU:
11372	11622	/* SP = 21LLU */
11373	11623	{
11374	11624	/* CALLBEGIN */

		@@ -11379,12 +11629,12 @@
11379	11629	{
11380	11630	/CALLEND/
11381	11631	stackbase += 24LLU;
11382		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF2LLU;
	11632	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCDALLU;
11383	11633	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
11384	11634	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
11385	11635	break;
11386	11636	}
11387		-case 0xFFFFFFFFFFFFFCF2LLU:
	11637	+case 0xFFFFFFFFFFFFFCDALLU:
11388	11638	/* SP = 22LLU */
11389	11639	{
11390	11640	/* CALLBEGIN */

		@@ -11395,12 +11645,12 @@
11395	11645	{
11396	11646	/CALLEND/
11397	11647	stackbase += 24LLU;
11398		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF1LLU;
	11648	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD9LLU;
11399	11649	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11400	11650	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
11401	11651	break;
11402	11652	}
11403		-case 0xFFFFFFFFFFFFFCF1LLU:
	11653	+case 0xFFFFFFFFFFFFFCD9LLU:
11404	11654	/* SP = 22LLU */
11405	11655	{
11406	11656	/* CALLBEGIN */

		@@ -11418,12 +11668,12 @@
11418	11668	{
11419	11669	/CALLEND/
11420	11670	stackbase += 30LLU;
11421		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCF0LLU;
	11671	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD8LLU;
11422	11672	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
11423	11673	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
11424	11674	break;
11425	11675	}
11426		-case 0xFFFFFFFFFFFFFCF0LLU:
	11676	+case 0xFFFFFFFFFFFFFCD8LLU:
11427	11677	/* SP = 28LLU */
11428	11678	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
11429	11679	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -11444,23 +11694,23 @@
11444	11694	{
11445	11695	/CALLEND/
11446	11696	stackbase += 42LLU;
11447		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCEFLLU;
	11697	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD7LLU;
11448	11698	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11449	11699	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11450	11700	break;
11451	11701	}
11452		-case 0xFFFFFFFFFFFFFCEFLLU:
	11702	+case 0xFFFFFFFFFFFFFCD7LLU:
11453	11703	/* SP = 40LLU */
11454	11704	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
11455	11705	{
11456	11706	/CALLEND/
11457	11707	stackbase += 25LLU;
11458		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCEELLU;
	11708	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD6LLU;
11459	11709	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
11460		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	11710	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
11461	11711	break;
11462	11712	}
11463		-case 0xFFFFFFFFFFFFFCEELLU:
	11713	+case 0xFFFFFFFFFFFFFCD6LLU:
11464	11714	/* SP = 23LLU // SP = 22LLU // assign */
11465	11715	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
11466	11716	{

		@@ -11472,12 +11722,12 @@
11472	11722	{
11473	11723	/CALLEND/
11474	11724	stackbase += 24LLU;
11475		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCEDLLU;
	11725	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD5LLU;
11476	11726	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11477	11727	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
11478	11728	break;
11479	11729	}
11480		-case 0xFFFFFFFFFFFFFCEDLLU:
	11730	+case 0xFFFFFFFFFFFFFCD5LLU:
11481	11731	/* SP = 22LLU */
11482	11732	{
11483	11733	/* CALLBEGIN */

		@@ -11489,12 +11739,12 @@
11489	11739	{
11490	11740	/CALLEND/
11491	11741	stackbase += 24LLU;
11492		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCECLLU;
	11742	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD4LLU;
11493	11743	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
11494	11744	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
11495	11745	break;
11496	11746	}
11497		-case 0xFFFFFFFFFFFFFCECLLU:
	11747	+case 0xFFFFFFFFFFFFFCD4LLU:
11498	11748	/* SP = 22LLU */
11499	11749	{
11500	11750	/* CALLBEGIN */

		@@ -11505,12 +11755,12 @@
11505	11755	{
11506	11756	/CALLEND/
11507	11757	stackbase += 24LLU;
11508		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCEBLLU;
	11758	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD3LLU;
11509	11759	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11510	11760	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
11511	11761	break;
11512	11762	}
11513		-case 0xFFFFFFFFFFFFFCEBLLU:
	11763	+case 0xFFFFFFFFFFFFFCD3LLU:
11514	11764	/* SP = 22LLU */
11515	11765	{
11516	11766	/* CALLBEGIN */

		@@ -11528,12 +11778,12 @@
11528	11778	{
11529	11779	/CALLEND/
11530	11780	stackbase += 30LLU;
11531		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCEALLU;
	11781	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD2LLU;
11532	11782	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
11533	11783	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
11534	11784	break;
11535	11785	}
11536		-case 0xFFFFFFFFFFFFFCEALLU:
	11786	+case 0xFFFFFFFFFFFFFCD2LLU:
11537	11787	/* SP = 28LLU */
11538	11788	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
11539	11789	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -11554,23 +11804,23 @@
11554	11804	{
11555	11805	/CALLEND/
11556	11806	stackbase += 42LLU;
11557		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE9LLU;
	11807	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD1LLU;
11558	11808	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11559	11809	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11560	11810	break;
11561	11811	}
11562		-case 0xFFFFFFFFFFFFFCE9LLU:
	11812	+case 0xFFFFFFFFFFFFFCD1LLU:
11563	11813	/* SP = 40LLU */
11564	11814	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
11565	11815	{
11566	11816	/CALLEND/
11567	11817	stackbase += 25LLU;
11568		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE8LLU;
	11818	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD0LLU;
11569	11819	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
11570		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	11820	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
11571	11821	break;
11572	11822	}
11573		-case 0xFFFFFFFFFFFFFCE8LLU:
	11823	+case 0xFFFFFFFFFFFFFCD0LLU:
11574	11824	/* SP = 23LLU // SP = 22LLU // assign */
11575	11825	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
11576	11826	{

		@@ -11585,15 +11835,15 @@
11585	11835	{
11586	11836	/CALLEND/
11587	11837	stackbase += 24LLU;
11588		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE7LLU;
	11838	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCFLLU;
11589	11839	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
11590	11840	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
11591	11841	break;
11592	11842	}
11593		-case 0xFFFFFFFFFFFFFCE7LLU:
	11843	+case 0xFFFFFFFFFFFFFCCFLLU:
11594	11844	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
11595		-{ /* JUMP / fnaddr = 18446744073709550837LLU; break; } / skip alternative */
11596		-case 18446744073709550838LLU: /* alternative // predicate */
	11845	+{ /* JUMP / fnaddr = 18446744073709550813LLU; break; } / skip alternative */
	11846	+case 18446744073709550814LLU: /* alternative // predicate */
11597	11847
11598	11848	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
11599	11849	{/* PUSH /stack[stackbase + 22LLU] = 8524164778543808512LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -11600,7 +11850,7 @@
11600	11850	{
11601	11851	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
11602	11852	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
11603		-{ /* JUMP / fnaddr = 18446744073709550822LLU; break; } / skip consequent */
	11853	+{ /* JUMP / fnaddr = 18446744073709550798LLU; break; } / skip consequent */
11604	11854	/* consequent */
11605	11855	{
11606	11856	/* CALLBEGIN */

		@@ -11619,22 +11869,22 @@
11619	11869	{
11620	11870	/CALLEND/
11621	11871	stackbase += 29LLU;
11622		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE4LLU;
	11872	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCCLLU;
11623	11873	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11624	11874	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11625	11875	break;
11626	11876	}
11627		-case 0xFFFFFFFFFFFFFCE4LLU:
	11877	+case 0xFFFFFFFFFFFFFCCCLLU:
11628	11878	/* SP = 27LLU */
11629	11879	{
11630	11880	/CALLEND/
11631	11881	stackbase += 23LLU;
11632		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE3LLU;
	11882	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCBLLU;
11633	11883	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
11634	11884	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
11635	11885	break;
11636	11886	}
11637		-case 0xFFFFFFFFFFFFFCE3LLU:
	11887	+case 0xFFFFFFFFFFFFFCCBLLU:
11638	11888	/* SP = 21LLU */
11639	11889	{
11640	11890	/* CALLBEGIN */

		@@ -11645,12 +11895,12 @@
11645	11895	{
11646	11896	/CALLEND/
11647	11897	stackbase += 24LLU;
11648		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE2LLU;
	11898	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCALLU;
11649	11899	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
11650	11900	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
11651	11901	break;
11652	11902	}
11653		-case 0xFFFFFFFFFFFFFCE2LLU:
	11903	+case 0xFFFFFFFFFFFFFCCALLU:
11654	11904	/* SP = 22LLU */
11655	11905	{
11656	11906	/* CALLBEGIN */

		@@ -11661,12 +11911,12 @@
11661	11911	{
11662	11912	/CALLEND/
11663	11913	stackbase += 24LLU;
11664		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE1LLU;
	11914	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC9LLU;
11665	11915	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11666	11916	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
11667	11917	break;
11668	11918	}
11669		-case 0xFFFFFFFFFFFFFCE1LLU:
	11919	+case 0xFFFFFFFFFFFFFCC9LLU:
11670	11920	/* SP = 22LLU */
11671	11921	{
11672	11922	/* CALLBEGIN */

		@@ -11684,12 +11934,12 @@
11684	11934	{
11685	11935	/CALLEND/
11686	11936	stackbase += 30LLU;
11687		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCE0LLU;
	11937	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC8LLU;
11688	11938	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
11689	11939	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
11690	11940	break;
11691	11941	}
11692		-case 0xFFFFFFFFFFFFFCE0LLU:
	11942	+case 0xFFFFFFFFFFFFFCC8LLU:
11693	11943	/* SP = 28LLU */
11694	11944	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
11695	11945	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -11710,23 +11960,23 @@
11710	11960	{
11711	11961	/CALLEND/
11712	11962	stackbase += 42LLU;
11713		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCDFLLU;
	11963	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC7LLU;
11714	11964	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11715	11965	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11716	11966	break;
11717	11967	}
11718		-case 0xFFFFFFFFFFFFFCDFLLU:
	11968	+case 0xFFFFFFFFFFFFFCC7LLU:
11719	11969	/* SP = 40LLU */
11720	11970	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
11721	11971	{
11722	11972	/CALLEND/
11723	11973	stackbase += 25LLU;
11724		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCDELLU;
	11974	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC6LLU;
11725	11975	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
11726		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	11976	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
11727	11977	break;
11728	11978	}
11729		-case 0xFFFFFFFFFFFFFCDELLU:
	11979	+case 0xFFFFFFFFFFFFFCC6LLU:
11730	11980	/* SP = 23LLU // SP = 22LLU // assign */
11731	11981	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
11732	11982	{

		@@ -11738,12 +11988,12 @@
11738	11988	{
11739	11989	/CALLEND/
11740	11990	stackbase += 24LLU;
11741		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCDDLLU;
	11991	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC5LLU;
11742	11992	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11743	11993	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
11744	11994	break;
11745	11995	}
11746		-case 0xFFFFFFFFFFFFFCDDLLU:
	11996	+case 0xFFFFFFFFFFFFFCC5LLU:
11747	11997	/* SP = 22LLU */
11748	11998	{
11749	11999	/* CALLBEGIN */

		@@ -11755,12 +12005,12 @@
11755	12005	{
11756	12006	/CALLEND/
11757	12007	stackbase += 24LLU;
11758		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCDCLLU;
	12008	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC4LLU;
11759	12009	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
11760	12010	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
11761	12011	break;
11762	12012	}
11763		-case 0xFFFFFFFFFFFFFCDCLLU:
	12013	+case 0xFFFFFFFFFFFFFCC4LLU:
11764	12014	/* SP = 22LLU */
11765	12015	{
11766	12016	/* CALLBEGIN */

		@@ -11771,12 +12021,12 @@
11771	12021	{
11772	12022	/CALLEND/
11773	12023	stackbase += 24LLU;
11774		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCDBLLU;
	12024	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC3LLU;
11775	12025	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11776	12026	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
11777	12027	break;
11778	12028	}
11779		-case 0xFFFFFFFFFFFFFCDBLLU:
	12029	+case 0xFFFFFFFFFFFFFCC3LLU:
11780	12030	/* SP = 22LLU */
11781	12031	{
11782	12032	/* CALLBEGIN */

		@@ -11794,12 +12044,12 @@
11794	12044	{
11795	12045	/CALLEND/
11796	12046	stackbase += 30LLU;
11797		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCDALLU;
	12047	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC2LLU;
11798	12048	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
11799	12049	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
11800	12050	break;
11801	12051	}
11802		-case 0xFFFFFFFFFFFFFCDALLU:
	12052	+case 0xFFFFFFFFFFFFFCC2LLU:
11803	12053	/* SP = 28LLU */
11804	12054	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
11805	12055	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -11820,23 +12070,23 @@
11820	12070	{
11821	12071	/CALLEND/
11822	12072	stackbase += 42LLU;
11823		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD9LLU;
	12073	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC1LLU;
11824	12074	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11825	12075	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11826	12076	break;
11827	12077	}
11828		-case 0xFFFFFFFFFFFFFCD9LLU:
	12078	+case 0xFFFFFFFFFFFFFCC1LLU:
11829	12079	/* SP = 40LLU */
11830	12080	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
11831	12081	{
11832	12082	/CALLEND/
11833	12083	stackbase += 25LLU;
11834		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD8LLU;
	12084	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC0LLU;
11835	12085	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
11836		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	12086	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
11837	12087	break;
11838	12088	}
11839		-case 0xFFFFFFFFFFFFFCD8LLU:
	12089	+case 0xFFFFFFFFFFFFFCC0LLU:
11840	12090	/* SP = 23LLU // SP = 22LLU // assign */
11841	12091	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
11842	12092	{

		@@ -11851,15 +12101,15 @@
11851	12101	{
11852	12102	/CALLEND/
11853	12103	stackbase += 24LLU;
11854		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD7LLU;
	12104	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBFLLU;
11855	12105	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
11856	12106	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
11857	12107	break;
11858	12108	}
11859		-case 0xFFFFFFFFFFFFFCD7LLU:
	12109	+case 0xFFFFFFFFFFFFFCBFLLU:
11860	12110	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
11861		-{ /* JUMP / fnaddr = 18446744073709550821LLU; break; } / skip alternative */
11862		-case 18446744073709550822LLU: /* alternative // predicate */
	12111	+{ /* JUMP / fnaddr = 18446744073709550797LLU; break; } / skip alternative */
	12112	+case 18446744073709550798LLU: /* alternative // predicate */
11863	12113
11864	12114	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
11865	12115	{/* PUSH /stack[stackbase + 22LLU] = 8212243551765921792LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -11866,7 +12116,7 @@
11866	12116	{
11867	12117	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
11868	12118	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
11869		-{ /* JUMP / fnaddr = 18446744073709550806LLU; break; } / skip consequent */
	12119	+{ /* JUMP / fnaddr = 18446744073709550782LLU; break; } / skip consequent */
11870	12120	/* consequent */
11871	12121	{
11872	12122	/* CALLBEGIN */

		@@ -11885,22 +12135,22 @@
11885	12135	{
11886	12136	/CALLEND/
11887	12137	stackbase += 29LLU;
11888		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD4LLU;
	12138	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBCLLU;
11889	12139	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11890	12140	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11891	12141	break;
11892	12142	}
11893		-case 0xFFFFFFFFFFFFFCD4LLU:
	12143	+case 0xFFFFFFFFFFFFFCBCLLU:
11894	12144	/* SP = 27LLU */
11895	12145	{
11896	12146	/CALLEND/
11897	12147	stackbase += 23LLU;
11898		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD3LLU;
	12148	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBBLLU;
11899	12149	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
11900	12150	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
11901	12151	break;
11902	12152	}
11903		-case 0xFFFFFFFFFFFFFCD3LLU:
	12153	+case 0xFFFFFFFFFFFFFCBBLLU:
11904	12154	/* SP = 21LLU */
11905	12155	{
11906	12156	/* CALLBEGIN */

		@@ -11911,12 +12161,12 @@
11911	12161	{
11912	12162	/CALLEND/
11913	12163	stackbase += 24LLU;
11914		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD2LLU;
	12164	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBALLU;
11915	12165	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
11916	12166	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
11917	12167	break;
11918	12168	}
11919		-case 0xFFFFFFFFFFFFFCD2LLU:
	12169	+case 0xFFFFFFFFFFFFFCBALLU:
11920	12170	/* SP = 22LLU */
11921	12171	{
11922	12172	/* CALLBEGIN */

		@@ -11927,12 +12177,12 @@
11927	12177	{
11928	12178	/CALLEND/
11929	12179	stackbase += 24LLU;
11930		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD1LLU;
	12180	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB9LLU;
11931	12181	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
11932	12182	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
11933	12183	break;
11934	12184	}
11935		-case 0xFFFFFFFFFFFFFCD1LLU:
	12185	+case 0xFFFFFFFFFFFFFCB9LLU:
11936	12186	/* SP = 22LLU */
11937	12187	{
11938	12188	/* CALLBEGIN */

		@@ -11950,12 +12200,12 @@
11950	12200	{
11951	12201	/CALLEND/
11952	12202	stackbase += 30LLU;
11953		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCD0LLU;
	12203	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB8LLU;
11954	12204	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
11955	12205	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
11956	12206	break;
11957	12207	}
11958		-case 0xFFFFFFFFFFFFFCD0LLU:
	12208	+case 0xFFFFFFFFFFFFFCB8LLU:
11959	12209	/* SP = 28LLU */
11960	12210	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
11961	12211	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -11976,23 +12226,23 @@
11976	12226	{
11977	12227	/CALLEND/
11978	12228	stackbase += 42LLU;
11979		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCFLLU;
	12229	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB7LLU;
11980	12230	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
11981	12231	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
11982	12232	break;
11983	12233	}
11984		-case 0xFFFFFFFFFFFFFCCFLLU:
	12234	+case 0xFFFFFFFFFFFFFCB7LLU:
11985	12235	/* SP = 40LLU */
11986	12236	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
11987	12237	{
11988	12238	/CALLEND/
11989	12239	stackbase += 25LLU;
11990		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCELLU;
	12240	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB6LLU;
11991	12241	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
11992		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	12242	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
11993	12243	break;
11994	12244	}
11995		-case 0xFFFFFFFFFFFFFCCELLU:
	12245	+case 0xFFFFFFFFFFFFFCB6LLU:
11996	12246	/* SP = 23LLU // SP = 22LLU // assign */
11997	12247	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
11998	12248	{

		@@ -12004,12 +12254,12 @@
12004	12254	{
12005	12255	/CALLEND/
12006	12256	stackbase += 24LLU;
12007		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCDLLU;
	12257	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB5LLU;
12008	12258	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12009	12259	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12010	12260	break;
12011	12261	}
12012		-case 0xFFFFFFFFFFFFFCCDLLU:
	12262	+case 0xFFFFFFFFFFFFFCB5LLU:
12013	12263	/* SP = 22LLU */
12014	12264	{
12015	12265	/* CALLBEGIN */

		@@ -12021,12 +12271,12 @@
12021	12271	{
12022	12272	/CALLEND/
12023	12273	stackbase += 24LLU;
12024		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCCLLU;
	12274	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB4LLU;
12025	12275	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
12026	12276	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
12027	12277	break;
12028	12278	}
12029		-case 0xFFFFFFFFFFFFFCCCLLU:
	12279	+case 0xFFFFFFFFFFFFFCB4LLU:
12030	12280	/* SP = 22LLU */
12031	12281	{
12032	12282	/* CALLBEGIN */

		@@ -12037,12 +12287,12 @@
12037	12287	{
12038	12288	/CALLEND/
12039	12289	stackbase += 24LLU;
12040		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCBLLU;
	12290	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB3LLU;
12041	12291	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12042	12292	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12043	12293	break;
12044	12294	}
12045		-case 0xFFFFFFFFFFFFFCCBLLU:
	12295	+case 0xFFFFFFFFFFFFFCB3LLU:
12046	12296	/* SP = 22LLU */
12047	12297	{
12048	12298	/* CALLBEGIN */

		@@ -12060,12 +12310,12 @@
12060	12310	{
12061	12311	/CALLEND/
12062	12312	stackbase += 30LLU;
12063		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCCALLU;
	12313	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB2LLU;
12064	12314	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
12065	12315	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
12066	12316	break;
12067	12317	}
12068		-case 0xFFFFFFFFFFFFFCCALLU:
	12318	+case 0xFFFFFFFFFFFFFCB2LLU:
12069	12319	/* SP = 28LLU */
12070	12320	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
12071	12321	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -12086,23 +12336,23 @@
12086	12336	{
12087	12337	/CALLEND/
12088	12338	stackbase += 42LLU;
12089		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC9LLU;
	12339	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB1LLU;
12090	12340	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
12091	12341	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
12092	12342	break;
12093	12343	}
12094		-case 0xFFFFFFFFFFFFFCC9LLU:
	12344	+case 0xFFFFFFFFFFFFFCB1LLU:
12095	12345	/* SP = 40LLU */
12096	12346	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
12097	12347	{
12098	12348	/CALLEND/
12099	12349	stackbase += 25LLU;
12100		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC8LLU;
	12350	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB0LLU;
12101	12351	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
12102		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	12352	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
12103	12353	break;
12104	12354	}
12105		-case 0xFFFFFFFFFFFFFCC8LLU:
	12355	+case 0xFFFFFFFFFFFFFCB0LLU:
12106	12356	/* SP = 23LLU // SP = 22LLU // assign */
12107	12357	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
12108	12358	{

		@@ -12117,15 +12367,15 @@
12117	12367	{
12118	12368	/CALLEND/
12119	12369	stackbase += 24LLU;
12120		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC7LLU;
	12370	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCAFLLU;
12121	12371	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
12122	12372	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
12123	12373	break;
12124	12374	}
12125		-case 0xFFFFFFFFFFFFFCC7LLU:
	12375	+case 0xFFFFFFFFFFFFFCAFLLU:
12126	12376	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
12127		-{ /* JUMP / fnaddr = 18446744073709550805LLU; break; } / skip alternative */
12128		-case 18446744073709550806LLU: /* alternative // predicate */
	12377	+{ /* JUMP / fnaddr = 18446744073709550781LLU; break; } / skip alternative */
	12378	+case 18446744073709550782LLU: /* alternative // predicate */
12129	12379
12130	12380	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
12131	12381	{/* PUSH /stack[stackbase + 22LLU] = 13476810778673676288LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -12132,7 +12382,7 @@
12132	12382	{
12133	12383	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
12134	12384	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
12135		-{ /* JUMP / fnaddr = 18446744073709550790LLU; break; } / skip consequent */
	12385	+{ /* JUMP / fnaddr = 18446744073709550766LLU; break; } / skip consequent */
12136	12386	/* consequent */
12137	12387	{
12138	12388	/* CALLBEGIN */

		@@ -12151,22 +12401,22 @@
12151	12401	{
12152	12402	/CALLEND/
12153	12403	stackbase += 29LLU;
12154		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC4LLU;
	12404	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCACLLU;
12155	12405	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
12156	12406	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
12157	12407	break;
12158	12408	}
12159		-case 0xFFFFFFFFFFFFFCC4LLU:
	12409	+case 0xFFFFFFFFFFFFFCACLLU:
12160	12410	/* SP = 27LLU */
12161	12411	{
12162	12412	/CALLEND/
12163	12413	stackbase += 23LLU;
12164		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC3LLU;
	12414	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCABLLU;
12165	12415	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
12166	12416	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
12167	12417	break;
12168	12418	}
12169		-case 0xFFFFFFFFFFFFFCC3LLU:
	12419	+case 0xFFFFFFFFFFFFFCABLLU:
12170	12420	/* SP = 21LLU */
12171	12421	{
12172	12422	/* CALLBEGIN */

		@@ -12177,12 +12427,12 @@
12177	12427	{
12178	12428	/CALLEND/
12179	12429	stackbase += 24LLU;
12180		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC2LLU;
	12430	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCAALLU;
12181	12431	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
12182	12432	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
12183	12433	break;
12184	12434	}
12185		-case 0xFFFFFFFFFFFFFCC2LLU:
	12435	+case 0xFFFFFFFFFFFFFCAALLU:
12186	12436	/* SP = 22LLU */
12187	12437	{
12188	12438	/* CALLBEGIN */

		@@ -12193,12 +12443,12 @@
12193	12443	{
12194	12444	/CALLEND/
12195	12445	stackbase += 24LLU;
12196		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC1LLU;
	12446	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA9LLU;
12197	12447	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12198	12448	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12199	12449	break;
12200	12450	}
12201		-case 0xFFFFFFFFFFFFFCC1LLU:
	12451	+case 0xFFFFFFFFFFFFFCA9LLU:
12202	12452	/* SP = 22LLU */
12203	12453	{
12204	12454	/* CALLBEGIN */

		@@ -12216,12 +12466,12 @@
12216	12466	{
12217	12467	/CALLEND/
12218	12468	stackbase += 30LLU;
12219		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCC0LLU;
	12469	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA8LLU;
12220	12470	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
12221	12471	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
12222	12472	break;
12223	12473	}
12224		-case 0xFFFFFFFFFFFFFCC0LLU:
	12474	+case 0xFFFFFFFFFFFFFCA8LLU:
12225	12475	/* SP = 28LLU */
12226	12476	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
12227	12477	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -12242,23 +12492,23 @@
12242	12492	{
12243	12493	/CALLEND/
12244	12494	stackbase += 42LLU;
12245		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBFLLU;
	12495	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA7LLU;
12246	12496	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
12247	12497	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
12248	12498	break;
12249	12499	}
12250		-case 0xFFFFFFFFFFFFFCBFLLU:
	12500	+case 0xFFFFFFFFFFFFFCA7LLU:
12251	12501	/* SP = 40LLU */
12252	12502	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
12253	12503	{
12254	12504	/CALLEND/
12255	12505	stackbase += 25LLU;
12256		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBELLU;
	12506	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA6LLU;
12257	12507	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
12258		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	12508	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
12259	12509	break;
12260	12510	}
12261		-case 0xFFFFFFFFFFFFFCBELLU:
	12511	+case 0xFFFFFFFFFFFFFCA6LLU:
12262	12512	/* SP = 23LLU // SP = 22LLU // assign */
12263	12513	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
12264	12514	{

		@@ -12270,12 +12520,12 @@
12270	12520	{
12271	12521	/CALLEND/
12272	12522	stackbase += 24LLU;
12273		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBDLLU;
	12523	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA5LLU;
12274	12524	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12275	12525	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12276	12526	break;
12277	12527	}
12278		-case 0xFFFFFFFFFFFFFCBDLLU:
	12528	+case 0xFFFFFFFFFFFFFCA5LLU:
12279	12529	/* SP = 22LLU */
12280	12530	{
12281	12531	/* CALLBEGIN */

		@@ -12287,12 +12537,12 @@
12287	12537	{
12288	12538	/CALLEND/
12289	12539	stackbase += 24LLU;
12290		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBCLLU;
	12540	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA4LLU;
12291	12541	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
12292	12542	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
12293	12543	break;
12294	12544	}
12295		-case 0xFFFFFFFFFFFFFCBCLLU:
	12545	+case 0xFFFFFFFFFFFFFCA4LLU:
12296	12546	/* SP = 22LLU */
12297	12547	{
12298	12548	/* CALLBEGIN */

		@@ -12303,12 +12553,12 @@
12303	12553	{
12304	12554	/CALLEND/
12305	12555	stackbase += 24LLU;
12306		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBBLLU;
	12556	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA3LLU;
12307	12557	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12308	12558	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12309	12559	break;
12310	12560	}
12311		-case 0xFFFFFFFFFFFFFCBBLLU:
	12561	+case 0xFFFFFFFFFFFFFCA3LLU:
12312	12562	/* SP = 22LLU */
12313	12563	{
12314	12564	/* CALLBEGIN */

		@@ -12326,12 +12576,12 @@
12326	12576	{
12327	12577	/CALLEND/
12328	12578	stackbase += 30LLU;
12329		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCBALLU;
	12579	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA2LLU;
12330	12580	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
12331	12581	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
12332	12582	break;
12333	12583	}
12334		-case 0xFFFFFFFFFFFFFCBALLU:
	12584	+case 0xFFFFFFFFFFFFFCA2LLU:
12335	12585	/* SP = 28LLU */
12336	12586	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
12337	12587	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -12352,23 +12602,23 @@
12352	12602	{
12353	12603	/CALLEND/
12354	12604	stackbase += 42LLU;
12355		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB9LLU;
	12605	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA1LLU;
12356	12606	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
12357	12607	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
12358	12608	break;
12359	12609	}
12360		-case 0xFFFFFFFFFFFFFCB9LLU:
	12610	+case 0xFFFFFFFFFFFFFCA1LLU:
12361	12611	/* SP = 40LLU */
12362	12612	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
12363	12613	{
12364	12614	/CALLEND/
12365	12615	stackbase += 25LLU;
12366		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB8LLU;
	12616	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA0LLU;
12367	12617	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
12368		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	12618	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
12369	12619	break;
12370	12620	}
12371		-case 0xFFFFFFFFFFFFFCB8LLU:
	12621	+case 0xFFFFFFFFFFFFFCA0LLU:
12372	12622	/* SP = 23LLU // SP = 22LLU // assign */
12373	12623	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
12374	12624	{

		@@ -12383,15 +12633,15 @@
12383	12633	{
12384	12634	/CALLEND/
12385	12635	stackbase += 24LLU;
12386		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB7LLU;
	12636	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9FLLU;
12387	12637	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
12388	12638	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
12389	12639	break;
12390	12640	}
12391		-case 0xFFFFFFFFFFFFFCB7LLU:
	12641	+case 0xFFFFFFFFFFFFFC9FLLU:
12392	12642	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
12393		-{ /* JUMP / fnaddr = 18446744073709550789LLU; break; } / skip alternative */
12394		-case 18446744073709550790LLU: /* alternative // predicate */
	12643	+{ /* JUMP / fnaddr = 18446744073709550765LLU; break; } / skip alternative */
	12644	+case 18446744073709550766LLU: /* alternative // predicate */
12395	12645
12396	12646	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
12397	12647	{/* PUSH /stack[stackbase + 22LLU] = 11748132209205182464LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -12398,7 +12648,7 @@
12398	12648	{
12399	12649	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
12400	12650	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
12401		-{ /* JUMP / fnaddr = 18446744073709550774LLU; break; } / skip consequent */
	12651	+{ /* JUMP / fnaddr = 18446744073709550750LLU; break; } / skip consequent */
12402	12652	/* consequent */
12403	12653	{
12404	12654	/* CALLBEGIN */

		@@ -12417,22 +12667,22 @@
12417	12667	{
12418	12668	/CALLEND/
12419	12669	stackbase += 29LLU;
12420		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB4LLU;
	12670	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9CLLU;
12421	12671	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
12422	12672	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
12423	12673	break;
12424	12674	}
12425		-case 0xFFFFFFFFFFFFFCB4LLU:
	12675	+case 0xFFFFFFFFFFFFFC9CLLU:
12426	12676	/* SP = 27LLU */
12427	12677	{
12428	12678	/CALLEND/
12429	12679	stackbase += 23LLU;
12430		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB3LLU;
	12680	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9BLLU;
12431	12681	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
12432	12682	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
12433	12683	break;
12434	12684	}
12435		-case 0xFFFFFFFFFFFFFCB3LLU:
	12685	+case 0xFFFFFFFFFFFFFC9BLLU:
12436	12686	/* SP = 21LLU */
12437	12687	{
12438	12688	/* CALLBEGIN */

		@@ -12443,12 +12693,12 @@
12443	12693	{
12444	12694	/CALLEND/
12445	12695	stackbase += 24LLU;
12446		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB2LLU;
	12696	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9ALLU;
12447	12697	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
12448	12698	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
12449	12699	break;
12450	12700	}
12451		-case 0xFFFFFFFFFFFFFCB2LLU:
	12701	+case 0xFFFFFFFFFFFFFC9ALLU:
12452	12702	/* SP = 22LLU */
12453	12703	{
12454	12704	/* CALLBEGIN */

		@@ -12459,12 +12709,12 @@
12459	12709	{
12460	12710	/CALLEND/
12461	12711	stackbase += 24LLU;
12462		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB1LLU;
	12712	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC99LLU;
12463	12713	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12464	12714	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12465	12715	break;
12466	12716	}
12467		-case 0xFFFFFFFFFFFFFCB1LLU:
	12717	+case 0xFFFFFFFFFFFFFC99LLU:
12468	12718	/* SP = 22LLU */
12469	12719	{
12470	12720	/* CALLBEGIN */

		@@ -12482,12 +12732,12 @@
12482	12732	{
12483	12733	/CALLEND/
12484	12734	stackbase += 30LLU;
12485		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCB0LLU;
	12735	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC98LLU;
12486	12736	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
12487	12737	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
12488	12738	break;
12489	12739	}
12490		-case 0xFFFFFFFFFFFFFCB0LLU:
	12740	+case 0xFFFFFFFFFFFFFC98LLU:
12491	12741	/* SP = 28LLU */
12492	12742	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
12493	12743	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -12508,23 +12758,23 @@
12508	12758	{
12509	12759	/CALLEND/
12510	12760	stackbase += 42LLU;
12511		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCAFLLU;
	12761	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC97LLU;
12512	12762	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
12513	12763	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
12514	12764	break;
12515	12765	}
12516		-case 0xFFFFFFFFFFFFFCAFLLU:
	12766	+case 0xFFFFFFFFFFFFFC97LLU:
12517	12767	/* SP = 40LLU */
12518	12768	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
12519	12769	{
12520	12770	/CALLEND/
12521	12771	stackbase += 25LLU;
12522		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCAELLU;
	12772	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC96LLU;
12523	12773	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
12524		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	12774	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
12525	12775	break;
12526	12776	}
12527		-case 0xFFFFFFFFFFFFFCAELLU:
	12777	+case 0xFFFFFFFFFFFFFC96LLU:
12528	12778	/* SP = 23LLU // SP = 22LLU // assign */
12529	12779	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
12530	12780	{

		@@ -12536,12 +12786,12 @@
12536	12786	{
12537	12787	/CALLEND/
12538	12788	stackbase += 24LLU;
12539		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCADLLU;
	12789	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC95LLU;
12540	12790	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12541	12791	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12542	12792	break;
12543	12793	}
12544		-case 0xFFFFFFFFFFFFFCADLLU:
	12794	+case 0xFFFFFFFFFFFFFC95LLU:
12545	12795	/* SP = 22LLU */
12546	12796	{
12547	12797	/* CALLBEGIN */

		@@ -12553,12 +12803,12 @@
12553	12803	{
12554	12804	/CALLEND/
12555	12805	stackbase += 24LLU;
12556		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCACLLU;
	12806	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC94LLU;
12557	12807	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
12558	12808	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
12559	12809	break;
12560	12810	}
12561		-case 0xFFFFFFFFFFFFFCACLLU:
	12811	+case 0xFFFFFFFFFFFFFC94LLU:
12562	12812	/* SP = 22LLU */
12563	12813	{
12564	12814	/* CALLBEGIN */

		@@ -12569,12 +12819,12 @@
12569	12819	{
12570	12820	/CALLEND/
12571	12821	stackbase += 24LLU;
12572		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCABLLU;
	12822	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC93LLU;
12573	12823	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12574	12824	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12575	12825	break;
12576	12826	}
12577		-case 0xFFFFFFFFFFFFFCABLLU:
	12827	+case 0xFFFFFFFFFFFFFC93LLU:
12578	12828	/* SP = 22LLU */
12579	12829	{
12580	12830	/* CALLBEGIN */

		@@ -12592,12 +12842,12 @@
12592	12842	{
12593	12843	/CALLEND/
12594	12844	stackbase += 30LLU;
12595		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCAALLU;
	12845	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC92LLU;
12596	12846	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
12597	12847	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
12598	12848	break;
12599	12849	}
12600		-case 0xFFFFFFFFFFFFFCAALLU:
	12850	+case 0xFFFFFFFFFFFFFC92LLU:
12601	12851	/* SP = 28LLU */
12602	12852	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
12603	12853	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -12618,23 +12868,23 @@
12618	12868	{
12619	12869	/CALLEND/
12620	12870	stackbase += 42LLU;
12621		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA9LLU;
	12871	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC91LLU;
12622	12872	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
12623	12873	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
12624	12874	break;
12625	12875	}
12626		-case 0xFFFFFFFFFFFFFCA9LLU:
	12876	+case 0xFFFFFFFFFFFFFC91LLU:
12627	12877	/* SP = 40LLU */
12628	12878	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
12629	12879	{
12630	12880	/CALLEND/
12631	12881	stackbase += 25LLU;
12632		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA8LLU;
	12882	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC90LLU;
12633	12883	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
12634		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	12884	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
12635	12885	break;
12636	12886	}
12637		-case 0xFFFFFFFFFFFFFCA8LLU:
	12887	+case 0xFFFFFFFFFFFFFC90LLU:
12638	12888	/* SP = 23LLU // SP = 22LLU // assign */
12639	12889	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
12640	12890	{

		@@ -12649,15 +12899,15 @@
12649	12899	{
12650	12900	/CALLEND/
12651	12901	stackbase += 24LLU;
12652		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA7LLU;
	12902	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8FLLU;
12653	12903	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
12654	12904	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
12655	12905	break;
12656	12906	}
12657		-case 0xFFFFFFFFFFFFFCA7LLU:
	12907	+case 0xFFFFFFFFFFFFFC8FLLU:
12658	12908	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
12659		-{ /* JUMP / fnaddr = 18446744073709550773LLU; break; } / skip alternative */
12660		-case 18446744073709550774LLU: /* alternative // predicate */
	12909	+{ /* JUMP / fnaddr = 18446744073709550749LLU; break; } / skip alternative */
	12910	+case 18446744073709550750LLU: /* alternative // predicate */
12661	12911
12662	12912	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
12663	12913	{/* PUSH /stack[stackbase + 22LLU] = 9100719315753107456LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -12664,7 +12914,7 @@
12664	12914	{
12665	12915	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
12666	12916	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
12667		-{ /* JUMP / fnaddr = 18446744073709550758LLU; break; } / skip consequent */
	12917	+{ /* JUMP / fnaddr = 18446744073709550734LLU; break; } / skip consequent */
12668	12918	/* consequent */
12669	12919	{
12670	12920	/* CALLBEGIN */

		@@ -12683,22 +12933,22 @@
12683	12933	{
12684	12934	/CALLEND/
12685	12935	stackbase += 29LLU;
12686		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA4LLU;
	12936	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8CLLU;
12687	12937	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
12688	12938	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
12689	12939	break;
12690	12940	}
12691		-case 0xFFFFFFFFFFFFFCA4LLU:
	12941	+case 0xFFFFFFFFFFFFFC8CLLU:
12692	12942	/* SP = 27LLU */
12693	12943	{
12694	12944	/CALLEND/
12695	12945	stackbase += 23LLU;
12696		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA3LLU;
	12946	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8BLLU;
12697	12947	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
12698	12948	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
12699	12949	break;
12700	12950	}
12701		-case 0xFFFFFFFFFFFFFCA3LLU:
	12951	+case 0xFFFFFFFFFFFFFC8BLLU:
12702	12952	/* SP = 21LLU */
12703	12953	{
12704	12954	/* CALLBEGIN */

		@@ -12709,12 +12959,12 @@
12709	12959	{
12710	12960	/CALLEND/
12711	12961	stackbase += 24LLU;
12712		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA2LLU;
	12962	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8ALLU;
12713	12963	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
12714	12964	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
12715	12965	break;
12716	12966	}
12717		-case 0xFFFFFFFFFFFFFCA2LLU:
	12967	+case 0xFFFFFFFFFFFFFC8ALLU:
12718	12968	/* SP = 22LLU */
12719	12969	{
12720	12970	/* CALLBEGIN */

		@@ -12725,12 +12975,12 @@
12725	12975	{
12726	12976	/CALLEND/
12727	12977	stackbase += 24LLU;
12728		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA1LLU;
	12978	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC89LLU;
12729	12979	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12730	12980	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12731	12981	break;
12732	12982	}
12733		-case 0xFFFFFFFFFFFFFCA1LLU:
	12983	+case 0xFFFFFFFFFFFFFC89LLU:
12734	12984	/* SP = 22LLU */
12735	12985	{
12736	12986	/* CALLBEGIN */

		@@ -12748,12 +12998,12 @@
12748	12998	{
12749	12999	/CALLEND/
12750	13000	stackbase += 30LLU;
12751		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFCA0LLU;
	13001	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC88LLU;
12752	13002	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
12753	13003	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
12754	13004	break;
12755	13005	}
12756		-case 0xFFFFFFFFFFFFFCA0LLU:
	13006	+case 0xFFFFFFFFFFFFFC88LLU:
12757	13007	/* SP = 28LLU */
12758	13008	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
12759	13009	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -12774,23 +13024,23 @@
12774	13024	{
12775	13025	/CALLEND/
12776	13026	stackbase += 42LLU;
12777		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9FLLU;
	13027	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC87LLU;
12778	13028	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
12779	13029	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
12780	13030	break;
12781	13031	}
12782		-case 0xFFFFFFFFFFFFFC9FLLU:
	13032	+case 0xFFFFFFFFFFFFFC87LLU:
12783	13033	/* SP = 40LLU */
12784	13034	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
12785	13035	{
12786	13036	/CALLEND/
12787	13037	stackbase += 25LLU;
12788		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9ELLU;
	13038	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC86LLU;
12789	13039	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
12790		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	13040	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
12791	13041	break;
12792	13042	}
12793		-case 0xFFFFFFFFFFFFFC9ELLU:
	13043	+case 0xFFFFFFFFFFFFFC86LLU:
12794	13044	/* SP = 23LLU // SP = 22LLU // assign */
12795	13045	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
12796	13046	{

		@@ -12802,12 +13052,12 @@
12802	13052	{
12803	13053	/CALLEND/
12804	13054	stackbase += 24LLU;
12805		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9DLLU;
	13055	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC85LLU;
12806	13056	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12807	13057	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12808	13058	break;
12809	13059	}
12810		-case 0xFFFFFFFFFFFFFC9DLLU:
	13060	+case 0xFFFFFFFFFFFFFC85LLU:
12811	13061	/* SP = 22LLU */
12812	13062	{
12813	13063	/* CALLBEGIN */

		@@ -12819,12 +13069,12 @@
12819	13069	{
12820	13070	/CALLEND/
12821	13071	stackbase += 24LLU;
12822		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9CLLU;
	13072	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC84LLU;
12823	13073	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
12824	13074	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
12825	13075	break;
12826	13076	}
12827		-case 0xFFFFFFFFFFFFFC9CLLU:
	13077	+case 0xFFFFFFFFFFFFFC84LLU:
12828	13078	/* SP = 22LLU */
12829	13079	{
12830	13080	/* CALLBEGIN */

		@@ -12835,12 +13085,12 @@
12835	13085	{
12836	13086	/CALLEND/
12837	13087	stackbase += 24LLU;
12838		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9BLLU;
	13088	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC83LLU;
12839	13089	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12840	13090	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12841	13091	break;
12842	13092	}
12843		-case 0xFFFFFFFFFFFFFC9BLLU:
	13093	+case 0xFFFFFFFFFFFFFC83LLU:
12844	13094	/* SP = 22LLU */
12845	13095	{
12846	13096	/* CALLBEGIN */

		@@ -12858,12 +13108,12 @@
12858	13108	{
12859	13109	/CALLEND/
12860	13110	stackbase += 30LLU;
12861		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC9ALLU;
	13111	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC82LLU;
12862	13112	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
12863	13113	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
12864	13114	break;
12865	13115	}
12866		-case 0xFFFFFFFFFFFFFC9ALLU:
	13116	+case 0xFFFFFFFFFFFFFC82LLU:
12867	13117	/* SP = 28LLU */
12868	13118	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
12869	13119	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -12884,23 +13134,23 @@
12884	13134	{
12885	13135	/CALLEND/
12886	13136	stackbase += 42LLU;
12887		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC99LLU;
	13137	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC81LLU;
12888	13138	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
12889	13139	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
12890	13140	break;
12891	13141	}
12892		-case 0xFFFFFFFFFFFFFC99LLU:
	13142	+case 0xFFFFFFFFFFFFFC81LLU:
12893	13143	/* SP = 40LLU */
12894	13144	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
12895	13145	{
12896	13146	/CALLEND/
12897	13147	stackbase += 25LLU;
12898		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC98LLU;
	13148	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC80LLU;
12899	13149	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
12900		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	13150	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
12901	13151	break;
12902	13152	}
12903		-case 0xFFFFFFFFFFFFFC98LLU:
	13153	+case 0xFFFFFFFFFFFFFC80LLU:
12904	13154	/* SP = 23LLU // SP = 22LLU // assign */
12905	13155	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
12906	13156	{

		@@ -12915,15 +13165,15 @@
12915	13165	{
12916	13166	/CALLEND/
12917	13167	stackbase += 24LLU;
12918		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC97LLU;
	13168	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7FLLU;
12919	13169	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
12920	13170	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
12921	13171	break;
12922	13172	}
12923		-case 0xFFFFFFFFFFFFFC97LLU:
	13173	+case 0xFFFFFFFFFFFFFC7FLLU:
12924	13174	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
12925		-{ /* JUMP / fnaddr = 18446744073709550757LLU; break; } / skip alternative */
12926		-case 18446744073709550758LLU: /* alternative // predicate */
	13175	+{ /* JUMP / fnaddr = 18446744073709550733LLU; break; } / skip alternative */
	13176	+case 18446744073709550734LLU: /* alternative // predicate */
12927	13177
12928	13178	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
12929	13179	{/* PUSH /stack[stackbase + 22LLU] = 11720547661487538176LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -12930,7 +13180,7 @@
12930	13180	{
12931	13181	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
12932	13182	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
12933		-{ /* JUMP / fnaddr = 18446744073709550742LLU; break; } / skip consequent */
	13183	+{ /* JUMP / fnaddr = 18446744073709550718LLU; break; } / skip consequent */
12934	13184	/* consequent */
12935	13185	{
12936	13186	/* CALLBEGIN */

		@@ -12949,22 +13199,22 @@
12949	13199	{
12950	13200	/CALLEND/
12951	13201	stackbase += 29LLU;
12952		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC94LLU;
	13202	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7CLLU;
12953	13203	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
12954	13204	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
12955	13205	break;
12956	13206	}
12957		-case 0xFFFFFFFFFFFFFC94LLU:
	13207	+case 0xFFFFFFFFFFFFFC7CLLU:
12958	13208	/* SP = 27LLU */
12959	13209	{
12960	13210	/CALLEND/
12961	13211	stackbase += 23LLU;
12962		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC93LLU;
	13212	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7BLLU;
12963	13213	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
12964	13214	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
12965	13215	break;
12966	13216	}
12967		-case 0xFFFFFFFFFFFFFC93LLU:
	13217	+case 0xFFFFFFFFFFFFFC7BLLU:
12968	13218	/* SP = 21LLU */
12969	13219	{
12970	13220	/* CALLBEGIN */

		@@ -12975,12 +13225,12 @@
12975	13225	{
12976	13226	/CALLEND/
12977	13227	stackbase += 24LLU;
12978		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC92LLU;
	13228	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7ALLU;
12979	13229	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
12980	13230	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
12981	13231	break;
12982	13232	}
12983		-case 0xFFFFFFFFFFFFFC92LLU:
	13233	+case 0xFFFFFFFFFFFFFC7ALLU:
12984	13234	/* SP = 22LLU */
12985	13235	{
12986	13236	/* CALLBEGIN */

		@@ -12991,12 +13241,12 @@
12991	13241	{
12992	13242	/CALLEND/
12993	13243	stackbase += 24LLU;
12994		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC91LLU;
	13244	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC79LLU;
12995	13245	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
12996	13246	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
12997	13247	break;
12998	13248	}
12999		-case 0xFFFFFFFFFFFFFC91LLU:
	13249	+case 0xFFFFFFFFFFFFFC79LLU:
13000	13250	/* SP = 22LLU */
13001	13251	{
13002	13252	/* CALLBEGIN */

		@@ -13014,12 +13264,12 @@
13014	13264	{
13015	13265	/CALLEND/
13016	13266	stackbase += 30LLU;
13017		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC90LLU;
	13267	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC78LLU;
13018	13268	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
13019	13269	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
13020	13270	break;
13021	13271	}
13022		-case 0xFFFFFFFFFFFFFC90LLU:
	13272	+case 0xFFFFFFFFFFFFFC78LLU:
13023	13273	/* SP = 28LLU */
13024	13274	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
13025	13275	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -13040,23 +13290,23 @@
13040	13290	{
13041	13291	/CALLEND/
13042	13292	stackbase += 42LLU;
13043		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8FLLU;
	13293	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC77LLU;
13044	13294	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
13045	13295	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
13046	13296	break;
13047	13297	}
13048		-case 0xFFFFFFFFFFFFFC8FLLU:
	13298	+case 0xFFFFFFFFFFFFFC77LLU:
13049	13299	/* SP = 40LLU */
13050	13300	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
13051	13301	{
13052	13302	/CALLEND/
13053	13303	stackbase += 25LLU;
13054		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8ELLU;
	13304	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC76LLU;
13055	13305	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
13056		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	13306	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
13057	13307	break;
13058	13308	}
13059		-case 0xFFFFFFFFFFFFFC8ELLU:
	13309	+case 0xFFFFFFFFFFFFFC76LLU:
13060	13310	/* SP = 23LLU // SP = 22LLU // assign */
13061	13311	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
13062	13312	{

		@@ -13068,12 +13318,12 @@
13068	13318	{
13069	13319	/CALLEND/
13070	13320	stackbase += 24LLU;
13071		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8DLLU;
	13321	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC75LLU;
13072	13322	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13073	13323	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
13074	13324	break;
13075	13325	}
13076		-case 0xFFFFFFFFFFFFFC8DLLU:
	13326	+case 0xFFFFFFFFFFFFFC75LLU:
13077	13327	/* SP = 22LLU */
13078	13328	{
13079	13329	/* CALLBEGIN */

		@@ -13085,12 +13335,12 @@
13085	13335	{
13086	13336	/CALLEND/
13087	13337	stackbase += 24LLU;
13088		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8CLLU;
	13338	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC74LLU;
13089	13339	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
13090	13340	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
13091	13341	break;
13092	13342	}
13093		-case 0xFFFFFFFFFFFFFC8CLLU:
	13343	+case 0xFFFFFFFFFFFFFC74LLU:
13094	13344	/* SP = 22LLU */
13095	13345	{
13096	13346	/* CALLBEGIN */

		@@ -13101,12 +13351,12 @@
13101	13351	{
13102	13352	/CALLEND/
13103	13353	stackbase += 24LLU;
13104		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8BLLU;
	13354	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC73LLU;
13105	13355	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13106	13356	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
13107	13357	break;
13108	13358	}
13109		-case 0xFFFFFFFFFFFFFC8BLLU:
	13359	+case 0xFFFFFFFFFFFFFC73LLU:
13110	13360	/* SP = 22LLU */
13111	13361	{
13112	13362	/* CALLBEGIN */

		@@ -13124,12 +13374,12 @@
13124	13374	{
13125	13375	/CALLEND/
13126	13376	stackbase += 30LLU;
13127		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC8ALLU;
	13377	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC72LLU;
13128	13378	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
13129	13379	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
13130	13380	break;
13131	13381	}
13132		-case 0xFFFFFFFFFFFFFC8ALLU:
	13382	+case 0xFFFFFFFFFFFFFC72LLU:
13133	13383	/* SP = 28LLU */
13134	13384	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
13135	13385	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -13150,23 +13400,23 @@
13150	13400	{
13151	13401	/CALLEND/
13152	13402	stackbase += 42LLU;
13153		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC89LLU;
	13403	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC71LLU;
13154	13404	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
13155	13405	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
13156	13406	break;
13157	13407	}
13158		-case 0xFFFFFFFFFFFFFC89LLU:
	13408	+case 0xFFFFFFFFFFFFFC71LLU:
13159	13409	/* SP = 40LLU */
13160	13410	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
13161	13411	{
13162	13412	/CALLEND/
13163	13413	stackbase += 25LLU;
13164		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC88LLU;
	13414	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC70LLU;
13165	13415	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
13166		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	13416	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
13167	13417	break;
13168	13418	}
13169		-case 0xFFFFFFFFFFFFFC88LLU:
	13419	+case 0xFFFFFFFFFFFFFC70LLU:
13170	13420	/* SP = 23LLU // SP = 22LLU // assign */
13171	13421	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
13172	13422	{

		@@ -13181,15 +13431,15 @@
13181	13431	{
13182	13432	/CALLEND/
13183	13433	stackbase += 24LLU;
13184		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC87LLU;
	13434	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6FLLU;
13185	13435	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
13186	13436	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
13187	13437	break;
13188	13438	}
13189		-case 0xFFFFFFFFFFFFFC87LLU:
	13439	+case 0xFFFFFFFFFFFFFC6FLLU:
13190	13440	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
13191		-{ /* JUMP / fnaddr = 18446744073709550741LLU; break; } / skip alternative */
13192		-case 18446744073709550742LLU: /* alternative // predicate */
	13441	+{ /* JUMP / fnaddr = 18446744073709550717LLU; break; } / skip alternative */
	13442	+case 18446744073709550718LLU: /* alternative // predicate */
13193	13443
13194	13444	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
13195	13445	{/* PUSH /stack[stackbase + 22LLU] = 13418793666670083072LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -13196,7 +13446,7 @@
13196	13446	{
13197	13447	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
13198	13448	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
13199		-{ /* JUMP / fnaddr = 18446744073709550726LLU; break; } / skip consequent */
	13449	+{ /* JUMP / fnaddr = 18446744073709550702LLU; break; } / skip consequent */
13200	13450	/* consequent */
13201	13451	{
13202	13452	/* CALLBEGIN */

		@@ -13215,22 +13465,22 @@
13215	13465	{
13216	13466	/CALLEND/
13217	13467	stackbase += 29LLU;
13218		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC84LLU;
	13468	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6CLLU;
13219	13469	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
13220	13470	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
13221	13471	break;
13222	13472	}
13223		-case 0xFFFFFFFFFFFFFC84LLU:
	13473	+case 0xFFFFFFFFFFFFFC6CLLU:
13224	13474	/* SP = 27LLU */
13225	13475	{
13226	13476	/CALLEND/
13227	13477	stackbase += 23LLU;
13228		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC83LLU;
	13478	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6BLLU;
13229	13479	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
13230	13480	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
13231	13481	break;
13232	13482	}
13233		-case 0xFFFFFFFFFFFFFC83LLU:
	13483	+case 0xFFFFFFFFFFFFFC6BLLU:
13234	13484	/* SP = 21LLU */
13235	13485	{
13236	13486	/* CALLBEGIN */

		@@ -13241,12 +13491,12 @@
13241	13491	{
13242	13492	/CALLEND/
13243	13493	stackbase += 24LLU;
13244		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC82LLU;
	13494	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6ALLU;
13245	13495	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
13246	13496	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
13247	13497	break;
13248	13498	}
13249		-case 0xFFFFFFFFFFFFFC82LLU:
	13499	+case 0xFFFFFFFFFFFFFC6ALLU:
13250	13500	/* SP = 22LLU */
13251	13501	{
13252	13502	/* CALLBEGIN */

		@@ -13257,12 +13507,12 @@
13257	13507	{
13258	13508	/CALLEND/
13259	13509	stackbase += 24LLU;
13260		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC81LLU;
	13510	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC69LLU;
13261	13511	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13262	13512	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
13263	13513	break;
13264	13514	}
13265		-case 0xFFFFFFFFFFFFFC81LLU:
	13515	+case 0xFFFFFFFFFFFFFC69LLU:
13266	13516	/* SP = 22LLU */
13267	13517	{
13268	13518	/* CALLBEGIN */

		@@ -13280,12 +13530,12 @@
13280	13530	{
13281	13531	/CALLEND/
13282	13532	stackbase += 30LLU;
13283		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC80LLU;
	13533	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC68LLU;
13284	13534	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
13285	13535	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
13286	13536	break;
13287	13537	}
13288		-case 0xFFFFFFFFFFFFFC80LLU:
	13538	+case 0xFFFFFFFFFFFFFC68LLU:
13289	13539	/* SP = 28LLU */
13290	13540	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
13291	13541	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -13306,23 +13556,23 @@
13306	13556	{
13307	13557	/CALLEND/
13308	13558	stackbase += 42LLU;
13309		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7FLLU;
	13559	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC67LLU;
13310	13560	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
13311	13561	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
13312	13562	break;
13313	13563	}
13314		-case 0xFFFFFFFFFFFFFC7FLLU:
	13564	+case 0xFFFFFFFFFFFFFC67LLU:
13315	13565	/* SP = 40LLU */
13316	13566	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
13317	13567	{
13318	13568	/CALLEND/
13319	13569	stackbase += 25LLU;
13320		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7ELLU;
	13570	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC66LLU;
13321	13571	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
13322		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	13572	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
13323	13573	break;
13324	13574	}
13325		-case 0xFFFFFFFFFFFFFC7ELLU:
	13575	+case 0xFFFFFFFFFFFFFC66LLU:
13326	13576	/* SP = 23LLU // SP = 22LLU // assign */
13327	13577	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
13328	13578	{

		@@ -13334,12 +13584,12 @@
13334	13584	{
13335	13585	/CALLEND/
13336	13586	stackbase += 24LLU;
13337		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7DLLU;
	13587	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC65LLU;
13338	13588	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13339	13589	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
13340	13590	break;
13341	13591	}
13342		-case 0xFFFFFFFFFFFFFC7DLLU:
	13592	+case 0xFFFFFFFFFFFFFC65LLU:
13343	13593	/* SP = 22LLU */
13344	13594	{
13345	13595	/* CALLBEGIN */

		@@ -13351,12 +13601,12 @@
13351	13601	{
13352	13602	/CALLEND/
13353	13603	stackbase += 24LLU;
13354		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7CLLU;
	13604	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC64LLU;
13355	13605	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
13356	13606	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
13357	13607	break;
13358	13608	}
13359		-case 0xFFFFFFFFFFFFFC7CLLU:
	13609	+case 0xFFFFFFFFFFFFFC64LLU:
13360	13610	/* SP = 22LLU */
13361	13611	{
13362	13612	/* CALLBEGIN */

		@@ -13367,12 +13617,12 @@
13367	13617	{
13368	13618	/CALLEND/
13369	13619	stackbase += 24LLU;
13370		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7BLLU;
	13620	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC63LLU;
13371	13621	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13372	13622	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
13373	13623	break;
13374	13624	}
13375		-case 0xFFFFFFFFFFFFFC7BLLU:
	13625	+case 0xFFFFFFFFFFFFFC63LLU:
13376	13626	/* SP = 22LLU */
13377	13627	{
13378	13628	/* CALLBEGIN */

		@@ -13390,12 +13640,12 @@
13390	13640	{
13391	13641	/CALLEND/
13392	13642	stackbase += 30LLU;
13393		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC7ALLU;
	13643	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC62LLU;
13394	13644	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
13395	13645	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
13396	13646	break;
13397	13647	}
13398		-case 0xFFFFFFFFFFFFFC7ALLU:
	13648	+case 0xFFFFFFFFFFFFFC62LLU:
13399	13649	/* SP = 28LLU */
13400	13650	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
13401	13651	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -13416,23 +13666,23 @@
13416	13666	{
13417	13667	/CALLEND/
13418	13668	stackbase += 42LLU;
13419		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC79LLU;
	13669	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC61LLU;
13420	13670	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
13421	13671	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
13422	13672	break;
13423	13673	}
13424		-case 0xFFFFFFFFFFFFFC79LLU:
	13674	+case 0xFFFFFFFFFFFFFC61LLU:
13425	13675	/* SP = 40LLU */
13426	13676	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
13427	13677	{
13428	13678	/CALLEND/
13429	13679	stackbase += 25LLU;
13430		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC78LLU;
	13680	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC60LLU;
13431	13681	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
13432		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	13682	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
13433	13683	break;
13434	13684	}
13435		-case 0xFFFFFFFFFFFFFC78LLU:
	13685	+case 0xFFFFFFFFFFFFFC60LLU:
13436	13686	/* SP = 23LLU // SP = 22LLU // assign */
13437	13687	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
13438	13688	{

		@@ -13447,15 +13697,15 @@
13447	13697	{
13448	13698	/CALLEND/
13449	13699	stackbase += 24LLU;
13450		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC77LLU;
	13700	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5FLLU;
13451	13701	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
13452	13702	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
13453	13703	break;
13454	13704	}
13455		-case 0xFFFFFFFFFFFFFC77LLU:
	13705	+case 0xFFFFFFFFFFFFFC5FLLU:
13456	13706	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
13457		-{ /* JUMP / fnaddr = 18446744073709550725LLU; break; } / skip alternative */
13458		-case 18446744073709550726LLU: /* alternative // predicate */
	13707	+{ /* JUMP / fnaddr = 18446744073709550701LLU; break; } / skip alternative */
	13708	+case 18446744073709550702LLU: /* alternative // predicate */
13459	13709
13460	13710	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
13461	13711	{/* PUSH /stack[stackbase + 22LLU] = 13418793668297527024LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -13462,7 +13712,7 @@
13462	13712	{
13463	13713	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
13464	13714	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
13465		-{ /* JUMP / fnaddr = 18446744073709550710LLU; break; } / skip consequent */
	13715	+{ /* JUMP / fnaddr = 18446744073709550686LLU; break; } / skip consequent */
13466	13716	/* consequent */
13467	13717	{
13468	13718	/* CALLBEGIN */

		@@ -13481,22 +13731,22 @@
13481	13731	{
13482	13732	/CALLEND/
13483	13733	stackbase += 29LLU;
13484		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC74LLU;
	13734	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5CLLU;
13485	13735	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
13486	13736	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
13487	13737	break;
13488	13738	}
13489		-case 0xFFFFFFFFFFFFFC74LLU:
	13739	+case 0xFFFFFFFFFFFFFC5CLLU:
13490	13740	/* SP = 27LLU */
13491	13741	{
13492	13742	/CALLEND/
13493	13743	stackbase += 23LLU;
13494		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC73LLU;
	13744	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5BLLU;
13495	13745	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
13496	13746	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
13497	13747	break;
13498	13748	}
13499		-case 0xFFFFFFFFFFFFFC73LLU:
	13749	+case 0xFFFFFFFFFFFFFC5BLLU:
13500	13750	/* SP = 21LLU */
13501	13751	{
13502	13752	/* CALLBEGIN */

		@@ -13507,12 +13757,12 @@
13507	13757	{
13508	13758	/CALLEND/
13509	13759	stackbase += 24LLU;
13510		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC72LLU;
	13760	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5ALLU;
13511	13761	fnaddr = /SP_GET____/0x4D00071540000000LLU;/* SP = 0LLU */
13512	13762	{ if(stackbase + 1LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /SP_GET____/\n"); exit(-1); } }
13513	13763	break;
13514	13764	}
13515		-case 0xFFFFFFFFFFFFFC72LLU:
	13765	+case 0xFFFFFFFFFFFFFC5ALLU:
13516	13766	/* SP = 22LLU */
13517	13767	{
13518	13768	/* CALLBEGIN */

		@@ -13523,12 +13773,12 @@
13523	13773	{
13524	13774	/CALLEND/
13525	13775	stackbase += 24LLU;
13526		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC71LLU;
	13776	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC59LLU;
13527	13777	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13528	13778	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
13529	13779	break;
13530	13780	}
13531		-case 0xFFFFFFFFFFFFFC71LLU:
	13781	+case 0xFFFFFFFFFFFFFC59LLU:
13532	13782	/* SP = 22LLU */
13533	13783	{
13534	13784	/* CALLBEGIN */

		@@ -13546,12 +13796,12 @@
13546	13796	{
13547	13797	/CALLEND/
13548	13798	stackbase += 30LLU;
13549		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC70LLU;
	13799	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC58LLU;
13550	13800	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
13551	13801	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
13552	13802	break;
13553	13803	}
13554		-case 0xFFFFFFFFFFFFFC70LLU:
	13804	+case 0xFFFFFFFFFFFFFC58LLU:
13555	13805	/* SP = 28LLU */
13556	13806	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
13557	13807	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -13572,23 +13822,23 @@
13572	13822	{
13573	13823	/CALLEND/
13574	13824	stackbase += 42LLU;
13575		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6FLLU;
	13825	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC57LLU;
13576	13826	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
13577	13827	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
13578	13828	break;
13579	13829	}
13580		-case 0xFFFFFFFFFFFFFC6FLLU:
	13830	+case 0xFFFFFFFFFFFFFC57LLU:
13581	13831	/* SP = 40LLU */
13582	13832	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
13583	13833	{
13584	13834	/CALLEND/
13585	13835	stackbase += 25LLU;
13586		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6ELLU;
	13836	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC56LLU;
13587	13837	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
13588		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	13838	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
13589	13839	break;
13590	13840	}
13591		-case 0xFFFFFFFFFFFFFC6ELLU:
	13841	+case 0xFFFFFFFFFFFFFC56LLU:
13592	13842	/* SP = 23LLU // SP = 22LLU // assign */
13593	13843	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
13594	13844	{

		@@ -13600,12 +13850,12 @@
13600	13850	{
13601	13851	/CALLEND/
13602	13852	stackbase += 24LLU;
13603		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6DLLU;
	13853	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC55LLU;
13604	13854	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13605	13855	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
13606	13856	break;
13607	13857	}
13608		-case 0xFFFFFFFFFFFFFC6DLLU:
	13858	+case 0xFFFFFFFFFFFFFC55LLU:
13609	13859	/* SP = 22LLU */
13610	13860	{
13611	13861	/* CALLBEGIN */

		@@ -13617,12 +13867,12 @@
13617	13867	{
13618	13868	/CALLEND/
13619	13869	stackbase += 24LLU;
13620		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6CLLU;
	13870	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC54LLU;
13621	13871	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
13622	13872	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
13623	13873	break;
13624	13874	}
13625		-case 0xFFFFFFFFFFFFFC6CLLU:
	13875	+case 0xFFFFFFFFFFFFFC54LLU:
13626	13876	/* SP = 22LLU */
13627	13877	{
13628	13878	/* CALLBEGIN */

		@@ -13633,12 +13883,12 @@
13633	13883	{
13634	13884	/CALLEND/
13635	13885	stackbase += 24LLU;
13636		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6BLLU;
	13886	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC53LLU;
13637	13887	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13638	13888	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
13639	13889	break;
13640	13890	}
13641		-case 0xFFFFFFFFFFFFFC6BLLU:
	13891	+case 0xFFFFFFFFFFFFFC53LLU:
13642	13892	/* SP = 22LLU */
13643	13893	{
13644	13894	/* CALLBEGIN */

		@@ -13656,12 +13906,12 @@
13656	13906	{
13657	13907	/CALLEND/
13658	13908	stackbase += 30LLU;
13659		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC6ALLU;
	13909	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC52LLU;
13660	13910	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
13661	13911	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
13662	13912	break;
13663	13913	}
13664		-case 0xFFFFFFFFFFFFFC6ALLU:
	13914	+case 0xFFFFFFFFFFFFFC52LLU:
13665	13915	/* SP = 28LLU */
13666	13916	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 29LLU */
13667	13917	{/* PUSH /stack[stackbase + 29LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 30LLU */

		@@ -13682,23 +13932,23 @@
13682	13932	{
13683	13933	/CALLEND/
13684	13934	stackbase += 42LLU;
13685		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC69LLU;
	13935	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC51LLU;
13686	13936	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
13687	13937	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
13688	13938	break;
13689	13939	}
13690		-case 0xFFFFFFFFFFFFFC69LLU:
	13940	+case 0xFFFFFFFFFFFFFC51LLU:
13691	13941	/* SP = 40LLU */
13692	13942	{/* PUSH /stack[stackbase + 40LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 41LLU */
13693	13943	{
13694	13944	/CALLEND/
13695	13945	stackbase += 25LLU;
13696		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC68LLU;
	13946	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC50LLU;
13697	13947	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
13698		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	13948	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
13699	13949	break;
13700	13950	}
13701		-case 0xFFFFFFFFFFFFFC68LLU:
	13951	+case 0xFFFFFFFFFFFFFC50LLU:
13702	13952	/* SP = 23LLU // SP = 22LLU // assign */
13703	13953	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 22LLU]; }
13704	13954	{

		@@ -13713,15 +13963,15 @@
13713	13963	{
13714	13964	/CALLEND/
13715	13965	stackbase += 24LLU;
13716		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC67LLU;
	13966	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4FLLU;
13717	13967	fnaddr = /emitinfix_/0x82892F929864CC00LLU;/* SP = 0LLU */
13718	13968	{ if(stackbase + 28LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /emitinfix_/\n"); exit(-1); } }
13719	13969	break;
13720	13970	}
13721		-case 0xFFFFFFFFFFFFFC67LLU:
	13971	+case 0xFFFFFFFFFFFFFC4FLLU:
13722	13972	/* SP = 22LLU // SP = 21LLU // SP = 21LLU */
13723		-{ /* JUMP / fnaddr = 18446744073709550709LLU; break; } / skip alternative */
13724		-case 18446744073709550710LLU: /* alternative // predicate */
	13973	+{ /* JUMP / fnaddr = 18446744073709550685LLU; break; } / skip alternative */
	13974	+case 18446744073709550686LLU: /* alternative // predicate */
13725	13975
13726	13976	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
13727	13977	{/* PUSH /stack[stackbase + 22LLU] = 12540314943855001600LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -13728,7 +13978,7 @@
13728	13978	{
13729	13979	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
13730	13980	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
13731		-{ /* JUMP / fnaddr = 18446744073709550694LLU; break; } / skip consequent */
	13981	+{ /* JUMP / fnaddr = 18446744073709550670LLU; break; } / skip consequent */
13732	13982	/* consequent */
13733	13983	{
13734	13984	/* CALLBEGIN */

		@@ -13747,22 +13997,22 @@
13747	13997	{
13748	13998	/CALLEND/
13749	13999	stackbase += 29LLU;
13750		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC64LLU;
	14000	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4CLLU;
13751	14001	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
13752	14002	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
13753	14003	break;
13754	14004	}
13755		-case 0xFFFFFFFFFFFFFC64LLU:
	14005	+case 0xFFFFFFFFFFFFFC4CLLU:
13756	14006	/* SP = 27LLU */
13757	14007	{
13758	14008	/CALLEND/
13759	14009	stackbase += 23LLU;
13760		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC63LLU;
	14010	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4BLLU;
13761	14011	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
13762	14012	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
13763	14013	break;
13764	14014	}
13765		-case 0xFFFFFFFFFFFFFC63LLU:
	14015	+case 0xFFFFFFFFFFFFFC4BLLU:
13766	14016	/* SP = 21LLU */
13767	14017	{
13768	14018	/* CALLBEGIN */

		@@ -13774,12 +14024,12 @@
13774	14024	{
13775	14025	/CALLEND/
13776	14026	stackbase += 23LLU;
13777		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC62LLU;
	14027	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4ALLU;
13778	14028	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
13779	14029	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
13780	14030	break;
13781	14031	}
13782		-case 0xFFFFFFFFFFFFFC62LLU:
	14032	+case 0xFFFFFFFFFFFFFC4ALLU:
13783	14033	/* SP = 21LLU */
13784	14034	{
13785	14035	/* CALLBEGIN */

		@@ -13790,12 +14040,12 @@
13790	14040	{
13791	14041	/CALLEND/
13792	14042	stackbase += 23LLU;
13793		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC61LLU;
	14043	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC49LLU;
13794	14044	fnaddr = /PUSH_START/0x4154C80135014940LLU;/* SP = 0LLU */
13795	14045	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_START/\n"); exit(-1); } }
13796	14046	break;
13797	14047	}
13798		-case 0xFFFFFFFFFFFFFC61LLU:
	14048	+case 0xFFFFFFFFFFFFFC49LLU:
13799	14049	/* SP = 21LLU */fputs("ungetc(fgetc(stdin), stdin)", stdout);
13800	14050	{
13801	14051	/* CALLBEGIN */

		@@ -13806,15 +14056,15 @@
13806	14056	{
13807	14057	/CALLEND/
13808	14058	stackbase += 23LLU;
13809		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC60LLU;
	14059	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC48LLU;
13810	14060	fnaddr = /PUSH_END__/0x4154C80053840000LLU;/* SP = 0LLU */
13811	14061	{ if(stackbase + 21LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH_END__/\n"); exit(-1); } }
13812	14062	break;
13813	14063	}
13814		-case 0xFFFFFFFFFFFFFC60LLU:
	14064	+case 0xFFFFFFFFFFFFFC48LLU:
13815	14065	/* SP = 21LLU // SP = 21LLU // SP = 21LLU */
13816		-{ /* JUMP / fnaddr = 18446744073709550693LLU; break; } / skip alternative */
13817		-case 18446744073709550694LLU: /* alternative // predicate */
	14066	+{ /* JUMP / fnaddr = 18446744073709550669LLU; break; } / skip alternative */
	14067	+case 18446744073709550670LLU: /* alternative // predicate */
13818	14068
13819	14069	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
13820	14070	{/* PUSH /stack[stackbase + 22LLU] = 12613386287613739008LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -13821,7 +14071,7 @@
13821	14071	{
13822	14072	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
13823	14073	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
13824		-{ /* JUMP / fnaddr = 18446744073709550687LLU; break; } / skip consequent */
	14074	+{ /* JUMP / fnaddr = 18446744073709550663LLU; break; } / skip consequent */
13825	14075	/* consequent */
13826	14076	{
13827	14077	/* CALLBEGIN */

		@@ -13840,22 +14090,22 @@
13840	14090	{
13841	14091	/CALLEND/
13842	14092	stackbase += 29LLU;
13843		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5DLLU;
	14093	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC45LLU;
13844	14094	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
13845	14095	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
13846	14096	break;
13847	14097	}
13848		-case 0xFFFFFFFFFFFFFC5DLLU:
	14098	+case 0xFFFFFFFFFFFFFC45LLU:
13849	14099	/* SP = 27LLU */
13850	14100	{
13851	14101	/CALLEND/
13852	14102	stackbase += 23LLU;
13853		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5CLLU;
	14103	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC44LLU;
13854	14104	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
13855	14105	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
13856	14106	break;
13857	14107	}
13858		-case 0xFFFFFFFFFFFFFC5CLLU:
	14108	+case 0xFFFFFFFFFFFFFC44LLU:
13859	14109	/* SP = 21LLU */
13860	14110	{
13861	14111	/* CALLBEGIN */

		@@ -13866,12 +14116,12 @@
13866	14116	{
13867	14117	/CALLEND/
13868	14118	stackbase += 23LLU;
13869		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5BLLU;
	14119	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC43LLU;
13870	14120	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13871	14121	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
13872	14122	break;
13873	14123	}
13874		-case 0xFFFFFFFFFFFFFC5BLLU:
	14124	+case 0xFFFFFFFFFFFFFC43LLU:
13875	14125	/* SP = 21LLU */
13876	14126	{
13877	14127	/* CALLBEGIN */

		@@ -13889,12 +14139,12 @@
13889	14139	{
13890	14140	/CALLEND/
13891	14141	stackbase += 29LLU;
13892		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC5ALLU;
	14142	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC42LLU;
13893	14143	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
13894	14144	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
13895	14145	break;
13896	14146	}
13897		-case 0xFFFFFFFFFFFFFC5ALLU:
	14147	+case 0xFFFFFFFFFFFFFC42LLU:
13898	14148	/* SP = 27LLU */
13899	14149	{/* PUSH /stack[stackbase + 27LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 28LLU */
13900	14150	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 29LLU */

		@@ -13915,23 +14165,23 @@
13915	14165	{
13916	14166	/CALLEND/
13917	14167	stackbase += 41LLU;
13918		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC59LLU;
	14168	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC41LLU;
13919	14169	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
13920	14170	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
13921	14171	break;
13922	14172	}
13923		-case 0xFFFFFFFFFFFFFC59LLU:
	14173	+case 0xFFFFFFFFFFFFFC41LLU:
13924	14174	/* SP = 39LLU */
13925	14175	{/* PUSH /stack[stackbase + 39LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 40LLU */
13926	14176	{
13927	14177	/CALLEND/
13928	14178	stackbase += 24LLU;
13929		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC58LLU;
	14179	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC40LLU;
13930	14180	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
13931		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	14181	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
13932	14182	break;
13933	14183	}
13934		-case 0xFFFFFFFFFFFFFC58LLU:
	14184	+case 0xFFFFFFFFFFFFFC40LLU:
13935	14185	/* SP = 22LLU // SP = 21LLU // assign */
13936	14186	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }
13937	14187	{

		@@ -13943,12 +14193,12 @@
13943	14193	{
13944	14194	/CALLEND/
13945	14195	stackbase += 23LLU;
13946		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC57LLU;
	14196	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3FLLU;
13947	14197	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
13948	14198	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
13949	14199	break;
13950	14200	}
13951		-case 0xFFFFFFFFFFFFFC57LLU:
	14201	+case 0xFFFFFFFFFFFFFC3FLLU:
13952	14202	/* SP = 21LLU */
13953	14203	{
13954	14204	/* CALLBEGIN */

		@@ -13960,12 +14210,12 @@
13960	14210	{
13961	14211	/CALLEND/
13962	14212	stackbase += 23LLU;
13963		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC56LLU;
	14213	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3ELLU;
13964	14214	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
13965	14215	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
13966	14216	break;
13967	14217	}
13968		-case 0xFFFFFFFFFFFFFC56LLU:
	14218	+case 0xFFFFFFFFFFFFFC3ELLU:
13969	14219	/* SP = 21LLU */fputs("\n{ fputc(", stdout);
13970	14220	{
13971	14221	/* CALLBEGIN */

		@@ -13976,15 +14226,15 @@
13976	14226	{
13977	14227	/CALLEND/
13978	14228	stackbase += 23LLU;
13979		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC55LLU;
	14229	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3DLLU;
13980	14230	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
13981	14231	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
13982	14232	break;
13983	14233	}
13984		-case 0xFFFFFFFFFFFFFC55LLU:
	14234	+case 0xFFFFFFFFFFFFFC3DLLU:
13985	14235	/* SP = 21LLU /fputs(", stdout); }", stdout); / SP = 21LLU // SP = 21LLU */
13986		-{ /* JUMP / fnaddr = 18446744073709550686LLU; break; } / skip alternative */
13987		-case 18446744073709550687LLU: /* alternative // predicate */
	14236	+{ /* JUMP / fnaddr = 18446744073709550662LLU; break; } / skip alternative */
	14237	+case 18446744073709550663LLU: /* alternative // predicate */
13988	14238
13989	14239	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
13990	14240	{/* PUSH /stack[stackbase + 22LLU] = 9420456197598740480LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -13991,7 +14241,7 @@
13991	14241	{
13992	14242	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
13993	14243	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
13994		-{ /* JUMP / fnaddr = 18446744073709550676LLU; break; } / skip consequent */
	14244	+{ /* JUMP / fnaddr = 18446744073709550652LLU; break; } / skip consequent */
13995	14245	/* consequent */
13996	14246	{
13997	14247	/* CALLBEGIN */

		@@ -14010,22 +14260,22 @@
14010	14260	{
14011	14261	/CALLEND/
14012	14262	stackbase += 29LLU;
14013		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC52LLU;
	14263	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3ALLU;
14014	14264	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
14015	14265	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
14016	14266	break;
14017	14267	}
14018		-case 0xFFFFFFFFFFFFFC52LLU:
	14268	+case 0xFFFFFFFFFFFFFC3ALLU:
14019	14269	/* SP = 27LLU */
14020	14270	{
14021	14271	/CALLEND/
14022	14272	stackbase += 23LLU;
14023		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC51LLU;
	14273	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC39LLU;
14024	14274	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
14025	14275	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
14026	14276	break;
14027	14277	}
14028		-case 0xFFFFFFFFFFFFFC51LLU:
	14278	+case 0xFFFFFFFFFFFFFC39LLU:
14029	14279	/* SP = 21LLU */
14030	14280	{
14031	14281	/* CALLBEGIN */

		@@ -14036,12 +14286,12 @@
14036	14286	{
14037	14287	/CALLEND/
14038	14288	stackbase += 23LLU;
14039		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC50LLU;
	14289	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC38LLU;
14040	14290	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14041	14291	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
14042	14292	break;
14043	14293	}
14044		-case 0xFFFFFFFFFFFFFC50LLU:
	14294	+case 0xFFFFFFFFFFFFFC38LLU:
14045	14295	/* SP = 21LLU */
14046	14296	{
14047	14297	/* CALLBEGIN */

		@@ -14059,12 +14309,12 @@
14059	14309	{
14060	14310	/CALLEND/
14061	14311	stackbase += 29LLU;
14062		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4FLLU;
	14312	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC37LLU;
14063	14313	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
14064	14314	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
14065	14315	break;
14066	14316	}
14067		-case 0xFFFFFFFFFFFFFC4FLLU:
	14317	+case 0xFFFFFFFFFFFFFC37LLU:
14068	14318	/* SP = 27LLU */
14069	14319	{/* PUSH /stack[stackbase + 27LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 28LLU */
14070	14320	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 29LLU */

		@@ -14085,23 +14335,23 @@
14085	14335	{
14086	14336	/CALLEND/
14087	14337	stackbase += 41LLU;
14088		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4ELLU;
	14338	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC36LLU;
14089	14339	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
14090	14340	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
14091	14341	break;
14092	14342	}
14093		-case 0xFFFFFFFFFFFFFC4ELLU:
	14343	+case 0xFFFFFFFFFFFFFC36LLU:
14094	14344	/* SP = 39LLU */
14095	14345	{/* PUSH /stack[stackbase + 39LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 40LLU */
14096	14346	{
14097	14347	/CALLEND/
14098	14348	stackbase += 24LLU;
14099		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4DLLU;
	14349	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC35LLU;
14100	14350	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
14101		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	14351	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
14102	14352	break;
14103	14353	}
14104		-case 0xFFFFFFFFFFFFFC4DLLU:
	14354	+case 0xFFFFFFFFFFFFFC35LLU:
14105	14355	/* SP = 22LLU // SP = 21LLU // assign */
14106	14356	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }
14107	14357	{

		@@ -14113,12 +14363,12 @@
14113	14363	{
14114	14364	/CALLEND/
14115	14365	stackbase += 23LLU;
14116		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4CLLU;
	14366	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC34LLU;
14117	14367	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14118	14368	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
14119	14369	break;
14120	14370	}
14121		-case 0xFFFFFFFFFFFFFC4CLLU:
	14371	+case 0xFFFFFFFFFFFFFC34LLU:
14122	14372	/* SP = 21LLU */
14123	14373	{
14124	14374	/* CALLBEGIN */

		@@ -14130,12 +14380,12 @@
14130	14380	{
14131	14381	/CALLEND/
14132	14382	stackbase += 23LLU;
14133		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4BLLU;
	14383	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC33LLU;
14134	14384	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
14135	14385	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
14136	14386	break;
14137	14387	}
14138		-case 0xFFFFFFFFFFFFFC4BLLU:
	14388	+case 0xFFFFFFFFFFFFFC33LLU:
14139	14389	/* SP = 21LLU */fputs("\n{ fputc(", stdout);
14140	14390	{
14141	14391	/* CALLBEGIN */

		@@ -14146,15 +14396,15 @@
14146	14396	{
14147	14397	/CALLEND/
14148	14398	stackbase += 23LLU;
14149		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC4ALLU;
	14399	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC32LLU;
14150	14400	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
14151	14401	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
14152	14402	break;
14153	14403	}
14154		-case 0xFFFFFFFFFFFFFC4ALLU:
	14404	+case 0xFFFFFFFFFFFFFC32LLU:
14155	14405	/* SP = 21LLU /fputs(", stderr); }", stdout); / SP = 21LLU // SP = 21LLU */
14156		-{ /* JUMP / fnaddr = 18446744073709550675LLU; break; } / skip alternative */
14157		-case 18446744073709550676LLU: /* alternative // predicate */
	14406	+{ /* JUMP / fnaddr = 18446744073709550651LLU; break; } / skip alternative */
	14407	+case 18446744073709550652LLU: /* alternative // predicate */
14158	14408
14159	14409	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
14160	14410	{/* PUSH /stack[stackbase + 22LLU] = 10586884850554241024LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -14161,7 +14411,7 @@
14161	14411	{
14162	14412	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
14163	14413	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
14164		-{ /* JUMP / fnaddr = 18446744073709550665LLU; break; } / skip consequent */
	14414	+{ /* JUMP / fnaddr = 18446744073709550641LLU; break; } / skip consequent */
14165	14415	/* consequent */
14166	14416	{
14167	14417	/* CALLBEGIN */

		@@ -14180,22 +14430,22 @@
14180	14430	{
14181	14431	/CALLEND/
14182	14432	stackbase += 29LLU;
14183		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC47LLU;
	14433	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2FLLU;
14184	14434	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
14185	14435	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
14186	14436	break;
14187	14437	}
14188		-case 0xFFFFFFFFFFFFFC47LLU:
	14438	+case 0xFFFFFFFFFFFFFC2FLLU:
14189	14439	/* SP = 27LLU */
14190	14440	{
14191	14441	/CALLEND/
14192	14442	stackbase += 23LLU;
14193		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC46LLU;
	14443	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2ELLU;
14194	14444	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
14195	14445	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
14196	14446	break;
14197	14447	}
14198		-case 0xFFFFFFFFFFFFFC46LLU:
	14448	+case 0xFFFFFFFFFFFFFC2ELLU:
14199	14449	/* SP = 21LLU */
14200	14450	{
14201	14451	/* CALLBEGIN */

		@@ -14206,12 +14456,12 @@
14206	14456	{
14207	14457	/CALLEND/
14208	14458	stackbase += 23LLU;
14209		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC45LLU;
	14459	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2DLLU;
14210	14460	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14211	14461	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
14212	14462	break;
14213	14463	}
14214		-case 0xFFFFFFFFFFFFFC45LLU:
	14464	+case 0xFFFFFFFFFFFFFC2DLLU:
14215	14465	/* SP = 21LLU */
14216	14466	{
14217	14467	/* CALLBEGIN */

		@@ -14229,12 +14479,12 @@
14229	14479	{
14230	14480	/CALLEND/
14231	14481	stackbase += 29LLU;
14232		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC44LLU;
	14482	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2CLLU;
14233	14483	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
14234	14484	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
14235	14485	break;
14236	14486	}
14237		-case 0xFFFFFFFFFFFFFC44LLU:
	14487	+case 0xFFFFFFFFFFFFFC2CLLU:
14238	14488	/* SP = 27LLU */
14239	14489	{/* PUSH /stack[stackbase + 27LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 28LLU */
14240	14490	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 29LLU */

		@@ -14255,23 +14505,23 @@
14255	14505	{
14256	14506	/CALLEND/
14257	14507	stackbase += 41LLU;
14258		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC43LLU;
	14508	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2BLLU;
14259	14509	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
14260	14510	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
14261	14511	break;
14262	14512	}
14263		-case 0xFFFFFFFFFFFFFC43LLU:
	14513	+case 0xFFFFFFFFFFFFFC2BLLU:
14264	14514	/* SP = 39LLU */
14265	14515	{/* PUSH /stack[stackbase + 39LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 40LLU */
14266	14516	{
14267	14517	/CALLEND/
14268	14518	stackbase += 24LLU;
14269		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC42LLU;
	14519	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2ALLU;
14270	14520	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
14271		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	14521	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
14272	14522	break;
14273	14523	}
14274		-case 0xFFFFFFFFFFFFFC42LLU:
	14524	+case 0xFFFFFFFFFFFFFC2ALLU:
14275	14525	/* SP = 22LLU // SP = 21LLU // assign */
14276	14526	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }
14277	14527	{

		@@ -14283,12 +14533,12 @@
14283	14533	{
14284	14534	/CALLEND/
14285	14535	stackbase += 23LLU;
14286		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC41LLU;
	14536	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC29LLU;
14287	14537	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14288	14538	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
14289	14539	break;
14290	14540	}
14291		-case 0xFFFFFFFFFFFFFC41LLU:
	14541	+case 0xFFFFFFFFFFFFFC29LLU:
14292	14542	/* SP = 21LLU */
14293	14543	{
14294	14544	/* CALLBEGIN */

		@@ -14300,12 +14550,12 @@
14300	14550	{
14301	14551	/CALLEND/
14302	14552	stackbase += 23LLU;
14303		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC40LLU;
	14553	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC28LLU;
14304	14554	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
14305	14555	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
14306	14556	break;
14307	14557	}
14308		-case 0xFFFFFFFFFFFFFC40LLU:
	14558	+case 0xFFFFFFFFFFFFFC28LLU:
14309	14559	/* SP = 21LLU */fputs("\n{ ", stdout);
14310	14560	{
14311	14561	/* CALLBEGIN */

		@@ -14316,12 +14566,12 @@
14316	14566	{
14317	14567	/CALLEND/
14318	14568	stackbase += 23LLU;
14319		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3FLLU;
	14569	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC27LLU;
14320	14570	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
14321	14571	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
14322	14572	break;
14323	14573	}
14324		-case 0xFFFFFFFFFFFFFC3FLLU:
	14574	+case 0xFFFFFFFFFFFFFC27LLU:
14325	14575	/* SP = 21LLU */fputs(" = isupper(", stdout);
14326	14576	{
14327	14577	/* CALLBEGIN */

		@@ -14332,15 +14582,15 @@
14332	14582	{
14333	14583	/CALLEND/
14334	14584	stackbase += 23LLU;
14335		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3ELLU;
	14585	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC26LLU;
14336	14586	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
14337	14587	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
14338	14588	break;
14339	14589	}
14340		-case 0xFFFFFFFFFFFFFC3ELLU:
	14590	+case 0xFFFFFFFFFFFFFC26LLU:
14341	14591	/* SP = 21LLU /fputs("); }", stdout); / SP = 21LLU // SP = 21LLU */
14342		-{ /* JUMP / fnaddr = 18446744073709550664LLU; break; } / skip alternative */
14343		-case 18446744073709550665LLU: /* alternative // predicate */
	14592	+{ /* JUMP / fnaddr = 18446744073709550640LLU; break; } / skip alternative */
	14593	+case 18446744073709550641LLU: /* alternative // predicate */
14344	14594
14345	14595	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
14346	14596	{/* PUSH /stack[stackbase + 22LLU] = 10586250552604098560LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -14347,7 +14597,7 @@
14347	14597	{
14348	14598	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
14349	14599	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
14350		-{ /* JUMP / fnaddr = 18446744073709550653LLU; break; } / skip consequent */
	14600	+{ /* JUMP / fnaddr = 18446744073709550629LLU; break; } / skip consequent */
14351	14601	/* consequent */
14352	14602	{
14353	14603	/* CALLBEGIN */

		@@ -14366,22 +14616,22 @@
14366	14616	{
14367	14617	/CALLEND/
14368	14618	stackbase += 29LLU;
14369		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3BLLU;
	14619	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC23LLU;
14370	14620	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
14371	14621	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
14372	14622	break;
14373	14623	}
14374		-case 0xFFFFFFFFFFFFFC3BLLU:
	14624	+case 0xFFFFFFFFFFFFFC23LLU:
14375	14625	/* SP = 27LLU */
14376	14626	{
14377	14627	/CALLEND/
14378	14628	stackbase += 23LLU;
14379		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC3ALLU;
	14629	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC22LLU;
14380	14630	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
14381	14631	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
14382	14632	break;
14383	14633	}
14384		-case 0xFFFFFFFFFFFFFC3ALLU:
	14634	+case 0xFFFFFFFFFFFFFC22LLU:
14385	14635	/* SP = 21LLU */
14386	14636	{
14387	14637	/* CALLBEGIN */

		@@ -14392,12 +14642,12 @@
14392	14642	{
14393	14643	/CALLEND/
14394	14644	stackbase += 23LLU;
14395		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC39LLU;
	14645	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC21LLU;
14396	14646	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14397	14647	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
14398	14648	break;
14399	14649	}
14400		-case 0xFFFFFFFFFFFFFC39LLU:
	14650	+case 0xFFFFFFFFFFFFFC21LLU:
14401	14651	/* SP = 21LLU */
14402	14652	{
14403	14653	/* CALLBEGIN */

		@@ -14415,12 +14665,12 @@
14415	14665	{
14416	14666	/CALLEND/
14417	14667	stackbase += 29LLU;
14418		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC38LLU;
	14668	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC20LLU;
14419	14669	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
14420	14670	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
14421	14671	break;
14422	14672	}
14423		-case 0xFFFFFFFFFFFFFC38LLU:
	14673	+case 0xFFFFFFFFFFFFFC20LLU:
14424	14674	/* SP = 27LLU */
14425	14675	{/* PUSH /stack[stackbase + 27LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 28LLU */
14426	14676	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 29LLU */

		@@ -14441,23 +14691,23 @@
14441	14691	{
14442	14692	/CALLEND/
14443	14693	stackbase += 41LLU;
14444		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC37LLU;
	14694	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1FLLU;
14445	14695	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
14446	14696	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
14447	14697	break;
14448	14698	}
14449		-case 0xFFFFFFFFFFFFFC37LLU:
	14699	+case 0xFFFFFFFFFFFFFC1FLLU:
14450	14700	/* SP = 39LLU */
14451	14701	{/* PUSH /stack[stackbase + 39LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 40LLU */
14452	14702	{
14453	14703	/CALLEND/
14454	14704	stackbase += 24LLU;
14455		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC36LLU;
	14705	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1ELLU;
14456	14706	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
14457		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	14707	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
14458	14708	break;
14459	14709	}
14460		-case 0xFFFFFFFFFFFFFC36LLU:
	14710	+case 0xFFFFFFFFFFFFFC1ELLU:
14461	14711	/* SP = 22LLU // SP = 21LLU // assign */
14462	14712	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }
14463	14713	{

		@@ -14469,12 +14719,12 @@
14469	14719	{
14470	14720	/CALLEND/
14471	14721	stackbase += 23LLU;
14472		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC35LLU;
	14722	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1DLLU;
14473	14723	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14474	14724	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
14475	14725	break;
14476	14726	}
14477		-case 0xFFFFFFFFFFFFFC35LLU:
	14727	+case 0xFFFFFFFFFFFFFC1DLLU:
14478	14728	/* SP = 21LLU */
14479	14729	{
14480	14730	/* CALLBEGIN */

		@@ -14486,12 +14736,12 @@
14486	14736	{
14487	14737	/CALLEND/
14488	14738	stackbase += 23LLU;
14489		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC34LLU;
	14739	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1CLLU;
14490	14740	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
14491	14741	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
14492	14742	break;
14493	14743	}
14494		-case 0xFFFFFFFFFFFFFC34LLU:
	14744	+case 0xFFFFFFFFFFFFFC1CLLU:
14495	14745	/* SP = 21LLU */fputs("\n{ ", stdout);
14496	14746	{
14497	14747	/* CALLBEGIN */

		@@ -14502,12 +14752,12 @@
14502	14752	{
14503	14753	/CALLEND/
14504	14754	stackbase += 23LLU;
14505		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC33LLU;
	14755	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1BLLU;
14506	14756	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
14507	14757	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
14508	14758	break;
14509	14759	}
14510		-case 0xFFFFFFFFFFFFFC33LLU:
	14760	+case 0xFFFFFFFFFFFFFC1BLLU:
14511	14761	/* SP = 21LLU */fputs(" = islower(", stdout);
14512	14762	{
14513	14763	/* CALLBEGIN */

		@@ -14518,15 +14768,15 @@
14518	14768	{
14519	14769	/CALLEND/
14520	14770	stackbase += 23LLU;
14521		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC32LLU;
	14771	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1ALLU;
14522	14772	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
14523	14773	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
14524	14774	break;
14525	14775	}
14526		-case 0xFFFFFFFFFFFFFC32LLU:
	14776	+case 0xFFFFFFFFFFFFFC1ALLU:
14527	14777	/* SP = 21LLU /fputs("); }", stdout); / SP = 21LLU // SP = 21LLU */
14528		-{ /* JUMP / fnaddr = 18446744073709550652LLU; break; } / skip alternative */
14529		-case 18446744073709550653LLU: /* alternative // predicate */
	14778	+{ /* JUMP / fnaddr = 18446744073709550628LLU; break; } / skip alternative */
	14779	+case 18446744073709550629LLU: /* alternative // predicate */
14530	14780
14531	14781	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
14532	14782	{/* PUSH /stack[stackbase + 22LLU] = 10585473078358179840LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -14533,7 +14783,7 @@
14533	14783	{
14534	14784	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
14535	14785	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
14536		-{ /* JUMP / fnaddr = 18446744073709550641LLU; break; } / skip consequent */
	14786	+{ /* JUMP / fnaddr = 18446744073709550617LLU; break; } / skip consequent */
14537	14787	/* consequent */
14538	14788	{
14539	14789	/* CALLBEGIN */

		@@ -14552,22 +14802,22 @@
14552	14802	{
14553	14803	/CALLEND/
14554	14804	stackbase += 29LLU;
14555		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2FLLU;
	14805	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC17LLU;
14556	14806	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
14557	14807	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
14558	14808	break;
14559	14809	}
14560		-case 0xFFFFFFFFFFFFFC2FLLU:
	14810	+case 0xFFFFFFFFFFFFFC17LLU:
14561	14811	/* SP = 27LLU */
14562	14812	{
14563	14813	/CALLEND/
14564	14814	stackbase += 23LLU;
14565		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2ELLU;
	14815	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC16LLU;
14566	14816	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
14567	14817	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
14568	14818	break;
14569	14819	}
14570		-case 0xFFFFFFFFFFFFFC2ELLU:
	14820	+case 0xFFFFFFFFFFFFFC16LLU:
14571	14821	/* SP = 21LLU */
14572	14822	{
14573	14823	/* CALLBEGIN */

		@@ -14578,12 +14828,12 @@
14578	14828	{
14579	14829	/CALLEND/
14580	14830	stackbase += 23LLU;
14581		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2DLLU;
	14831	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC15LLU;
14582	14832	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14583	14833	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
14584	14834	break;
14585	14835	}
14586		-case 0xFFFFFFFFFFFFFC2DLLU:
	14836	+case 0xFFFFFFFFFFFFFC15LLU:
14587	14837	/* SP = 21LLU */
14588	14838	{
14589	14839	/* CALLBEGIN */

		@@ -14601,12 +14851,12 @@
14601	14851	{
14602	14852	/CALLEND/
14603	14853	stackbase += 29LLU;
14604		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2CLLU;
	14854	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC14LLU;
14605	14855	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
14606	14856	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
14607	14857	break;
14608	14858	}
14609		-case 0xFFFFFFFFFFFFFC2CLLU:
	14859	+case 0xFFFFFFFFFFFFFC14LLU:
14610	14860	/* SP = 27LLU */
14611	14861	{/* PUSH /stack[stackbase + 27LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 28LLU */
14612	14862	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 29LLU */

		@@ -14627,23 +14877,23 @@
14627	14877	{
14628	14878	/CALLEND/
14629	14879	stackbase += 41LLU;
14630		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2BLLU;
	14880	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC13LLU;
14631	14881	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
14632	14882	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
14633	14883	break;
14634	14884	}
14635		-case 0xFFFFFFFFFFFFFC2BLLU:
	14885	+case 0xFFFFFFFFFFFFFC13LLU:
14636	14886	/* SP = 39LLU */
14637	14887	{/* PUSH /stack[stackbase + 39LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 40LLU */
14638	14888	{
14639	14889	/CALLEND/
14640	14890	stackbase += 24LLU;
14641		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC2ALLU;
	14891	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC12LLU;
14642	14892	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
14643		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	14893	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
14644	14894	break;
14645	14895	}
14646		-case 0xFFFFFFFFFFFFFC2ALLU:
	14896	+case 0xFFFFFFFFFFFFFC12LLU:
14647	14897	/* SP = 22LLU // SP = 21LLU // assign */
14648	14898	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }
14649	14899	{

		@@ -14655,12 +14905,12 @@
14655	14905	{
14656	14906	/CALLEND/
14657	14907	stackbase += 23LLU;
14658		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC29LLU;
	14908	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC11LLU;
14659	14909	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14660	14910	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
14661	14911	break;
14662	14912	}
14663		-case 0xFFFFFFFFFFFFFC29LLU:
	14913	+case 0xFFFFFFFFFFFFFC11LLU:
14664	14914	/* SP = 21LLU */
14665	14915	{
14666	14916	/* CALLBEGIN */

		@@ -14672,12 +14922,12 @@
14672	14922	{
14673	14923	/CALLEND/
14674	14924	stackbase += 23LLU;
14675		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC28LLU;
	14925	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC10LLU;
14676	14926	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
14677	14927	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
14678	14928	break;
14679	14929	}
14680		-case 0xFFFFFFFFFFFFFC28LLU:
	14930	+case 0xFFFFFFFFFFFFFC10LLU:
14681	14931	/* SP = 21LLU */fputs("\n{ ", stdout);
14682	14932	{
14683	14933	/* CALLBEGIN */

		@@ -14688,12 +14938,12 @@
14688	14938	{
14689	14939	/CALLEND/
14690	14940	stackbase += 23LLU;
14691		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC27LLU;
	14941	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0FLLU;
14692	14942	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
14693	14943	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
14694	14944	break;
14695	14945	}
14696		-case 0xFFFFFFFFFFFFFC27LLU:
	14946	+case 0xFFFFFFFFFFFFFC0FLLU:
14697	14947	/* SP = 21LLU */fputs(" = isalpha(", stdout);
14698	14948	{
14699	14949	/* CALLBEGIN */

		@@ -14704,15 +14954,15 @@
14704	14954	{
14705	14955	/CALLEND/
14706	14956	stackbase += 23LLU;
14707		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC26LLU;
	14957	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0ELLU;
14708	14958	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
14709	14959	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
14710	14960	break;
14711	14961	}
14712		-case 0xFFFFFFFFFFFFFC26LLU:
	14962	+case 0xFFFFFFFFFFFFFC0ELLU:
14713	14963	/* SP = 21LLU /fputs("); }", stdout); / SP = 21LLU // SP = 21LLU */
14714		-{ /* JUMP / fnaddr = 18446744073709550640LLU; break; } / skip alternative */
14715		-case 18446744073709550641LLU: /* alternative // predicate */
	14964	+{ /* JUMP / fnaddr = 18446744073709550616LLU; break; } / skip alternative */
	14965	+case 18446744073709550617LLU: /* alternative // predicate */
14716	14966
14717	14967	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
14718	14968	{/* PUSH /stack[stackbase + 22LLU] = 10585680731785134080LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -14719,7 +14969,7 @@
14719	14969	{
14720	14970	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
14721	14971	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
14722		-{ /* JUMP / fnaddr = 18446744073709550629LLU; break; } / skip consequent */
	14972	+{ /* JUMP / fnaddr = 18446744073709550605LLU; break; } / skip consequent */
14723	14973	/* consequent */
14724	14974	{
14725	14975	/* CALLBEGIN */

		@@ -14738,22 +14988,22 @@
14738	14988	{
14739	14989	/CALLEND/
14740	14990	stackbase += 29LLU;
14741		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC23LLU;
	14991	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0BLLU;
14742	14992	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
14743	14993	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
14744	14994	break;
14745	14995	}
14746		-case 0xFFFFFFFFFFFFFC23LLU:
	14996	+case 0xFFFFFFFFFFFFFC0BLLU:
14747	14997	/* SP = 27LLU */
14748	14998	{
14749	14999	/CALLEND/
14750	15000	stackbase += 23LLU;
14751		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC22LLU;
	15001	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0ALLU;
14752	15002	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
14753	15003	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
14754	15004	break;
14755	15005	}
14756		-case 0xFFFFFFFFFFFFFC22LLU:
	15006	+case 0xFFFFFFFFFFFFFC0ALLU:
14757	15007	/* SP = 21LLU */
14758	15008	{
14759	15009	/* CALLBEGIN */

		@@ -14764,12 +15014,12 @@
14764	15014	{
14765	15015	/CALLEND/
14766	15016	stackbase += 23LLU;
14767		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC21LLU;
	15017	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC09LLU;
14768	15018	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14769	15019	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
14770	15020	break;
14771	15021	}
14772		-case 0xFFFFFFFFFFFFFC21LLU:
	15022	+case 0xFFFFFFFFFFFFFC09LLU:
14773	15023	/* SP = 21LLU */
14774	15024	{
14775	15025	/* CALLBEGIN */

		@@ -14787,12 +15037,12 @@
14787	15037	{
14788	15038	/CALLEND/
14789	15039	stackbase += 29LLU;
14790		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC20LLU;
	15040	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC08LLU;
14791	15041	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
14792	15042	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
14793	15043	break;
14794	15044	}
14795		-case 0xFFFFFFFFFFFFFC20LLU:
	15045	+case 0xFFFFFFFFFFFFFC08LLU:
14796	15046	/* SP = 27LLU */
14797	15047	{/* PUSH /stack[stackbase + 27LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 28LLU */
14798	15048	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 29LLU */

		@@ -14813,23 +15063,23 @@
14813	15063	{
14814	15064	/CALLEND/
14815	15065	stackbase += 41LLU;
14816		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1FLLU;
	15066	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC07LLU;
14817	15067	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
14818	15068	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
14819	15069	break;
14820	15070	}
14821		-case 0xFFFFFFFFFFFFFC1FLLU:
	15071	+case 0xFFFFFFFFFFFFFC07LLU:
14822	15072	/* SP = 39LLU */
14823	15073	{/* PUSH /stack[stackbase + 39LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 40LLU */
14824	15074	{
14825	15075	/CALLEND/
14826	15076	stackbase += 24LLU;
14827		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1ELLU;
	15077	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC06LLU;
14828	15078	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
14829		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	15079	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
14830	15080	break;
14831	15081	}
14832		-case 0xFFFFFFFFFFFFFC1ELLU:
	15082	+case 0xFFFFFFFFFFFFFC06LLU:
14833	15083	/* SP = 22LLU // SP = 21LLU // assign */
14834	15084	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }
14835	15085	{

		@@ -14841,12 +15091,12 @@
14841	15091	{
14842	15092	/CALLEND/
14843	15093	stackbase += 23LLU;
14844		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1DLLU;
	15094	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC05LLU;
14845	15095	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14846	15096	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
14847	15097	break;
14848	15098	}
14849		-case 0xFFFFFFFFFFFFFC1DLLU:
	15099	+case 0xFFFFFFFFFFFFFC05LLU:
14850	15100	/* SP = 21LLU */
14851	15101	{
14852	15102	/* CALLBEGIN */

		@@ -14858,12 +15108,12 @@
14858	15108	{
14859	15109	/CALLEND/
14860	15110	stackbase += 23LLU;
14861		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1CLLU;
	15111	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC04LLU;
14862	15112	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
14863	15113	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
14864	15114	break;
14865	15115	}
14866		-case 0xFFFFFFFFFFFFFC1CLLU:
	15116	+case 0xFFFFFFFFFFFFFC04LLU:
14867	15117	/* SP = 21LLU */fputs("\n{ ", stdout);
14868	15118	{
14869	15119	/* CALLBEGIN */

		@@ -14874,12 +15124,12 @@
14874	15124	{
14875	15125	/CALLEND/
14876	15126	stackbase += 23LLU;
14877		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1BLLU;
	15127	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC03LLU;
14878	15128	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
14879	15129	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
14880	15130	break;
14881	15131	}
14882		-case 0xFFFFFFFFFFFFFC1BLLU:
	15132	+case 0xFFFFFFFFFFFFFC03LLU:
14883	15133	/* SP = 21LLU */fputs(" = isdigit(", stdout);
14884	15134	{
14885	15135	/* CALLBEGIN */

		@@ -14890,15 +15140,15 @@
14890	15140	{
14891	15141	/CALLEND/
14892	15142	stackbase += 23LLU;
14893		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC1ALLU;
	15143	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFC02LLU;
14894	15144	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
14895	15145	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
14896	15146	break;
14897	15147	}
14898		-case 0xFFFFFFFFFFFFFC1ALLU:
	15148	+case 0xFFFFFFFFFFFFFC02LLU:
14899	15149	/* SP = 21LLU /fputs("); }", stdout); / SP = 21LLU // SP = 21LLU */
14900		-{ /* JUMP / fnaddr = 18446744073709550628LLU; break; } / skip alternative */
14901		-case 18446744073709550629LLU: /* alternative // predicate */
	15150	+{ /* JUMP / fnaddr = 18446744073709550604LLU; break; } / skip alternative */
	15151	+case 18446744073709550605LLU: /* alternative // predicate */
14902	15152
14903	15153	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
14904	15154	{/* PUSH /stack[stackbase + 22LLU] = 10586743854776451072LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -14905,7 +15155,7 @@
14905	15155	{
14906	15156	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
14907	15157	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
14908		-{ /* JUMP / fnaddr = 18446744073709550617LLU; break; } / skip consequent */
	15158	+{ /* JUMP / fnaddr = 18446744073709550593LLU; break; } / skip consequent */
14909	15159	/* consequent */
14910	15160	{
14911	15161	/* CALLBEGIN */

		@@ -14924,22 +15174,22 @@
14924	15174	{
14925	15175	/CALLEND/
14926	15176	stackbase += 29LLU;
14927		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC17LLU;
	15177	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFFLLU;
14928	15178	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
14929	15179	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
14930	15180	break;
14931	15181	}
14932		-case 0xFFFFFFFFFFFFFC17LLU:
	15182	+case 0xFFFFFFFFFFFFFBFFLLU:
14933	15183	/* SP = 27LLU */
14934	15184	{
14935	15185	/CALLEND/
14936	15186	stackbase += 23LLU;
14937		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC16LLU;
	15187	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFELLU;
14938	15188	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
14939	15189	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
14940	15190	break;
14941	15191	}
14942		-case 0xFFFFFFFFFFFFFC16LLU:
	15192	+case 0xFFFFFFFFFFFFFBFELLU:
14943	15193	/* SP = 21LLU */
14944	15194	{
14945	15195	/* CALLBEGIN */

		@@ -14950,12 +15200,12 @@
14950	15200	{
14951	15201	/CALLEND/
14952	15202	stackbase += 23LLU;
14953		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC15LLU;
	15203	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFDLLU;
14954	15204	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
14955	15205	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
14956	15206	break;
14957	15207	}
14958		-case 0xFFFFFFFFFFFFFC15LLU:
	15208	+case 0xFFFFFFFFFFFFFBFDLLU:
14959	15209	/* SP = 21LLU */
14960	15210	{
14961	15211	/* CALLBEGIN */

		@@ -14973,12 +15223,12 @@
14973	15223	{
14974	15224	/CALLEND/
14975	15225	stackbase += 29LLU;
14976		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC14LLU;
	15226	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFCLLU;
14977	15227	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
14978	15228	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
14979	15229	break;
14980	15230	}
14981		-case 0xFFFFFFFFFFFFFC14LLU:
	15231	+case 0xFFFFFFFFFFFFFBFCLLU:
14982	15232	/* SP = 27LLU */
14983	15233	{/* PUSH /stack[stackbase + 27LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 28LLU */
14984	15234	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 29LLU */

		@@ -14999,23 +15249,23 @@
14999	15249	{
15000	15250	/CALLEND/
15001	15251	stackbase += 41LLU;
15002		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC13LLU;
	15252	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFBLLU;
15003	15253	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
15004	15254	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
15005	15255	break;
15006	15256	}
15007		-case 0xFFFFFFFFFFFFFC13LLU:
	15257	+case 0xFFFFFFFFFFFFFBFBLLU:
15008	15258	/* SP = 39LLU */
15009	15259	{/* PUSH /stack[stackbase + 39LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 40LLU */
15010	15260	{
15011	15261	/CALLEND/
15012	15262	stackbase += 24LLU;
15013		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC12LLU;
	15263	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFALLU;
15014	15264	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
15015		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	15265	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
15016	15266	break;
15017	15267	}
15018		-case 0xFFFFFFFFFFFFFC12LLU:
	15268	+case 0xFFFFFFFFFFFFFBFALLU:
15019	15269	/* SP = 22LLU // SP = 21LLU // assign */
15020	15270	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }
15021	15271	{

		@@ -15027,12 +15277,12 @@
15027	15277	{
15028	15278	/CALLEND/
15029	15279	stackbase += 23LLU;
15030		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC11LLU;
	15280	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF9LLU;
15031	15281	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15032	15282	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
15033	15283	break;
15034	15284	}
15035		-case 0xFFFFFFFFFFFFFC11LLU:
	15285	+case 0xFFFFFFFFFFFFFBF9LLU:
15036	15286	/* SP = 21LLU */
15037	15287	{
15038	15288	/* CALLBEGIN */

		@@ -15044,12 +15294,12 @@
15044	15294	{
15045	15295	/CALLEND/
15046	15296	stackbase += 23LLU;
15047		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC10LLU;
	15297	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF8LLU;
15048	15298	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
15049	15299	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
15050	15300	break;
15051	15301	}
15052		-case 0xFFFFFFFFFFFFFC10LLU:
	15302	+case 0xFFFFFFFFFFFFFBF8LLU:
15053	15303	/* SP = 21LLU */fputs("\n{ ", stdout);
15054	15304	{
15055	15305	/* CALLBEGIN */

		@@ -15060,12 +15310,12 @@
15060	15310	{
15061	15311	/CALLEND/
15062	15312	stackbase += 23LLU;
15063		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0FLLU;
	15313	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF7LLU;
15064	15314	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
15065	15315	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
15066	15316	break;
15067	15317	}
15068		-case 0xFFFFFFFFFFFFFC0FLLU:
	15318	+case 0xFFFFFFFFFFFFFBF7LLU:
15069	15319	/* SP = 21LLU */fputs(" = isspace(", stdout);
15070	15320	{
15071	15321	/* CALLBEGIN */

		@@ -15076,15 +15326,15 @@
15076	15326	{
15077	15327	/CALLEND/
15078	15328	stackbase += 23LLU;
15079		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0ELLU;
	15329	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF6LLU;
15080	15330	fnaddr = /TOP_START_/0x50F4004D40525000LLU;/* SP = 0LLU */
15081	15331	{ if(stackbase + 16LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_START_/\n"); exit(-1); } }
15082	15332	break;
15083	15333	}
15084		-case 0xFFFFFFFFFFFFFC0ELLU:
	15334	+case 0xFFFFFFFFFFFFFBF6LLU:
15085	15335	/* SP = 21LLU /fputs("); }", stdout); / SP = 21LLU // SP = 21LLU */
15086		-{ /* JUMP / fnaddr = 18446744073709550616LLU; break; } / skip alternative */
15087		-case 18446744073709550617LLU: /* alternative // predicate */
	15336	+{ /* JUMP / fnaddr = 18446744073709550592LLU; break; } / skip alternative */
	15337	+case 18446744073709550593LLU: /* alternative // predicate */
15088	15338
15089	15339	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
15090	15340	{/* PUSH /stack[stackbase + 22LLU] = 1175603453495219200LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -15091,7 +15341,7 @@
15091	15341	{
15092	15342	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
15093	15343	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
15094		-{ /* JUMP / fnaddr = 18446744073709550605LLU; break; } / skip consequent */
	15344	+{ /* JUMP / fnaddr = 18446744073709550581LLU; break; } / skip consequent */
15095	15345	/* consequent */
15096	15346	{
15097	15347	/* CALLBEGIN */

		@@ -15110,22 +15360,22 @@
15110	15360	{
15111	15361	/CALLEND/
15112	15362	stackbase += 29LLU;
15113		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0BLLU;
	15363	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF3LLU;
15114	15364	fnaddr = /typeunit__/0xBF4AE0C2992F0000LLU;/* SP = 0LLU */
15115	15365	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeunit__/\n"); exit(-1); } }
15116	15366	break;
15117	15367	}
15118		-case 0xFFFFFFFFFFFFFC0BLLU:
	15368	+case 0xFFFFFFFFFFFFFBF3LLU:
15119	15369	/* SP = 27LLU */
15120	15370	{
15121	15371	/CALLEND/
15122	15372	stackbase += 23LLU;
15123		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC0ALLU;
	15373	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF2LLU;
15124	15374	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
15125	15375	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
15126	15376	break;
15127	15377	}
15128		-case 0xFFFFFFFFFFFFFC0ALLU:
	15378	+case 0xFFFFFFFFFFFFFBF2LLU:
15129	15379	/* SP = 21LLU */
15130	15380	{
15131	15381	/* CALLBEGIN */

		@@ -15136,12 +15386,12 @@
15136	15386	{
15137	15387	/CALLEND/
15138	15388	stackbase += 23LLU;
15139		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC09LLU;
	15389	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF1LLU;
15140	15390	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15141	15391	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
15142	15392	break;
15143	15393	}
15144		-case 0xFFFFFFFFFFFFFC09LLU:
	15394	+case 0xFFFFFFFFFFFFFBF1LLU:
15145	15395	/* SP = 21LLU */
15146	15396	{
15147	15397	/* CALLBEGIN */

		@@ -15153,15 +15403,15 @@
15153	15403	{
15154	15404	/CALLEND/
15155	15405	stackbase += 23LLU;
15156		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC08LLU;
	15406	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF0LLU;
15157	15407	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
15158	15408	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
15159	15409	break;
15160	15410	}
15161		-case 0xFFFFFFFFFFFFFC08LLU:
	15411	+case 0xFFFFFFFFFFFFFBF0LLU:
15162	15412	/* SP = 21LLU /fputs("\nfprintf(stderr, \"[line %llu]\", (long long unsigned int)stack[4]);", stdout); / SP = 21LLU // SP = 21LLU */
15163		-{ /* JUMP / fnaddr = 18446744073709550604LLU; break; } / skip alternative */
15164		-case 18446744073709550605LLU: /* alternative // predicate */
	15413	+{ /* JUMP / fnaddr = 18446744073709550580LLU; break; } / skip alternative */
	15414	+case 18446744073709550581LLU: /* alternative // predicate */
15165	15415
15166	15416	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
15167	15417	{/* PUSH /stack[stackbase + 22LLU] = 3500287570728976384LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -15168,7 +15418,7 @@
15168	15418	{
15169	15419	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
15170	15420	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
15171		-{ /* JUMP / fnaddr = 18446744073709550599LLU; break; } / skip consequent */
	15421	+{ /* JUMP / fnaddr = 18446744073709550575LLU; break; } / skip consequent */
15172	15422	/* consequent */
15173	15423	{
15174	15424	/* CALLBEGIN */

		@@ -15187,22 +15437,22 @@
15187	15437	{
15188	15438	/CALLEND/
15189	15439	stackbase += 29LLU;
15190		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC05LLU;
	15440	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBEDLLU;
15191	15441	fnaddr = /typeunit__/0xBF4AE0C2992F0000LLU;/* SP = 0LLU */
15192	15442	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeunit__/\n"); exit(-1); } }
15193	15443	break;
15194	15444	}
15195		-case 0xFFFFFFFFFFFFFC05LLU:
	15445	+case 0xFFFFFFFFFFFFFBEDLLU:
15196	15446	/* SP = 27LLU */
15197	15447	{
15198	15448	/CALLEND/
15199	15449	stackbase += 23LLU;
15200		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC04LLU;
	15450	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBECLLU;
15201	15451	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
15202	15452	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
15203	15453	break;
15204	15454	}
15205		-case 0xFFFFFFFFFFFFFC04LLU:
	15455	+case 0xFFFFFFFFFFFFFBECLLU:
15206	15456	/* SP = 21LLU */
15207	15457	{
15208	15458	/* CALLBEGIN */

		@@ -15213,12 +15463,12 @@
15213	15463	{
15214	15464	/CALLEND/
15215	15465	stackbase += 23LLU;
15216		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC03LLU;
	15466	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBEBLLU;
15217	15467	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15218	15468	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
15219	15469	break;
15220	15470	}
15221		-case 0xFFFFFFFFFFFFFC03LLU:
	15471	+case 0xFFFFFFFFFFFFFBEBLLU:
15222	15472	/* SP = 21LLU */
15223	15473	{
15224	15474	/* CALLBEGIN */

		@@ -15236,12 +15486,12 @@
15236	15486	{
15237	15487	/CALLEND/
15238	15488	stackbase += 29LLU;
15239		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC02LLU;
	15489	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBEALLU;
15240	15490	fnaddr = /parsetoken/0xADCB6E82FAA68290LLU;/* SP = 0LLU */
15241	15491	{ if(stackbase + 18LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsetoken/\n"); exit(-1); } }
15242	15492	break;
15243	15493	}
15244		-case 0xFFFFFFFFFFFFFC02LLU:
	15494	+case 0xFFFFFFFFFFFFFBEALLU:
15245	15495	/* SP = 27LLU */
15246	15496	{/* PUSH /stack[stackbase + 27LLU] = stack[stackbase + 3LLU]; }/ SP + 1LLU = 28LLU */
15247	15497	{/* PUSH /stack[stackbase + 28LLU] = stack[stackbase + 4LLU]; }/ SP + 1LLU = 29LLU */

		@@ -15262,23 +15512,23 @@
15262	15512	{
15263	15513	/CALLEND/
15264	15514	stackbase += 41LLU;
15265		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC01LLU;
	15515	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE9LLU;
15266	15516	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
15267	15517	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
15268	15518	break;
15269	15519	}
15270		-case 0xFFFFFFFFFFFFFC01LLU:
	15520	+case 0xFFFFFFFFFFFFFBE9LLU:
15271	15521	/* SP = 39LLU */
15272	15522	{/* PUSH /stack[stackbase + 39LLU] = stack[stackbase + 15LLU]; }/ SP + 1LLU = 40LLU */
15273	15523	{
15274	15524	/CALLEND/
15275	15525	stackbase += 24LLU;
15276		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFC00LLU;
	15526	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE8LLU;
15277	15527	fnaddr = /parsestep_/0xADCB6E82EBE0AC00LLU;/* SP = 0LLU */
15278		-{ if(stackbase + 94LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
	15528	+{ if(stackbase + 95LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /parsestep_/\n"); exit(-1); } }
15279	15529	break;
15280	15530	}
15281		-case 0xFFFFFFFFFFFFFC00LLU:
	15531	+case 0xFFFFFFFFFFFFFBE8LLU:
15282	15532	/* SP = 22LLU // SP = 21LLU // assign */
15283	15533	{ /* RESULT */stack[stackbase + 15LLU] = stack[stackbase + 21LLU]; }
15284	15534	{

		@@ -15290,12 +15540,12 @@
15290	15540	{
15291	15541	/CALLEND/
15292	15542	stackbase += 23LLU;
15293		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFFLLU;
	15543	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE7LLU;
15294	15544	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15295	15545	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
15296	15546	break;
15297	15547	}
15298		-case 0xFFFFFFFFFFFFFBFFLLU:
	15548	+case 0xFFFFFFFFFFFFFBE7LLU:
15299	15549	/* SP = 21LLU */
15300	15550	{
15301	15551	/* CALLBEGIN */

		@@ -15307,12 +15557,12 @@
15307	15557	{
15308	15558	/CALLEND/
15309	15559	stackbase += 23LLU;
15310		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFELLU;
	15560	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE6LLU;
15311	15561	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
15312	15562	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
15313	15563	break;
15314	15564	}
15315		-case 0xFFFFFFFFFFFFFBFELLU:
	15565	+case 0xFFFFFFFFFFFFFBE6LLU:
15316	15566	/* SP = 21LLU */fputs("\n{ stack[4] += ", stdout);
15317	15567	{
15318	15568	/* CALLBEGIN */

		@@ -15323,15 +15573,15 @@
15323	15573	{
15324	15574	/CALLEND/
15325	15575	stackbase += 23LLU;
15326		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFDLLU;
	15576	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE5LLU;
15327	15577	fnaddr = /POP_______/0x40F4000000000000LLU;/* SP = 0LLU */
15328	15578	{ if(stackbase + 21LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /POP_______/\n"); exit(-1); } }
15329	15579	break;
15330	15580	}
15331		-case 0xFFFFFFFFFFFFFBFDLLU:
	15581	+case 0xFFFFFFFFFFFFFBE5LLU:
15332	15582	/* SP = 21LLU /fputs(" }", stdout); / SP = 21LLU // SP = 21LLU */
15333		-{ /* JUMP / fnaddr = 18446744073709550598LLU; break; } / skip alternative */
15334		-case 18446744073709550599LLU: /* alternative // predicate */
	15583	+{ /* JUMP / fnaddr = 18446744073709550574LLU; break; } / skip alternative */
	15584	+case 18446744073709550575LLU: /* alternative // predicate */
15335	15585
15336	15586	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 20LLU]; }/ SP + 1LLU = 22LLU */
15337	15587	{/* PUSH /stack[stackbase + 22LLU] = 6117226504067482736LLU; }/ SP + 1LLU = 23LLU // SP = 21LLU */

		@@ -15338,7 +15588,7 @@
15338	15588	{
15339	15589	{/* PUSH /stack[stackbase + 21LLU] = stack[stackbase + 21LLU] == stack[stackbase + 22LLU]; }/ SP + 1LLU = 22LLU */ }
15340	15590	if(!/* SP - 1LLU = 21LLU // POP */stack[stackbase + 21LLU])
15341		-{ /* JUMP / fnaddr = 18446744073709550588LLU; break; } / skip consequent */
	15591	+{ /* JUMP / fnaddr = 18446744073709550564LLU; break; } / skip consequent */
15342	15592	/* consequent */
15343	15593	{
15344	15594	/* CALLBEGIN */

		@@ -15357,22 +15607,22 @@
15357	15607	{
15358	15608	/CALLEND/
15359	15609	stackbase += 29LLU;
15360		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBFALLU;
	15610	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE2LLU;
15361	15611	fnaddr = /typeu64___/0xBF4AE0C3CE800000LLU;/* SP = 0LLU */
15362	15612	{ if(stackbase + 6LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typeu64___/\n"); exit(-1); } }
15363	15613	break;
15364	15614	}
15365		-case 0xFFFFFFFFFFFFFBFALLU:
	15615	+case 0xFFFFFFFFFFFFFBE2LLU:
15366	15616	/* SP = 27LLU */
15367	15617	{
15368	15618	/CALLEND/
15369	15619	stackbase += 23LLU;
15370		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF9LLU;
	15620	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE1LLU;
15371	15621	fnaddr = /typecheck_/0xBF4AE07A381E9800LLU;/* SP = 0LLU */
15372	15622	{ if(stackbase + 20LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /typecheck_/\n"); exit(-1); } }
15373	15623	break;
15374	15624	}
15375		-case 0xFFFFFFFFFFFFFBF9LLU:
	15625	+case 0xFFFFFFFFFFFFFBE1LLU:
15376	15626	/* SP = 21LLU */
15377	15627	{
15378	15628	/* CALLBEGIN */

		@@ -15383,12 +15633,12 @@
15383	15633	{
15384	15634	/CALLEND/
15385	15635	stackbase += 23LLU;
15386		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF8LLU;
	15636	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBE0LLU;
15387	15637	fnaddr = /skipcmnts_/0xBA692B7A8A6FB800LLU;/* SP = 0LLU */
15388	15638	{ if(stackbase + 13LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /skipcmnts_/\n"); exit(-1); } }
15389	15639	break;
15390	15640	}
15391		-case 0xFFFFFFFFFFFFFBF8LLU:
	15641	+case 0xFFFFFFFFFFFFFBE0LLU:
15392	15642	/* SP = 21LLU */
15393	15643	{
15394	15644	/* CALLBEGIN */

		@@ -15400,12 +15650,12 @@
15400	15650	{
15401	15651	/CALLEND/
15402	15652	stackbase += 23LLU;
15403		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF7LLU;
	15653	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDFLLU;
15404	15654	fnaddr = /match_____/0xA1CBDE8C00000000LLU;/* SP = 0LLU */
15405	15655	{ if(stackbase + 9LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /match_____/\n"); exit(-1); } }
15406	15656	break;
15407	15657	}
15408		-case 0xFFFFFFFFFFFFFBF7LLU:
	15658	+case 0xFFFFFFFFFFFFFBDFLLU:
15409	15659	/* SP = 21LLU */
15410	15660	{
15411	15661	/* CALLBEGIN */

		@@ -15417,12 +15667,12 @@
15417	15667	{
15418	15668	/CALLEND/
15419	15669	stackbase += 23LLU;
15420		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF6LLU;
	15670	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDELLU;
15421	15671	fnaddr = /PUSH______/0x4154C80000000000LLU;/* SP = 0LLU */
15422	15672	{ if(stackbase + 24LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /PUSH______/\n"); exit(-1); } }
15423	15673	break;
15424	15674	}
15425		-case 0xFFFFFFFFFFFFFBF6LLU:
	15675	+case 0xFFFFFFFFFFFFFBDELLU:
15426	15676	/* SP = 21LLU */fputs("\n{", stdout); fputs("\n for(uint32_t Arg = 0; Arg < ArgCount && Args[Arg]; Arg++)", stdout); fputs("\n {", stdout); fputs("\n if(Args[Arg][0] && Args[Arg][1] && Args[Arg][2] && Args[Arg][3] && Args[Arg][4] && Args[Arg][5] && Args[Arg][6] && Args[Arg][7])", stdout); fputs("\n if(Args[Arg][0] == '-' && Args[Arg][1] == '-' && Args[Arg][2] == 'u' && Args[Arg][3] == 'n' && Args[Arg][4] == 's' && Args[Arg][5] == 'a' && Args[Arg][6] == 'f' && Args[Arg][7] == 'e')", stdout); fputs("\n ", stdout);
15427	15677	{
15428	15678	/* CALLBEGIN */

		@@ -15434,15 +15684,15 @@
15434	15684	{
15435	15685	/CALLEND/
15436	15686	stackbase += 23LLU;
15437		- stack[stackbase - 1] = 0xFFFFFFFFFFFFFBF5LLU;
	15687	+ stack[stackbase - 1] = 0xFFFFFFFFFFFFFBDDLLU;
15438	15688	fnaddr = /TOP_SET___/0x50F4004C55000000LLU;/* SP = 0LLU */
15439	15689	{ if(stackbase + 19LLU >= 0x0000000000100000LLU) { fprintf(stderr, "STACKOVERFLOW calling /TOP_SET___/\n"); exit(-1); } }
15440	15690	break;
15441	15691	}
15442		-case 0xFFFFFFFFFFFFFBF5LLU:
	15692	+case 0xFFFFFFFFFFFFFBDDLLU:
15443	15693	/* SP = 21LLU /fputs("\n }", stdout); fputs("\n}", stdout); / SP = 21LLU // SP = 21LLU */
15444		-{ /* JUMP / fnaddr = 18446744073709550587LLU; break; } / skip alternative */
15445		-case 18446744073709550588LLU: /* alternative */
	15694	+{ /* JUMP */ f

差分はサイズ制限により省略されました。全ての差分を見るためにはローカルクライアントを利用してください。

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