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

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revision	811 (tree)
Time	2019-10-07 10:21:52
Author	jakobthomsen

Log Message

pre-declaration of functions enables mutual recursion

Change Summary

Incremental Difference

--- trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)/jpl_compiler.c (revision 810)

+++ trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)/jpl_compiler.c (revision 811)

		@@ -1563,10 +1563,10 @@
1563	1563	state.addr = type_data.elem0;
1564	1564	break;
1565	1565	}
1566		- case 861504787186880512LLU: // typemain__
	1566	+ case 589060043891015680LLU: // equtype___
1567	1567	{
1568	1568
1569		- state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551551LLU : 18446744073709551550LLU;
	1569	+ state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 ? 18446744073709551551LLU : 18446744073709551550LLU;
1570	1570
1571	1571	break;
1572	1572	}

		@@ -1573,6 +1573,205 @@
1573	1573	case 18446744073709551551LLU: // 9999999989'''''''''''''''
1574	1574	{
1575	1575	{
	1576	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem1;
	1577	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	1578	+ }
	1579	+
	1580	+ state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 ? 18446744073709551549LLU : 18446744073709551548LLU;
	1581	+
	1582	+ break;
	1583	+ }
	1584	+ case 18446744073709551549LLU: // 9999999987'''''''''''''''
	1585	+ {
	1586	+ {
	1587	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem1;
	1588	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	1589	+ }
	1590	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
	1591	+ // parameter typeu64___ y_________ goes out of scope
	1592	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 5
	1593	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1594	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1595	+
	1596	+ state.addr = 18446744073709551547LLU; // 9999999985'''''''''''''''
	1597	+
	1598	+ break;
	1599	+ }
	1600	+ case 18446744073709551548LLU: // 9999999986'''''''''''''''
	1601	+ {
	1602	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = 0LLU;
	1603	+ state.addr = 18446744073709551547LLU; // 9999999985'''''''''''''''
	1604	+
	1605	+ break;
	1606	+ }
	1607	+ case 18446744073709551547LLU: // 9999999985'''''''''''''''
	1608	+ {
	1609	+ // parameter typeu64___ x_________ goes out of scope
	1610	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 4
	1611	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1612	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1613	+
	1614	+ state.addr = 18446744073709551546LLU; // 9999999984'''''''''''''''
	1615	+
	1616	+ break;
	1617	+ }
	1618	+ case 18446744073709551550LLU: // 9999999988'''''''''''''''
	1619	+ {
	1620	+
	1621	+ state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 ? 18446744073709551545LLU : 18446744073709551544LLU;
	1622	+
	1623	+ break;
	1624	+ }
	1625	+ case 18446744073709551545LLU: // 9999999983'''''''''''''''
	1626	+ {
	1627	+ {
	1628	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem1;
	1629	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	1630	+ }
	1631	+
	1632	+ state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 ? 18446744073709551543LLU : 18446744073709551542LLU;
	1633	+
	1634	+ break;
	1635	+ }
	1636	+ case 18446744073709551543LLU: // 9999999981'''''''''''''''
	1637	+ {
	1638	+ {
	1639	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem1;
	1640	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	1641	+ }
	1642	+
	1643	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 1LLU, LOCAL_ACCESS_ADDR(heap.data, 5LLU, 3LLU), 0LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 1LLU, LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU), 0LLU));
	1644	+ // parameter typename__ y_________ goes out of scope
	1645	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 5
	1646	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1647	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1648	+
	1649	+ state.addr = 18446744073709551541LLU; // 999999998z'''''''''''''''
	1650	+
	1651	+ break;
	1652	+ }
	1653	+ case 18446744073709551542LLU: // 9999999980'''''''''''''''
	1654	+ {
	1655	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = 0LLU;
	1656	+ state.addr = 18446744073709551541LLU; // 999999998z'''''''''''''''
	1657	+
	1658	+ break;
	1659	+ }
	1660	+ case 18446744073709551541LLU: // 999999998z'''''''''''''''
	1661	+ {
	1662	+ // parameter typename__ x_________ goes out of scope
	1663	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 4
	1664	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1665	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1666	+
	1667	+ state.addr = 18446744073709551540LLU; // 999999998y'''''''''''''''
	1668	+
	1669	+ break;
	1670	+ }
	1671	+ case 18446744073709551544LLU: // 9999999982'''''''''''''''
	1672	+ {
	1673	+
	1674	+ state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 ? 18446744073709551539LLU : 18446744073709551538LLU;
	1675	+
	1676	+ break;
	1677	+ }
	1678	+ case 18446744073709551539LLU: // 999999998x'''''''''''''''
	1679	+ {
	1680	+ {
	1681	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem1;
	1682	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	1683	+ }
	1684	+
	1685	+ state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 ? 18446744073709551537LLU : 18446744073709551536LLU;
	1686	+
	1687	+ break;
	1688	+ }
	1689	+ case 18446744073709551537LLU: // 999999998v'''''''''''''''
	1690	+ {
	1691	+ {
	1692	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem1;
	1693	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	1694	+ }
	1695	+
	1696	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 1LLU, LOCAL_ACCESS_ADDR(heap.data, 5LLU, 3LLU), 0LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 1LLU, LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU), 0LLU));
	1697	+ // parameter typelist__ y_________ goes out of scope
	1698	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 5
	1699	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1700	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1701	+
	1702	+ state.addr = 18446744073709551535LLU; // 999999998t'''''''''''''''
	1703	+
	1704	+ break;
	1705	+ }
	1706	+ case 18446744073709551536LLU: // 999999998u'''''''''''''''
	1707	+ {
	1708	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = 0LLU;
	1709	+ state.addr = 18446744073709551535LLU; // 999999998t'''''''''''''''
	1710	+
	1711	+ break;
	1712	+ }
	1713	+ case 18446744073709551535LLU: // 999999998t'''''''''''''''
	1714	+ {
	1715	+ // parameter typelist__ x_________ goes out of scope
	1716	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 4
	1717	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1718	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	1719	+
	1720	+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
	1721	+
	1722	+ break;
	1723	+ }
	1724	+ case 18446744073709551538LLU: // 999999998w'''''''''''''''
	1725	+ {
	1726	+
	1727	+ {
	1728	+ fprintf(stderr, "%s\n", "equtype: missing case");
	1729	+ exit(-1);
	1730	+ }
	1731	+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
	1732	+
	1733	+ break;
	1734	+ }
	1735	+ case 18446744073709551534LLU: // 999999998s'''''''''''''''
	1736	+ {
	1737	+ state.addr = 18446744073709551540LLU; // 999999998y'''''''''''''''
	1738	+
	1739	+ break;
	1740	+ }
	1741	+ case 18446744073709551540LLU: // 999999998y'''''''''''''''
	1742	+ {
	1743	+ state.addr = 18446744073709551546LLU; // 9999999984'''''''''''''''
	1744	+
	1745	+ break;
	1746	+ }
	1747	+ case 18446744073709551546LLU: // 9999999984'''''''''''''''
	1748	+ {
	1749	+ // parameter-reference type______ y_________ goes out of scope
	1750	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 3
	1751	+ // parameter-reference type______ x_________ goes out of scope
	1752	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 2
	1753	+ // parameter-reference u64 equal_____ goes out of scope
	1754	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference equal_____ at 1
	1755	+
	1756	+ {
	1757	+ uint64_t baseinfo = heap.data[0].elem1;
	1758	+ struct pair pair = unpair(&heap, &baseinfo);
	1759	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	1760	+ state.addr = pair.elem1;
	1761	+ }
	1762	+
	1763	+ break;
	1764	+ }
	1765	+ case 861504787186880512LLU: // typemain__
	1766	+ {
	1767	+
	1768	+ state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551533LLU : 18446744073709551532LLU;
	1769	+
	1770	+ break;
	1771	+ }
	1772	+ case 18446744073709551533LLU: // 999999998r'''''''''''''''
	1773	+ {
	1774	+ {
1576	1775	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;
1577	1776	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
1578	1777	}

		@@ -1582,18 +1781,18 @@
1582	1781	heap.availilable_size_for_dynamic_objects += 0LLU;
1583	1782	heap.availilable_size_for_dynamic_objects += 0LLU;
1584	1783
1585		- state.addr = 18446744073709551549LLU; // 9999999987'''''''''''''''
	1784	+ state.addr = 18446744073709551531LLU; // 999999998p'''''''''''''''
1586	1785
1587	1786	break;
1588	1787	}
1589		- case 18446744073709551550LLU: // 9999999988'''''''''''''''
	1788	+ case 18446744073709551532LLU: // 999999998q'''''''''''''''
1590	1789	{
1591	1790
1592		- state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551548LLU : 18446744073709551547LLU;
	1791	+ state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551530LLU : 18446744073709551529LLU;
1593	1792
1594	1793	break;
1595	1794	}
1596		- case 18446744073709551548LLU: // 9999999986'''''''''''''''
	1795	+ case 18446744073709551530LLU: // 999999998o'''''''''''''''
1597	1796	{
1598	1797	{
1599	1798	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -1605,18 +1804,18 @@
1605	1804	heap.availilable_size_for_dynamic_objects += 0LLU;
1606	1805	heap.availilable_size_for_dynamic_objects += 0LLU;
1607	1806
1608		- state.addr = 18446744073709551546LLU; // 9999999984'''''''''''''''
	1807	+ state.addr = 18446744073709551528LLU; // 999999998m'''''''''''''''
1609	1808
1610	1809	break;
1611	1810	}
1612		- case 18446744073709551547LLU: // 9999999985'''''''''''''''
	1811	+ case 18446744073709551529LLU: // 999999998n'''''''''''''''
1613	1812	{
1614	1813
1615		- state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551545LLU : 18446744073709551544LLU;
	1814	+ state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551527LLU : 18446744073709551526LLU;
1616	1815
1617	1816	break;
1618	1817	}
1619		- case 18446744073709551545LLU: // 9999999983'''''''''''''''
	1818	+ case 18446744073709551527LLU: // 999999998l'''''''''''''''
1620	1819	{
1621	1820	{
1622	1821	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -1628,30 +1827,30 @@
1628	1827	heap.availilable_size_for_dynamic_objects += 0LLU;
1629	1828	heap.availilable_size_for_dynamic_objects += 0LLU;
1630	1829
1631		- state.addr = 18446744073709551543LLU; // 9999999981'''''''''''''''
	1830	+ state.addr = 18446744073709551525LLU; // 999999998j'''''''''''''''
1632	1831
1633	1832	break;
1634	1833	}
1635		- case 18446744073709551544LLU: // 9999999982'''''''''''''''
	1834	+ case 18446744073709551526LLU: // 999999998k'''''''''''''''
1636	1835	{
1637	1836	fprintf(stderr, "%s", "typemain: missing case");
1638		- state.addr = 18446744073709551543LLU; // 9999999981'''''''''''''''
	1837	+ state.addr = 18446744073709551525LLU; // 999999998j'''''''''''''''
1639	1838
1640	1839	break;
1641	1840	}
1642		- case 18446744073709551543LLU: // 9999999981'''''''''''''''
	1841	+ case 18446744073709551525LLU: // 999999998j'''''''''''''''
1643	1842	{
1644		- state.addr = 18446744073709551546LLU; // 9999999984'''''''''''''''
	1843	+ state.addr = 18446744073709551528LLU; // 999999998m'''''''''''''''
1645	1844
1646	1845	break;
1647	1846	}
1648		- case 18446744073709551546LLU: // 9999999984'''''''''''''''
	1847	+ case 18446744073709551528LLU: // 999999998m'''''''''''''''
1649	1848	{
1650		- state.addr = 18446744073709551549LLU; // 9999999987'''''''''''''''
	1849	+ state.addr = 18446744073709551531LLU; // 999999998p'''''''''''''''
1651	1850
1652	1851	break;
1653	1852	}
1654		- case 18446744073709551549LLU: // 9999999987'''''''''''''''
	1853	+ case 18446744073709551531LLU: // 999999998p'''''''''''''''
1655	1854	{
1656	1855	// parameter-reference type______ type______ goes out of scope
1657	1856	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 2

		@@ -1670,11 +1869,11 @@
1670	1869	case 861504793962872832LLU: // typesub___
1671	1870	{
1672	1871
1673		- state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551542LLU : 18446744073709551541LLU;
	1872	+ state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551524LLU : 18446744073709551523LLU;
1674	1873
1675	1874	break;
1676	1875	}
1677		- case 18446744073709551542LLU: // 9999999980'''''''''''''''
	1876	+ case 18446744073709551524LLU: // 999999998i'''''''''''''''
1678	1877	{
1679	1878	{
1680	1879	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -1686,18 +1885,18 @@
1686	1885	heap.availilable_size_for_dynamic_objects += 0LLU;
1687	1886	heap.availilable_size_for_dynamic_objects += 0LLU;
1688	1887
1689		- state.addr = 18446744073709551540LLU; // 999999998y'''''''''''''''
	1888	+ state.addr = 18446744073709551522LLU; // 999999998g'''''''''''''''
1690	1889
1691	1890	break;
1692	1891	}
1693		- case 18446744073709551541LLU: // 999999998z'''''''''''''''
	1892	+ case 18446744073709551523LLU: // 999999998h'''''''''''''''
1694	1893	{
1695	1894
1696		- state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551539LLU : 18446744073709551538LLU;
	1895	+ state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551521LLU : 18446744073709551520LLU;
1697	1896
1698	1897	break;
1699	1898	}
1700		- case 18446744073709551539LLU: // 999999998x'''''''''''''''
	1899	+ case 18446744073709551521LLU: // 999999998f'''''''''''''''
1701	1900	{
1702	1901	{
1703	1902	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -1709,18 +1908,18 @@
1709	1908	heap.availilable_size_for_dynamic_objects += 0LLU;
1710	1909	heap.availilable_size_for_dynamic_objects += 0LLU;
1711	1910
1712		- state.addr = 18446744073709551537LLU; // 999999998v'''''''''''''''
	1911	+ state.addr = 18446744073709551519LLU; // 999999998d'''''''''''''''
1713	1912
1714	1913	break;
1715	1914	}
1716		- case 18446744073709551538LLU: // 999999998w'''''''''''''''
	1915	+ case 18446744073709551520LLU: // 999999998e'''''''''''''''
1717	1916	{
1718	1917
1719		- state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551536LLU : 18446744073709551535LLU;
	1918	+ state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551518LLU : 18446744073709551517LLU;
1720	1919
1721	1920	break;
1722	1921	}
1723		- case 18446744073709551536LLU: // 999999998u'''''''''''''''
	1922	+ case 18446744073709551518LLU: // 999999998c'''''''''''''''
1724	1923	{
1725	1924	{
1726	1925	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -1732,30 +1931,30 @@
1732	1931	heap.availilable_size_for_dynamic_objects += 0LLU;
1733	1932	heap.availilable_size_for_dynamic_objects += 0LLU;
1734	1933
1735		- state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
	1934	+ state.addr = 18446744073709551516LLU; // 999999998a'''''''''''''''
1736	1935
1737	1936	break;
1738	1937	}
1739		- case 18446744073709551535LLU: // 999999998t'''''''''''''''
	1938	+ case 18446744073709551517LLU: // 999999998b'''''''''''''''
1740	1939	{
1741	1940	fprintf(stderr, "%s", "typesub: missing case");
1742		- state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
	1941	+ state.addr = 18446744073709551516LLU; // 999999998a'''''''''''''''
1743	1942
1744	1943	break;
1745	1944	}
1746		- case 18446744073709551534LLU: // 999999998s'''''''''''''''
	1945	+ case 18446744073709551516LLU: // 999999998a'''''''''''''''
1747	1946	{
1748		- state.addr = 18446744073709551537LLU; // 999999998v'''''''''''''''
	1947	+ state.addr = 18446744073709551519LLU; // 999999998d'''''''''''''''
1749	1948
1750	1949	break;
1751	1950	}
1752		- case 18446744073709551537LLU: // 999999998v'''''''''''''''
	1951	+ case 18446744073709551519LLU: // 999999998d'''''''''''''''
1753	1952	{
1754		- state.addr = 18446744073709551540LLU; // 999999998y'''''''''''''''
	1953	+ state.addr = 18446744073709551522LLU; // 999999998g'''''''''''''''
1755	1954
1756	1955	break;
1757	1956	}
1758		- case 18446744073709551540LLU: // 999999998y'''''''''''''''
	1957	+ case 18446744073709551522LLU: // 999999998g'''''''''''''''
1759	1958	{
1760	1959	// parameter-reference type______ type______ goes out of scope
1761	1960	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 2

		@@ -1784,11 +1983,11 @@
1784	1983
1785	1984	/result____/LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = /buf_______/LOCAL_ACCESS(heap.data, 5LLU, 4LLU) == /maintype__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 1LLU));
1786	1985
1787		- state.addr = /result____/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) ? 18446744073709551533LLU : 18446744073709551532LLU;
	1986	+ state.addr = /result____/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) ? 18446744073709551515LLU : 18446744073709551514LLU;
1788	1987
1789	1988	break;
1790	1989	}
1791		- case 18446744073709551533LLU: // 999999998r'''''''''''''''
	1990	+ case 18446744073709551515LLU: // 999999998$'''''''''''''''
1792	1991	{
1793	1992	{
1794	1993	uint64_t arg = 0LLU;

		@@ -1808,7 +2007,7 @@
1808	2007	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
1809	2008	}
1810	2009	// 1LLU
1811		- uint64_t return_to = 18446744073709551531LLU;
	2010	+ uint64_t return_to = 18446744073709551513LLU;
1812	2011	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
1813	2012	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
1814	2013	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -1818,27 +2017,27 @@
1818	2017
1819	2018	break;
1820	2019	}
1821		- case 18446744073709551531LLU: // 999999998p'''''''''''''''
	2020	+ case 18446744073709551513LLU: // 999999998Y'''''''''''''''
1822	2021	{
1823	2022	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 6
1824	2023	heap.availilable_size_for_dynamic_objects += 0LLU;
1825	2024	heap.availilable_size_for_dynamic_objects += 0LLU;
1826	2025
1827		- state.addr = 18446744073709551530LLU; // 999999998o'''''''''''''''
	2026	+ state.addr = 18446744073709551512LLU; // 999999998X'''''''''''''''
1828	2027
1829	2028	break;
1830	2029	}
1831		- case 18446744073709551532LLU: // 999999998q'''''''''''''''
	2030	+ case 18446744073709551514LLU: // 999999998Z'''''''''''''''
1832	2031	{
1833	2032	/buf_______/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = 712900180986298368LLU;
1834	2033
1835	2034	/result____/LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = /buf_______/LOCAL_ACCESS(heap.data, 5LLU, 4LLU) == /maintype__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 1LLU));
1836	2035
1837		- state.addr = /result____/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) ? 18446744073709551529LLU : 18446744073709551528LLU;
	2036	+ state.addr = /result____/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) ? 18446744073709551511LLU : 18446744073709551510LLU;
1838	2037
1839	2038	break;
1840	2039	}
1841		- case 18446744073709551529LLU: // 999999998n'''''''''''''''
	2040	+ case 18446744073709551511LLU: // 999999998W'''''''''''''''
1842	2041	{
1843	2042	{
1844	2043	uint64_t arg = /subtype___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 2LLU));

		@@ -1863,7 +2062,7 @@
1863	2062	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
1864	2063	}
1865	2064	// 1LLU
1866		- uint64_t return_to = 18446744073709551527LLU;
	2065	+ uint64_t return_to = 18446744073709551509LLU;
1867	2066	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
1868	2067	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
1869	2068	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -1873,7 +2072,7 @@
1873	2072
1874	2073	break;
1875	2074	}
1876		- case 18446744073709551527LLU: // 999999998l'''''''''''''''
	2075	+ case 18446744073709551509LLU: // 999999998U'''''''''''''''
1877	2076	{
1878	2077	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 7
1879	2078	// variable u64 subtype___ goes out of scope

		@@ -1882,18 +2081,18 @@
1882	2081	heap.availilable_size_for_dynamic_objects += 0LLU;
1883	2082	heap.availilable_size_for_dynamic_objects += 0LLU;
1884	2083
1885		- state.addr = 18446744073709551526LLU; // 999999998k'''''''''''''''
	2084	+ state.addr = 18446744073709551508LLU; // 999999998T'''''''''''''''
1886	2085
1887	2086	break;
1888	2087	}
1889		- case 18446744073709551528LLU: // 999999998m'''''''''''''''
	2088	+ case 18446744073709551510LLU: // 999999998V'''''''''''''''
1890	2089	{
1891	2090
1892		- state.addr = /subtype___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 2LLU)) ? 18446744073709551525LLU : 18446744073709551524LLU;
	2091	+ state.addr = /subtype___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 2LLU)) ? 18446744073709551507LLU : 18446744073709551506LLU;
1893	2092
1894	2093	break;
1895	2094	}
1896		- case 18446744073709551525LLU: // 999999998j'''''''''''''''
	2095	+ case 18446744073709551507LLU: // 999999998S'''''''''''''''
1897	2096	{
1898	2097	fprintf(stderr, "%s", "typeinit: struct/union ");
1899	2098

		@@ -1901,11 +2100,11 @@
1901	2100	fprintf(stderr, "%s", " must not have subtype but found ");
1902	2101
1903	2102	printid(stderr, /subtype___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 2LLU)));
1904		- state.addr = 18446744073709551524LLU; // 999999998i'''''''''''''''
	2103	+ state.addr = 18446744073709551506LLU; // 999999998R'''''''''''''''
1905	2104
1906	2105	break;
1907	2106	}
1908		- case 18446744073709551524LLU: // 999999998i'''''''''''''''
	2107	+ case 18446744073709551506LLU: // 999999998R'''''''''''''''
1909	2108	{
1910	2109	{
1911	2110	uint64_t arg = /maintype__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 1LLU));

		@@ -1930,7 +2129,7 @@
1930	2129	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
1931	2130	}
1932	2131	// 1LLU
1933		- uint64_t return_to = 18446744073709551523LLU;
	2132	+ uint64_t return_to = 18446744073709551505LLU;
1934	2133	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
1935	2134	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
1936	2135	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -1940,23 +2139,23 @@
1940	2139
1941	2140	break;
1942	2141	}
1943		- case 18446744073709551523LLU: // 999999998h'''''''''''''''
	2142	+ case 18446744073709551505LLU: // 999999998Q'''''''''''''''
1944	2143	{
1945	2144	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 7
1946	2145	// variable u64 maintype__ goes out of scope
1947	2146	// (uninitialized -> no destructor-call)
1948	2147	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference maintype__ at 6
1949		- state.addr = 18446744073709551526LLU; // 999999998k'''''''''''''''
	2148	+ state.addr = 18446744073709551508LLU; // 999999998T'''''''''''''''
1950	2149
1951	2150	break;
1952	2151	}
1953		- case 18446744073709551526LLU: // 999999998k'''''''''''''''
	2152	+ case 18446744073709551508LLU: // 999999998T'''''''''''''''
1954	2153	{
1955		- state.addr = 18446744073709551530LLU; // 999999998o'''''''''''''''
	2154	+ state.addr = 18446744073709551512LLU; // 999999998X'''''''''''''''
1956	2155
1957	2156	break;
1958	2157	}
1959		- case 18446744073709551530LLU: // 999999998o'''''''''''''''
	2158	+ case 18446744073709551512LLU: // 999999998X'''''''''''''''
1960	2159	{
1961	2160	// variable u64 buf_______ goes out of scope
1962	2161	// emitted destructur for type u64

		@@ -2005,7 +2204,7 @@
2005	2204	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
2006	2205	}
2007	2206	// 3LLU
2008		- uint64_t return_to = 18446744073709551521LLU;
	2207	+ uint64_t return_to = 18446744073709551503LLU;
2009	2208	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
2010	2209	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
2011	2210	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -2015,13 +2214,13 @@
2015	2214
2016	2215	break;
2017	2216	}
2018		- case 18446744073709551521LLU: // 999999998f'''''''''''''''
	2217	+ case 18446744073709551503LLU: // 999999998O'''''''''''''''
2019	2218	{
2020		- state.addr = 18446744073709551522LLU; // 999999998g'''''''''''''''
	2219	+ state.addr = 18446744073709551504LLU; // 999999998P'''''''''''''''
2021	2220
2022	2221	break;
2023	2222	}
2024		- case 18446744073709551522LLU: // 999999998g'''''''''''''''
	2223	+ case 18446744073709551504LLU: // 999999998P'''''''''''''''
2025	2224	{
2026	2225	swap(&/new_______/LOCAL_ACCESS(heap.data, 4LLU, 3LLU), &/type______/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)));
2027	2226	// variable type______ new_______ goes out of scope

		@@ -2068,7 +2267,7 @@
2068	2267	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
2069	2268	}
2070	2269	// 3LLU
2071		- uint64_t return_to = 18446744073709551519LLU;
	2270	+ uint64_t return_to = 18446744073709551501LLU;
2072	2271	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
2073	2272	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
2074	2273	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -2078,13 +2277,13 @@
2078	2277
2079	2278	break;
2080	2279	}
2081		- case 18446744073709551519LLU: // 999999998d'''''''''''''''
	2280	+ case 18446744073709551501LLU: // 999999998M'''''''''''''''
2082	2281	{
2083		- state.addr = 18446744073709551520LLU; // 999999998e'''''''''''''''
	2282	+ state.addr = 18446744073709551502LLU; // 999999998N'''''''''''''''
2084	2283
2085	2284	break;
2086	2285	}
2087		- case 18446744073709551520LLU: // 999999998e'''''''''''''''
	2286	+ case 18446744073709551502LLU: // 999999998N'''''''''''''''
2088	2287	{
2089	2288
2090	2289	swap(&/new_______/LOCAL_ACCESS(heap.data, 4LLU, 3LLU), &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU))); // result

		@@ -2109,11 +2308,11 @@
2109	2308	case 861504776686223360LLU: // typecopy__
2110	2309	{
2111	2310
2112		- state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551518LLU : 18446744073709551517LLU;
	2311	+ state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551500LLU : 18446744073709551499LLU;
2113	2312
2114	2313	break;
2115	2314	}
2116		- case 18446744073709551518LLU: // 999999998c'''''''''''''''
	2315	+ case 18446744073709551500LLU: // 999999998L'''''''''''''''
2117	2316	{
2118	2317	{
2119	2318	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -2137,7 +2336,7 @@
2137	2336	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
2138	2337	}
2139	2338	// 1LLU
2140		- uint64_t return_to = 18446744073709551516LLU;
	2339	+ uint64_t return_to = 18446744073709551498LLU;
2141	2340	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
2142	2341	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
2143	2342	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -2147,7 +2346,7 @@
2147	2346
2148	2347	break;
2149	2348	}
2150		- case 18446744073709551516LLU: // 999999998a'''''''''''''''
	2349	+ case 18446744073709551498LLU: // 999999998J'''''''''''''''
2151	2350	{
2152	2351	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 4
2153	2352	// parameter typeu64___ src_______ goes out of scope

		@@ -2155,18 +2354,18 @@
2155	2354	heap.availilable_size_for_dynamic_objects += 0LLU;
2156	2355	heap.availilable_size_for_dynamic_objects += 0LLU;
2157	2356
2158		- state.addr = 18446744073709551515LLU; // 999999998$'''''''''''''''
	2357	+ state.addr = 18446744073709551497LLU; // 999999998I'''''''''''''''
2159	2358
2160	2359	break;
2161	2360	}
2162		- case 18446744073709551517LLU: // 999999998b'''''''''''''''
	2361	+ case 18446744073709551499LLU: // 999999998K'''''''''''''''
2163	2362	{
2164	2363
2165		- state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551514LLU : 18446744073709551513LLU;
	2364	+ state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551496LLU : 18446744073709551495LLU;
2166	2365
2167	2366	break;
2168	2367	}
2169		- case 18446744073709551514LLU: // 999999998Z'''''''''''''''
	2368	+ case 18446744073709551496LLU: // 999999998H'''''''''''''''
2170	2369	{
2171	2370	{
2172	2371	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -2195,7 +2394,7 @@
2195	2394	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
2196	2395	}
2197	2396	// 1LLU
2198		- uint64_t return_to = 18446744073709551512LLU;
	2397	+ uint64_t return_to = 18446744073709551494LLU;
2199	2398	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
2200	2399	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
2201	2400	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -2205,7 +2404,7 @@
2205	2404
2206	2405	break;
2207	2406	}
2208		- case 18446744073709551512LLU: // 999999998X'''''''''''''''
	2407	+ case 18446744073709551494LLU: // 999999998F'''''''''''''''
2209	2408	{
2210	2409	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 5
2211	2410	// variable u64 tmp_______ goes out of scope

		@@ -2216,18 +2415,18 @@
2216	2415	heap.availilable_size_for_dynamic_objects += 0LLU;
2217	2416	heap.availilable_size_for_dynamic_objects += 0LLU;
2218	2417
2219		- state.addr = 18446744073709551511LLU; // 999999998W'''''''''''''''
	2418	+ state.addr = 18446744073709551493LLU; // 999999998E'''''''''''''''
2220	2419
2221	2420	break;
2222	2421	}
2223		- case 18446744073709551513LLU: // 999999998Y'''''''''''''''
	2422	+ case 18446744073709551495LLU: // 999999998G'''''''''''''''
2224	2423	{
2225	2424
2226		- state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551510LLU : 18446744073709551509LLU;
	2425	+ state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551492LLU : 18446744073709551491LLU;
2227	2426
2228	2427	break;
2229	2428	}
2230		- case 18446744073709551510LLU: // 999999998V'''''''''''''''
	2429	+ case 18446744073709551492LLU: // 999999998D'''''''''''''''
2231	2430	{
2232	2431	{
2233	2432	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -2256,7 +2455,7 @@
2256	2455	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
2257	2456	}
2258	2457	// 1LLU
2259		- uint64_t return_to = 18446744073709551508LLU;
	2458	+ uint64_t return_to = 18446744073709551490LLU;
2260	2459	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
2261	2460	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
2262	2461	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -2266,7 +2465,7 @@
2266	2465
2267	2466	break;
2268	2467	}
2269		- case 18446744073709551508LLU: // 999999998T'''''''''''''''
	2468	+ case 18446744073709551490LLU: // 999999998B'''''''''''''''
2270	2469	{
2271	2470	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 5
2272	2471	// variable u64 tmp_______ goes out of scope

		@@ -2277,30 +2476,30 @@
2277	2476	heap.availilable_size_for_dynamic_objects += 0LLU;
2278	2477	heap.availilable_size_for_dynamic_objects += 0LLU;
2279	2478
2280		- state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
	2479	+ state.addr = 18446744073709551489LLU; // 999999998A'''''''''''''''
2281	2480
2282	2481	break;
2283	2482	}
2284		- case 18446744073709551509LLU: // 999999998U'''''''''''''''
	2483	+ case 18446744073709551491LLU: // 999999998C'''''''''''''''
2285	2484	{
2286	2485	fprintf(stderr, "%s", "typecopy: missing case");
2287		- state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
	2486	+ state.addr = 18446744073709551489LLU; // 999999998A'''''''''''''''
2288	2487
2289	2488	break;
2290	2489	}
2291		- case 18446744073709551507LLU: // 999999998S'''''''''''''''
	2490	+ case 18446744073709551489LLU: // 999999998A'''''''''''''''
2292	2491	{
2293		- state.addr = 18446744073709551511LLU; // 999999998W'''''''''''''''
	2492	+ state.addr = 18446744073709551493LLU; // 999999998E'''''''''''''''
2294	2493
2295	2494	break;
2296	2495	}
2297		- case 18446744073709551511LLU: // 999999998W'''''''''''''''
	2496	+ case 18446744073709551493LLU: // 999999998E'''''''''''''''
2298	2497	{
2299		- state.addr = 18446744073709551515LLU; // 999999998$'''''''''''''''
	2498	+ state.addr = 18446744073709551497LLU; // 999999998I'''''''''''''''
2300	2499
2301	2500	break;
2302	2501	}
2303		- case 18446744073709551515LLU: // 999999998$'''''''''''''''
	2502	+ case 18446744073709551497LLU: // 999999998I'''''''''''''''
2304	2503	{
2305	2504	// parameter-reference type______ src_______ goes out of scope
2306	2505	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference src_______ at 2

		@@ -2337,7 +2536,7 @@
2337	2536	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
2338	2537	}
2339	2538	// 2LLU
2340		- uint64_t return_to = 18446744073709551505LLU;
	2539	+ uint64_t return_to = 18446744073709551487LLU;
2341	2540	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
2342	2541	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
2343	2542	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -2347,13 +2546,13 @@
2347	2546
2348	2547	break;
2349	2548	}
2350		- case 18446744073709551505LLU: // 999999998Q'''''''''''''''
	2549	+ case 18446744073709551487LLU: // 9999999979'''''''''''''''
2351	2550	{
2352		- state.addr = 18446744073709551506LLU; // 999999998R'''''''''''''''
	2551	+ state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
2353	2552
2354	2553	break;
2355	2554	}
2356		- case 18446744073709551506LLU: // 999999998R'''''''''''''''
	2555	+ case 18446744073709551488LLU: // 999999998_'''''''''''''''
2357	2556	{
2358	2557	swap(&/dst_______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)), &/tmp_______/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU));
2359	2558	// variable type______ tmp_______ goes out of scope

		@@ -2376,11 +2575,11 @@
2376	2575	case 819847183518878432LLU: // reporttype
2377	2576	{
2378	2577
2379		- state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551504LLU : 18446744073709551503LLU;
	2578	+ state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551486LLU : 18446744073709551485LLU;
2380	2579
2381	2580	break;
2382	2581	}
2383		- case 18446744073709551504LLU: // 999999998P'''''''''''''''
	2582	+ case 18446744073709551486LLU: // 9999999978'''''''''''''''
2384	2583	{
2385	2584	{
2386	2585	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem1;

		@@ -2392,18 +2591,18 @@
2392	2591	heap.availilable_size_for_dynamic_objects += 0LLU;
2393	2592	heap.availilable_size_for_dynamic_objects += 0LLU;
2394	2593
2395		- state.addr = 18446744073709551502LLU; // 999999998N'''''''''''''''
	2594	+ state.addr = 18446744073709551484LLU; // 9999999976'''''''''''''''
2396	2595
2397	2596	break;
2398	2597	}
2399		- case 18446744073709551503LLU: // 999999998O'''''''''''''''
	2598	+ case 18446744073709551485LLU: // 9999999977'''''''''''''''
2400	2599	{
2401	2600
2402		- state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551501LLU : 18446744073709551500LLU;
	2601	+ state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551483LLU : 18446744073709551482LLU;
2403	2602
2404	2603	break;
2405	2604	}
2406		- case 18446744073709551501LLU: // 999999998M'''''''''''''''
	2605	+ case 18446744073709551483LLU: // 9999999975'''''''''''''''
2407	2606	{
2408	2607	{
2409	2608	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem1;

		@@ -2416,18 +2615,18 @@
2416	2615	heap.availilable_size_for_dynamic_objects += 0LLU;
2417	2616	heap.availilable_size_for_dynamic_objects += 0LLU;
2418	2617
2419		- state.addr = 18446744073709551499LLU; // 999999998K'''''''''''''''
	2618	+ state.addr = 18446744073709551481LLU; // 9999999973'''''''''''''''
2420	2619
2421	2620	break;
2422	2621	}
2423		- case 18446744073709551500LLU: // 999999998L'''''''''''''''
	2622	+ case 18446744073709551482LLU: // 9999999974'''''''''''''''
2424	2623	{
2425	2624
2426		- state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551498LLU : 18446744073709551497LLU;
	2625	+ state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551480LLU : 18446744073709551479LLU;
2427	2626
2428	2627	break;
2429	2628	}
2430		- case 18446744073709551498LLU: // 999999998J'''''''''''''''
	2629	+ case 18446744073709551480LLU: // 9999999972'''''''''''''''
2431	2630	{
2432	2631	{
2433	2632	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem1;

		@@ -2434,21 +2633,21 @@
2434	2633	LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
2435	2634	}
2436	2635
2437		- state.addr = /type______/*access_heap(heap.data, tree_elem_addr(heap.data, 1LLU, LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU), 0LLU)) ? 18446744073709551496LLU : 18446744073709551495LLU;
	2636	+ state.addr = /type______/*access_heap(heap.data, tree_elem_addr(heap.data, 1LLU, LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU), 0LLU)) ? 18446744073709551478LLU : 18446744073709551477LLU;
2438	2637
2439	2638	break;
2440	2639	}
2441		- case 18446744073709551496LLU: // 999999998H'''''''''''''''
	2640	+ case 18446744073709551478LLU: // 9999999970'''''''''''''''
2442	2641	{
2443	2642	fprintf(stderr, "%s", "list<");
2444	2643
2445	2644	printid(stderr, /type______/*access_heap(heap.data, tree_elem_addr(heap.data, 1LLU, LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU), 0LLU)));
2446	2645	fprintf(stderr, "%s", ">");
2447		- state.addr = 18446744073709551495LLU; // 999999998G'''''''''''''''
	2646	+ state.addr = 18446744073709551477LLU; // 999999997z'''''''''''''''
2448	2647
2449	2648	break;
2450	2649	}
2451		- case 18446744073709551495LLU: // 999999998G'''''''''''''''
	2650	+ case 18446744073709551477LLU: // 999999997z'''''''''''''''
2452	2651	{
2453	2652	// parameter typelist__ type______ goes out of scope
2454	2653	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 2

		@@ -2455,30 +2654,30 @@
2455	2654	heap.availilable_size_for_dynamic_objects += 0LLU;
2456	2655	heap.availilable_size_for_dynamic_objects += 0LLU;
2457	2656
2458		- state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
	2657	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
2459	2658
2460	2659	break;
2461	2660	}
2462		- case 18446744073709551497LLU: // 999999998I'''''''''''''''
	2661	+ case 18446744073709551479LLU: // 9999999971'''''''''''''''
2463	2662	{
2464	2663	fprintf(stderr, "%s", "printtype: missing case");
2465		- state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
	2664	+ state.addr = 18446744073709551476LLU; // 999999997y'''''''''''''''
2466	2665
2467	2666	break;
2468	2667	}
2469		- case 18446744073709551494LLU: // 999999998F'''''''''''''''
	2668	+ case 18446744073709551476LLU: // 999999997y'''''''''''''''
2470	2669	{
2471		- state.addr = 18446744073709551499LLU; // 999999998K'''''''''''''''
	2670	+ state.addr = 18446744073709551481LLU; // 9999999973'''''''''''''''
2472	2671
2473	2672	break;
2474	2673	}
2475		- case 18446744073709551499LLU: // 999999998K'''''''''''''''
	2674	+ case 18446744073709551481LLU: // 9999999973'''''''''''''''
2476	2675	{
2477		- state.addr = 18446744073709551502LLU; // 999999998N'''''''''''''''
	2676	+ state.addr = 18446744073709551484LLU; // 9999999976'''''''''''''''
2478	2677
2479	2678	break;
2480	2679	}
2481		- case 18446744073709551502LLU: // 999999998N'''''''''''''''
	2680	+ case 18446744073709551484LLU: // 9999999976'''''''''''''''
2482	2681	{
2483	2682	// parameter-reference type______ type______ goes out of scope
2484	2683	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 1

		@@ -2495,11 +2694,11 @@
2495	2694	case 787446708300855296LLU: // printtype_
2496	2695	{
2497	2696
2498		- state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551493LLU : 18446744073709551492LLU;
	2697	+ state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551475LLU : 18446744073709551474LLU;
2499	2698
2500	2699	break;
2501	2700	}
2502		- case 18446744073709551493LLU: // 999999998E'''''''''''''''
	2701	+ case 18446744073709551475LLU: // 999999997x'''''''''''''''
2503	2702	{
2504	2703	{
2505	2704	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem1;

		@@ -2511,18 +2710,18 @@
2511	2710	heap.availilable_size_for_dynamic_objects += 0LLU;
2512	2711	heap.availilable_size_for_dynamic_objects += 0LLU;
2513	2712
2514		- state.addr = 18446744073709551491LLU; // 999999998C'''''''''''''''
	2713	+ state.addr = 18446744073709551473LLU; // 999999997v'''''''''''''''
2515	2714
2516	2715	break;
2517	2716	}
2518		- case 18446744073709551492LLU: // 999999998D'''''''''''''''
	2717	+ case 18446744073709551474LLU: // 999999997w'''''''''''''''
2519	2718	{
2520	2719
2521		- state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551490LLU : 18446744073709551489LLU;
	2720	+ state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551472LLU : 18446744073709551471LLU;
2522	2721
2523	2722	break;
2524	2723	}
2525		- case 18446744073709551490LLU: // 999999998B'''''''''''''''
	2724	+ case 18446744073709551472LLU: // 999999997u'''''''''''''''
2526	2725	{
2527	2726	{
2528	2727	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem1;

		@@ -2535,18 +2734,18 @@
2535	2734	heap.availilable_size_for_dynamic_objects += 0LLU;
2536	2735	heap.availilable_size_for_dynamic_objects += 0LLU;
2537	2736
2538		- state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
	2737	+ state.addr = 18446744073709551470LLU; // 999999997s'''''''''''''''
2539	2738
2540	2739	break;
2541	2740	}
2542		- case 18446744073709551489LLU: // 999999998A'''''''''''''''
	2741	+ case 18446744073709551471LLU: // 999999997t'''''''''''''''
2543	2742	{
2544	2743
2545		- state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551487LLU : 18446744073709551486LLU;
	2744	+ state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551469LLU : 18446744073709551468LLU;
2546	2745
2547	2746	break;
2548	2747	}
2549		- case 18446744073709551487LLU: // 9999999979'''''''''''''''
	2748	+ case 18446744073709551469LLU: // 999999997r'''''''''''''''
2550	2749	{
2551	2750	{
2552	2751	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem1;

		@@ -2553,21 +2752,21 @@
2553	2752	LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
2554	2753	}
2555	2754
2556		- state.addr = /type______/*access_heap(heap.data, tree_elem_addr(heap.data, 1LLU, LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU), 0LLU)) ? 18446744073709551485LLU : 18446744073709551484LLU;
	2755	+ state.addr = /type______/*access_heap(heap.data, tree_elem_addr(heap.data, 1LLU, LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU), 0LLU)) ? 18446744073709551467LLU : 18446744073709551466LLU;
2557	2756
2558	2757	break;
2559	2758	}
2560		- case 18446744073709551485LLU: // 9999999977'''''''''''''''
	2759	+ case 18446744073709551467LLU: // 999999997p'''''''''''''''
2561	2760	{
2562	2761	fprintf(stdout, "%s", "list<");
2563	2762
2564	2763	printid(stdout, /type______/*access_heap(heap.data, tree_elem_addr(heap.data, 1LLU, LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU), 0LLU)));
2565	2764	fprintf(stdout, "%s", ">");
2566		- state.addr = 18446744073709551484LLU; // 9999999976'''''''''''''''
	2765	+ state.addr = 18446744073709551466LLU; // 999999997o'''''''''''''''
2567	2766
2568	2767	break;
2569	2768	}
2570		- case 18446744073709551484LLU: // 9999999976'''''''''''''''
	2769	+ case 18446744073709551466LLU: // 999999997o'''''''''''''''
2571	2770	{
2572	2771	// parameter typelist__ type______ goes out of scope
2573	2772	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 2

		@@ -2574,30 +2773,30 @@
2574	2773	heap.availilable_size_for_dynamic_objects += 0LLU;
2575	2774	heap.availilable_size_for_dynamic_objects += 0LLU;
2576	2775
2577		- state.addr = 18446744073709551483LLU; // 9999999975'''''''''''''''
	2776	+ state.addr = 18446744073709551465LLU; // 999999997n'''''''''''''''
2578	2777
2579	2778	break;
2580	2779	}
2581		- case 18446744073709551486LLU: // 9999999978'''''''''''''''
	2780	+ case 18446744073709551468LLU: // 999999997q'''''''''''''''
2582	2781	{
2583	2782	fprintf(stderr, "%s", "printtype: missing case");
2584		- state.addr = 18446744073709551483LLU; // 9999999975'''''''''''''''
	2783	+ state.addr = 18446744073709551465LLU; // 999999997n'''''''''''''''
2585	2784
2586	2785	break;
2587	2786	}
2588		- case 18446744073709551483LLU: // 9999999975'''''''''''''''
	2787	+ case 18446744073709551465LLU: // 999999997n'''''''''''''''
2589	2788	{
2590		- state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
	2789	+ state.addr = 18446744073709551470LLU; // 999999997s'''''''''''''''
2591	2790
2592	2791	break;
2593	2792	}
2594		- case 18446744073709551488LLU: // 999999998_'''''''''''''''
	2793	+ case 18446744073709551470LLU: // 999999997s'''''''''''''''
2595	2794	{
2596		- state.addr = 18446744073709551491LLU; // 999999998C'''''''''''''''
	2795	+ state.addr = 18446744073709551473LLU; // 999999997v'''''''''''''''
2597	2796
2598	2797	break;
2599	2798	}
2600		- case 18446744073709551491LLU: // 999999998C'''''''''''''''
	2799	+ case 18446744073709551473LLU: // 999999997v'''''''''''''''
2601	2800	{
2602	2801	// parameter-reference type______ type______ goes out of scope
2603	2802	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 1

		@@ -2631,7 +2830,7 @@
2631	2830	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
2632	2831	}
2633	2832	// 1LLU
2634		- uint64_t return_to = 18446744073709551482LLU;
	2833	+ uint64_t return_to = 18446744073709551464LLU;
2635	2834	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
2636	2835	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
2637	2836	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -2641,7 +2840,7 @@
2641	2840
2642	2841	break;
2643	2842	}
2644		- case 18446744073709551482LLU: // 9999999974'''''''''''''''
	2843	+ case 18446744073709551464LLU: // 999999997m'''''''''''''''
2645	2844	{
2646	2845
2647	2846	// RELEASE temporary destructor-variable

		@@ -2657,6 +2856,88 @@
2657	2856
2658	2857	break;
2659	2858	}
	2859	+ case 589059885019168768LLU: // equres____
	2860	+ {
	2861	+ {
	2862	+ uint64_t mainresult = heap.data[0].elem0;
	2863	+ heap.data[0].elem0 = 0;
	2864	+ {
	2865	+ uint64_t arg = /equal_____/*LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
	2866	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	2867	+ }
	2868	+ {
	2869	+ uint64_t arg = /x_________/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 0LLU);
	2870	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	2871	+ }
	2872	+ {
	2873	+ uint64_t arg = /y_________/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
	2874	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	2875	+ }
	2876	+ // 3LLU
	2877	+ uint64_t return_to = 18446744073709551462LLU;
	2878	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	2879	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	2880	+ heap.data[0].elem1 = heap.data[0].elem0;
	2881	+ heap.data[0].elem0 = mainresult;
	2882	+ }
	2883	+ state.addr = 589060043891015680LLU; // equtype___
	2884	+
	2885	+ break;
	2886	+ }
	2887	+ case 18446744073709551462LLU: // 999999997k'''''''''''''''
	2888	+ {
	2889	+ state.addr = 18446744073709551463LLU; // 999999997l'''''''''''''''
	2890	+
	2891	+ break;
	2892	+ }
	2893	+ case 18446744073709551463LLU: // 999999997l'''''''''''''''
	2894	+ {
	2895	+
	2896	+ state.addr = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551461LLU : 18446744073709551460LLU;
	2897	+
	2898	+ break;
	2899	+ }
	2900	+ case 18446744073709551461LLU: // 999999997j'''''''''''''''
	2901	+ {
	2902	+
	2903	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU));
	2904	+
	2905	+ state.addr = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551459LLU : 18446744073709551458LLU;
	2906	+
	2907	+ break;
	2908	+ }
	2909	+ case 18446744073709551459LLU: // 999999997h'''''''''''''''
	2910	+ {
	2911	+
	2912	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 2LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 2LLU));
	2913	+ state.addr = 18446744073709551458LLU; // 999999997g'''''''''''''''
	2914	+
	2915	+ break;
	2916	+ }
	2917	+ case 18446744073709551458LLU: // 999999997g'''''''''''''''
	2918	+ {
	2919	+ state.addr = 18446744073709551460LLU; // 999999997i'''''''''''''''
	2920	+
	2921	+ break;
	2922	+ }
	2923	+ case 18446744073709551460LLU: // 999999997i'''''''''''''''
	2924	+ {
	2925	+ // parameter-reference resdest___ y_________ goes out of scope
	2926	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 3
	2927	+ // parameter-reference resdest___ x_________ goes out of scope
	2928	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 2
	2929	+ // parameter-reference u64 equal_____ goes out of scope
	2930	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference equal_____ at 1
	2931	+
	2932	+ {
	2933	+ uint64_t baseinfo = heap.data[0].elem1;
	2934	+ struct pair pair = unpair(&heap, &baseinfo);
	2935	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	2936	+ state.addr = pair.elem1;
	2937	+ }
	2938	+
	2939	+ break;
	2940	+ }
2660	2941	case 325737967258195136LLU: // REPORTRES_
2661	2942	{
2662	2943	{

		@@ -2667,7 +2948,7 @@
2667	2948	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
2668	2949	}
2669	2950	// 1LLU
2670		- uint64_t return_to = 18446744073709551480LLU;
	2951	+ uint64_t return_to = 18446744073709551456LLU;
2671	2952	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
2672	2953	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
2673	2954	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -2677,13 +2958,13 @@
2677	2958
2678	2959	break;
2679	2960	}
2680		- case 18446744073709551480LLU: // 9999999972'''''''''''''''
	2961	+ case 18446744073709551456LLU: // 999999997e'''''''''''''''
2681	2962	{
2682		- state.addr = 18446744073709551481LLU; // 9999999973'''''''''''''''
	2963	+ state.addr = 18446744073709551457LLU; // 999999997f'''''''''''''''
2683	2964
2684	2965	break;
2685	2966	}
2686		- case 18446744073709551481LLU: // 9999999973'''''''''''''''
	2967	+ case 18446744073709551457LLU: // 999999997f'''''''''''''''
2687	2968	{
2688	2969	fprintf(stderr, "%s", " ");
2689	2970	fprintf(stderr, "%s", "(");

		@@ -2716,11 +2997,11 @@
2716	2997	uint64_t arg = 0;
2717	2998	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
2718	2999	}
2719		- state.addr = 18446744073709551479LLU; // 9999999971'''''''''''''''
	3000	+ state.addr = 18446744073709551455LLU; // 999999997d'''''''''''''''
2720	3001
2721	3002	break;
2722	3003	}
2723		- case 18446744073709551479LLU: // 9999999971'''''''''''''''
	3004	+ case 18446744073709551455LLU: // 999999997d'''''''''''''''
2724	3005	{
2725	3006	if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
2726	3007	{

		@@ -2727,7 +3008,7 @@
2727	3008	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
2728	3009	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
2729	3010	{
2730		- state.addr = 18446744073709551478LLU; // 9999999970'''''''''''''''
	3011	+ state.addr = 18446744073709551454LLU; // 999999997c'''''''''''''''
2731	3012
2732	3013	break;
2733	3014	}

		@@ -2735,28 +3016,28 @@
2735	3016	/direct/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
2736	3017	LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
2737	3018
2738		- state.addr = /first_____/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU) ? 18446744073709551477LLU : 18446744073709551476LLU;
	3019	+ state.addr = /first_____/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU) ? 18446744073709551453LLU : 18446744073709551452LLU;
2739	3020
2740	3021	break;
2741	3022	}
2742		- case 18446744073709551477LLU: // 999999997z'''''''''''''''
	3023	+ case 18446744073709551453LLU: // 999999997b'''''''''''''''
2743	3024	{
2744	3025	/first_____/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU) = 0LLU;
2745	3026	heap.availilable_size_for_dynamic_objects += 0LLU;
2746	3027	heap.availilable_size_for_dynamic_objects += 0LLU;
2747	3028
2748		- state.addr = 18446744073709551475LLU; // 999999997x'''''''''''''''
	3029	+ state.addr = 18446744073709551451LLU; // 999999997$'''''''''''''''
2749	3030
2750	3031	break;
2751	3032	}
2752		- case 18446744073709551476LLU: // 999999997y'''''''''''''''
	3033	+ case 18446744073709551452LLU: // 999999997a'''''''''''''''
2753	3034	{
2754	3035	fprintf(stderr, "%s", ", ");
2755		- state.addr = 18446744073709551475LLU; // 999999997x'''''''''''''''
	3036	+ state.addr = 18446744073709551451LLU; // 999999997$'''''''''''''''
2756	3037
2757	3038	break;
2758	3039	}
2759		- case 18446744073709551475LLU: // 999999997x'''''''''''''''
	3040	+ case 18446744073709551451LLU: // 999999997$'''''''''''''''
2760	3041	{
2761	3042	{
2762	3043	uint64_t mainresult = heap.data[0].elem0;

		@@ -2766,7 +3047,7 @@
2766	3047	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
2767	3048	}
2768	3049	// 1LLU
2769		- uint64_t return_to = 18446744073709551473LLU;
	3050	+ uint64_t return_to = 18446744073709551449LLU;
2770	3051	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
2771	3052	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
2772	3053	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -2776,21 +3057,21 @@
2776	3057
2777	3058	break;
2778	3059	}
2779		- case 18446744073709551473LLU: // 999999997v'''''''''''''''
	3060	+ case 18446744073709551449LLU: // 999999997Y'''''''''''''''
2780	3061	{
2781		- state.addr = 18446744073709551474LLU; // 999999997w'''''''''''''''
	3062	+ state.addr = 18446744073709551450LLU; // 999999997Z'''''''''''''''
2782	3063
2783	3064	break;
2784	3065	}
2785		- case 18446744073709551474LLU: // 999999997w'''''''''''''''
	3066	+ case 18446744073709551450LLU: // 999999997Z'''''''''''''''
2786	3067	{
2787	3068	// parameter-reference resdest___ r_________ goes out of scope
2788	3069	// parameter-reference list<resdest___> rs________ goes out of scope
2789		- state.addr = 18446744073709551479LLU; // 9999999971'''''''''''''''
	3070	+ state.addr = 18446744073709551455LLU; // 999999997d'''''''''''''''
2790	3071
2791	3072	break;
2792	3073	}
2793		- case 18446744073709551478LLU: // 9999999970'''''''''''''''
	3074	+ case 18446744073709551454LLU: // 999999997c'''''''''''''''
2794	3075	{
2795	3076	fprintf(stderr, "%s", ")");
2796	3077	// variable u64 first_____ goes out of scope

		@@ -2926,11 +3207,11 @@
2926	3207	case 819847183514106240LLU: // reportblk_
2927	3208	{
2928	3209
2929		- state.addr = 533565069926072320LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551472LLU : 18446744073709551471LLU;
	3210	+ state.addr = 533565069926072320LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551448LLU : 18446744073709551447LLU;
2930	3211
2931	3212	break;
2932	3213	}
2933		- case 18446744073709551472LLU: // 999999997u'''''''''''''''
	3214	+ case 18446744073709551448LLU: // 999999997X'''''''''''''''
2934	3215	{
2935	3216	{
2936	3217	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -2942,18 +3223,18 @@
2942	3223	heap.availilable_size_for_dynamic_objects += 0LLU;
2943	3224	heap.availilable_size_for_dynamic_objects += 0LLU;
2944	3225
2945		- state.addr = 18446744073709551470LLU; // 999999997s'''''''''''''''
	3226	+ state.addr = 18446744073709551446LLU; // 999999997V'''''''''''''''
2946	3227
2947	3228	break;
2948	3229	}
2949		- case 18446744073709551471LLU: // 999999997t'''''''''''''''
	3230	+ case 18446744073709551447LLU: // 999999997W'''''''''''''''
2950	3231	{
2951	3232
2952		- state.addr = 533565680736534528LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551469LLU : 18446744073709551468LLU;
	3233	+ state.addr = 533565680736534528LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551445LLU : 18446744073709551444LLU;
2953	3234
2954	3235	break;
2955	3236	}
2956		- case 18446744073709551469LLU: // 999999997r'''''''''''''''
	3237	+ case 18446744073709551445LLU: // 999999997U'''''''''''''''
2957	3238	{
2958	3239	{
2959	3240	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -2965,18 +3246,18 @@
2965	3246	heap.availilable_size_for_dynamic_objects += 0LLU;
2966	3247	heap.availilable_size_for_dynamic_objects += 0LLU;
2967	3248
2968		- state.addr = 18446744073709551467LLU; // 999999997p'''''''''''''''
	3249	+ state.addr = 18446744073709551443LLU; // 999999997S'''''''''''''''
2969	3250
2970	3251	break;
2971	3252	}
2972		- case 18446744073709551468LLU: // 999999997q'''''''''''''''
	3253	+ case 18446744073709551444LLU: // 999999997T'''''''''''''''
2973	3254	{
2974	3255
2975		- state.addr = 533564715968757760LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551466LLU : 18446744073709551465LLU;
	3256	+ state.addr = 533564715968757760LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551442LLU : 18446744073709551441LLU;
2976	3257
2977	3258	break;
2978	3259	}
2979		- case 18446744073709551466LLU: // 999999997o'''''''''''''''
	3260	+ case 18446744073709551442LLU: // 999999997R'''''''''''''''
2980	3261	{
2981	3262	{
2982	3263	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -2988,18 +3269,18 @@
2988	3269	heap.availilable_size_for_dynamic_objects += 0LLU;
2989	3270	heap.availilable_size_for_dynamic_objects += 0LLU;
2990	3271
2991		- state.addr = 18446744073709551464LLU; // 999999997m'''''''''''''''
	3272	+ state.addr = 18446744073709551440LLU; // 999999997P'''''''''''''''
2992	3273
2993	3274	break;
2994	3275	}
2995		- case 18446744073709551465LLU: // 999999997n'''''''''''''''
	3276	+ case 18446744073709551441LLU: // 999999997Q'''''''''''''''
2996	3277	{
2997	3278
2998		- state.addr = 533564448313442304LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551463LLU : 18446744073709551462LLU;
	3279	+ state.addr = 533564448313442304LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551439LLU : 18446744073709551438LLU;
2999	3280
3000	3281	break;
3001	3282	}
3002		- case 18446744073709551463LLU: // 999999997l'''''''''''''''
	3283	+ case 18446744073709551439LLU: // 999999997O'''''''''''''''
3003	3284	{
3004	3285	{
3005	3286	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -3011,18 +3292,18 @@
3011	3292	heap.availilable_size_for_dynamic_objects += 0LLU;
3012	3293	heap.availilable_size_for_dynamic_objects += 0LLU;
3013	3294
3014		- state.addr = 18446744073709551461LLU; // 999999997j'''''''''''''''
	3295	+ state.addr = 18446744073709551437LLU; // 999999997M'''''''''''''''
3015	3296
3016	3297	break;
3017	3298	}
3018		- case 18446744073709551462LLU: // 999999997k'''''''''''''''
	3299	+ case 18446744073709551438LLU: // 999999997N'''''''''''''''
3019	3300	{
3020	3301
3021		- state.addr = 533564932506779648LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551460LLU : 18446744073709551459LLU;
	3302	+ state.addr = 533564932506779648LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551436LLU : 18446744073709551435LLU;
3022	3303
3023	3304	break;
3024	3305	}
3025		- case 18446744073709551460LLU: // 999999997i'''''''''''''''
	3306	+ case 18446744073709551436LLU: // 999999997L'''''''''''''''
3026	3307	{
3027	3308	{
3028	3309	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -3034,42 +3315,42 @@
3034	3315	heap.availilable_size_for_dynamic_objects += 0LLU;
3035	3316	heap.availilable_size_for_dynamic_objects += 0LLU;
3036	3317
3037		- state.addr = 18446744073709551458LLU; // 999999997g'''''''''''''''
	3318	+ state.addr = 18446744073709551434LLU; // 999999997J'''''''''''''''
3038	3319
3039	3320	break;
3040	3321	}
3041		- case 18446744073709551459LLU: // 999999997h'''''''''''''''
	3322	+ case 18446744073709551435LLU: // 999999997K'''''''''''''''
3042	3323	{
3043	3324	fprintf(stderr, "%s", "blk UNKNOWN");
3044		- state.addr = 18446744073709551458LLU; // 999999997g'''''''''''''''
	3325	+ state.addr = 18446744073709551434LLU; // 999999997J'''''''''''''''
3045	3326
3046	3327	break;
3047	3328	}
3048		- case 18446744073709551458LLU: // 999999997g'''''''''''''''
	3329	+ case 18446744073709551434LLU: // 999999997J'''''''''''''''
3049	3330	{
3050		- state.addr = 18446744073709551461LLU; // 999999997j'''''''''''''''
	3331	+ state.addr = 18446744073709551437LLU; // 999999997M'''''''''''''''
3051	3332
3052	3333	break;
3053	3334	}
3054		- case 18446744073709551461LLU: // 999999997j'''''''''''''''
	3335	+ case 18446744073709551437LLU: // 999999997M'''''''''''''''
3055	3336	{
3056		- state.addr = 18446744073709551464LLU; // 999999997m'''''''''''''''
	3337	+ state.addr = 18446744073709551440LLU; // 999999997P'''''''''''''''
3057	3338
3058	3339	break;
3059	3340	}
3060		- case 18446744073709551464LLU: // 999999997m'''''''''''''''
	3341	+ case 18446744073709551440LLU: // 999999997P'''''''''''''''
3061	3342	{
3062		- state.addr = 18446744073709551467LLU; // 999999997p'''''''''''''''
	3343	+ state.addr = 18446744073709551443LLU; // 999999997S'''''''''''''''
3063	3344
3064	3345	break;
3065	3346	}
3066		- case 18446744073709551467LLU: // 999999997p'''''''''''''''
	3347	+ case 18446744073709551443LLU: // 999999997S'''''''''''''''
3067	3348	{
3068		- state.addr = 18446744073709551470LLU; // 999999997s'''''''''''''''
	3349	+ state.addr = 18446744073709551446LLU; // 999999997V'''''''''''''''
3069	3350
3070	3351	break;
3071	3352	}
3072		- case 18446744073709551470LLU: // 999999997s'''''''''''''''
	3353	+ case 18446744073709551446LLU: // 999999997V'''''''''''''''
3073	3354	{
3074	3355	// parameter blockvar__ kind______ goes out of scope
3075	3356	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference kind______ at 1

		@@ -3103,7 +3384,7 @@
3103	3384	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3104	3385	}
3105	3386	// 1LLU
3106		- uint64_t return_to = 18446744073709551457LLU;
	3387	+ uint64_t return_to = 18446744073709551433LLU;
3107	3388	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3108	3389	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
3109	3390	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -3113,7 +3394,7 @@
3113	3394
3114	3395	break;
3115	3396	}
3116		- case 18446744073709551457LLU: // 999999997f'''''''''''''''
	3397	+ case 18446744073709551433LLU: // 999999997I'''''''''''''''
3117	3398	{
3118	3399	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
3119	3400	// emitted destructur for type u64

		@@ -3155,7 +3436,7 @@
3155	3436	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3156	3437	}
3157	3438	// 1LLU
3158		- uint64_t return_to = 18446744073709551456LLU;
	3439	+ uint64_t return_to = 18446744073709551432LLU;
3159	3440	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3160	3441	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
3161	3442	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -3165,7 +3446,7 @@
3165	3446
3166	3447	break;
3167	3448	}
3168		- case 18446744073709551456LLU: // 999999997e'''''''''''''''
	3449	+ case 18446744073709551432LLU: // 999999997H'''''''''''''''
3169	3450	{
3170	3451	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
3171	3452	// emitted destructur for type u64

		@@ -3205,7 +3486,7 @@
3205	3486	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3206	3487	}
3207	3488	// 1LLU
3208		- uint64_t return_to = 18446744073709551455LLU;
	3489	+ uint64_t return_to = 18446744073709551431LLU;
3209	3490	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3210	3491	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
3211	3492	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -3215,7 +3496,7 @@
3215	3496
3216	3497	break;
3217	3498	}
3218		- case 18446744073709551455LLU: // 999999997d'''''''''''''''
	3499	+ case 18446744073709551431LLU: // 999999997G'''''''''''''''
3219	3500	{
3220	3501	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
3221	3502	// emitted destructur for type u64

		@@ -3309,11 +3590,11 @@
3309	3590	case 819847183519304512LLU: // reportvar_
3310	3591	{
3311	3592
3312		- state.addr = 890788136479621120LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551454LLU : 18446744073709551453LLU;
	3593	+ state.addr = 890788136479621120LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551430LLU : 18446744073709551429LLU;
3313	3594
3314	3595	break;
3315	3596	}
3316		- case 18446744073709551454LLU: // 999999997c'''''''''''''''
	3597	+ case 18446744073709551430LLU: // 999999997F'''''''''''''''
3317	3598	{
3318	3599	{
3319	3600	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -3325,18 +3606,18 @@
3325	3606	heap.availilable_size_for_dynamic_objects += 0LLU;
3326	3607	heap.availilable_size_for_dynamic_objects += 0LLU;
3327	3608
3328		- state.addr = 18446744073709551452LLU; // 999999997a'''''''''''''''
	3609	+ state.addr = 18446744073709551428LLU; // 999999997D'''''''''''''''
3329	3610
3330	3611	break;
3331	3612	}
3332		- case 18446744073709551453LLU: // 999999997b'''''''''''''''
	3613	+ case 18446744073709551429LLU: // 999999997E'''''''''''''''
3333	3614	{
3334	3615
3335		- state.addr = 890787865695354880LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551451LLU : 18446744073709551450LLU;
	3616	+ state.addr = 890787865695354880LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551427LLU : 18446744073709551426LLU;
3336	3617
3337	3618	break;
3338	3619	}
3339		- case 18446744073709551451LLU: // 999999997$'''''''''''''''
	3620	+ case 18446744073709551427LLU: // 999999997C'''''''''''''''
3340	3621	{
3341	3622	{
3342	3623	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -3348,18 +3629,18 @@
3348	3629	heap.availilable_size_for_dynamic_objects += 0LLU;
3349	3630	heap.availilable_size_for_dynamic_objects += 0LLU;
3350	3631
3351		- state.addr = 18446744073709551449LLU; // 999999997Y'''''''''''''''
	3632	+ state.addr = 18446744073709551425LLU; // 999999997A'''''''''''''''
3352	3633
3353	3634	break;
3354	3635	}
3355		- case 18446744073709551450LLU: // 999999997Z'''''''''''''''
	3636	+ case 18446744073709551426LLU: // 999999997B'''''''''''''''
3356	3637	{
3357	3638
3358		- state.addr = 890788145081876480LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551448LLU : 18446744073709551447LLU;
	3639	+ state.addr = 890788145081876480LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551424LLU : 18446744073709551423LLU;
3359	3640
3360	3641	break;
3361	3642	}
3362		- case 18446744073709551448LLU: // 999999997X'''''''''''''''
	3643	+ case 18446744073709551424LLU: // 999999997_'''''''''''''''
3363	3644	{
3364	3645	{
3365	3646	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -3371,18 +3652,18 @@
3371	3652	heap.availilable_size_for_dynamic_objects += 0LLU;
3372	3653	heap.availilable_size_for_dynamic_objects += 0LLU;
3373	3654
3374		- state.addr = 18446744073709551446LLU; // 999999997V'''''''''''''''
	3655	+ state.addr = 18446744073709551422LLU; // 9999999968'''''''''''''''
3375	3656
3376	3657	break;
3377	3658	}
3378		- case 18446744073709551447LLU: // 999999997W'''''''''''''''
	3659	+ case 18446744073709551423LLU: // 9999999969'''''''''''''''
3379	3660	{
3380	3661
3381		- state.addr = 890786773858934784LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551445LLU : 18446744073709551444LLU;
	3662	+ state.addr = 890786773858934784LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551421LLU : 18446744073709551420LLU;
3382	3663
3383	3664	break;
3384	3665	}
3385		- case 18446744073709551445LLU: // 999999997U'''''''''''''''
	3666	+ case 18446744073709551421LLU: // 9999999967'''''''''''''''
3386	3667	{
3387	3668	{
3388	3669	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -3394,18 +3675,18 @@
3394	3675	heap.availilable_size_for_dynamic_objects += 0LLU;
3395	3676	heap.availilable_size_for_dynamic_objects += 0LLU;
3396	3677
3397		- state.addr = 18446744073709551443LLU; // 999999997S'''''''''''''''
	3678	+ state.addr = 18446744073709551419LLU; // 9999999965'''''''''''''''
3398	3679
3399	3680	break;
3400	3681	}
3401		- case 18446744073709551444LLU: // 999999997T'''''''''''''''
	3682	+ case 18446744073709551420LLU: // 9999999966'''''''''''''''
3402	3683	{
3403	3684
3404		- state.addr = 587568545413988352LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551442LLU : 18446744073709551441LLU;
	3685	+ state.addr = 587568545413988352LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551418LLU : 18446744073709551417LLU;
3405	3686
3406	3687	break;
3407	3688	}
3408		- case 18446744073709551442LLU: // 999999997R'''''''''''''''
	3689	+ case 18446744073709551418LLU: // 9999999964'''''''''''''''
3409	3690	{
3410	3691	{
3411	3692	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -3417,18 +3698,18 @@
3417	3698	heap.availilable_size_for_dynamic_objects += 0LLU;
3418	3699	heap.availilable_size_for_dynamic_objects += 0LLU;
3419	3700
3420		- state.addr = 18446744073709551440LLU; // 999999997P'''''''''''''''
	3701	+ state.addr = 18446744073709551416LLU; // 9999999962'''''''''''''''
3421	3702
3422	3703	break;
3423	3704	}
3424		- case 18446744073709551441LLU: // 999999997Q'''''''''''''''
	3705	+ case 18446744073709551417LLU: // 9999999963'''''''''''''''
3425	3706	{
3426	3707
3427		- state.addr = 890787182770388992LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551439LLU : 18446744073709551438LLU;
	3708	+ state.addr = 890787182770388992LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551415LLU : 18446744073709551414LLU;
3428	3709
3429	3710	break;
3430	3711	}
3431		- case 18446744073709551439LLU: // 999999997O'''''''''''''''
	3712	+ case 18446744073709551415LLU: // 9999999961'''''''''''''''
3432	3713	{
3433	3714	{
3434	3715	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -3440,48 +3721,48 @@
3440	3721	heap.availilable_size_for_dynamic_objects += 0LLU;
3441	3722	heap.availilable_size_for_dynamic_objects += 0LLU;
3442	3723
3443		- state.addr = 18446744073709551437LLU; // 999999997M'''''''''''''''
	3724	+ state.addr = 18446744073709551413LLU; // 999999996z'''''''''''''''
3444	3725
3445	3726	break;
3446	3727	}
3447		- case 18446744073709551438LLU: // 999999997N'''''''''''''''
	3728	+ case 18446744073709551414LLU: // 9999999960'''''''''''''''
3448	3729	{
3449	3730	fprintf(stderr, "%s", "varkind UNKNOWN");
3450		- state.addr = 18446744073709551437LLU; // 999999997M'''''''''''''''
	3731	+ state.addr = 18446744073709551413LLU; // 999999996z'''''''''''''''
3451	3732
3452	3733	break;
3453	3734	}
3454		- case 18446744073709551437LLU: // 999999997M'''''''''''''''
	3735	+ case 18446744073709551413LLU: // 999999996z'''''''''''''''
3455	3736	{
3456		- state.addr = 18446744073709551440LLU; // 999999997P'''''''''''''''
	3737	+ state.addr = 18446744073709551416LLU; // 9999999962'''''''''''''''
3457	3738
3458	3739	break;
3459	3740	}
3460		- case 18446744073709551440LLU: // 999999997P'''''''''''''''
	3741	+ case 18446744073709551416LLU: // 9999999962'''''''''''''''
3461	3742	{
3462		- state.addr = 18446744073709551443LLU; // 999999997S'''''''''''''''
	3743	+ state.addr = 18446744073709551419LLU; // 9999999965'''''''''''''''
3463	3744
3464	3745	break;
3465	3746	}
3466		- case 18446744073709551443LLU: // 999999997S'''''''''''''''
	3747	+ case 18446744073709551419LLU: // 9999999965'''''''''''''''
3467	3748	{
3468		- state.addr = 18446744073709551446LLU; // 999999997V'''''''''''''''
	3749	+ state.addr = 18446744073709551422LLU; // 9999999968'''''''''''''''
3469	3750
3470	3751	break;
3471	3752	}
3472		- case 18446744073709551446LLU: // 999999997V'''''''''''''''
	3753	+ case 18446744073709551422LLU: // 9999999968'''''''''''''''
3473	3754	{
3474		- state.addr = 18446744073709551449LLU; // 999999997Y'''''''''''''''
	3755	+ state.addr = 18446744073709551425LLU; // 999999997A'''''''''''''''
3475	3756
3476	3757	break;
3477	3758	}
3478		- case 18446744073709551449LLU: // 999999997Y'''''''''''''''
	3759	+ case 18446744073709551425LLU: // 999999997A'''''''''''''''
3479	3760	{
3480		- state.addr = 18446744073709551452LLU; // 999999997a'''''''''''''''
	3761	+ state.addr = 18446744073709551428LLU; // 999999997D'''''''''''''''
3481	3762
3482	3763	break;
3483	3764	}
3484		- case 18446744073709551452LLU: // 999999997a'''''''''''''''
	3765	+ case 18446744073709551428LLU: // 999999997D'''''''''''''''
3485	3766	{
3486	3767	// parameter varkind___ kind______ goes out of scope
3487	3768	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference kind______ at 1

		@@ -3547,11 +3828,11 @@
3547	3828	case 819847183517731686LLU: // reportpark
3548	3829	{
3549	3830
3550		- state.addr = 782701745422729216LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551436LLU : 18446744073709551435LLU;
	3831	+ state.addr = 782701745422729216LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551412LLU : 18446744073709551411LLU;
3551	3832
3552	3833	break;
3553	3834	}
3554		- case 18446744073709551436LLU: // 999999997L'''''''''''''''
	3835	+ case 18446744073709551412LLU: // 999999996y'''''''''''''''
3555	3836	{
3556	3837	{
3557	3838	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -3563,18 +3844,18 @@
3563	3844	heap.availilable_size_for_dynamic_objects += 0LLU;
3564	3845	heap.availilable_size_for_dynamic_objects += 0LLU;
3565	3846
3566		- state.addr = 18446744073709551434LLU; // 999999997J'''''''''''''''
	3847	+ state.addr = 18446744073709551410LLU; // 999999996w'''''''''''''''
3567	3848
3568	3849	break;
3569	3850	}
3570		- case 18446744073709551435LLU: // 999999997K'''''''''''''''
	3851	+ case 18446744073709551411LLU: // 999999996x'''''''''''''''
3571	3852	{
3572	3853
3573		- state.addr = 782701474638462976LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551433LLU : 18446744073709551432LLU;
	3854	+ state.addr = 782701474638462976LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551409LLU : 18446744073709551408LLU;
3574	3855
3575	3856	break;
3576	3857	}
3577		- case 18446744073709551433LLU: // 999999997I'''''''''''''''
	3858	+ case 18446744073709551409LLU: // 999999996v'''''''''''''''
3578	3859	{
3579	3860	{
3580	3861	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -3586,24 +3867,24 @@
3586	3867	heap.availilable_size_for_dynamic_objects += 0LLU;
3587	3868	heap.availilable_size_for_dynamic_objects += 0LLU;
3588	3869
3589		- state.addr = 18446744073709551431LLU; // 999999997G'''''''''''''''
	3870	+ state.addr = 18446744073709551407LLU; // 999999996t'''''''''''''''
3590	3871
3591	3872	break;
3592	3873	}
3593		- case 18446744073709551432LLU: // 999999997H'''''''''''''''
	3874	+ case 18446744073709551408LLU: // 999999996u'''''''''''''''
3594	3875	{
3595	3876	fprintf(stderr, "%s", "parkind UNKNOWN");
3596		- state.addr = 18446744073709551431LLU; // 999999997G'''''''''''''''
	3877	+ state.addr = 18446744073709551407LLU; // 999999996t'''''''''''''''
3597	3878
3598	3879	break;
3599	3880	}
3600		- case 18446744073709551431LLU: // 999999997G'''''''''''''''
	3881	+ case 18446744073709551407LLU: // 999999996t'''''''''''''''
3601	3882	{
3602		- state.addr = 18446744073709551434LLU; // 999999997J'''''''''''''''
	3883	+ state.addr = 18446744073709551410LLU; // 999999996w'''''''''''''''
3603	3884
3604	3885	break;
3605	3886	}
3606		- case 18446744073709551434LLU: // 999999997J'''''''''''''''
	3887	+ case 18446744073709551410LLU: // 999999996w'''''''''''''''
3607	3888	{
3608	3889	// parameter parkind___ kind______ goes out of scope
3609	3890	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference kind______ at 1

		@@ -3686,14 +3967,211 @@
3686	3967	state.addr = type_data.elem0;
3687	3968	break;
3688	3969	}
	3970	+ case 589059476921895744LLU: // equlinear_
	3971	+ {
	3972	+
	3973	+ state.addr = 728618437845356544LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 ? 18446744073709551406LLU : 18446744073709551405LLU;
	3974	+
	3975	+ break;
	3976	+ }
	3977	+ case 18446744073709551406LLU: // 999999996s'''''''''''''''
	3978	+ {
	3979	+ {
	3980	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem1;
	3981	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	3982	+ }
	3983	+
	3984	+ state.addr = 728618437845356544LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 ? 18446744073709551404LLU : 18446744073709551403LLU;
	3985	+
	3986	+ break;
	3987	+ }
	3988	+ case 18446744073709551404LLU: // 999999996q'''''''''''''''
	3989	+ {
	3990	+ {
	3991	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem1;
	3992	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	3993	+ }
	3994	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
	3995	+ // parameter maintain__ y_________ goes out of scope
	3996	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 5
	3997	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	3998	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	3999	+
	4000	+ state.addr = 18446744073709551402LLU; // 999999996o'''''''''''''''
	4001	+
	4002	+ break;
	4003	+ }
	4004	+ case 18446744073709551403LLU: // 999999996p'''''''''''''''
	4005	+ {
	4006	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = 0LLU;
	4007	+ state.addr = 18446744073709551402LLU; // 999999996o'''''''''''''''
	4008	+
	4009	+ break;
	4010	+ }
	4011	+ case 18446744073709551402LLU: // 999999996o'''''''''''''''
	4012	+ {
	4013	+ // parameter maintain__ x_________ goes out of scope
	4014	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 4
	4015	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4016	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4017	+
	4018	+ state.addr = 18446744073709551401LLU; // 999999996n'''''''''''''''
	4019	+
	4020	+ break;
	4021	+ }
	4022	+ case 18446744073709551405LLU: // 999999996r'''''''''''''''
	4023	+ {
	4024	+
	4025	+ state.addr = 552437437528276992LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 ? 18446744073709551400LLU : 18446744073709551399LLU;
	4026	+
	4027	+ break;
	4028	+ }
	4029	+ case 18446744073709551400LLU: // 999999996m'''''''''''''''
	4030	+ {
	4031	+ {
	4032	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem1;
	4033	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	4034	+ }
	4035	+
	4036	+ state.addr = 552437437528276992LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 ? 18446744073709551398LLU : 18446744073709551397LLU;
	4037	+
	4038	+ break;
	4039	+ }
	4040	+ case 18446744073709551398LLU: // 999999996k'''''''''''''''
	4041	+ {
	4042	+ {
	4043	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem1;
	4044	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	4045	+ }
	4046	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
	4047	+ // parameter consume___ y_________ goes out of scope
	4048	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 5
	4049	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4050	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4051	+
	4052	+ state.addr = 18446744073709551396LLU; // 999999996i'''''''''''''''
	4053	+
	4054	+ break;
	4055	+ }
	4056	+ case 18446744073709551397LLU: // 999999996j'''''''''''''''
	4057	+ {
	4058	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = 0LLU;
	4059	+ state.addr = 18446744073709551396LLU; // 999999996i'''''''''''''''
	4060	+
	4061	+ break;
	4062	+ }
	4063	+ case 18446744073709551396LLU: // 999999996i'''''''''''''''
	4064	+ {
	4065	+ // parameter consume___ x_________ goes out of scope
	4066	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 4
	4067	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4068	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4069	+
	4070	+ state.addr = 18446744073709551395LLU; // 999999996h'''''''''''''''
	4071	+
	4072	+ break;
	4073	+ }
	4074	+ case 18446744073709551399LLU: // 999999996l'''''''''''''''
	4075	+ {
	4076	+
	4077	+ state.addr = 787472410168262656LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 ? 18446744073709551394LLU : 18446744073709551393LLU;
	4078	+
	4079	+ break;
	4080	+ }
	4081	+ case 18446744073709551394LLU: // 999999996g'''''''''''''''
	4082	+ {
	4083	+ {
	4084	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem1;
	4085	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	4086	+ }
	4087	+
	4088	+ state.addr = 787472410168262656LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 ? 18446744073709551392LLU : 18446744073709551391LLU;
	4089	+
	4090	+ break;
	4091	+ }
	4092	+ case 18446744073709551392LLU: // 999999996e'''''''''''''''
	4093	+ {
	4094	+ {
	4095	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem1;
	4096	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	4097	+ }
	4098	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
	4099	+ // parameter produce___ y_________ goes out of scope
	4100	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 5
	4101	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4102	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4103	+
	4104	+ state.addr = 18446744073709551390LLU; // 999999996c'''''''''''''''
	4105	+
	4106	+ break;
	4107	+ }
	4108	+ case 18446744073709551391LLU: // 999999996d'''''''''''''''
	4109	+ {
	4110	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = 0LLU;
	4111	+ state.addr = 18446744073709551390LLU; // 999999996c'''''''''''''''
	4112	+
	4113	+ break;
	4114	+ }
	4115	+ case 18446744073709551390LLU: // 999999996c'''''''''''''''
	4116	+ {
	4117	+ // parameter produce___ x_________ goes out of scope
	4118	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 4
	4119	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4120	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4121	+
	4122	+ state.addr = 18446744073709551389LLU; // 999999996b'''''''''''''''
	4123	+
	4124	+ break;
	4125	+ }
	4126	+ case 18446744073709551393LLU: // 999999996f'''''''''''''''
	4127	+ {
	4128	+
	4129	+ {
	4130	+ fprintf(stderr, "%s\n", "equlinear: missing case");
	4131	+ exit(-1);
	4132	+ }
	4133	+ state.addr = 18446744073709551389LLU; // 999999996b'''''''''''''''
	4134	+
	4135	+ break;
	4136	+ }
	4137	+ case 18446744073709551389LLU: // 999999996b'''''''''''''''
	4138	+ {
	4139	+ state.addr = 18446744073709551395LLU; // 999999996h'''''''''''''''
	4140	+
	4141	+ break;
	4142	+ }
	4143	+ case 18446744073709551395LLU: // 999999996h'''''''''''''''
	4144	+ {
	4145	+ state.addr = 18446744073709551401LLU; // 999999996n'''''''''''''''
	4146	+
	4147	+ break;
	4148	+ }
	4149	+ case 18446744073709551401LLU: // 999999996n'''''''''''''''
	4150	+ {
	4151	+ // parameter-reference linear____ y_________ goes out of scope
	4152	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 3
	4153	+ // parameter-reference linear____ x_________ goes out of scope
	4154	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 2
	4155	+ // parameter-reference u64 equal_____ goes out of scope
	4156	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference equal_____ at 1
	4157	+
	4158	+ {
	4159	+ uint64_t baseinfo = heap.data[0].elem1;
	4160	+ struct pair pair = unpair(&heap, &baseinfo);
	4161	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	4162	+ state.addr = pair.elem1;
	4163	+ }
	4164	+
	4165	+ break;
	4166	+ }
3689	4167	case 552446636209866541LLU: // copylinear
3690	4168	{
3691	4169
3692		- state.addr = 728618437845356544LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551430LLU : 18446744073709551429LLU;
	4170	+ state.addr = 728618437845356544LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551388LLU : 18446744073709551387LLU;
3693	4171
3694	4172	break;
3695	4173	}
3696		- case 18446744073709551430LLU: // 999999997F'''''''''''''''
	4174	+ case 18446744073709551388LLU: // 999999996a'''''''''''''''
3697	4175	{
3698	4176	{
3699	4177	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -3717,7 +4195,7 @@
3717	4195	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3718	4196	}
3719	4197	// 1LLU
3720		- uint64_t return_to = 18446744073709551428LLU;
	4198	+ uint64_t return_to = 18446744073709551386LLU;
3721	4199	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3722	4200	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
3723	4201	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -3727,7 +4205,7 @@
3727	4205
3728	4206	break;
3729	4207	}
3730		- case 18446744073709551428LLU: // 999999997D'''''''''''''''
	4208	+ case 18446744073709551386LLU: // 999999996Z'''''''''''''''
3731	4209	{
3732	4210	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 4
3733	4211	// parameter maintain__ src_______ goes out of scope

		@@ -3735,18 +4213,18 @@
3735	4213	heap.availilable_size_for_dynamic_objects += 0LLU;
3736	4214	heap.availilable_size_for_dynamic_objects += 0LLU;
3737	4215
3738		- state.addr = 18446744073709551427LLU; // 999999997C'''''''''''''''
	4216	+ state.addr = 18446744073709551385LLU; // 999999996Y'''''''''''''''
3739	4217
3740	4218	break;
3741	4219	}
3742		- case 18446744073709551429LLU: // 999999997E'''''''''''''''
	4220	+ case 18446744073709551387LLU: // 999999996$'''''''''''''''
3743	4221	{
3744	4222
3745		- state.addr = 552437437528276992LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551426LLU : 18446744073709551425LLU;
	4223	+ state.addr = 552437437528276992LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551384LLU : 18446744073709551383LLU;
3746	4224
3747	4225	break;
3748	4226	}
3749		- case 18446744073709551426LLU: // 999999997B'''''''''''''''
	4227	+ case 18446744073709551384LLU: // 999999996X'''''''''''''''
3750	4228	{
3751	4229	{
3752	4230	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -3770,7 +4248,7 @@
3770	4248	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3771	4249	}
3772	4250	// 1LLU
3773		- uint64_t return_to = 18446744073709551424LLU;
	4251	+ uint64_t return_to = 18446744073709551382LLU;
3774	4252	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3775	4253	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
3776	4254	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -3780,7 +4258,7 @@
3780	4258
3781	4259	break;
3782	4260	}
3783		- case 18446744073709551424LLU: // 999999997_'''''''''''''''
	4261	+ case 18446744073709551382LLU: // 999999996V'''''''''''''''
3784	4262	{
3785	4263	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 4
3786	4264	// parameter consume___ src_______ goes out of scope

		@@ -3788,18 +4266,18 @@
3788	4266	heap.availilable_size_for_dynamic_objects += 0LLU;
3789	4267	heap.availilable_size_for_dynamic_objects += 0LLU;
3790	4268
3791		- state.addr = 18446744073709551423LLU; // 9999999969'''''''''''''''
	4269	+ state.addr = 18446744073709551381LLU; // 999999996U'''''''''''''''
3792	4270
3793	4271	break;
3794	4272	}
3795		- case 18446744073709551425LLU: // 999999997A'''''''''''''''
	4273	+ case 18446744073709551383LLU: // 999999996W'''''''''''''''
3796	4274	{
3797	4275
3798		- state.addr = 787472410168262656LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551422LLU : 18446744073709551421LLU;
	4276	+ state.addr = 787472410168262656LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551380LLU : 18446744073709551379LLU;
3799	4277
3800	4278	break;
3801	4279	}
3802		- case 18446744073709551422LLU: // 9999999968'''''''''''''''
	4280	+ case 18446744073709551380LLU: // 999999996T'''''''''''''''
3803	4281	{
3804	4282	{
3805	4283	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -3823,7 +4301,7 @@
3823	4301	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3824	4302	}
3825	4303	// 1LLU
3826		- uint64_t return_to = 18446744073709551420LLU;
	4304	+ uint64_t return_to = 18446744073709551378LLU;
3827	4305	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3828	4306	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
3829	4307	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -3833,7 +4311,7 @@
3833	4311
3834	4312	break;
3835	4313	}
3836		- case 18446744073709551420LLU: // 9999999966'''''''''''''''
	4314	+ case 18446744073709551378LLU: // 999999996R'''''''''''''''
3837	4315	{
3838	4316	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 4
3839	4317	// parameter produce___ src_______ goes out of scope

		@@ -3841,11 +4319,11 @@
3841	4319	heap.availilable_size_for_dynamic_objects += 0LLU;
3842	4320	heap.availilable_size_for_dynamic_objects += 0LLU;
3843	4321
3844		- state.addr = 18446744073709551419LLU; // 9999999965'''''''''''''''
	4322	+ state.addr = 18446744073709551377LLU; // 999999996Q'''''''''''''''
3845	4323
3846	4324	break;
3847	4325	}
3848		- case 18446744073709551421LLU: // 9999999967'''''''''''''''
	4326	+ case 18446744073709551379LLU: // 999999996S'''''''''''''''
3849	4327	{
3850	4328
3851	4329	{

		@@ -3852,23 +4330,23 @@
3852	4330	fprintf(stderr, "%s\n", "copylinear: unimplemented linear constructor");
3853	4331	exit(-1);
3854	4332	}
3855		- state.addr = 18446744073709551419LLU; // 9999999965'''''''''''''''
	4333	+ state.addr = 18446744073709551377LLU; // 999999996Q'''''''''''''''
3856	4334
3857	4335	break;
3858	4336	}
3859		- case 18446744073709551419LLU: // 9999999965'''''''''''''''
	4337	+ case 18446744073709551377LLU: // 999999996Q'''''''''''''''
3860	4338	{
3861		- state.addr = 18446744073709551423LLU; // 9999999969'''''''''''''''
	4339	+ state.addr = 18446744073709551381LLU; // 999999996U'''''''''''''''
3862	4340
3863	4341	break;
3864	4342	}
3865		- case 18446744073709551423LLU: // 9999999969'''''''''''''''
	4343	+ case 18446744073709551381LLU: // 999999996U'''''''''''''''
3866	4344	{
3867		- state.addr = 18446744073709551427LLU; // 999999997C'''''''''''''''
	4345	+ state.addr = 18446744073709551385LLU; // 999999996Y'''''''''''''''
3868	4346
3869	4347	break;
3870	4348	}
3871		- case 18446744073709551427LLU: // 999999997C'''''''''''''''
	4349	+ case 18446744073709551385LLU: // 999999996Y'''''''''''''''
3872	4350	{
3873	4351	// parameter-reference linear____ src_______ goes out of scope
3874	4352	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference src_______ at 2

		@@ -3884,6 +4362,74 @@
3884	4362
3885	4363	break;
3886	4364	}
	4365	+ case 552454062075020996LLU: // corepar_$D
	4366	+ {
	4367	+ {
	4368	+ uint64_t arg = 0;
	4369	+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
	4370	+ }
	4371	+ LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 4LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
	4372	+ // emitted destructur for type u64
	4373	+ LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 3LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
	4374	+ // emitted destructur for type linear____
	4375	+ {
	4376	+ uint64_t mainresult = heap.data[0].elem0;
	4377	+ heap.data[0].elem0 = 0;
	4378	+ {
	4379	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
	4380	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4381	+ }
	4382	+ // 1LLU
	4383	+ uint64_t return_to = 18446744073709551376LLU;
	4384	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	4385	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	4386	+ heap.data[0].elem1 = heap.data[0].elem0;
	4387	+ heap.data[0].elem0 = mainresult;
	4388	+ }
	4389	+ state.addr = 712877190781339332LLU; // linear__$D
	4390	+
	4391	+ break;
	4392	+ }
	4393	+ case 18446744073709551376LLU: // 999999996P'''''''''''''''
	4394	+ {
	4395	+ LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
	4396	+ // emitted destructur for type u64
	4397	+ LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 1LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
	4398	+ // emitted destructur for type type______
	4399	+ {
	4400	+ uint64_t mainresult = heap.data[0].elem0;
	4401	+ heap.data[0].elem0 = 0;
	4402	+ {
	4403	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
	4404	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4405	+ }
	4406	+ // 1LLU
	4407	+ uint64_t return_to = 18446744073709551375LLU;
	4408	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	4409	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	4410	+ heap.data[0].elem1 = heap.data[0].elem0;
	4411	+ heap.data[0].elem0 = mainresult;
	4412	+ }
	4413	+ state.addr = 861504743757842116LLU; // type____$D
	4414	+
	4415	+ break;
	4416	+ }
	4417	+ case 18446744073709551375LLU: // 999999996O'''''''''''''''
	4418	+ {
	4419	+
	4420	+ // RELEASE temporary destructor-variable
	4421	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2
	4422	+ // RELEASE destructor-argument
	4423	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 1
	4424	+ {
	4425	+ uint64_t baseinfo = heap.data[0].elem1;
	4426	+ struct pair pair = unpair(&heap, &baseinfo);
	4427	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	4428	+ state.addr = pair.elem1;
	4429	+ }
	4430	+
	4431	+ break;
	4432	+ }
3887	4433	case 782700512565790404LLU: // pardef__$D
3888	4434	{
3889	4435	{

		@@ -3902,7 +4448,7 @@
3902	4448	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3903	4449	}
3904	4450	// 1LLU
3905		- uint64_t return_to = 18446744073709551418LLU;
	4451	+ uint64_t return_to = 18446744073709551374LLU;
3906	4452	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3907	4453	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
3908	4454	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -3912,7 +4458,7 @@
3912	4458
3913	4459	break;
3914	4460	}
3915		- case 18446744073709551418LLU: // 9999999964'''''''''''''''
	4461	+ case 18446744073709551374LLU: // 999999996N'''''''''''''''
3916	4462	{
3917	4463	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 3LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
3918	4464	// emitted destructur for type u64

		@@ -3926,7 +4472,7 @@
3926	4472	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3927	4473	}
3928	4474	// 1LLU
3929		- uint64_t return_to = 18446744073709551417LLU;
	4475	+ uint64_t return_to = 18446744073709551373LLU;
3930	4476	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3931	4477	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
3932	4478	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -3936,7 +4482,7 @@
3936	4482
3937	4483	break;
3938	4484	}
3939		- case 18446744073709551417LLU: // 9999999963'''''''''''''''
	4485	+ case 18446744073709551373LLU: // 999999996M'''''''''''''''
3940	4486	{
3941	4487	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 1LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
3942	4488	// emitted destructur for type u64

		@@ -3954,6 +4500,338 @@
3954	4500
3955	4501	break;
3956	4502	}
	4503	+ case 587581796494083780LLU: // elemdef_$D
	4504	+ {
	4505	+ {
	4506	+ uint64_t arg = 0;
	4507	+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
	4508	+ }
	4509	+ LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
	4510	+ // emitted destructur for type type______
	4511	+ {
	4512	+ uint64_t mainresult = heap.data[0].elem0;
	4513	+ heap.data[0].elem0 = 0;
	4514	+ {
	4515	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
	4516	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4517	+ }
	4518	+ // 1LLU
	4519	+ uint64_t return_to = 18446744073709551372LLU;
	4520	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	4521	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	4522	+ heap.data[0].elem1 = heap.data[0].elem0;
	4523	+ heap.data[0].elem0 = mainresult;
	4524	+ }
	4525	+ state.addr = 861504743757842116LLU; // type____$D
	4526	+
	4527	+ break;
	4528	+ }
	4529	+ case 18446744073709551372LLU: // 999999996L'''''''''''''''
	4530	+ {
	4531	+ LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 1LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
	4532	+ // emitted destructur for type u64
	4533	+
	4534	+ // RELEASE temporary destructor-variable
	4535	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 2
	4536	+ // RELEASE destructor-argument
	4537	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 1
	4538	+ {
	4539	+ uint64_t baseinfo = heap.data[0].elem1;
	4540	+ struct pair pair = unpair(&heap, &baseinfo);
	4541	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	4542	+ state.addr = pair.elem1;
	4543	+ }
	4544	+
	4545	+ break;
	4546	+ }
	4547	+ case 589059743276730432LLU: // equpardef_
	4548	+ {
	4549	+ {
	4550	+ uint64_t mainresult = heap.data[0].elem0;
	4551	+ heap.data[0].elem0 = 0;
	4552	+ {
	4553	+ uint64_t arg = /equal_____/*LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
	4554	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4555	+ }
	4556	+ {
	4557	+ uint64_t arg = /x_________/tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
	4558	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4559	+ }
	4560	+ {
	4561	+ uint64_t arg = /y_________/tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU);
	4562	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4563	+ }
	4564	+ // 3LLU
	4565	+ uint64_t return_to = 18446744073709551370LLU;
	4566	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	4567	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	4568	+ heap.data[0].elem1 = heap.data[0].elem0;
	4569	+ heap.data[0].elem0 = mainresult;
	4570	+ }
	4571	+ state.addr = 589060043891015680LLU; // equtype___
	4572	+
	4573	+ break;
	4574	+ }
	4575	+ case 18446744073709551370LLU: // 999999996J'''''''''''''''
	4576	+ {
	4577	+ state.addr = 18446744073709551371LLU; // 999999996K'''''''''''''''
	4578	+
	4579	+ break;
	4580	+ }
	4581	+ case 18446744073709551371LLU: // 999999996K'''''''''''''''
	4582	+ {
	4583	+
	4584	+ state.addr = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551369LLU : 18446744073709551368LLU;
	4585	+
	4586	+ break;
	4587	+ }
	4588	+ case 18446744073709551369LLU: // 999999996I'''''''''''''''
	4589	+ {
	4590	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4591	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4592	+
	4593	+ state.addr = 18446744073709551367LLU; // 999999996G'''''''''''''''
	4594	+
	4595	+ break;
	4596	+ }
	4597	+ case 18446744073709551368LLU: // 999999996H'''''''''''''''
	4598	+ {
	4599	+ fprintf(stderr, "%s", "type");
	4600	+ state.addr = 18446744073709551367LLU; // 999999996G'''''''''''''''
	4601	+
	4602	+ break;
	4603	+ }
	4604	+ case 18446744073709551367LLU: // 999999996G'''''''''''''''
	4605	+ {
	4606	+
	4607	+ state.addr = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551366LLU : 18446744073709551365LLU;
	4608	+
	4609	+ break;
	4610	+ }
	4611	+ case 18446744073709551366LLU: // 999999996F'''''''''''''''
	4612	+ {
	4613	+
	4614	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 2LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 2LLU));
	4615	+
	4616	+ state.addr = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551364LLU : 18446744073709551363LLU;
	4617	+
	4618	+ break;
	4619	+ }
	4620	+ case 18446744073709551364LLU: // 999999996D'''''''''''''''
	4621	+ {
	4622	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4623	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4624	+
	4625	+ state.addr = 18446744073709551362LLU; // 999999996B'''''''''''''''
	4626	+
	4627	+ break;
	4628	+ }
	4629	+ case 18446744073709551363LLU: // 999999996C'''''''''''''''
	4630	+ {
	4631	+ fprintf(stderr, "%s", "mutable");
	4632	+ state.addr = 18446744073709551362LLU; // 999999996B'''''''''''''''
	4633	+
	4634	+ break;
	4635	+ }
	4636	+ case 18446744073709551362LLU: // 999999996B'''''''''''''''
	4637	+ {
	4638	+
	4639	+ state.addr = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551361LLU : 18446744073709551360LLU;
	4640	+
	4641	+ break;
	4642	+ }
	4643	+ case 18446744073709551361LLU: // 999999996A'''''''''''''''
	4644	+ {
	4645	+ {
	4646	+ uint64_t mainresult = heap.data[0].elem0;
	4647	+ heap.data[0].elem0 = 0;
	4648	+ {
	4649	+ uint64_t arg = /equal_____/*LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
	4650	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4651	+ }
	4652	+ {
	4653	+ uint64_t arg = /x_________/tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 3LLU);
	4654	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4655	+ }
	4656	+ {
	4657	+ uint64_t arg = /y_________/tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 3LLU);
	4658	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4659	+ }
	4660	+ // 3LLU
	4661	+ uint64_t return_to = 18446744073709551358LLU;
	4662	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	4663	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	4664	+ heap.data[0].elem1 = heap.data[0].elem0;
	4665	+ heap.data[0].elem0 = mainresult;
	4666	+ }
	4667	+ state.addr = 589059476921895744LLU; // equlinear_
	4668	+
	4669	+ break;
	4670	+ }
	4671	+ case 18446744073709551358LLU: // 9999999958'''''''''''''''
	4672	+ {
	4673	+ state.addr = 18446744073709551359LLU; // 9999999959'''''''''''''''
	4674	+
	4675	+ break;
	4676	+ }
	4677	+ case 18446744073709551359LLU: // 9999999959'''''''''''''''
	4678	+ {
	4679	+
	4680	+ state.addr = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551357LLU : 18446744073709551356LLU;
	4681	+
	4682	+ break;
	4683	+ }
	4684	+ case 18446744073709551357LLU: // 9999999957'''''''''''''''
	4685	+ {
	4686	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4687	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4688	+
	4689	+ state.addr = 18446744073709551355LLU; // 9999999955'''''''''''''''
	4690	+
	4691	+ break;
	4692	+ }
	4693	+ case 18446744073709551356LLU: // 9999999956'''''''''''''''
	4694	+ {
	4695	+ fprintf(stderr, "%s", "linearity");
	4696	+ state.addr = 18446744073709551355LLU; // 9999999955'''''''''''''''
	4697	+
	4698	+ break;
	4699	+ }
	4700	+ case 18446744073709551355LLU: // 9999999955'''''''''''''''
	4701	+ {
	4702	+
	4703	+ state.addr = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551354LLU : 18446744073709551353LLU;
	4704	+
	4705	+ break;
	4706	+ }
	4707	+ case 18446744073709551354LLU: // 9999999954'''''''''''''''
	4708	+ {
	4709	+
	4710	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 4LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 4LLU));
	4711	+
	4712	+ state.addr = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551352LLU : 18446744073709551351LLU;
	4713	+
	4714	+ break;
	4715	+ }
	4716	+ case 18446744073709551352LLU: // 9999999952'''''''''''''''
	4717	+ {
	4718	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4719	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	4720	+
	4721	+ state.addr = 18446744073709551350LLU; // 9999999950'''''''''''''''
	4722	+
	4723	+ break;
	4724	+ }
	4725	+ case 18446744073709551351LLU: // 9999999951'''''''''''''''
	4726	+ {
	4727	+ fprintf(stderr, "%s", "REFERENCE");
	4728	+ state.addr = 18446744073709551350LLU; // 9999999950'''''''''''''''
	4729	+
	4730	+ break;
	4731	+ }
	4732	+ case 18446744073709551350LLU: // 9999999950'''''''''''''''
	4733	+ {
	4734	+ state.addr = 18446744073709551353LLU; // 9999999953'''''''''''''''
	4735	+
	4736	+ break;
	4737	+ }
	4738	+ case 18446744073709551353LLU: // 9999999953'''''''''''''''
	4739	+ {
	4740	+ state.addr = 18446744073709551360LLU; // 999999996_'''''''''''''''
	4741	+
	4742	+ break;
	4743	+ }
	4744	+ case 18446744073709551360LLU: // 999999996_'''''''''''''''
	4745	+ {
	4746	+ state.addr = 18446744073709551365LLU; // 999999996E'''''''''''''''
	4747	+
	4748	+ break;
	4749	+ }
	4750	+ case 18446744073709551365LLU: // 999999996E'''''''''''''''
	4751	+ {
	4752	+ // parameter-reference pardef____ y_________ goes out of scope
	4753	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 3
	4754	+ // parameter-reference pardef____ x_________ goes out of scope
	4755	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 2
	4756	+ // parameter-reference u64 equal_____ goes out of scope
	4757	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference equal_____ at 1
	4758	+
	4759	+ {
	4760	+ uint64_t baseinfo = heap.data[0].elem1;
	4761	+ struct pair pair = unpair(&heap, &baseinfo);
	4762	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	4763	+ state.addr = pair.elem1;
	4764	+ }
	4765	+
	4766	+ break;
	4767	+ }
	4768	+ case 589058998957897761LLU: // equelemdef
	4769	+ {
	4770	+
	4771	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 0LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU));
	4772	+
	4773	+ state.addr = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551349LLU : 18446744073709551348LLU;
	4774	+
	4775	+ break;
	4776	+ }
	4777	+ case 18446744073709551349LLU: // 999999995z'''''''''''''''
	4778	+ {
	4779	+ {
	4780	+ uint64_t mainresult = heap.data[0].elem0;
	4781	+ heap.data[0].elem0 = 0;
	4782	+ {
	4783	+ uint64_t arg = /equal_____/*LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
	4784	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4785	+ }
	4786	+ {
	4787	+ uint64_t arg = /x_________/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
	4788	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4789	+ }
	4790	+ {
	4791	+ uint64_t arg = /y_________/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU);
	4792	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4793	+ }
	4794	+ // 3LLU
	4795	+ uint64_t return_to = 18446744073709551346LLU;
	4796	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	4797	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	4798	+ heap.data[0].elem1 = heap.data[0].elem0;
	4799	+ heap.data[0].elem0 = mainresult;
	4800	+ }
	4801	+ state.addr = 589060043891015680LLU; // equtype___
	4802	+
	4803	+ break;
	4804	+ }
	4805	+ case 18446744073709551346LLU: // 999999995w'''''''''''''''
	4806	+ {
	4807	+ state.addr = 18446744073709551347LLU; // 999999995x'''''''''''''''
	4808	+
	4809	+ break;
	4810	+ }
	4811	+ case 18446744073709551347LLU: // 999999995x'''''''''''''''
	4812	+ {
	4813	+ state.addr = 18446744073709551348LLU; // 999999995y'''''''''''''''
	4814	+
	4815	+ break;
	4816	+ }
	4817	+ case 18446744073709551348LLU: // 999999995y'''''''''''''''
	4818	+ {
	4819	+ // parameter-reference elemdef___ y_________ goes out of scope
	4820	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 3
	4821	+ // parameter-reference elemdef___ x_________ goes out of scope
	4822	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 2
	4823	+ // parameter-reference u64 equal_____ goes out of scope
	4824	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference equal_____ at 1
	4825	+
	4826	+ {
	4827	+ uint64_t baseinfo = heap.data[0].elem1;
	4828	+ struct pair pair = unpair(&heap, &baseinfo);
	4829	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	4830	+ state.addr = pair.elem1;
	4831	+ }
	4832	+
	4833	+ break;
	4834	+ }
3957	4835	case 782700512573827828LLU: // pardefcopy
3958	4836	{
3959	4837	/dst_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU)) = /src_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU));

		@@ -3969,7 +4847,7 @@
3969	4847	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
3970	4848	}
3971	4849	// 2LLU
3972		- uint64_t return_to = 18446744073709551415LLU;
	4850	+ uint64_t return_to = 18446744073709551344LLU;
3973	4851	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
3974	4852	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
3975	4853	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -3979,13 +4857,13 @@
3979	4857
3980	4858	break;
3981	4859	}
3982		- case 18446744073709551415LLU: // 9999999961'''''''''''''''
	4860	+ case 18446744073709551344LLU: // 999999995u'''''''''''''''
3983	4861	{
3984		- state.addr = 18446744073709551416LLU; // 9999999962'''''''''''''''
	4862	+ state.addr = 18446744073709551345LLU; // 999999995v'''''''''''''''
3985	4863
3986	4864	break;
3987	4865	}
3988		- case 18446744073709551416LLU: // 9999999962'''''''''''''''
	4866	+ case 18446744073709551345LLU: // 999999995v'''''''''''''''
3989	4867	{
3990	4868	{
3991	4869	uint64_t mainresult = heap.data[0].elem0;

		@@ -3999,7 +4877,7 @@
3999	4877	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4000	4878	}
4001	4879	// 2LLU
4002		- uint64_t return_to = 18446744073709551413LLU;
	4880	+ uint64_t return_to = 18446744073709551342LLU;
4003	4881	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4004	4882	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4005	4883	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4009,13 +4887,13 @@
4009	4887
4010	4888	break;
4011	4889	}
4012		- case 18446744073709551413LLU: // 999999996z'''''''''''''''
	4890	+ case 18446744073709551342LLU: // 999999995s'''''''''''''''
4013	4891	{
4014		- state.addr = 18446744073709551414LLU; // 9999999960'''''''''''''''
	4892	+ state.addr = 18446744073709551343LLU; // 999999995t'''''''''''''''
4015	4893
4016	4894	break;
4017	4895	}
4018		- case 18446744073709551414LLU: // 9999999960'''''''''''''''
	4896	+ case 18446744073709551343LLU: // 999999995t'''''''''''''''
4019	4897	{
4020	4898	/dst_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 2LLU)) = /src_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 2LLU));
4021	4899	/dst_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 4LLU)) = /src_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 4LLU));

		@@ -4033,6 +4911,194 @@
4033	4911
4034	4912	break;
4035	4913	}
	4914	+ case 288591296313750553LLU: // PARDEFCOPY
	4915	+ {
	4916	+ {
	4917	+ uint64_t arg = 0LLU;
	4918	+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
	4919	+ }
	4920	+ {
	4921	+ uint64_t arg = 0LLU;
	4922	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	4923	+ }
	4924	+ {
	4925	+ uint64_t arg = 0LLU;
	4926	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	4927	+ }
	4928	+ {
	4929	+ uint64_t arg = 0LLU;
	4930	+ tree_push_move(&heap, 0LLU, &arg, &*LOCAL_ACCESS(heap.data, 5LLU, 2LLU));
	4931	+ {
	4932	+ uint64_t arg1 = 0LLU;
	4933	+ uint64_t constrid = 861504796319285248LLU; // typeu64___
	4934	+ arg1 = pair_move(&heap, &constrid, &arg1);
	4935	+ tree_push_move(&heap, 1LLU, &arg, &arg1);
	4936	+ }
	4937	+
	4938	+ tree_push_move(&heap, 2LLU, &arg, &*LOCAL_ACCESS(heap.data, 5LLU, 3LLU));
	4939	+ {
	4940	+ uint64_t arg1 = 0LLU;
	4941	+ uint64_t constrid = 728618437845356544LLU; // maintain__
	4942	+ arg1 = pair_move(&heap, &constrid, &arg1);
	4943	+ tree_push_move(&heap, 3LLU, &arg, &arg1);
	4944	+ }
	4945	+
	4946	+ tree_push_move(&heap, 4LLU, &arg, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU));
	4947	+;
	4948	+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
	4949	+ }
	4950	+ {
	4951	+ uint64_t mainresult = heap.data[0].elem0;
	4952	+ heap.data[0].elem0 = 0;
	4953	+ {
	4954	+ uint64_t arg = /new_______/LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
	4955	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4956	+ }
	4957	+ {
	4958	+ uint64_t arg = /src_______/*LOCAL_ACCESS(heap.data, 6LLU, 1LLU);
	4959	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	4960	+ }
	4961	+ // 2LLU
	4962	+ uint64_t return_to = 18446744073709551340LLU;
	4963	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	4964	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	4965	+ heap.data[0].elem1 = heap.data[0].elem0;
	4966	+ heap.data[0].elem0 = mainresult;
	4967	+ }
	4968	+ state.addr = 782700512573827828LLU; // pardefcopy
	4969	+
	4970	+ break;
	4971	+ }
	4972	+ case 18446744073709551340LLU: // 999999995q'''''''''''''''
	4973	+ {
	4974	+ state.addr = 18446744073709551341LLU; // 999999995r'''''''''''''''
	4975	+
	4976	+ break;
	4977	+ }
	4978	+ case 18446744073709551341LLU: // 999999995r'''''''''''''''
	4979	+ {
	4980	+ swap(&/new_______/LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &/dst_______/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)));
	4981	+ // variable pardef____ new_______ goes out of scope
	4982	+ // (uninitialized -> no destructor-call)
	4983	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 6
	4984	+ // variable u64 tmp4______ goes out of scope
	4985	+ // (uninitialized -> no destructor-call)
	4986	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp4______ at 5
	4987	+ // variable u64 tmp3______ goes out of scope
	4988	+ // (uninitialized -> no destructor-call)
	4989	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp3______ at 4
	4990	+ // variable u64 tmp0______ goes out of scope
	4991	+ // (uninitialized -> no destructor-call)
	4992	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp0______ at 3
	4993	+ // parameter-reference pardef____ src_______ goes out of scope
	4994	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference src_______ at 2
	4995	+ // parameter-reference pardef____ dst_______ goes out of scope
	4996	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dst_______ at 1
	4997	+
	4998	+ {
	4999	+ uint64_t baseinfo = heap.data[0].elem1;
	5000	+ struct pair pair = unpair(&heap, &baseinfo);
	5001	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	5002	+ state.addr = pair.elem1;
	5003	+ }
	5004	+
	5005	+ break;
	5006	+ }
	5007	+ case 587581796494207680LLU: // elemdefcp_
	5008	+ {
	5009	+ /dst_______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU)) = /src_______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU));
	5010	+ {
	5011	+ uint64_t mainresult = heap.data[0].elem0;
	5012	+ heap.data[0].elem0 = 0;
	5013	+ {
	5014	+ uint64_t arg = /dst_______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 1LLU);
	5015	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5016	+ }
	5017	+ {
	5018	+ uint64_t arg = /src_______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
	5019	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5020	+ }
	5021	+ // 2LLU
	5022	+ uint64_t return_to = 18446744073709551338LLU;
	5023	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5024	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5025	+ heap.data[0].elem1 = heap.data[0].elem0;
	5026	+ heap.data[0].elem0 = mainresult;
	5027	+ }
	5028	+ state.addr = 861504776686223360LLU; // typecopy__
	5029	+
	5030	+ break;
	5031	+ }
	5032	+ case 18446744073709551338LLU: // 999999995o'''''''''''''''
	5033	+ {
	5034	+ state.addr = 18446744073709551339LLU; // 999999995p'''''''''''''''
	5035	+
	5036	+ break;
	5037	+ }
	5038	+ case 18446744073709551339LLU: // 999999995p'''''''''''''''
	5039	+ {
	5040	+ // parameter-reference elemdef___ src_______ goes out of scope
	5041	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference src_______ at 2
	5042	+ // parameter-reference elemdef___ dst_______ goes out of scope
	5043	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dst_______ at 1
	5044	+
	5045	+ {
	5046	+ uint64_t baseinfo = heap.data[0].elem1;
	5047	+ struct pair pair = unpair(&heap, &baseinfo);
	5048	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	5049	+ state.addr = pair.elem1;
	5050	+ }
	5051	+
	5052	+ break;
	5053	+ }
	5054	+ case 819859607546145524LLU: // resdefcopy
	5055	+ {
	5056	+ {
	5057	+ uint64_t mainresult = heap.data[0].elem0;
	5058	+ heap.data[0].elem0 = 0;
	5059	+ {
	5060	+ uint64_t arg = /dst_______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU);
	5061	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5062	+ }
	5063	+ {
	5064	+ uint64_t arg = /src_______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
	5065	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5066	+ }
	5067	+ // 2LLU
	5068	+ uint64_t return_to = 18446744073709551336LLU;
	5069	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5070	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5071	+ heap.data[0].elem1 = heap.data[0].elem0;
	5072	+ heap.data[0].elem0 = mainresult;
	5073	+ }
	5074	+ state.addr = 861504776686223360LLU; // typecopy__
	5075	+
	5076	+ break;
	5077	+ }
	5078	+ case 18446744073709551336LLU: // 999999995m'''''''''''''''
	5079	+ {
	5080	+ state.addr = 18446744073709551337LLU; // 999999995n'''''''''''''''
	5081	+
	5082	+ break;
	5083	+ }
	5084	+ case 18446744073709551337LLU: // 999999995n'''''''''''''''
	5085	+ {
	5086	+ /dst_______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 1LLU)) = /src_______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU));
	5087	+ /dst_______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 2LLU)) = /src_______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 2LLU));
	5088	+ // parameter-reference resdest___ src_______ goes out of scope
	5089	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference src_______ at 2
	5090	+ // parameter-reference resdest___ dst_______ goes out of scope
	5091	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference dst_______ at 1
	5092	+
	5093	+ {
	5094	+ uint64_t baseinfo = heap.data[0].elem1;
	5095	+ struct pair pair = unpair(&heap, &baseinfo);
	5096	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	5097	+ state.addr = pair.elem1;
	5098	+ }
	5099	+
	5100	+ break;
	5101	+ }
4036	5102	case 325750391286068249LLU: // RESDEFCOPY
4037	5103	{
4038	5104	{

		@@ -4060,11 +5126,11 @@
4060	5126	tree_push_move(&heap, 1LLU, arg, &*LOCAL_ACCESS(heap.data, 6LLU, 4LLU));
4061	5127	tree_push_move(&heap, 2LLU, arg, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU));
4062	5128	}
4063		- state.addr = 18446744073709551411LLU; // 999999996x'''''''''''''''
	5129	+ state.addr = 18446744073709551334LLU; // 999999995k'''''''''''''''
4064	5130
4065	5131	break;
4066	5132	}
4067		- case 18446744073709551411LLU: // 999999996x'''''''''''''''
	5133	+ case 18446744073709551334LLU: // 999999995k'''''''''''''''
4068	5134	{
4069	5135	// variable u64 reference_ goes out of scope
4070	5136	// (uninitialized -> no destructor-call)

		@@ -4075,11 +5141,11 @@
4075	5141	// variable type______ type______ goes out of scope
4076	5142	// (uninitialized -> no destructor-call)
4077	5143	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 4
4078		- state.addr = 18446744073709551412LLU; // 999999996y'''''''''''''''
	5144	+ state.addr = 18446744073709551335LLU; // 999999995l'''''''''''''''
4079	5145
4080	5146	break;
4081	5147	}
4082		- case 18446744073709551412LLU: // 999999996y'''''''''''''''
	5148	+ case 18446744073709551335LLU: // 999999995l'''''''''''''''
4083	5149	{
4084	5150	{
4085	5151	uint64_t mainresult = heap.data[0].elem0;

		@@ -4093,7 +5159,7 @@
4093	5159	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4094	5160	}
4095	5161	// 2LLU
4096		- uint64_t return_to = 18446744073709551409LLU;
	5162	+ uint64_t return_to = 18446744073709551332LLU;
4097	5163	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4098	5164	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4099	5165	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4103,13 +5169,13 @@
4103	5169
4104	5170	break;
4105	5171	}
4106		- case 18446744073709551409LLU: // 999999996v'''''''''''''''
	5172	+ case 18446744073709551332LLU: // 999999995i'''''''''''''''
4107	5173	{
4108		- state.addr = 18446744073709551410LLU; // 999999996w'''''''''''''''
	5174	+ state.addr = 18446744073709551333LLU; // 999999995j'''''''''''''''
4109	5175
4110	5176	break;
4111	5177	}
4112		- case 18446744073709551410LLU: // 999999996w'''''''''''''''
	5178	+ case 18446744073709551333LLU: // 999999995j'''''''''''''''
4113	5179	{
4114	5180	swap(&/tmp_______/LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &/dst_______/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)));
4115	5181	// variable resdest___ tmp_______ goes out of scope

		@@ -4176,15 +5242,15 @@
4176	5242	uint64_t arg = 0;
4177	5243	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
4178	5244	}
4179		- state.addr = 18446744073709551407LLU; // 999999996t'''''''''''''''
	5245	+ state.addr = 18446744073709551330LLU; // 999999995g'''''''''''''''
4180	5246
4181	5247	break;
4182	5248	}
4183		- case 18446744073709551407LLU: // 999999996t'''''''''''''''
	5249	+ case 18446744073709551330LLU: // 999999995g'''''''''''''''
4184	5250	{
4185	5251	if(!LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list*/)
4186	5252	{
4187		- state.addr = 18446744073709551408LLU; // 999999996u'''''''''''''''
	5253	+ state.addr = 18446744073709551331LLU; // 999999995h'''''''''''''''
4188	5254
4189	5255	break;
4190	5256	}

		@@ -4197,7 +5263,7 @@
4197	5263	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4198	5264	}
4199	5265	// 1LLU
4200		- uint64_t return_to = 18446744073709551406LLU;
	5266	+ uint64_t return_to = 18446744073709551329LLU;
4201	5267	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4202	5268	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4203	5269	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4207,13 +5273,13 @@
4207	5273
4208	5274	break;
4209	5275	}
4210		- case 18446744073709551406LLU: // 999999996s'''''''''''''''
	5276	+ case 18446744073709551329LLU: // 999999995f'''''''''''''''
4211	5277	{
4212		- state.addr = 18446744073709551407LLU; // 999999996t'''''''''''''''
	5278	+ state.addr = 18446744073709551330LLU; // 999999995g'''''''''''''''
4213	5279
4214	5280	break;
4215	5281	}
4216		- case 18446744073709551408LLU: // 999999996u'''''''''''''''
	5282	+ case 18446744073709551331LLU: // 999999995h'''''''''''''''
4217	5283	{
4218	5284	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
4219	5285	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 1LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));

		@@ -4223,15 +5289,15 @@
4223	5289	uint64_t arg = 0;
4224	5290	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
4225	5291	}
4226		- state.addr = 18446744073709551404LLU; // 999999996q'''''''''''''''
	5292	+ state.addr = 18446744073709551327LLU; // 999999995d'''''''''''''''
4227	5293
4228	5294	break;
4229	5295	}
4230		- case 18446744073709551404LLU: // 999999996q'''''''''''''''
	5296	+ case 18446744073709551327LLU: // 999999995d'''''''''''''''
4231	5297	{
4232	5298	if(!LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list*/)
4233	5299	{
4234		- state.addr = 18446744073709551405LLU; // 999999996r'''''''''''''''
	5300	+ state.addr = 18446744073709551328LLU; // 999999995e'''''''''''''''
4235	5301
4236	5302	break;
4237	5303	}

		@@ -4244,7 +5310,7 @@
4244	5310	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4245	5311	}
4246	5312	// 1LLU
4247		- uint64_t return_to = 18446744073709551403LLU;
	5313	+ uint64_t return_to = 18446744073709551326LLU;
4248	5314	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4249	5315	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4250	5316	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4254,13 +5320,13 @@
4254	5320
4255	5321	break;
4256	5322	}
4257		- case 18446744073709551403LLU: // 999999996p'''''''''''''''
	5323	+ case 18446744073709551326LLU: // 999999995c'''''''''''''''
4258	5324	{
4259		- state.addr = 18446744073709551404LLU; // 999999996q'''''''''''''''
	5325	+ state.addr = 18446744073709551327LLU; // 999999995d'''''''''''''''
4260	5326
4261	5327	break;
4262	5328	}
4263		- case 18446744073709551405LLU: // 999999996r'''''''''''''''
	5329	+ case 18446744073709551328LLU: // 999999995e'''''''''''''''
4264	5330	{
4265	5331	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
4266	5332

		@@ -4277,6 +5343,895 @@
4277	5343
4278	5344	break;
4279	5345	}
	5346	+ case 589059069805989888LLU: // equfndef__
	5347	+ {
	5348	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 1LLU;
	5349	+ {
	5350	+ uint64_t arg = 0LLU;
	5351	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	5352	+ }
	5353	+ {
	5354	+ uint64_t arg = /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 0LLU));
	5355	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	5356	+ }
	5357	+ {
	5358	+ uint64_t arg = 0;
	5359	+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
	5360	+ }
	5361	+ state.addr = 18446744073709551324LLU; // 999999995a'''''''''''''''
	5362	+
	5363	+ break;
	5364	+ }
	5365	+ case 18446744073709551324LLU: // 999999995a'''''''''''''''
	5366	+ {
	5367	+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
	5368	+ {
	5369	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
	5370	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
	5371	+ {
	5372	+ state.addr = 18446744073709551323LLU; // 999999995$'''''''''''''''
	5373	+
	5374	+ break;
	5375	+ }
	5376	+ }
	5377	+ /direct/LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
	5378	+ LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
	5379	+ {
	5380	+ uint64_t arg = 0LLU;
	5381	+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
	5382	+ }
	5383	+ {
	5384	+ uint64_t arg = 0LLU;
	5385	+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
	5386	+ }
	5387	+ {
	5388	+ uint64_t arg = 0LLU;
	5389	+ {
	5390	+ uint64_t arg1 = 0LLU;
	5391	+ uint64_t constrid = 861504796319285248LLU; // typeu64___
	5392	+ arg1 = pair_move(&heap, &constrid, &arg1);
	5393	+ tree_push_move(&heap, 0LLU, &arg, &arg1);
	5394	+ }
	5395	+
	5396	+ tree_push_move(&heap, 1LLU, &arg, &*LOCAL_ACCESS(heap.data, 8LLU, 6LLU));
	5397	+ tree_push_move(&heap, 2LLU, &arg, &*LOCAL_ACCESS(heap.data, 8LLU, 7LLU));
	5398	+;
	5399	+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
	5400	+ }
	5401	+ {
	5402	+ uint64_t mainresult = heap.data[0].elem0;
	5403	+ heap.data[0].elem0 = 0;
	5404	+ {
	5405	+ uint64_t arg = /new_______/LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
	5406	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5407	+ }
	5408	+ {
	5409	+ uint64_t arg = /respar1___/*LOCAL_ACCESS(heap.data, 9LLU, 5LLU);
	5410	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5411	+ }
	5412	+ // 2LLU
	5413	+ uint64_t return_to = 18446744073709551321LLU;
	5414	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5415	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5416	+ heap.data[0].elem1 = heap.data[0].elem0;
	5417	+ heap.data[0].elem0 = mainresult;
	5418	+ }
	5419	+ state.addr = 819859607546145524LLU; // resdefcopy
	5420	+
	5421	+ break;
	5422	+ }
	5423	+ case 18446744073709551321LLU: // 999999995Y'''''''''''''''
	5424	+ {
	5425	+ state.addr = 18446744073709551322LLU; // 999999995Z'''''''''''''''
	5426	+
	5427	+ break;
	5428	+ }
	5429	+ case 18446744073709551322LLU: // 999999995Z'''''''''''''''
	5430	+ {
	5431	+
	5432	+ state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &/yres______/LOCAL_ACCESS(heap.data, 9LLU, 3LLU), 4) ? 18446744073709551320LLU : 18446744073709551319LLU;
	5433	+
	5434	+ break;
	5435	+ }
	5436	+ case 18446744073709551320LLU: // 999999995X'''''''''''''''
	5437	+ {
	5438	+ {
	5439	+ uint64_t arg = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU);
	5440	+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/address of current closure/, &arg);
	5441	+ }
	5442	+
	5443	+ {
	5444	+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
	5445	+ exit(-1);
	5446	+ }
	5447	+ // variable resdest___ new_______ goes out of scope
	5448	+ // emitted destructur for type resdest___
	5449	+ {
	5450	+ uint64_t mainresult = heap.data[0].elem0;
	5451	+ heap.data[0].elem0 = 0;
	5452	+ {
	5453	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
	5454	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5455	+ }
	5456	+ // 1LLU
	5457	+ uint64_t return_to = 18446744073709551318LLU;
	5458	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5459	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5460	+ heap.data[0].elem1 = heap.data[0].elem0;
	5461	+ heap.data[0].elem0 = mainresult;
	5462	+ }
	5463	+ state.addr = 819859607768532676LLU; // resdest_$D
	5464	+
	5465	+ break;
	5466	+ }
	5467	+ case 18446744073709551318LLU: // 999999995V'''''''''''''''
	5468	+ {
	5469	+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 10
	5470	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	5471	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	5472	+
	5473	+ state.addr = 18446744073709551317LLU; // 999999995U'''''''''''''''
	5474	+
	5475	+ break;
	5476	+ }
	5477	+ case 18446744073709551319LLU: // 999999995W'''''''''''''''
	5478	+ {
	5479	+ state.addr = 18446744073709551317LLU; // 999999995U'''''''''''''''
	5480	+
	5481	+ break;
	5482	+ }
	5483	+ case 18446744073709551317LLU: // 999999995U'''''''''''''''
	5484	+ {
	5485	+ // variable resdest___ new_______ goes out of scope
	5486	+ // (uninitialized -> no destructor-call)
	5487	+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 9
	5488	+ // variable u64 tmp2______ goes out of scope
	5489	+ // (uninitialized -> no destructor-call)
	5490	+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp2______ at 8
	5491	+ // variable u64 tmp1______ goes out of scope
	5492	+ // (uninitialized -> no destructor-call)
	5493	+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp1______ at 7
	5494	+ // parameter-reference resdest___ respar1___ goes out of scope
	5495	+ // parameter-reference function__ y_________ goes out of scope
	5496	+ state.addr = 18446744073709551324LLU; // 999999995a'''''''''''''''
	5497	+
	5498	+ break;
	5499	+ }
	5500	+ case 18446744073709551323LLU: // 999999995$'''''''''''''''
	5501	+ {
	5502	+ list_reverse(heap.data, &/yres______/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU));
	5503	+ {
	5504	+ uint64_t arg = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 0LLU));
	5505	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	5506	+ }
	5507	+ {
	5508	+ uint64_t arg = 0;
	5509	+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
	5510	+ }
	5511	+ state.addr = 18446744073709551316LLU; // 999999995T'''''''''''''''
	5512	+
	5513	+ break;
	5514	+ }
	5515	+ case 18446744073709551316LLU: // 999999995T'''''''''''''''
	5516	+ {
	5517	+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
	5518	+ {
	5519	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
	5520	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
	5521	+ {
	5522	+ state.addr = 18446744073709551315LLU; // 999999995S'''''''''''''''
	5523	+
	5524	+ break;
	5525	+ }
	5526	+ }
	5527	+ /direct/LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
	5528	+ LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
	5529	+
	5530	+ state.addr = /yres______/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551314LLU : 18446744073709551313LLU;
	5531	+
	5532	+ break;
	5533	+ }
	5534	+ case 18446744073709551314LLU: // 999999995R'''''''''''''''
	5535	+ {
	5536	+ {
	5537	+ uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 3LLU)/list*/, 4);
	5538	+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
	5539	+ }
	5540	+ {
	5541	+ uint64_t arg = 0LLU;
	5542	+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
	5543	+ }
	5544	+ {
	5545	+ uint64_t mainresult = heap.data[0].elem0;
	5546	+ heap.data[0].elem0 = 0;
	5547	+ {
	5548	+ uint64_t arg = /EQUAL_____/LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
	5549	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5550	+ }
	5551	+ {
	5552	+ uint64_t arg = /res0______/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU);
	5553	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5554	+ }
	5555	+ {
	5556	+ uint64_t arg = /res1______/LOCAL_ACCESS_ADDR(heap.data, 8LLU, 6LLU);
	5557	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5558	+ }
	5559	+ // 3LLU
	5560	+ uint64_t return_to = 18446744073709551311LLU;
	5561	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5562	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5563	+ heap.data[0].elem1 = heap.data[0].elem0;
	5564	+ heap.data[0].elem0 = mainresult;
	5565	+ }
	5566	+ state.addr = 589059885019168768LLU; // equres____
	5567	+
	5568	+ break;
	5569	+ }
	5570	+ case 18446744073709551311LLU: // 999999995O'''''''''''''''
	5571	+ {
	5572	+ state.addr = 18446744073709551312LLU; // 999999995P'''''''''''''''
	5573	+
	5574	+ break;
	5575	+ }
	5576	+ case 18446744073709551312LLU: // 999999995P'''''''''''''''
	5577	+ {
	5578	+
	5579	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU);
	5580	+ // variable u64 EQUAL_____ goes out of scope
	5581	+ // emitted destructur for type u64
	5582	+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference EQUAL_____ at 8
	5583	+ // variable resdest___ res1______ goes out of scope
	5584	+ // emitted destructur for type resdest___
	5585	+ {
	5586	+ uint64_t mainresult = heap.data[0].elem0;
	5587	+ heap.data[0].elem0 = 0;
	5588	+ {
	5589	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
	5590	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5591	+ }
	5592	+ // 1LLU
	5593	+ uint64_t return_to = 18446744073709551310LLU;
	5594	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5595	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5596	+ heap.data[0].elem1 = heap.data[0].elem0;
	5597	+ heap.data[0].elem0 = mainresult;
	5598	+ }
	5599	+ state.addr = 819859607768532676LLU; // resdest_$D
	5600	+
	5601	+ break;
	5602	+ }
	5603	+ case 18446744073709551310LLU: // 999999995N'''''''''''''''
	5604	+ {
	5605	+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference res1______ at 7
	5606	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	5607	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	5608	+
	5609	+ state.addr = 18446744073709551309LLU; // 999999995M'''''''''''''''
	5610	+
	5611	+ break;
	5612	+ }
	5613	+ case 18446744073709551313LLU: // 999999995Q'''''''''''''''
	5614	+ {
	5615	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 0LLU;
	5616	+ state.addr = 18446744073709551309LLU; // 999999995M'''''''''''''''
	5617	+
	5618	+ break;
	5619	+ }
	5620	+ case 18446744073709551309LLU: // 999999995M'''''''''''''''
	5621	+ {
	5622	+ // parameter-reference resdest___ res0______ goes out of scope
	5623	+ // parameter-reference function__ x_________ goes out of scope
	5624	+ state.addr = 18446744073709551316LLU; // 999999995T'''''''''''''''
	5625	+
	5626	+ break;
	5627	+ }
	5628	+ case 18446744073709551315LLU: // 999999995S'''''''''''''''
	5629	+ {
	5630	+
	5631	+ state.addr = /yres______/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551308LLU : 18446744073709551307LLU;
	5632	+
	5633	+ break;
	5634	+ }
	5635	+ case 18446744073709551308LLU: // 999999995L'''''''''''''''
	5636	+ {
	5637	+ {
	5638	+ uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/list*/, 4);
	5639	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	5640	+ }
	5641	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
	5642	+ // variable resdest___ res1______ goes out of scope
	5643	+ // emitted destructur for type resdest___
	5644	+ {
	5645	+ uint64_t mainresult = heap.data[0].elem0;
	5646	+ heap.data[0].elem0 = 0;
	5647	+ {
	5648	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
	5649	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5650	+ }
	5651	+ // 1LLU
	5652	+ uint64_t return_to = 18446744073709551306LLU;
	5653	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5654	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5655	+ heap.data[0].elem1 = heap.data[0].elem0;
	5656	+ heap.data[0].elem0 = mainresult;
	5657	+ }
	5658	+ state.addr = 819859607768532676LLU; // resdest_$D
	5659	+
	5660	+ break;
	5661	+ }
	5662	+ case 18446744073709551306LLU: // 999999995J'''''''''''''''
	5663	+ {
	5664	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference res1______ at 5
	5665	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	5666	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	5667	+
	5668	+ state.addr = 18446744073709551305LLU; // 999999995I'''''''''''''''
	5669	+
	5670	+ break;
	5671	+ }
	5672	+ case 18446744073709551307LLU: // 999999995K'''''''''''''''
	5673	+ {
	5674	+ state.addr = 18446744073709551305LLU; // 999999995I'''''''''''''''
	5675	+
	5676	+ break;
	5677	+ }
	5678	+ case 18446744073709551305LLU: // 999999995I'''''''''''''''
	5679	+ {
	5680	+ // variable list<resdest___> yres______ goes out of scope
	5681	+ // emitted destructur for type list<resdest___>
	5682	+ // temporary list-element
	5683	+ {
	5684	+ uint64_t arg = 0;
	5685	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	5686	+ }
	5687	+ state.addr = 18446744073709551303LLU; // 999999995G'''''''''''''''
	5688	+
	5689	+ break;
	5690	+ }
	5691	+ case 18446744073709551303LLU: // 999999995G'''''''''''''''
	5692	+ {
	5693	+ if(!LOCAL_ACCESS(heap.data, 5LLU, 3LLU)/list*/)
	5694	+ {
	5695	+ state.addr = 18446744073709551304LLU; // 999999995H'''''''''''''''
	5696	+
	5697	+ break;
	5698	+ }
	5699	+ LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 5LLU, 3LLU)/list/, 4);
	5700	+ {
	5701	+ uint64_t mainresult = heap.data[0].elem0;
	5702	+ heap.data[0].elem0 = 0;
	5703	+ {
	5704	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
	5705	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5706	+ }
	5707	+ // 1LLU
	5708	+ uint64_t return_to = 18446744073709551302LLU;
	5709	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5710	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5711	+ heap.data[0].elem1 = heap.data[0].elem0;
	5712	+ heap.data[0].elem0 = mainresult;
	5713	+ }
	5714	+ state.addr = 819859607768532676LLU; // resdest_$D
	5715	+
	5716	+ break;
	5717	+ }
	5718	+ case 18446744073709551302LLU: // 999999995F'''''''''''''''
	5719	+ {
	5720	+ state.addr = 18446744073709551303LLU; // 999999995G'''''''''''''''
	5721	+
	5722	+ break;
	5723	+ }
	5724	+ case 18446744073709551304LLU: // 999999995H'''''''''''''''
	5725	+ {
	5726	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
	5727	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference yres______ at 4
	5728	+ state.addr = 18446744073709551325LLU; // 999999995b'''''''''''''''
	5729	+
	5730	+ break;
	5731	+ }
	5732	+ case 18446744073709551325LLU: // 999999995b'''''''''''''''
	5733	+ {
	5734	+ {
	5735	+ uint64_t arg = 0LLU;
	5736	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	5737	+ }
	5738	+ {
	5739	+ uint64_t arg = /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU));
	5740	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	5741	+ }
	5742	+ {
	5743	+ uint64_t arg = 0;
	5744	+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
	5745	+ }
	5746	+ state.addr = 18446744073709551300LLU; // 999999995D'''''''''''''''
	5747	+
	5748	+ break;
	5749	+ }
	5750	+ case 18446744073709551300LLU: // 999999995D'''''''''''''''
	5751	+ {
	5752	+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
	5753	+ {
	5754	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
	5755	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
	5756	+ {
	5757	+ state.addr = 18446744073709551299LLU; // 999999995C'''''''''''''''
	5758	+
	5759	+ break;
	5760	+ }
	5761	+ }
	5762	+ /direct/LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
	5763	+ LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
	5764	+ {
	5765	+ uint64_t arg = 0LLU;
	5766	+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
	5767	+ }
	5768	+ {
	5769	+ uint64_t arg = 0LLU;
	5770	+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
	5771	+ }
	5772	+ {
	5773	+ uint64_t arg = 0LLU;
	5774	+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
	5775	+ }
	5776	+ {
	5777	+ uint64_t arg = 0LLU;
	5778	+ tree_push_move(&heap, 0LLU, &arg, &*LOCAL_ACCESS(heap.data, 9LLU, 6LLU));
	5779	+ {
	5780	+ uint64_t arg1 = 0LLU;
	5781	+ uint64_t constrid = 861504796319285248LLU; // typeu64___
	5782	+ arg1 = pair_move(&heap, &constrid, &arg1);
	5783	+ tree_push_move(&heap, 1LLU, &arg, &arg1);
	5784	+ }
	5785	+
	5786	+ tree_push_move(&heap, 2LLU, &arg, &*LOCAL_ACCESS(heap.data, 9LLU, 7LLU));
	5787	+ {
	5788	+ uint64_t arg1 = 0LLU;
	5789	+ uint64_t constrid = 728618437845356544LLU; // maintain__
	5790	+ arg1 = pair_move(&heap, &constrid, &arg1);
	5791	+ tree_push_move(&heap, 3LLU, &arg, &arg1);
	5792	+ }
	5793	+
	5794	+ tree_push_move(&heap, 4LLU, &arg, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU));
	5795	+;
	5796	+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/address of current closure/, &arg);
	5797	+ }
	5798	+ {
	5799	+ uint64_t mainresult = heap.data[0].elem0;
	5800	+ heap.data[0].elem0 = 0;
	5801	+ {
	5802	+ uint64_t arg = /new_______/LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
	5803	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5804	+ }
	5805	+ {
	5806	+ uint64_t arg = /par1______/*LOCAL_ACCESS(heap.data, 10LLU, 5LLU);
	5807	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5808	+ }
	5809	+ // 2LLU
	5810	+ uint64_t return_to = 18446744073709551297LLU;
	5811	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5812	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5813	+ heap.data[0].elem1 = heap.data[0].elem0;
	5814	+ heap.data[0].elem0 = mainresult;
	5815	+ }
	5816	+ state.addr = 782700512573827828LLU; // pardefcopy
	5817	+
	5818	+ break;
	5819	+ }
	5820	+ case 18446744073709551297LLU: // 999999995A'''''''''''''''
	5821	+ {
	5822	+ state.addr = 18446744073709551298LLU; // 999999995B'''''''''''''''
	5823	+
	5824	+ break;
	5825	+ }
	5826	+ case 18446744073709551298LLU: // 999999995B'''''''''''''''
	5827	+ {
	5828	+
	5829	+ state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 10LLU, 9LLU), &/ypars_____/LOCAL_ACCESS(heap.data, 10LLU, 3LLU), 6) ? 18446744073709551296LLU : 18446744073709551295LLU;
	5830	+
	5831	+ break;
	5832	+ }
	5833	+ case 18446744073709551296LLU: // 999999995_'''''''''''''''
	5834	+ {
	5835	+ {
	5836	+ uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 9LLU);
	5837	+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/address of current closure/, &arg);
	5838	+ }
	5839	+
	5840	+ {
	5841	+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
	5842	+ exit(-1);
	5843	+ }
	5844	+ // variable pardef____ new_______ goes out of scope
	5845	+ // emitted destructur for type pardef____
	5846	+ {
	5847	+ uint64_t mainresult = heap.data[0].elem0;
	5848	+ heap.data[0].elem0 = 0;
	5849	+ {
	5850	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU);
	5851	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5852	+ }
	5853	+ // 1LLU
	5854	+ uint64_t return_to = 18446744073709551294LLU;
	5855	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5856	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5857	+ heap.data[0].elem1 = heap.data[0].elem0;
	5858	+ heap.data[0].elem0 = mainresult;
	5859	+ }
	5860	+ state.addr = 782700512565790404LLU; // pardef__$D
	5861	+
	5862	+ break;
	5863	+ }
	5864	+ case 18446744073709551294LLU: // 9999999948'''''''''''''''
	5865	+ {
	5866	+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 11
	5867	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	5868	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	5869	+
	5870	+ state.addr = 18446744073709551293LLU; // 9999999947'''''''''''''''
	5871	+
	5872	+ break;
	5873	+ }
	5874	+ case 18446744073709551295LLU: // 9999999949'''''''''''''''
	5875	+ {
	5876	+ state.addr = 18446744073709551293LLU; // 9999999947'''''''''''''''
	5877	+
	5878	+ break;
	5879	+ }
	5880	+ case 18446744073709551293LLU: // 9999999947'''''''''''''''
	5881	+ {
	5882	+ // variable pardef____ new_______ goes out of scope
	5883	+ // (uninitialized -> no destructor-call)
	5884	+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 10
	5885	+ // variable u64 tmp4______ goes out of scope
	5886	+ // (uninitialized -> no destructor-call)
	5887	+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp4______ at 9
	5888	+ // variable u64 tmp3______ goes out of scope
	5889	+ // (uninitialized -> no destructor-call)
	5890	+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp3______ at 8
	5891	+ // variable u64 tmp0______ goes out of scope
	5892	+ // (uninitialized -> no destructor-call)
	5893	+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp0______ at 7
	5894	+ // parameter-reference pardef____ par1______ goes out of scope
	5895	+ // parameter-reference function__ y_________ goes out of scope
	5896	+ state.addr = 18446744073709551300LLU; // 999999995D'''''''''''''''
	5897	+
	5898	+ break;
	5899	+ }
	5900	+ case 18446744073709551299LLU: // 999999995C'''''''''''''''
	5901	+ {
	5902	+ list_reverse(heap.data, &/ypars_____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU));
	5903	+ {
	5904	+ uint64_t arg = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 1LLU));
	5905	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	5906	+ }
	5907	+ {
	5908	+ uint64_t arg = 0;
	5909	+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
	5910	+ }
	5911	+ state.addr = 18446744073709551292LLU; // 9999999946'''''''''''''''
	5912	+
	5913	+ break;
	5914	+ }
	5915	+ case 18446744073709551292LLU: // 9999999946'''''''''''''''
	5916	+ {
	5917	+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
	5918	+ {
	5919	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
	5920	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
	5921	+ {
	5922	+ state.addr = 18446744073709551291LLU; // 9999999945'''''''''''''''
	5923	+
	5924	+ break;
	5925	+ }
	5926	+ }
	5927	+ /direct/LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
	5928	+ LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
	5929	+
	5930	+ state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551290LLU : 18446744073709551289LLU;
	5931	+
	5932	+ break;
	5933	+ }
	5934	+ case 18446744073709551290LLU: // 9999999944'''''''''''''''
	5935	+ {
	5936	+ {
	5937	+ uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 6LLU, 3LLU)/list*/, 6);
	5938	+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
	5939	+ }
	5940	+ {
	5941	+ uint64_t arg = 0LLU;
	5942	+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
	5943	+ }
	5944	+ {
	5945	+ uint64_t mainresult = heap.data[0].elem0;
	5946	+ heap.data[0].elem0 = 0;
	5947	+ {
	5948	+ uint64_t arg = /EQUAL_____/LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
	5949	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5950	+ }
	5951	+ {
	5952	+ uint64_t arg = /par0______/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU);
	5953	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5954	+ }
	5955	+ {
	5956	+ uint64_t arg = /par1______/LOCAL_ACCESS_ADDR(heap.data, 8LLU, 6LLU);
	5957	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5958	+ }
	5959	+ // 3LLU
	5960	+ uint64_t return_to = 18446744073709551287LLU;
	5961	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5962	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5963	+ heap.data[0].elem1 = heap.data[0].elem0;
	5964	+ heap.data[0].elem0 = mainresult;
	5965	+ }
	5966	+ state.addr = 589059743276730432LLU; // equpardef_
	5967	+
	5968	+ break;
	5969	+ }
	5970	+ case 18446744073709551287LLU: // 9999999941'''''''''''''''
	5971	+ {
	5972	+ state.addr = 18446744073709551288LLU; // 9999999942'''''''''''''''
	5973	+
	5974	+ break;
	5975	+ }
	5976	+ case 18446744073709551288LLU: // 9999999942'''''''''''''''
	5977	+ {
	5978	+
	5979	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU);
	5980	+ // variable u64 EQUAL_____ goes out of scope
	5981	+ // emitted destructur for type u64
	5982	+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference EQUAL_____ at 8
	5983	+ // variable pardef____ par1______ goes out of scope
	5984	+ // emitted destructur for type pardef____
	5985	+ {
	5986	+ uint64_t mainresult = heap.data[0].elem0;
	5987	+ heap.data[0].elem0 = 0;
	5988	+ {
	5989	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
	5990	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	5991	+ }
	5992	+ // 1LLU
	5993	+ uint64_t return_to = 18446744073709551286LLU;
	5994	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	5995	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	5996	+ heap.data[0].elem1 = heap.data[0].elem0;
	5997	+ heap.data[0].elem0 = mainresult;
	5998	+ }
	5999	+ state.addr = 782700512565790404LLU; // pardef__$D
	6000	+
	6001	+ break;
	6002	+ }
	6003	+ case 18446744073709551286LLU: // 9999999940'''''''''''''''
	6004	+ {
	6005	+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par1______ at 7
	6006	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	6007	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	6008	+
	6009	+ state.addr = 18446744073709551285LLU; // 999999994z'''''''''''''''
	6010	+
	6011	+ break;
	6012	+ }
	6013	+ case 18446744073709551289LLU: // 9999999943'''''''''''''''
	6014	+ {
	6015	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 0LLU;
	6016	+ state.addr = 18446744073709551285LLU; // 999999994z'''''''''''''''
	6017	+
	6018	+ break;
	6019	+ }
	6020	+ case 18446744073709551285LLU: // 999999994z'''''''''''''''
	6021	+ {
	6022	+ // parameter-reference pardef____ par0______ goes out of scope
	6023	+ // parameter-reference function__ x_________ goes out of scope
	6024	+ state.addr = 18446744073709551292LLU; // 9999999946'''''''''''''''
	6025	+
	6026	+ break;
	6027	+ }
	6028	+ case 18446744073709551291LLU: // 9999999945'''''''''''''''
	6029	+ {
	6030	+
	6031	+ state.addr = /ypars_____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551284LLU : 18446744073709551283LLU;
	6032	+
	6033	+ break;
	6034	+ }
	6035	+ case 18446744073709551284LLU: // 999999994y'''''''''''''''
	6036	+ {
	6037	+ {
	6038	+ uint64_t arg = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/list*/, 6);
	6039	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	6040	+ }
	6041	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
	6042	+ // variable pardef____ par1______ goes out of scope
	6043	+ // emitted destructur for type pardef____
	6044	+ {
	6045	+ uint64_t mainresult = heap.data[0].elem0;
	6046	+ heap.data[0].elem0 = 0;
	6047	+ {
	6048	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
	6049	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	6050	+ }
	6051	+ // 1LLU
	6052	+ uint64_t return_to = 18446744073709551282LLU;
	6053	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	6054	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	6055	+ heap.data[0].elem1 = heap.data[0].elem0;
	6056	+ heap.data[0].elem0 = mainresult;
	6057	+ }
	6058	+ state.addr = 782700512565790404LLU; // pardef__$D
	6059	+
	6060	+ break;
	6061	+ }
	6062	+ case 18446744073709551282LLU: // 999999994w'''''''''''''''
	6063	+ {
	6064	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par1______ at 5
	6065	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	6066	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	6067	+
	6068	+ state.addr = 18446744073709551281LLU; // 999999994v'''''''''''''''
	6069	+
	6070	+ break;
	6071	+ }
	6072	+ case 18446744073709551283LLU: // 999999994x'''''''''''''''
	6073	+ {
	6074	+ state.addr = 18446744073709551281LLU; // 999999994v'''''''''''''''
	6075	+
	6076	+ break;
	6077	+ }
	6078	+ case 18446744073709551281LLU: // 999999994v'''''''''''''''
	6079	+ {
	6080	+ // variable list<pardef____> ypars_____ goes out of scope
	6081	+ // emitted destructur for type list<pardef____>
	6082	+ // temporary list-element
	6083	+ {
	6084	+ uint64_t arg = 0;
	6085	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
	6086	+ }
	6087	+ state.addr = 18446744073709551279LLU; // 999999994t'''''''''''''''
	6088	+
	6089	+ break;
	6090	+ }
	6091	+ case 18446744073709551279LLU: // 999999994t'''''''''''''''
	6092	+ {
	6093	+ if(!LOCAL_ACCESS(heap.data, 5LLU, 3LLU)/list*/)
	6094	+ {
	6095	+ state.addr = 18446744073709551280LLU; // 999999994u'''''''''''''''
	6096	+
	6097	+ break;
	6098	+ }
	6099	+ LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 5LLU, 3LLU)/list/, 6);
	6100	+ {
	6101	+ uint64_t mainresult = heap.data[0].elem0;
	6102	+ heap.data[0].elem0 = 0;
	6103	+ {
	6104	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
	6105	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	6106	+ }
	6107	+ // 1LLU
	6108	+ uint64_t return_to = 18446744073709551278LLU;
	6109	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	6110	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	6111	+ heap.data[0].elem1 = heap.data[0].elem0;
	6112	+ heap.data[0].elem0 = mainresult;
	6113	+ }
	6114	+ state.addr = 782700512565790404LLU; // pardef__$D
	6115	+
	6116	+ break;
	6117	+ }
	6118	+ case 18446744073709551278LLU: // 999999994s'''''''''''''''
	6119	+ {
	6120	+ state.addr = 18446744073709551279LLU; // 999999994t'''''''''''''''
	6121	+
	6122	+ break;
	6123	+ }
	6124	+ case 18446744073709551280LLU: // 999999994u'''''''''''''''
	6125	+ {
	6126	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
	6127	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference ypars_____ at 4
	6128	+ state.addr = 18446744073709551301LLU; // 999999995E'''''''''''''''
	6129	+
	6130	+ break;
	6131	+ }
	6132	+ case 18446744073709551301LLU: // 999999995E'''''''''''''''
	6133	+ {
	6134	+ {
	6135	+ uint64_t arg = 0LLU;
	6136	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	6137	+ }
	6138	+
	6139	+ /EQUAL_____/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 2LLU));
	6140	+
	6141	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
	6142	+ // variable u64 EQUAL_____ goes out of scope
	6143	+ // emitted destructur for type u64
	6144	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference EQUAL_____ at 4
	6145	+ state.addr = 18446744073709551277LLU; // 999999994r'''''''''''''''
	6146	+
	6147	+ break;
	6148	+ }
	6149	+ case 18446744073709551277LLU: // 999999994r'''''''''''''''
	6150	+ {
	6151	+ {
	6152	+ uint64_t arg = 0LLU;
	6153	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	6154	+ }
	6155	+
	6156	+ /EQUAL_____/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 3LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 3LLU));
	6157	+
	6158	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
	6159	+ // variable u64 EQUAL_____ goes out of scope
	6160	+ // emitted destructur for type u64
	6161	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference EQUAL_____ at 4
	6162	+ state.addr = 18446744073709551276LLU; // 999999994q'''''''''''''''
	6163	+
	6164	+ break;
	6165	+ }
	6166	+ case 18446744073709551276LLU: // 999999994q'''''''''''''''
	6167	+ {
	6168	+ {
	6169	+ uint64_t arg = 0LLU;
	6170	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	6171	+ }
	6172	+
	6173	+ /EQUAL_____/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 4LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 4LLU));
	6174	+
	6175	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
	6176	+ // variable u64 EQUAL_____ goes out of scope
	6177	+ // emitted destructur for type u64
	6178	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference EQUAL_____ at 4
	6179	+ state.addr = 18446744073709551275LLU; // 999999994p'''''''''''''''
	6180	+
	6181	+ break;
	6182	+ }
	6183	+ case 18446744073709551275LLU: // 999999994p'''''''''''''''
	6184	+ {
	6185	+ {
	6186	+ uint64_t arg = 0LLU;
	6187	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	6188	+ }
	6189	+
	6190	+ /EQUAL_____/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 5LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 5LLU));
	6191	+
	6192	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
	6193	+ // variable u64 EQUAL_____ goes out of scope
	6194	+ // emitted destructur for type u64
	6195	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference EQUAL_____ at 4
	6196	+ state.addr = 18446744073709551274LLU; // 999999994o'''''''''''''''
	6197	+
	6198	+ break;
	6199	+ }
	6200	+ case 18446744073709551274LLU: // 999999994o'''''''''''''''
	6201	+ {
	6202	+ {
	6203	+ uint64_t arg = 0LLU;
	6204	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	6205	+ }
	6206	+
	6207	+ /EQUAL_____/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /x_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 6LLU)) == /y_________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 6LLU));
	6208	+
	6209	+ /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /equal_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) && /EQUAL_____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
	6210	+ // variable u64 EQUAL_____ goes out of scope
	6211	+ // emitted destructur for type u64
	6212	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference EQUAL_____ at 4
	6213	+ state.addr = 18446744073709551273LLU; // 999999994n'''''''''''''''
	6214	+
	6215	+ break;
	6216	+ }
	6217	+ case 18446744073709551273LLU: // 999999994n'''''''''''''''
	6218	+ {
	6219	+ // parameter-reference function__ y_________ goes out of scope
	6220	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference y_________ at 3
	6221	+ // parameter-reference function__ x_________ goes out of scope
	6222	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference x_________ at 2
	6223	+ // parameter-reference u64 equal_____ goes out of scope
	6224	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference equal_____ at 1
	6225	+
	6226	+ {
	6227	+ uint64_t baseinfo = heap.data[0].elem1;
	6228	+ struct pair pair = unpair(&heap, &baseinfo);
	6229	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	6230	+ state.addr = pair.elem1;
	6231	+ }
	6232	+
	6233	+ break;
	6234	+ }
4280	6235	case 861519017821271748LLU: // tystruct$D
4281	6236	{
4282	6237	{

		@@ -4293,7 +6248,7 @@
4293	6248	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4294	6249	}
4295	6250	// 1LLU
4296		- uint64_t return_to = 18446744073709551402LLU;
	6251	+ uint64_t return_to = 18446744073709551272LLU;
4297	6252	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4298	6253	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4299	6254	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4303,30 +6258,30 @@
4303	6258
4304	6259	break;
4305	6260	}
4306		- case 18446744073709551402LLU: // 999999996o'''''''''''''''
	6261	+ case 18446744073709551272LLU: // 999999994m'''''''''''''''
4307	6262	{
4308	6263	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
4309	6264	// emitted destructur for type u64
4310	6265	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 1LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
4311		- // emitted destructur for type list<pardef____>
	6266	+ // emitted destructur for type list<elemdef___>
4312	6267	// temporary list-element
4313	6268	{
4314	6269	uint64_t arg = 0;
4315	6270	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
4316	6271	}
4317		- state.addr = 18446744073709551400LLU; // 999999996m'''''''''''''''
	6272	+ state.addr = 18446744073709551270LLU; // 999999994k'''''''''''''''
4318	6273
4319	6274	break;
4320	6275	}
4321		- case 18446744073709551400LLU: // 999999996m'''''''''''''''
	6276	+ case 18446744073709551270LLU: // 999999994k'''''''''''''''
4322	6277	{
4323	6278	if(!LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list*/)
4324	6279	{
4325		- state.addr = 18446744073709551401LLU; // 999999996n'''''''''''''''
	6280	+ state.addr = 18446744073709551271LLU; // 999999994l'''''''''''''''
4326	6281
4327	6282	break;
4328	6283	}
4329		- LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list/, 6);
	6284	+ LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list/, 3);
4330	6285	{
4331	6286	uint64_t mainresult = heap.data[0].elem0;
4332	6287	heap.data[0].elem0 = 0;

		@@ -4335,23 +6290,23 @@
4335	6290	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4336	6291	}
4337	6292	// 1LLU
4338		- uint64_t return_to = 18446744073709551399LLU;
	6293	+ uint64_t return_to = 18446744073709551269LLU;
4339	6294	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4340	6295	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4341	6296	heap.data[0].elem1 = heap.data[0].elem0;
4342	6297	heap.data[0].elem0 = mainresult;
4343	6298	}
4344		- state.addr = 782700512565790404LLU; // pardef__$D
	6299	+ state.addr = 587581796494083780LLU; // elemdef_$D
4345	6300
4346	6301	break;
4347	6302	}
4348		- case 18446744073709551399LLU: // 999999996l'''''''''''''''
	6303	+ case 18446744073709551269LLU: // 999999994j'''''''''''''''
4349	6304	{
4350		- state.addr = 18446744073709551400LLU; // 999999996m'''''''''''''''
	6305	+ state.addr = 18446744073709551270LLU; // 999999994k'''''''''''''''
4351	6306
4352	6307	break;
4353	6308	}
4354		- case 18446744073709551401LLU: // 999999996n'''''''''''''''
	6309	+ case 18446744073709551271LLU: // 999999994l'''''''''''''''
4355	6310	{
4356	6311	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
4357	6312

		@@ -4384,7 +6339,7 @@
4384	6339	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4385	6340	}
4386	6341	// 1LLU
4387		- uint64_t return_to = 18446744073709551398LLU;
	6342	+ uint64_t return_to = 18446744073709551268LLU;
4388	6343	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4389	6344	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4390	6345	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4394,30 +6349,30 @@
4394	6349
4395	6350	break;
4396	6351	}
4397		- case 18446744073709551398LLU: // 999999996k'''''''''''''''
	6352	+ case 18446744073709551268LLU: // 999999994i'''''''''''''''
4398	6353	{
4399	6354	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
4400	6355	// emitted destructur for type u64
4401	6356	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 1LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
4402		- // emitted destructur for type list<pardef____>
	6357	+ // emitted destructur for type list<elemdef___>
4403	6358	// temporary list-element
4404	6359	{
4405	6360	uint64_t arg = 0;
4406	6361	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
4407	6362	}
4408		- state.addr = 18446744073709551396LLU; // 999999996i'''''''''''''''
	6363	+ state.addr = 18446744073709551266LLU; // 999999994g'''''''''''''''
4409	6364
4410	6365	break;
4411	6366	}
4412		- case 18446744073709551396LLU: // 999999996i'''''''''''''''
	6367	+ case 18446744073709551266LLU: // 999999994g'''''''''''''''
4413	6368	{
4414	6369	if(!LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list*/)
4415	6370	{
4416		- state.addr = 18446744073709551397LLU; // 999999996j'''''''''''''''
	6371	+ state.addr = 18446744073709551267LLU; // 999999994h'''''''''''''''
4417	6372
4418	6373	break;
4419	6374	}
4420		- LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list/, 6);
	6375	+ LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list/, 3);
4421	6376	{
4422	6377	uint64_t mainresult = heap.data[0].elem0;
4423	6378	heap.data[0].elem0 = 0;

		@@ -4426,23 +6381,23 @@
4426	6381	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4427	6382	}
4428	6383	// 1LLU
4429		- uint64_t return_to = 18446744073709551395LLU;
	6384	+ uint64_t return_to = 18446744073709551265LLU;
4430	6385	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4431	6386	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4432	6387	heap.data[0].elem1 = heap.data[0].elem0;
4433	6388	heap.data[0].elem0 = mainresult;
4434	6389	}
4435		- state.addr = 782700512565790404LLU; // pardef__$D
	6390	+ state.addr = 587581796494083780LLU; // elemdef_$D
4436	6391
4437	6392	break;
4438	6393	}
4439		- case 18446744073709551395LLU: // 999999996h'''''''''''''''
	6394	+ case 18446744073709551265LLU: // 999999994f'''''''''''''''
4440	6395	{
4441		- state.addr = 18446744073709551396LLU; // 999999996i'''''''''''''''
	6396	+ state.addr = 18446744073709551266LLU; // 999999994g'''''''''''''''
4442	6397
4443	6398	break;
4444	6399	}
4445		- case 18446744073709551397LLU: // 999999996j'''''''''''''''
	6400	+ case 18446744073709551267LLU: // 999999994h'''''''''''''''
4446	6401	{
4447	6402	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
4448	6403

		@@ -4474,25 +6429,25 @@
4474	6429	uint64_t arg = 0;
4475	6430	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
4476	6431	}
4477		- state.addr = 18446744073709551393LLU; // 999999996f'''''''''''''''
	6432	+ state.addr = 18446744073709551263LLU; // 999999994d'''''''''''''''
4478	6433
4479	6434	break;
4480	6435	}
4481		- case 18446744073709551393LLU: // 999999996f'''''''''''''''
	6436	+ case 18446744073709551263LLU: // 999999994d'''''''''''''''
4482	6437	{
4483	6438	if(!LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list*/)
4484	6439	{
4485		- state.addr = 18446744073709551394LLU; // 999999996g'''''''''''''''
	6440	+ state.addr = 18446744073709551264LLU; // 999999994e'''''''''''''''
4486	6441
4487	6442	break;
4488	6443	}
4489	6444	LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = list_pop_move(&heap, &LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list/, 1);
4490	6445	// omitting u64 destructor
4491		- state.addr = 18446744073709551393LLU; // 999999996f'''''''''''''''
	6446	+ state.addr = 18446744073709551263LLU; // 999999994d'''''''''''''''
4492	6447
4493	6448	break;
4494	6449	}
4495		- case 18446744073709551394LLU: // 999999996g'''''''''''''''
	6450	+ case 18446744073709551264LLU: // 999999994e'''''''''''''''
4496	6451	{
4497	6452	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
4498	6453

		@@ -4521,11 +6476,11 @@
4521	6476	case 819847183518878080LLU: // reporttyk_
4522	6477	{
4523	6478
4524		- state.addr = 861519017821270016LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551392LLU : 18446744073709551391LLU;
	6479	+ state.addr = 861519017821270016LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551262LLU : 18446744073709551261LLU;
4525	6480
4526	6481	break;
4527	6482	}
4528		- case 18446744073709551392LLU: // 999999996e'''''''''''''''
	6483	+ case 18446744073709551262LLU: // 999999994c'''''''''''''''
4529	6484	{
4530	6485	{
4531	6486	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -4537,18 +6492,18 @@
4537	6492	heap.availilable_size_for_dynamic_objects += 0LLU;
4538	6493	heap.availilable_size_for_dynamic_objects += 0LLU;
4539	6494
4540		- state.addr = 18446744073709551390LLU; // 999999996c'''''''''''''''
	6495	+ state.addr = 18446744073709551260LLU; // 999999994a'''''''''''''''
4541	6496
4542	6497	break;
4543	6498	}
4544		- case 18446744073709551391LLU: // 999999996d'''''''''''''''
	6499	+ case 18446744073709551261LLU: // 999999994b'''''''''''''''
4545	6500	{
4546	6501
4547		- state.addr = 861527391835906048LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551389LLU : 18446744073709551388LLU;
	6502	+ state.addr = 861527391835906048LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551259LLU : 18446744073709551258LLU;
4548	6503
4549	6504	break;
4550	6505	}
4551		- case 18446744073709551389LLU: // 999999996b'''''''''''''''
	6506	+ case 18446744073709551259LLU: // 999999994$'''''''''''''''
4552	6507	{
4553	6508	{
4554	6509	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -4560,18 +6515,18 @@
4560	6515	heap.availilable_size_for_dynamic_objects += 0LLU;
4561	6516	heap.availilable_size_for_dynamic_objects += 0LLU;
4562	6517
4563		- state.addr = 18446744073709551387LLU; // 999999996$'''''''''''''''
	6518	+ state.addr = 18446744073709551257LLU; // 999999994Y'''''''''''''''
4564	6519
4565	6520	break;
4566	6521	}
4567		- case 18446744073709551388LLU: // 999999996a'''''''''''''''
	6522	+ case 18446744073709551258LLU: // 999999994Z'''''''''''''''
4568	6523	{
4569	6524
4570		- state.addr = 861527391835975680LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551386LLU : 18446744073709551385LLU;
	6525	+ state.addr = 861527391835975680LLU == heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem0 ? 18446744073709551256LLU : 18446744073709551255LLU;
4571	6526
4572	6527	break;
4573	6528	}
4574		- case 18446744073709551386LLU: // 999999996Z'''''''''''''''
	6529	+ case 18446744073709551256LLU: // 999999994X'''''''''''''''
4575	6530	{
4576	6531	{
4577	6532	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 1LLU, 0LLU)].elem1;

		@@ -4583,30 +6538,30 @@
4583	6538	heap.availilable_size_for_dynamic_objects += 0LLU;
4584	6539	heap.availilable_size_for_dynamic_objects += 0LLU;
4585	6540
4586		- state.addr = 18446744073709551384LLU; // 999999996X'''''''''''''''
	6541	+ state.addr = 18446744073709551254LLU; // 999999994V'''''''''''''''
4587	6542
4588	6543	break;
4589	6544	}
4590		- case 18446744073709551385LLU: // 999999996Y'''''''''''''''
	6545	+ case 18446744073709551255LLU: // 999999994W'''''''''''''''
4591	6546	{
4592	6547	fprintf(stderr, "%s", "typekind UNKNOWN");
4593		- state.addr = 18446744073709551384LLU; // 999999996X'''''''''''''''
	6548	+ state.addr = 18446744073709551254LLU; // 999999994V'''''''''''''''
4594	6549
4595	6550	break;
4596	6551	}
4597		- case 18446744073709551384LLU: // 999999996X'''''''''''''''
	6552	+ case 18446744073709551254LLU: // 999999994V'''''''''''''''
4598	6553	{
4599		- state.addr = 18446744073709551387LLU; // 999999996$'''''''''''''''
	6554	+ state.addr = 18446744073709551257LLU; // 999999994Y'''''''''''''''
4600	6555
4601	6556	break;
4602	6557	}
4603		- case 18446744073709551387LLU: // 999999996$'''''''''''''''
	6558	+ case 18446744073709551257LLU: // 999999994Y'''''''''''''''
4604	6559	{
4605		- state.addr = 18446744073709551390LLU; // 999999996c'''''''''''''''
	6560	+ state.addr = 18446744073709551260LLU; // 999999994a'''''''''''''''
4606	6561
4607	6562	break;
4608	6563	}
4609		- case 18446744073709551390LLU: // 999999996c'''''''''''''''
	6564	+ case 18446744073709551260LLU: // 999999994a'''''''''''''''
4610	6565	{
4611	6566	// parameter typekind__ kind______ goes out of scope
4612	6567	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference kind______ at 1

		@@ -4638,7 +6593,7 @@
4638	6593	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4639	6594	}
4640	6595	// 1LLU
4641		- uint64_t return_to = 18446744073709551383LLU;
	6596	+ uint64_t return_to = 18446744073709551253LLU;
4642	6597	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4643	6598	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4644	6599	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4648,7 +6603,7 @@
4648	6603
4649	6604	break;
4650	6605	}
4651		- case 18446744073709551383LLU: // 999999996W'''''''''''''''
	6606	+ case 18446744073709551253LLU: // 999999994U'''''''''''''''
4652	6607	{
4653	6608
4654	6609	// RELEASE temporary destructor-variable

		@@ -4677,15 +6632,15 @@
4677	6632	uint64_t arg = 0;
4678	6633	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
4679	6634	}
4680		- state.addr = 18446744073709551381LLU; // 999999996U'''''''''''''''
	6635	+ state.addr = 18446744073709551251LLU; // 999999994S'''''''''''''''
4681	6636
4682	6637	break;
4683	6638	}
4684		- case 18446744073709551381LLU: // 999999996U'''''''''''''''
	6639	+ case 18446744073709551251LLU: // 999999994S'''''''''''''''
4685	6640	{
4686	6641	if(!LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list*/)
4687	6642	{
4688		- state.addr = 18446744073709551382LLU; // 999999996V'''''''''''''''
	6643	+ state.addr = 18446744073709551252LLU; // 999999994T'''''''''''''''
4689	6644
4690	6645	break;
4691	6646	}

		@@ -4698,7 +6653,7 @@
4698	6653	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4699	6654	}
4700	6655	// 1LLU
4701		- uint64_t return_to = 18446744073709551380LLU;
	6656	+ uint64_t return_to = 18446744073709551250LLU;
4702	6657	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4703	6658	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4704	6659	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4708,13 +6663,13 @@
4708	6663
4709	6664	break;
4710	6665	}
4711		- case 18446744073709551380LLU: // 999999996T'''''''''''''''
	6666	+ case 18446744073709551250LLU: // 999999994R'''''''''''''''
4712	6667	{
4713		- state.addr = 18446744073709551381LLU; // 999999996U'''''''''''''''
	6668	+ state.addr = 18446744073709551251LLU; // 999999994S'''''''''''''''
4714	6669
4715	6670	break;
4716	6671	}
4717		- case 18446744073709551382LLU: // 999999996V'''''''''''''''
	6672	+ case 18446744073709551252LLU: // 999999994T'''''''''''''''
4718	6673	{
4719	6674	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
4720	6675	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 5LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));

		@@ -4724,15 +6679,15 @@
4724	6679	uint64_t arg = 0;
4725	6680	LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
4726	6681	}
4727		- state.addr = 18446744073709551378LLU; // 999999996R'''''''''''''''
	6682	+ state.addr = 18446744073709551248LLU; // 999999994P'''''''''''''''
4728	6683
4729	6684	break;
4730	6685	}
4731		- case 18446744073709551378LLU: // 999999996R'''''''''''''''
	6686	+ case 18446744073709551248LLU: // 999999994P'''''''''''''''
4732	6687	{
4733	6688	if(!LOCAL_ACCESS(heap.data, 3LLU, 1LLU)/list*/)
4734	6689	{
4735		- state.addr = 18446744073709551379LLU; // 999999996S'''''''''''''''
	6690	+ state.addr = 18446744073709551249LLU; // 999999994Q'''''''''''''''
4736	6691
4737	6692	break;
4738	6693	}

		@@ -4745,7 +6700,7 @@
4745	6700	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4746	6701	}
4747	6702	// 1LLU
4748		- uint64_t return_to = 18446744073709551377LLU;
	6703	+ uint64_t return_to = 18446744073709551247LLU;
4749	6704	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4750	6705	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4751	6706	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4755,13 +6710,13 @@
4755	6710
4756	6711	break;
4757	6712	}
4758		- case 18446744073709551377LLU: // 999999996Q'''''''''''''''
	6713	+ case 18446744073709551247LLU: // 999999994O'''''''''''''''
4759	6714	{
4760		- state.addr = 18446744073709551378LLU; // 999999996R'''''''''''''''
	6715	+ state.addr = 18446744073709551248LLU; // 999999994P'''''''''''''''
4761	6716
4762	6717	break;
4763	6718	}
4764		- case 18446744073709551379LLU: // 999999996S'''''''''''''''
	6719	+ case 18446744073709551249LLU: // 999999994Q'''''''''''''''
4765	6720	{
4766	6721	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
4767	6722	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 4LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));

		@@ -4780,7 +6735,7 @@
4780	6735	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4781	6736	}
4782	6737	// 1LLU
4783		- uint64_t return_to = 18446744073709551376LLU;
	6738	+ uint64_t return_to = 18446744073709551246LLU;
4784	6739	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4785	6740	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4786	6741	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4790,7 +6745,7 @@
4790	6745
4791	6746	break;
4792	6747	}
4793		- case 18446744073709551376LLU: // 999999996P'''''''''''''''
	6748	+ case 18446744073709551246LLU: // 999999994N'''''''''''''''
4794	6749	{
4795	6750
4796	6751	// RELEASE temporary destructor-variable

		@@ -4812,6 +6767,8 @@
4812	6767	uint64_t arg = 0;
4813	6768	LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/address of current closure/, &arg);
4814	6769	}
	6770	+ LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 3LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
	6771	+ // emitted destructur for type u64
4815	6772	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 2LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
4816	6773	// emitted destructur for type function__
4817	6774	{

		@@ -4822,7 +6779,7 @@
4822	6779	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4823	6780	}
4824	6781	// 1LLU
4825		- uint64_t return_to = 18446744073709551375LLU;
	6782	+ uint64_t return_to = 18446744073709551245LLU;
4826	6783	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4827	6784	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4828	6785	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4832,7 +6789,7 @@
4832	6789
4833	6790	break;
4834	6791	}
4835		- case 18446744073709551375LLU: // 999999996O'''''''''''''''
	6792	+ case 18446744073709551245LLU: // 999999994M'''''''''''''''
4836	6793	{
4837	6794	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 1LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
4838	6795	// emitted destructur for type u64

		@@ -4866,7 +6823,7 @@
4866	6823	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
4867	6824	}
4868	6825	// 1LLU
4869		- uint64_t return_to = 18446744073709551374LLU;
	6826	+ uint64_t return_to = 18446744073709551244LLU;
4870	6827	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
4871	6828	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
4872	6829	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -4876,7 +6833,7 @@
4876	6833
4877	6834	break;
4878	6835	}
4879		- case 18446744073709551374LLU: // 999999996N'''''''''''''''
	6836	+ case 18446744073709551244LLU: // 999999994L'''''''''''''''
4880	6837	{
4881	6838	LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = tree_pop_move(&heap, 1LLU, &access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
4882	6839	// emitted destructur for type u64

		@@ -4905,11 +6862,11 @@
4905	6862	uint64_t arg = 0;
4906	6863	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
4907	6864	}
4908		- state.addr = 18446744073709551373LLU; // 999999996M'''''''''''''''
	6865	+ state.addr = 18446744073709551243LLU; // 999999994K'''''''''''''''
4909	6866
4910	6867	break;
4911	6868	}
4912		- case 18446744073709551373LLU: // 999999996M'''''''''''''''
	6869	+ case 18446744073709551243LLU: // 999999994K'''''''''''''''
4913	6870	{
4914	6871	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
4915	6872	{

		@@ -4916,7 +6873,7 @@
4916	6873	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
4917	6874	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
4918	6875	{
4919		- state.addr = 18446744073709551372LLU; // 999999996L'''''''''''''''
	6876	+ state.addr = 18446744073709551242LLU; // 999999994J'''''''''''''''
4920	6877
4921	6878	break;
4922	6879	}

		@@ -4928,20 +6885,20 @@
4928	6885	LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/address of current closure/, &arg);
4929	6886	}
4930	6887
4931		- /match_____/LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU), 0LLU));
	6888	+ /match_____/LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU), 0LLU));
4932	6889
4933		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551371LLU : 18446744073709551370LLU;
	6890	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551241LLU : 18446744073709551240LLU;
4934	6891
4935	6892	break;
4936	6893	}
4937		- case 18446744073709551371LLU: // 999999996K'''''''''''''''
	6894	+ case 18446744073709551241LLU: // 999999994I'''''''''''''''
4938	6895	{
4939	6896	/found_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 1LLU;
4940		- state.addr = 18446744073709551370LLU; // 999999996J'''''''''''''''
	6897	+ state.addr = 18446744073709551240LLU; // 999999994H'''''''''''''''
4941	6898
4942	6899	break;
4943	6900	}
4944		- case 18446744073709551370LLU: // 999999996J'''''''''''''''
	6901	+ case 18446744073709551240LLU: // 999999994H'''''''''''''''
4945	6902	{
4946	6903	// variable u64 match_____ goes out of scope
4947	6904	// emitted destructur for type u64

		@@ -4948,11 +6905,11 @@
4948	6905	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference match_____ at 6
4949	6906	// parameter-reference defidfn___ elem______ goes out of scope
4950	6907	// parameter-reference list<defidfn___> fndefs____ goes out of scope
4951		- state.addr = 18446744073709551373LLU; // 999999996M'''''''''''''''
	6908	+ state.addr = 18446744073709551243LLU; // 999999994K'''''''''''''''
4952	6909
4953	6910	break;
4954	6911	}
4955		- case 18446744073709551372LLU: // 999999996L'''''''''''''''
	6912	+ case 18446744073709551242LLU: // 999999994J'''''''''''''''
4956	6913	{
4957	6914	// parameter-reference u64 id________ goes out of scope
4958	6915	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 3

		@@ -4981,11 +6938,11 @@
4981	6938	uint64_t arg = 0;
4982	6939	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
4983	6940	}
4984		- state.addr = 18446744073709551369LLU; // 999999996I'''''''''''''''
	6941	+ state.addr = 18446744073709551239LLU; // 999999994G'''''''''''''''
4985	6942
4986	6943	break;
4987	6944	}
4988		- case 18446744073709551369LLU: // 999999996I'''''''''''''''
	6945	+ case 18446744073709551239LLU: // 999999994G'''''''''''''''
4989	6946	{
4990	6947	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
4991	6948	{

		@@ -4992,7 +6949,7 @@
4992	6949	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
4993	6950	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
4994	6951	{
4995		- state.addr = 18446744073709551368LLU; // 999999996H'''''''''''''''
	6952	+ state.addr = 18446744073709551238LLU; // 999999994F'''''''''''''''
4996	6953
4997	6954	break;
4998	6955	}

		@@ -5006,18 +6963,18 @@
5006	6963
5007	6964	/match_____/LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU), 0LLU));
5008	6965
5009		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551367LLU : 18446744073709551366LLU;
	6966	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551237LLU : 18446744073709551236LLU;
5010	6967
5011	6968	break;
5012	6969	}
5013		- case 18446744073709551367LLU: // 999999996G'''''''''''''''
	6970	+ case 18446744073709551237LLU: // 999999994E'''''''''''''''
5014	6971	{
5015	6972	/found_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 1LLU;
5016		- state.addr = 18446744073709551366LLU; // 999999996F'''''''''''''''
	6973	+ state.addr = 18446744073709551236LLU; // 999999994D'''''''''''''''
5017	6974
5018	6975	break;
5019	6976	}
5020		- case 18446744073709551366LLU: // 999999996F'''''''''''''''
	6977	+ case 18446744073709551236LLU: // 999999994D'''''''''''''''
5021	6978	{
5022	6979	// variable u64 match_____ goes out of scope
5023	6980	// emitted destructur for type u64

		@@ -5024,11 +6981,11 @@
5024	6981	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference match_____ at 6
5025	6982	// parameter-reference typedef___ elem______ goes out of scope
5026	6983	// parameter-reference list<typedef___> typedefs__ goes out of scope
5027		- state.addr = 18446744073709551369LLU; // 999999996I'''''''''''''''
	6984	+ state.addr = 18446744073709551239LLU; // 999999994G'''''''''''''''
5028	6985
5029	6986	break;
5030	6987	}
5031		- case 18446744073709551368LLU: // 999999996H'''''''''''''''
	6988	+ case 18446744073709551238LLU: // 999999994F'''''''''''''''
5032	6989	{
5033	6990	// parameter-reference u64 id________ goes out of scope
5034	6991	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 3

		@@ -5049,11 +7006,11 @@
5049	7006	case 696275822682439680LLU: // knowtype__
5050	7007	{
5051	7008
5052		- state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 ? 18446744073709551365LLU : 18446744073709551364LLU;
	7009	+ state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 ? 18446744073709551235LLU : 18446744073709551234LLU;
5053	7010
5054	7011	break;
5055	7012	}
5056		- case 18446744073709551365LLU: // 999999996E'''''''''''''''
	7013	+ case 18446744073709551235LLU: // 999999994C'''''''''''''''
5057	7014	{
5058	7015	{
5059	7016	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem1;

		@@ -5065,18 +7022,18 @@
5065	7022	heap.availilable_size_for_dynamic_objects += 0LLU;
5066	7023	heap.availilable_size_for_dynamic_objects += 0LLU;
5067	7024
5068		- state.addr = 18446744073709551363LLU; // 999999996C'''''''''''''''
	7025	+ state.addr = 18446744073709551233LLU; // 999999994A'''''''''''''''
5069	7026
5070	7027	break;
5071	7028	}
5072		- case 18446744073709551364LLU: // 999999996D'''''''''''''''
	7029	+ case 18446744073709551234LLU: // 999999994B'''''''''''''''
5073	7030	{
5074	7031
5075		- state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 ? 18446744073709551362LLU : 18446744073709551361LLU;
	7032	+ state.addr = 861504788261634048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 ? 18446744073709551232LLU : 18446744073709551231LLU;
5076	7033
5077	7034	break;
5078	7035	}
5079		- case 18446744073709551362LLU: // 999999996B'''''''''''''''
	7036	+ case 18446744073709551232LLU: // 999999994_'''''''''''''''
5080	7037	{
5081	7038	{
5082	7039	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem1;

		@@ -5098,7 +7055,7 @@
5098	7055	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5099	7056	}
5100	7057	// 3LLU
5101		- uint64_t return_to = 18446744073709551359LLU;
	7058	+ uint64_t return_to = 18446744073709551229LLU;
5102	7059	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5103	7060	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5104	7061	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -5108,13 +7065,13 @@
5108	7065
5109	7066	break;
5110	7067	}
5111		- case 18446744073709551359LLU: // 9999999959'''''''''''''''
	7068	+ case 18446744073709551229LLU: // 9999999937'''''''''''''''
5112	7069	{
5113		- state.addr = 18446744073709551360LLU; // 999999996_'''''''''''''''
	7070	+ state.addr = 18446744073709551230LLU; // 9999999938'''''''''''''''
5114	7071
5115	7072	break;
5116	7073	}
5117		- case 18446744073709551360LLU: // 999999996_'''''''''''''''
	7074	+ case 18446744073709551230LLU: // 9999999938'''''''''''''''
5118	7075	{
5119	7076	// parameter typename__ type______ goes out of scope
5120	7077	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 4

		@@ -5121,18 +7078,18 @@
5121	7078	heap.availilable_size_for_dynamic_objects += 0LLU;
5122	7079	heap.availilable_size_for_dynamic_objects += 0LLU;
5123	7080
5124		- state.addr = 18446744073709551358LLU; // 9999999958'''''''''''''''
	7081	+ state.addr = 18446744073709551228LLU; // 9999999936'''''''''''''''
5125	7082
5126	7083	break;
5127	7084	}
5128		- case 18446744073709551361LLU: // 999999996A'''''''''''''''
	7085	+ case 18446744073709551231LLU: // 9999999939'''''''''''''''
5129	7086	{
5130	7087
5131		- state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 ? 18446744073709551357LLU : 18446744073709551356LLU;
	7088	+ state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 ? 18446744073709551227LLU : 18446744073709551226LLU;
5132	7089
5133	7090	break;
5134	7091	}
5135		- case 18446744073709551357LLU: // 9999999957'''''''''''''''
	7092	+ case 18446744073709551227LLU: // 9999999935'''''''''''''''
5136	7093	{
5137	7094	{
5138	7095	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem1;

		@@ -5145,20 +7102,20 @@
5145	7102
5146	7103	/found_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = /sym_______/LOCAL_ACCESS(heap.data, 5LLU, 4LLU) == /type______/access_heap(heap.data, tree_elem_addr(heap.data, 1LLU, LOCAL_ACCESS_ADDR(heap.data, 5LLU, 3LLU), 0LLU));
5147	7104
5148		- state.addr = /found_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) ? 18446744073709551355LLU : 18446744073709551354LLU;
	7105	+ state.addr = /found_____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) ? 18446744073709551225LLU : 18446744073709551224LLU;
5149	7106
5150	7107	break;
5151	7108	}
5152		- case 18446744073709551355LLU: // 9999999955'''''''''''''''
	7109	+ case 18446744073709551225LLU: // 9999999933'''''''''''''''
5153	7110	{
5154	7111	heap.availilable_size_for_dynamic_objects += 0LLU;
5155	7112	heap.availilable_size_for_dynamic_objects += 0LLU;
5156	7113
5157		- state.addr = 18446744073709551353LLU; // 9999999953'''''''''''''''
	7114	+ state.addr = 18446744073709551223LLU; // 9999999931'''''''''''''''
5158	7115
5159	7116	break;
5160	7117	}
5161		- case 18446744073709551354LLU: // 9999999954'''''''''''''''
	7118	+ case 18446744073709551224LLU: // 9999999932'''''''''''''''
5162	7119	{
5163	7120	{
5164	7121	uint64_t mainresult = heap.data[0].elem0;

		@@ -5176,7 +7133,7 @@
5176	7133	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5177	7134	}
5178	7135	// 3LLU
5179		- uint64_t return_to = 18446744073709551351LLU;
	7136	+ uint64_t return_to = 18446744073709551221LLU;
5180	7137	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5181	7138	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5182	7139	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -5186,19 +7143,19 @@
5186	7143
5187	7144	break;
5188	7145	}
5189		- case 18446744073709551351LLU: // 9999999951'''''''''''''''
	7146	+ case 18446744073709551221LLU: // 999999993z'''''''''''''''
5190	7147	{
5191		- state.addr = 18446744073709551352LLU; // 9999999952'''''''''''''''
	7148	+ state.addr = 18446744073709551222LLU; // 9999999930'''''''''''''''
5192	7149
5193	7150	break;
5194	7151	}
5195		- case 18446744073709551352LLU: // 9999999952'''''''''''''''
	7152	+ case 18446744073709551222LLU: // 9999999930'''''''''''''''
5196	7153	{
5197		- state.addr = 18446744073709551353LLU; // 9999999953'''''''''''''''
	7154	+ state.addr = 18446744073709551223LLU; // 9999999931'''''''''''''''
5198	7155
5199	7156	break;
5200	7157	}
5201		- case 18446744073709551353LLU: // 9999999953'''''''''''''''
	7158	+ case 18446744073709551223LLU: // 9999999931'''''''''''''''
5202	7159	{
5203	7160	// variable u64 sym_______ goes out of scope
5204	7161	// emitted destructur for type u64

		@@ -5208,11 +7165,11 @@
5208	7165	heap.availilable_size_for_dynamic_objects += 0LLU;
5209	7166	heap.availilable_size_for_dynamic_objects += 0LLU;
5210	7167
5211		- state.addr = 18446744073709551350LLU; // 9999999950'''''''''''''''
	7168	+ state.addr = 18446744073709551220LLU; // 999999993y'''''''''''''''
5212	7169
5213	7170	break;
5214	7171	}
5215		- case 18446744073709551356LLU: // 9999999956'''''''''''''''
	7172	+ case 18446744073709551226LLU: // 9999999934'''''''''''''''
5216	7173	{
5217	7174
5218	7175	{

		@@ -5219,23 +7176,23 @@
5219	7176	fprintf(stderr, "%s\n", "missing case in knowtype");
5220	7177	exit(-1);
5221	7178	}
5222		- state.addr = 18446744073709551350LLU; // 9999999950'''''''''''''''
	7179	+ state.addr = 18446744073709551220LLU; // 999999993y'''''''''''''''
5223	7180
5224	7181	break;
5225	7182	}
5226		- case 18446744073709551350LLU: // 9999999950'''''''''''''''
	7183	+ case 18446744073709551220LLU: // 999999993y'''''''''''''''
5227	7184	{
5228		- state.addr = 18446744073709551358LLU; // 9999999958'''''''''''''''
	7185	+ state.addr = 18446744073709551228LLU; // 9999999936'''''''''''''''
5229	7186
5230	7187	break;
5231	7188	}
5232		- case 18446744073709551358LLU: // 9999999958'''''''''''''''
	7189	+ case 18446744073709551228LLU: // 9999999936'''''''''''''''
5233	7190	{
5234		- state.addr = 18446744073709551363LLU; // 999999996C'''''''''''''''
	7191	+ state.addr = 18446744073709551233LLU; // 999999994A'''''''''''''''
5235	7192
5236	7193	break;
5237	7194	}
5238		- case 18446744073709551363LLU: // 999999996C'''''''''''''''
	7195	+ case 18446744073709551233LLU: // 999999994A'''''''''''''''
5239	7196	{
5240	7197	// parameter-reference type______ type______ goes out of scope
5241	7198	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 3

		@@ -5256,11 +7213,11 @@
5256	7213	case 819847183516715616LLU: // reportline
5257	7214	{
5258	7215
5259		- state.addr = 728618437845356544LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551349LLU : 18446744073709551348LLU;
	7216	+ state.addr = 728618437845356544LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551219LLU : 18446744073709551218LLU;
5260	7217
5261	7218	break;
5262	7219	}
5263		- case 18446744073709551349LLU: // 999999995z'''''''''''''''
	7220	+ case 18446744073709551219LLU: // 999999993x'''''''''''''''
5264	7221	{
5265	7222	{
5266	7223	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem1;

		@@ -5272,18 +7229,18 @@
5272	7229	heap.availilable_size_for_dynamic_objects += 0LLU;
5273	7230	heap.availilable_size_for_dynamic_objects += 0LLU;
5274	7231
5275		- state.addr = 18446744073709551347LLU; // 999999995x'''''''''''''''
	7232	+ state.addr = 18446744073709551217LLU; // 999999993v'''''''''''''''
5276	7233
5277	7234	break;
5278	7235	}
5279		- case 18446744073709551348LLU: // 999999995y'''''''''''''''
	7236	+ case 18446744073709551218LLU: // 999999993w'''''''''''''''
5280	7237	{
5281	7238
5282		- state.addr = 787472410168262656LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551346LLU : 18446744073709551345LLU;
	7239	+ state.addr = 787472410168262656LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551216LLU : 18446744073709551215LLU;
5283	7240
5284	7241	break;
5285	7242	}
5286		- case 18446744073709551346LLU: // 999999995w'''''''''''''''
	7243	+ case 18446744073709551216LLU: // 999999993u'''''''''''''''
5287	7244	{
5288	7245	{
5289	7246	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem1;

		@@ -5295,18 +7252,18 @@
5295	7252	heap.availilable_size_for_dynamic_objects += 0LLU;
5296	7253	heap.availilable_size_for_dynamic_objects += 0LLU;
5297	7254
5298		- state.addr = 18446744073709551344LLU; // 999999995u'''''''''''''''
	7255	+ state.addr = 18446744073709551214LLU; // 999999993s'''''''''''''''
5299	7256
5300	7257	break;
5301	7258	}
5302		- case 18446744073709551345LLU: // 999999995v'''''''''''''''
	7259	+ case 18446744073709551215LLU: // 999999993t'''''''''''''''
5303	7260	{
5304	7261
5305		- state.addr = 552437437528276992LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551343LLU : 18446744073709551342LLU;
	7262	+ state.addr = 552437437528276992LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 ? 18446744073709551213LLU : 18446744073709551212LLU;
5306	7263
5307	7264	break;
5308	7265	}
5309		- case 18446744073709551343LLU: // 999999995t'''''''''''''''
	7266	+ case 18446744073709551213LLU: // 999999993r'''''''''''''''
5310	7267	{
5311	7268	{
5312	7269	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem1;

		@@ -5318,11 +7275,11 @@
5318	7275	heap.availilable_size_for_dynamic_objects += 0LLU;
5319	7276	heap.availilable_size_for_dynamic_objects += 0LLU;
5320	7277
5321		- state.addr = 18446744073709551341LLU; // 999999995r'''''''''''''''
	7278	+ state.addr = 18446744073709551211LLU; // 999999993p'''''''''''''''
5322	7279
5323	7280	break;
5324	7281	}
5325		- case 18446744073709551342LLU: // 999999995s'''''''''''''''
	7282	+ case 18446744073709551212LLU: // 999999993q'''''''''''''''
5326	7283	{
5327	7284
5328	7285	{

		@@ -5329,23 +7286,23 @@
5329	7286	fprintf(stderr, "%s\n", "reportline unknown constructor");
5330	7287	exit(-1);
5331	7288	}
5332		- state.addr = 18446744073709551341LLU; // 999999995r'''''''''''''''
	7289	+ state.addr = 18446744073709551211LLU; // 999999993p'''''''''''''''
5333	7290
5334	7291	break;
5335	7292	}
5336		- case 18446744073709551341LLU: // 999999995r'''''''''''''''
	7293	+ case 18446744073709551211LLU: // 999999993p'''''''''''''''
5337	7294	{
5338		- state.addr = 18446744073709551344LLU; // 999999995u'''''''''''''''
	7295	+ state.addr = 18446744073709551214LLU; // 999999993s'''''''''''''''
5339	7296
5340	7297	break;
5341	7298	}
5342		- case 18446744073709551344LLU: // 999999995u'''''''''''''''
	7299	+ case 18446744073709551214LLU: // 999999993s'''''''''''''''
5343	7300	{
5344		- state.addr = 18446744073709551347LLU; // 999999995x'''''''''''''''
	7301	+ state.addr = 18446744073709551217LLU; // 999999993v'''''''''''''''
5345	7302
5346	7303	break;
5347	7304	}
5348		- case 18446744073709551347LLU: // 999999995x'''''''''''''''
	7305	+ case 18446744073709551217LLU: // 999999993v'''''''''''''''
5349	7306	{
5350	7307	// parameter-reference linear____ linearity_ goes out of scope
5351	7308	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference linearity_ at 1

		@@ -5369,7 +7326,7 @@
5369	7326	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5370	7327	}
5371	7328	// 1LLU
5372		- uint64_t return_to = 18446744073709551339LLU;
	7329	+ uint64_t return_to = 18446744073709551209LLU;
5373	7330	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5374	7331	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5375	7332	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -5379,27 +7336,27 @@
5379	7336
5380	7337	break;
5381	7338	}
5382		- case 18446744073709551339LLU: // 999999995p'''''''''''''''
	7339	+ case 18446744073709551209LLU: // 999999993n'''''''''''''''
5383	7340	{
5384		- state.addr = 18446744073709551340LLU; // 999999995q'''''''''''''''
	7341	+ state.addr = 18446744073709551210LLU; // 999999993o'''''''''''''''
5385	7342
5386	7343	break;
5387	7344	}
5388		- case 18446744073709551340LLU: // 999999995q'''''''''''''''
	7345	+ case 18446744073709551210LLU: // 999999993o'''''''''''''''
5389	7346	{
5390	7347
5391		- state.addr = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 2LLU)) ? 18446744073709551338LLU : 18446744073709551337LLU;
	7348	+ state.addr = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 2LLU)) ? 18446744073709551208LLU : 18446744073709551207LLU;
5392	7349
5393	7350	break;
5394	7351	}
5395		- case 18446744073709551338LLU: // 999999995o'''''''''''''''
	7352	+ case 18446744073709551208LLU: // 999999993m'''''''''''''''
5396	7353	{
5397	7354	fprintf(stderr, "%s", "mut ");
5398		- state.addr = 18446744073709551337LLU; // 999999995n'''''''''''''''
	7355	+ state.addr = 18446744073709551207LLU; // 999999993l'''''''''''''''
5399	7356
5400	7357	break;
5401	7358	}
5402		- case 18446744073709551337LLU: // 999999995n'''''''''''''''
	7359	+ case 18446744073709551207LLU: // 999999993l'''''''''''''''
5403	7360	{
5404	7361	{
5405	7362	uint64_t mainresult = heap.data[0].elem0;

		@@ -5409,7 +7366,7 @@
5409	7366	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5410	7367	}
5411	7368	// 1LLU
5412		- uint64_t return_to = 18446744073709551335LLU;
	7369	+ uint64_t return_to = 18446744073709551205LLU;
5413	7370	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5414	7371	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5415	7372	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -5419,13 +7376,13 @@
5419	7376
5420	7377	break;
5421	7378	}
5422		- case 18446744073709551335LLU: // 999999995l'''''''''''''''
	7379	+ case 18446744073709551205LLU: // 999999993j'''''''''''''''
5423	7380	{
5424		- state.addr = 18446744073709551336LLU; // 999999995m'''''''''''''''
	7381	+ state.addr = 18446744073709551206LLU; // 999999993k'''''''''''''''
5425	7382
5426	7383	break;
5427	7384	}
5428		- case 18446744073709551336LLU: // 999999995m'''''''''''''''
	7385	+ case 18446744073709551206LLU: // 999999993k'''''''''''''''
5429	7386	{
5430	7387	fprintf(stderr, "%s", " ");
5431	7388

		@@ -5452,7 +7409,7 @@
5452	7409	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5453	7410	}
5454	7411	// 1LLU
5455		- uint64_t return_to = 18446744073709551333LLU;
	7412	+ uint64_t return_to = 18446744073709551203LLU;
5456	7413	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5457	7414	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5458	7415	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -5462,36 +7419,36 @@
5462	7419
5463	7420	break;
5464	7421	}
5465		- case 18446744073709551333LLU: // 999999995j'''''''''''''''
	7422	+ case 18446744073709551203LLU: // 999999993h'''''''''''''''
5466	7423	{
5467		- state.addr = 18446744073709551334LLU; // 999999995k'''''''''''''''
	7424	+ state.addr = 18446744073709551204LLU; // 999999993i'''''''''''''''
5468	7425
5469	7426	break;
5470	7427	}
5471		- case 18446744073709551334LLU: // 999999995k'''''''''''''''
	7428	+ case 18446744073709551204LLU: // 999999993i'''''''''''''''
5472	7429	{
5473	7430
5474		- state.addr = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 2LLU)) ? 18446744073709551332LLU : 18446744073709551331LLU;
	7431	+ state.addr = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 2LLU)) ? 18446744073709551202LLU : 18446744073709551201LLU;
5475	7432
5476	7433	break;
5477	7434	}
5478		- case 18446744073709551332LLU: // 999999995i'''''''''''''''
	7435	+ case 18446744073709551202LLU: // 999999993g'''''''''''''''
5479	7436	{
5480	7437	heap.availilable_size_for_dynamic_objects += 0LLU;
5481	7438	heap.availilable_size_for_dynamic_objects += 0LLU;
5482	7439
5483		- state.addr = 18446744073709551330LLU; // 999999995g'''''''''''''''
	7440	+ state.addr = 18446744073709551200LLU; // 999999993e'''''''''''''''
5484	7441
5485	7442	break;
5486	7443	}
5487		- case 18446744073709551331LLU: // 999999995h'''''''''''''''
	7444	+ case 18446744073709551201LLU: // 999999993f'''''''''''''''
5488	7445	{
5489	7446	fprintf(stderr, "%s", "#");
5490		- state.addr = 18446744073709551330LLU; // 999999995g'''''''''''''''
	7447	+ state.addr = 18446744073709551200LLU; // 999999993e'''''''''''''''
5491	7448
5492	7449	break;
5493	7450	}
5494		- case 18446744073709551330LLU: // 999999995g'''''''''''''''
	7451	+ case 18446744073709551200LLU: // 999999993e'''''''''''''''
5495	7452	{
5496	7453	fprintf(stderr, "%s", "(");
5497	7454	fprintf(stderr, "%llu", (unsigned long long)/par_______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU)));

		@@ -5514,11 +7471,11 @@
5514	7471	uint64_t mainresult = heap.data[0].elem0;
5515	7472	heap.data[0].elem0 = 0;
5516	7473	{
5517		- uint64_t arg = /par_______/tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
	7474	+ uint64_t arg = /elem______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
5518	7475	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5519	7476	}
5520	7477	// 1LLU
5521		- uint64_t return_to = 18446744073709551328LLU;
	7478	+ uint64_t return_to = 18446744073709551198LLU;
5522	7479	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5523	7480	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5524	7481	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -5528,19 +7485,19 @@
5528	7485
5529	7486	break;
5530	7487	}
5531		- case 18446744073709551328LLU: // 999999995e'''''''''''''''
	7488	+ case 18446744073709551198LLU: // 999999993c'''''''''''''''
5532	7489	{
5533		- state.addr = 18446744073709551329LLU; // 999999995f'''''''''''''''
	7490	+ state.addr = 18446744073709551199LLU; // 999999993d'''''''''''''''
5534	7491
5535	7492	break;
5536	7493	}
5537		- case 18446744073709551329LLU: // 999999995f'''''''''''''''
	7494	+ case 18446744073709551199LLU: // 999999993d'''''''''''''''
5538	7495	{
5539	7496	fprintf(stderr, "%s", " ");
5540	7497
5541		- printid(stderr, /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 0LLU)));
5542		- // parameter-reference pardef____ par_______ goes out of scope
5543		- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par_______ at 1
	7498	+ printid(stderr, /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 0LLU)));
	7499	+ // parameter-reference elemdef___ elem______ goes out of scope
	7500	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference elem______ at 1
5544	7501
5545	7502	{
5546	7503	uint64_t baseinfo = heap.data[0].elem1;

		@@ -5554,97 +7511,97 @@
5554	7511	case 819847183514344320LLU: // reportcfs_
5555	7512	{
5556	7513
5557		- state.addr = /safe______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU)) ? 18446744073709551327LLU : 18446744073709551326LLU;
	7514	+ state.addr = /safe______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU)) ? 18446744073709551197LLU : 18446744073709551196LLU;
5558	7515
5559	7516	break;
5560	7517	}
5561		- case 18446744073709551327LLU: // 999999995d'''''''''''''''
	7518	+ case 18446744073709551197LLU: // 999999993b'''''''''''''''
5562	7519	{
5563	7520
5564		- state.addr = /finite____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) ? 18446744073709551325LLU : 18446744073709551324LLU;
	7521	+ state.addr = /finite____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) ? 18446744073709551195LLU : 18446744073709551194LLU;
5565	7522
5566	7523	break;
5567	7524	}
5568		- case 18446744073709551325LLU: // 999999995b'''''''''''''''
	7525	+ case 18446744073709551195LLU: // 999999993$'''''''''''''''
5569	7526	{
5570	7527
5571		- state.addr = /complete__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551323LLU : 18446744073709551322LLU;
	7528	+ state.addr = /complete__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551193LLU : 18446744073709551192LLU;
5572	7529
5573	7530	break;
5574	7531	}
5575		- case 18446744073709551323LLU: // 999999995$'''''''''''''''
	7532	+ case 18446744073709551193LLU: // 999999993Y'''''''''''''''
5576	7533	{
5577	7534	fprintf(stderr, "%s", "total");
5578	7535	heap.availilable_size_for_dynamic_objects += 0LLU;
5579	7536	heap.availilable_size_for_dynamic_objects += 0LLU;
5580	7537
5581		- state.addr = 18446744073709551321LLU; // 999999995Y'''''''''''''''
	7538	+ state.addr = 18446744073709551191LLU; // 999999993W'''''''''''''''
5582	7539
5583	7540	break;
5584	7541	}
5585		- case 18446744073709551322LLU: // 999999995Z'''''''''''''''
	7542	+ case 18446744073709551192LLU: // 999999993X'''''''''''''''
5586	7543	{
5587	7544	fprintf(stderr, "%s", "finite");
5588		- state.addr = 18446744073709551321LLU; // 999999995Y'''''''''''''''
	7545	+ state.addr = 18446744073709551191LLU; // 999999993W'''''''''''''''
5589	7546
5590	7547	break;
5591	7548	}
5592		- case 18446744073709551321LLU: // 999999995Y'''''''''''''''
	7549	+ case 18446744073709551191LLU: // 999999993W'''''''''''''''
5593	7550	{
5594	7551	heap.availilable_size_for_dynamic_objects += 0LLU;
5595	7552	heap.availilable_size_for_dynamic_objects += 0LLU;
5596	7553
5597		- state.addr = 18446744073709551320LLU; // 999999995X'''''''''''''''
	7554	+ state.addr = 18446744073709551190LLU; // 999999993V'''''''''''''''
5598	7555
5599	7556	break;
5600	7557	}
5601		- case 18446744073709551324LLU: // 999999995a'''''''''''''''
	7558	+ case 18446744073709551194LLU: // 999999993Z'''''''''''''''
5602	7559	{
5603	7560
5604		- state.addr = /complete__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551319LLU : 18446744073709551318LLU;
	7561	+ state.addr = /complete__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) ? 18446744073709551189LLU : 18446744073709551188LLU;
5605	7562
5606	7563	break;
5607	7564	}
5608		- case 18446744073709551319LLU: // 999999995W'''''''''''''''
	7565	+ case 18446744073709551189LLU: // 999999993U'''''''''''''''
5609	7566	{
5610	7567	fprintf(stderr, "%s", "complete");
5611	7568	heap.availilable_size_for_dynamic_objects += 0LLU;
5612	7569	heap.availilable_size_for_dynamic_objects += 0LLU;
5613	7570
5614		- state.addr = 18446744073709551317LLU; // 999999995U'''''''''''''''
	7571	+ state.addr = 18446744073709551187LLU; // 999999993S'''''''''''''''
5615	7572
5616	7573	break;
5617	7574	}
5618		- case 18446744073709551318LLU: // 999999995V'''''''''''''''
	7575	+ case 18446744073709551188LLU: // 999999993T'''''''''''''''
5619	7576	{
5620	7577	fprintf(stderr, "%s", "partial");
5621		- state.addr = 18446744073709551317LLU; // 999999995U'''''''''''''''
	7578	+ state.addr = 18446744073709551187LLU; // 999999993S'''''''''''''''
5622	7579
5623	7580	break;
5624	7581	}
5625		- case 18446744073709551317LLU: // 999999995U'''''''''''''''
	7582	+ case 18446744073709551187LLU: // 999999993S'''''''''''''''
5626	7583	{
5627		- state.addr = 18446744073709551320LLU; // 999999995X'''''''''''''''
	7584	+ state.addr = 18446744073709551190LLU; // 999999993V'''''''''''''''
5628	7585
5629	7586	break;
5630	7587	}
5631		- case 18446744073709551320LLU: // 999999995X'''''''''''''''
	7588	+ case 18446744073709551190LLU: // 999999993V'''''''''''''''
5632	7589	{
5633	7590	heap.availilable_size_for_dynamic_objects += 0LLU;
5634	7591	heap.availilable_size_for_dynamic_objects += 0LLU;
5635	7592
5636		- state.addr = 18446744073709551316LLU; // 999999995T'''''''''''''''
	7593	+ state.addr = 18446744073709551186LLU; // 999999993R'''''''''''''''
5637	7594
5638	7595	break;
5639	7596	}
5640		- case 18446744073709551326LLU: // 999999995c'''''''''''''''
	7597	+ case 18446744073709551196LLU: // 999999993a'''''''''''''''
5641	7598	{
5642	7599	fprintf(stderr, "%s", "unsafe");
5643		- state.addr = 18446744073709551316LLU; // 999999995T'''''''''''''''
	7600	+ state.addr = 18446744073709551186LLU; // 999999993R'''''''''''''''
5644	7601
5645	7602	break;
5646	7603	}
5647		- case 18446744073709551316LLU: // 999999995T'''''''''''''''
	7604	+ case 18446744073709551186LLU: // 999999993R'''''''''''''''
5648	7605	{
5649	7606	// parameter-reference u64 safe______ goes out of scope
5650	7607	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference safe______ at 3

		@@ -5668,19 +7625,19 @@
5668	7625	uint64_t mainresult = heap.data[0].elem0;
5669	7626	heap.data[0].elem0 = 0;
5670	7627	{
5671		- uint64_t arg = /kind______/tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 4LLU);
	7628	+ uint64_t arg = /kind______/tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 4LLU);
5672	7629	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5673	7630	}
5674	7631	{
5675		- uint64_t arg = /kind______/tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 5LLU);
	7632	+ uint64_t arg = /kind______/tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 5LLU);
5676	7633	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5677	7634	}
5678	7635	{
5679		- uint64_t arg = /kind______/tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 6LLU);
	7636	+ uint64_t arg = /kind______/tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 6LLU);
5680	7637	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5681	7638	}
5682	7639	// 3LLU
5683		- uint64_t return_to = 18446744073709551314LLU;
	7640	+ uint64_t return_to = 18446744073709551184LLU;
5684	7641	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5685	7642	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5686	7643	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -5690,51 +7647,51 @@
5690	7647
5691	7648	break;
5692	7649	}
5693		- case 18446744073709551314LLU: // 999999995R'''''''''''''''
	7650	+ case 18446744073709551184LLU: // 999999993P'''''''''''''''
5694	7651	{
5695		- state.addr = 18446744073709551315LLU; // 999999995S'''''''''''''''
	7652	+ state.addr = 18446744073709551185LLU; // 999999993Q'''''''''''''''
5696	7653
5697	7654	break;
5698	7655	}
5699		- case 18446744073709551315LLU: // 999999995S'''''''''''''''
	7656	+ case 18446744073709551185LLU: // 999999993Q'''''''''''''''
5700	7657	{
5701	7658	fprintf(stderr, "%s", " ");
5702	7659	fprintf(stderr, "%s", "(");
5703	7660	{
5704		- uint64_t arg = /kind______/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU));
5705		- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
	7661	+ uint64_t arg = /kind______/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 0LLU));
	7662	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5706	7663	}
5707	7664	{
5708	7665	uint64_t arg = 0;
5709		- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	7666	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
5710	7667	}
5711		- state.addr = 18446744073709551313LLU; // 999999995Q'''''''''''''''
	7668	+ state.addr = 18446744073709551183LLU; // 999999993O'''''''''''''''
5712	7669
5713	7670	break;
5714	7671	}
5715		- case 18446744073709551313LLU: // 999999995Q'''''''''''''''
	7672	+ case 18446744073709551183LLU: // 999999993O'''''''''''''''
5716	7673	{
5717		- if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
	7674	+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
5718	7675	{
	7676	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
5719	7677	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5720		- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
5721	7678	{
5722		- state.addr = 18446744073709551312LLU; // 999999995P'''''''''''''''
	7679	+ state.addr = 18446744073709551182LLU; // 999999993N'''''''''''''''
5723	7680
5724	7681	break;
5725	7682	}
5726	7683	}
5727		- /direct/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
5728		- LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
	7684	+ /direct/LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
	7685	+ LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
5729	7686	{
5730	7687	uint64_t mainresult = heap.data[0].elem0;
5731	7688	heap.data[0].elem0 = 0;
5732	7689	{
5733		- uint64_t arg = /par_______/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
	7690	+ uint64_t arg = /par_______/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU);
5734	7691	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5735	7692	}
5736	7693	// 1LLU
5737		- uint64_t return_to = 18446744073709551310LLU;
	7694	+ uint64_t return_to = 18446744073709551180LLU;
5738	7695	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5739	7696	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5740	7697	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -5744,61 +7701,61 @@
5744	7701
5745	7702	break;
5746	7703	}
5747		- case 18446744073709551310LLU: // 999999995N'''''''''''''''
	7704	+ case 18446744073709551180LLU: // 999999993L'''''''''''''''
5748	7705	{
5749		- state.addr = 18446744073709551311LLU; // 999999995O'''''''''''''''
	7706	+ state.addr = 18446744073709551181LLU; // 999999993M'''''''''''''''
5750	7707
5751	7708	break;
5752	7709	}
5753		- case 18446744073709551311LLU: // 999999995O'''''''''''''''
	7710	+ case 18446744073709551181LLU: // 999999993M'''''''''''''''
5754	7711	{
5755	7712	// parameter-reference resdest___ par_______ goes out of scope
5756	7713	// parameter-reference function__ kind______ goes out of scope
5757		- state.addr = 18446744073709551313LLU; // 999999995Q'''''''''''''''
	7714	+ state.addr = 18446744073709551183LLU; // 999999993O'''''''''''''''
5758	7715
5759	7716	break;
5760	7717	}
5761		- case 18446744073709551312LLU: // 999999995P'''''''''''''''
	7718	+ case 18446744073709551182LLU: // 999999993N'''''''''''''''
5762	7719	{
5763	7720	fprintf(stderr, "%s", ") ");
5764	7721
5765		- printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU)));
	7722	+ printid(stderr, /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 0LLU)));
5766	7723	fprintf(stderr, "%s", "(");
5767	7724	{
5768		- uint64_t arg = /kind______/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU));
5769		- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/address of current closure/, &arg);
	7725	+ uint64_t arg = /kind______/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU));
	7726	+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5770	7727	}
5771	7728	{
5772	7729	uint64_t arg = 0;
5773		- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
	7730	+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
5774	7731	}
5775		- state.addr = 18446744073709551309LLU; // 999999995M'''''''''''''''
	7732	+ state.addr = 18446744073709551179LLU; // 999999993K'''''''''''''''
5776	7733
5777	7734	break;
5778	7735	}
5779		- case 18446744073709551309LLU: // 999999995M'''''''''''''''
	7736	+ case 18446744073709551179LLU: // 999999993K'''''''''''''''
5780	7737	{
5781		- if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
	7738	+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
5782	7739	{
	7740	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
5783	7741	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5784		- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
5785	7742	{
5786		- state.addr = 18446744073709551308LLU; // 999999995L'''''''''''''''
	7743	+ state.addr = 18446744073709551178LLU; // 999999993J'''''''''''''''
5787	7744
5788	7745	break;
5789	7746	}
5790	7747	}
5791		- /direct/LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
5792		- LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
	7748	+ /direct/LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
	7749	+ LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
5793	7750	{
5794	7751	uint64_t mainresult = heap.data[0].elem0;
5795	7752	heap.data[0].elem0 = 0;
5796	7753	{
5797		- uint64_t arg = /par_______/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
	7754	+ uint64_t arg = /par_______/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU);
5798	7755	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5799	7756	}
5800	7757	// 1LLU
5801		- uint64_t return_to = 18446744073709551306LLU;
	7758	+ uint64_t return_to = 18446744073709551176LLU;
5802	7759	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5803	7760	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5804	7761	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -5808,22 +7765,22 @@
5808	7765
5809	7766	break;
5810	7767	}
5811		- case 18446744073709551306LLU: // 999999995J'''''''''''''''
	7768	+ case 18446744073709551176LLU: // 999999993H'''''''''''''''
5812	7769	{
5813		- state.addr = 18446744073709551307LLU; // 999999995K'''''''''''''''
	7770	+ state.addr = 18446744073709551177LLU; // 999999993I'''''''''''''''
5814	7771
5815	7772	break;
5816	7773	}
5817		- case 18446744073709551307LLU: // 999999995K'''''''''''''''
	7774	+ case 18446744073709551177LLU: // 999999993I'''''''''''''''
5818	7775	{
5819	7776	fprintf(stderr, "%s", " ");
5820	7777	// parameter-reference pardef____ par_______ goes out of scope
5821	7778	// parameter-reference function__ kind______ goes out of scope
5822		- state.addr = 18446744073709551309LLU; // 999999995M'''''''''''''''
	7779	+ state.addr = 18446744073709551179LLU; // 999999993K'''''''''''''''
5823	7780
5824	7781	break;
5825	7782	}
5826		- case 18446744073709551308LLU: // 999999995L'''''''''''''''
	7783	+ case 18446744073709551178LLU: // 999999993J'''''''''''''''
5827	7784	{
5828	7785	fprintf(stderr, "%s", ") ");
5829	7786	{

		@@ -5830,11 +7787,11 @@
5830	7787	uint64_t mainresult = heap.data[0].elem0;
5831	7788	heap.data[0].elem0 = 0;
5832	7789	{
5833		- uint64_t arg = /kind______/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 3LLU));
	7790	+ uint64_t arg = /kind______/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 3LLU));
5834	7791	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5835	7792	}
5836	7793	// 1LLU
5837		- uint64_t return_to = 18446744073709551304LLU;
	7794	+ uint64_t return_to = 18446744073709551174LLU;
5838	7795	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5839	7796	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5840	7797	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -5844,13 +7801,13 @@
5844	7801
5845	7802	break;
5846	7803	}
5847		- case 18446744073709551304LLU: // 999999995H'''''''''''''''
	7804	+ case 18446744073709551174LLU: // 999999993F'''''''''''''''
5848	7805	{
5849		- state.addr = 18446744073709551305LLU; // 999999995I'''''''''''''''
	7806	+ state.addr = 18446744073709551175LLU; // 999999993G'''''''''''''''
5850	7807
5851	7808	break;
5852	7809	}
5853		- case 18446744073709551305LLU: // 999999995I'''''''''''''''
	7810	+ case 18446744073709551175LLU: // 999999993G'''''''''''''''
5854	7811	{
5855	7812	fprintf(stderr, "%s", " ");
5856	7813	{

		@@ -5857,11 +7814,11 @@
5857	7814	uint64_t mainresult = heap.data[0].elem0;
5858	7815	heap.data[0].elem0 = 0;
5859	7816	{
5860		- uint64_t arg = /kind______/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 2LLU));
	7817	+ uint64_t arg = /kind______/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 2LLU));
5861	7818	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5862	7819	}
5863	7820	// 1LLU
5864		- uint64_t return_to = 18446744073709551302LLU;
	7821	+ uint64_t return_to = 18446744073709551172LLU;
5865	7822	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5866	7823	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5867	7824	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -5871,15 +7828,42 @@
5871	7828
5872	7829	break;
5873	7830	}
5874		- case 18446744073709551302LLU: // 999999995F'''''''''''''''
	7831	+ case 18446744073709551172LLU: // 999999993D'''''''''''''''
5875	7832	{
5876		- state.addr = 18446744073709551303LLU; // 999999995G'''''''''''''''
	7833	+ state.addr = 18446744073709551173LLU; // 999999993E'''''''''''''''
5877	7834
5878	7835	break;
5879	7836	}
5880		- case 18446744073709551303LLU: // 999999995G'''''''''''''''
	7837	+ case 18446744073709551173LLU: // 999999993E'''''''''''''''
5881	7838	{
	7839	+ fprintf(stderr, "%s", " ");
	7840	+
	7841	+ state.addr = /defined___/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 2LLU)) ? 18446744073709551171LLU : 18446744073709551170LLU;
	7842	+
	7843	+ break;
	7844	+ }
	7845	+ case 18446744073709551171LLU: // 999999993C'''''''''''''''
	7846	+ {
	7847	+ fprintf(stderr, "%s", "DEFINITION");
	7848	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	7849	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	7850	+
	7851	+ state.addr = 18446744073709551169LLU; // 999999993A'''''''''''''''
	7852	+
	7853	+ break;
	7854	+ }
	7855	+ case 18446744073709551170LLU: // 999999993B'''''''''''''''
	7856	+ {
	7857	+ fprintf(stderr, "%s", "DECLARATION");
	7858	+ state.addr = 18446744073709551169LLU; // 999999993A'''''''''''''''
	7859	+
	7860	+ break;
	7861	+ }
	7862	+ case 18446744073709551169LLU: // 999999993A'''''''''''''''
	7863	+ {
5882	7864	fprintf(stderr, "%s", "\n");
	7865	+ // parameter-reference u64 defined___ goes out of scope
	7866	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference defined___ at 3
5883	7867	// parameter-reference function__ kind______ goes out of scope
5884	7868	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference kind______ at 2
5885	7869	// parameter-reference u64 id________ goes out of scope

		@@ -5904,11 +7888,11 @@
5904	7888	uint64_t arg = 0;
5905	7889	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
5906	7890	}
5907		- state.addr = 18446744073709551301LLU; // 999999995E'''''''''''''''
	7891	+ state.addr = 18446744073709551168LLU; // 999999993_'''''''''''''''
5908	7892
5909	7893	break;
5910	7894	}
5911		- case 18446744073709551301LLU: // 999999995E'''''''''''''''
	7895	+ case 18446744073709551168LLU: // 999999993_'''''''''''''''
5912	7896	{
5913	7897	if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
5914	7898	{

		@@ -5915,7 +7899,7 @@
5915	7899	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
5916	7900	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
5917	7901	{
5918		- state.addr = 18446744073709551300LLU; // 999999995D'''''''''''''''
	7902	+ state.addr = 18446744073709551167LLU; // 9999999929'''''''''''''''
5919	7903
5920	7904	break;
5921	7905	}

		@@ -5926,17 +7910,21 @@
5926	7910	uint64_t mainresult = heap.data[0].elem0;
5927	7911	heap.data[0].elem0 = 0;
5928	7912	{
5929		- uint64_t arg = /def_______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 0LLU);
	7913	+ uint64_t arg = /def_______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 0LLU);
5930	7914	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5931	7915	}
5932	7916	{
5933		- uint64_t arg = /def_______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 1LLU);
	7917	+ uint64_t arg = /def_______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 1LLU);
5934	7918	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
5935	7919	}
5936		- // 2LLU
5937		- uint64_t return_to = 18446744073709551298LLU;
	7920	+ {
	7921	+ uint64_t arg = /def_______/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 2LLU);
	7922	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	7923	+ }
	7924	+ // 3LLU
	7925	+ uint64_t return_to = 18446744073709551165LLU;
5938	7926	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
5939		- access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	7927	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
5940	7928	heap.data[0].elem1 = heap.data[0].elem0;
5941	7929	heap.data[0].elem0 = mainresult;
5942	7930	}

		@@ -5944,21 +7932,21 @@
5944	7932
5945	7933	break;
5946	7934	}
5947		- case 18446744073709551298LLU: // 999999995B'''''''''''''''
	7935	+ case 18446744073709551165LLU: // 9999999927'''''''''''''''
5948	7936	{
5949		- state.addr = 18446744073709551299LLU; // 999999995C'''''''''''''''
	7937	+ state.addr = 18446744073709551166LLU; // 9999999928'''''''''''''''
5950	7938
5951	7939	break;
5952	7940	}
5953		- case 18446744073709551299LLU: // 999999995C'''''''''''''''
	7941	+ case 18446744073709551166LLU: // 9999999928'''''''''''''''
5954	7942	{
5955	7943	// parameter-reference defidfn___ def_______ goes out of scope
5956	7944	// parameter-reference list<defidfn___> fndefs____ goes out of scope
5957		- state.addr = 18446744073709551301LLU; // 999999995E'''''''''''''''
	7945	+ state.addr = 18446744073709551168LLU; // 999999993_'''''''''''''''
5958	7946
5959	7947	break;
5960	7948	}
5961		- case 18446744073709551300LLU: // 999999995D'''''''''''''''
	7949	+ case 18446744073709551167LLU: // 9999999929'''''''''''''''
5962	7950	{
5963	7951	// parameter-reference list<defidfn___> fndefs____ goes out of scope
5964	7952	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference fndefs____ at 2

		@@ -5977,11 +7965,11 @@
5977	7965	case 819847183518878400LLU: // reporttyp_
5978	7966	{
5979	7967
5980		- state.addr = 861519017821270016LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551297LLU : 18446744073709551296LLU;
	7968	+ state.addr = 861519017821270016LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551164LLU : 18446744073709551163LLU;
5981	7969
5982	7970	break;
5983	7971	}
5984		- case 18446744073709551297LLU: // 999999995A'''''''''''''''
	7972	+ case 18446744073709551164LLU: // 9999999926'''''''''''''''
5985	7973	{
5986	7974	{
5987	7975	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -5999,11 +7987,11 @@
5999	7987	uint64_t arg = 0;
6000	7988	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
6001	7989	}
6002		- state.addr = 18446744073709551295LLU; // 9999999949'''''''''''''''
	7990	+ state.addr = 18446744073709551162LLU; // 9999999924'''''''''''''''
6003	7991
6004	7992	break;
6005	7993	}
6006		- case 18446744073709551295LLU: // 9999999949'''''''''''''''
	7994	+ case 18446744073709551162LLU: // 9999999924'''''''''''''''
6007	7995	{
6008	7996	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
6009	7997	{

		@@ -6010,7 +7998,7 @@
6010	7998	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
6011	7999	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
6012	8000	{
6013		- state.addr = 18446744073709551294LLU; // 9999999948'''''''''''''''
	8001	+ state.addr = 18446744073709551161LLU; // 9999999923'''''''''''''''
6014	8002
6015	8003	break;
6016	8004	}

		@@ -6025,32 +8013,32 @@
6025	8013	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6026	8014	}
6027	8015	// 1LLU
6028		- uint64_t return_to = 18446744073709551292LLU;
	8016	+ uint64_t return_to = 18446744073709551159LLU;
6029	8017	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6030	8018	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6031	8019	heap.data[0].elem1 = heap.data[0].elem0;
6032	8020	heap.data[0].elem0 = mainresult;
6033	8021	}
6034		- state.addr = 819847183517731648LLU; // reportpar_
	8022	+ state.addr = 819847183514892328LLU; // reportelem
6035	8023
6036	8024	break;
6037	8025	}
6038		- case 18446744073709551292LLU: // 9999999946'''''''''''''''
	8026	+ case 18446744073709551159LLU: // 9999999921'''''''''''''''
6039	8027	{
6040		- state.addr = 18446744073709551293LLU; // 9999999947'''''''''''''''
	8028	+ state.addr = 18446744073709551160LLU; // 9999999922'''''''''''''''
6041	8029
6042	8030	break;
6043	8031	}
6044		- case 18446744073709551293LLU: // 9999999947'''''''''''''''
	8032	+ case 18446744073709551160LLU: // 9999999922'''''''''''''''
6045	8033	{
6046	8034	fprintf(stderr, "%s", " ");
6047		- // parameter-reference pardef____ par_______ goes out of scope
	8035	+ // parameter-reference elemdef___ par_______ goes out of scope
6048	8036	// parameter tystruct__ kind______ goes out of scope
6049		- state.addr = 18446744073709551295LLU; // 9999999949'''''''''''''''
	8037	+ state.addr = 18446744073709551162LLU; // 9999999924'''''''''''''''
6050	8038
6051	8039	break;
6052	8040	}
6053		- case 18446744073709551294LLU: // 9999999948'''''''''''''''
	8041	+ case 18446744073709551161LLU: // 9999999923'''''''''''''''
6054	8042	{
6055	8043	fprintf(stderr, "%s", ") 0 ");
6056	8044	{

		@@ -6061,7 +8049,7 @@
6061	8049	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6062	8050	}
6063	8051	// 1LLU
6064		- uint64_t return_to = 18446744073709551290LLU;
	8052	+ uint64_t return_to = 18446744073709551157LLU;
6065	8053	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6066	8054	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6067	8055	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -6071,13 +8059,13 @@
6071	8059
6072	8060	break;
6073	8061	}
6074		- case 18446744073709551290LLU: // 9999999944'''''''''''''''
	8062	+ case 18446744073709551157LLU: // 999999992z'''''''''''''''
6075	8063	{
6076		- state.addr = 18446744073709551291LLU; // 9999999945'''''''''''''''
	8064	+ state.addr = 18446744073709551158LLU; // 9999999920'''''''''''''''
6077	8065
6078	8066	break;
6079	8067	}
6080		- case 18446744073709551291LLU: // 9999999945'''''''''''''''
	8068	+ case 18446744073709551158LLU: // 9999999920'''''''''''''''
6081	8069	{
6082	8070	// parameter tystruct__ kind______ goes out of scope
6083	8071	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference kind______ at 3

		@@ -6084,18 +8072,18 @@
6084	8072	heap.availilable_size_for_dynamic_objects += 0LLU;
6085	8073	heap.availilable_size_for_dynamic_objects += 0LLU;
6086	8074
6087		- state.addr = 18446744073709551289LLU; // 9999999943'''''''''''''''
	8075	+ state.addr = 18446744073709551156LLU; // 999999992y'''''''''''''''
6088	8076
6089	8077	break;
6090	8078	}
6091		- case 18446744073709551296LLU: // 999999995_'''''''''''''''
	8079	+ case 18446744073709551163LLU: // 9999999925'''''''''''''''
6092	8080	{
6093	8081
6094		- state.addr = 861527391835906048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551288LLU : 18446744073709551287LLU;
	8082	+ state.addr = 861527391835906048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551155LLU : 18446744073709551154LLU;
6095	8083
6096	8084	break;
6097	8085	}
6098		- case 18446744073709551288LLU: // 9999999942'''''''''''''''
	8086	+ case 18446744073709551155LLU: // 999999992x'''''''''''''''
6099	8087	{
6100	8088	{
6101	8089	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -6113,11 +8101,11 @@
6113	8101	uint64_t arg = 0;
6114	8102	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
6115	8103	}
6116		- state.addr = 18446744073709551286LLU; // 9999999940'''''''''''''''
	8104	+ state.addr = 18446744073709551153LLU; // 999999992v'''''''''''''''
6117	8105
6118	8106	break;
6119	8107	}
6120		- case 18446744073709551286LLU: // 9999999940'''''''''''''''
	8108	+ case 18446744073709551153LLU: // 999999992v'''''''''''''''
6121	8109	{
6122	8110	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
6123	8111	{

		@@ -6124,7 +8112,7 @@
6124	8112	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
6125	8113	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
6126	8114	{
6127		- state.addr = 18446744073709551285LLU; // 999999994z'''''''''''''''
	8115	+ state.addr = 18446744073709551152LLU; // 999999992u'''''''''''''''
6128	8116
6129	8117	break;
6130	8118	}

		@@ -6139,32 +8127,32 @@
6139	8127	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6140	8128	}
6141	8129	// 1LLU
6142		- uint64_t return_to = 18446744073709551283LLU;
	8130	+ uint64_t return_to = 18446744073709551150LLU;
6143	8131	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6144	8132	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6145	8133	heap.data[0].elem1 = heap.data[0].elem0;
6146	8134	heap.data[0].elem0 = mainresult;
6147	8135	}
6148		- state.addr = 819847183517731648LLU; // reportpar_
	8136	+ state.addr = 819847183514892328LLU; // reportelem
6149	8137
6150	8138	break;
6151	8139	}
6152		- case 18446744073709551283LLU: // 999999994x'''''''''''''''
	8140	+ case 18446744073709551150LLU: // 999999992s'''''''''''''''
6153	8141	{
6154		- state.addr = 18446744073709551284LLU; // 999999994y'''''''''''''''
	8142	+ state.addr = 18446744073709551151LLU; // 999999992t'''''''''''''''
6155	8143
6156	8144	break;
6157	8145	}
6158		- case 18446744073709551284LLU: // 999999994y'''''''''''''''
	8146	+ case 18446744073709551151LLU: // 999999992t'''''''''''''''
6159	8147	{
6160	8148	fprintf(stderr, "%s", " ");
6161		- // parameter-reference pardef____ par_______ goes out of scope
	8149	+ // parameter-reference elemdef___ par_______ goes out of scope
6162	8150	// parameter tyunionc__ kind______ goes out of scope
6163		- state.addr = 18446744073709551286LLU; // 9999999940'''''''''''''''
	8151	+ state.addr = 18446744073709551153LLU; // 999999992v'''''''''''''''
6164	8152
6165	8153	break;
6166	8154	}
6167		- case 18446744073709551285LLU: // 999999994z'''''''''''''''
	8155	+ case 18446744073709551152LLU: // 999999992u'''''''''''''''
6168	8156	{
6169	8157	fprintf(stderr, "%s", ") 0 ");
6170	8158	{

		@@ -6175,7 +8163,7 @@
6175	8163	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6176	8164	}
6177	8165	// 1LLU
6178		- uint64_t return_to = 18446744073709551281LLU;
	8166	+ uint64_t return_to = 18446744073709551148LLU;
6179	8167	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6180	8168	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6181	8169	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -6185,13 +8173,13 @@
6185	8173
6186	8174	break;
6187	8175	}
6188		- case 18446744073709551281LLU: // 999999994v'''''''''''''''
	8176	+ case 18446744073709551148LLU: // 999999992q'''''''''''''''
6189	8177	{
6190		- state.addr = 18446744073709551282LLU; // 999999994w'''''''''''''''
	8178	+ state.addr = 18446744073709551149LLU; // 999999992r'''''''''''''''
6191	8179
6192	8180	break;
6193	8181	}
6194		- case 18446744073709551282LLU: // 999999994w'''''''''''''''
	8182	+ case 18446744073709551149LLU: // 999999992r'''''''''''''''
6195	8183	{
6196	8184	// parameter tyunionc__ kind______ goes out of scope
6197	8185	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference kind______ at 3

		@@ -6198,18 +8186,18 @@
6198	8186	heap.availilable_size_for_dynamic_objects += 0LLU;
6199	8187	heap.availilable_size_for_dynamic_objects += 0LLU;
6200	8188
6201		- state.addr = 18446744073709551280LLU; // 999999994u'''''''''''''''
	8189	+ state.addr = 18446744073709551147LLU; // 999999992p'''''''''''''''
6202	8190
6203	8191	break;
6204	8192	}
6205		- case 18446744073709551287LLU: // 9999999941'''''''''''''''
	8193	+ case 18446744073709551154LLU: // 999999992w'''''''''''''''
6206	8194	{
6207	8195
6208		- state.addr = 861527391835975680LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551279LLU : 18446744073709551278LLU;
	8196	+ state.addr = 861527391835975680LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551146LLU : 18446744073709551145LLU;
6209	8197
6210	8198	break;
6211	8199	}
6212		- case 18446744073709551279LLU: // 999999994t'''''''''''''''
	8200	+ case 18446744073709551146LLU: // 999999992o'''''''''''''''
6213	8201	{
6214	8202	{
6215	8203	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -6227,11 +8215,11 @@
6227	8215	uint64_t arg = 0;
6228	8216	LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/address of current closure/, &arg);
6229	8217	}
6230		- state.addr = 18446744073709551277LLU; // 999999994r'''''''''''''''
	8218	+ state.addr = 18446744073709551144LLU; // 999999992m'''''''''''''''
6231	8219
6232	8220	break;
6233	8221	}
6234		- case 18446744073709551277LLU: // 999999994r'''''''''''''''
	8222	+ case 18446744073709551144LLU: // 999999992m'''''''''''''''
6235	8223	{
6236	8224	if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
6237	8225	{

		@@ -6238,7 +8226,7 @@
6238	8226	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 5
6239	8227	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
6240	8228	{
6241		- state.addr = 18446744073709551276LLU; // 999999994q'''''''''''''''
	8229	+ state.addr = 18446744073709551143LLU; // 999999992l'''''''''''''''
6242	8230
6243	8231	break;
6244	8232	}

		@@ -6250,11 +8238,11 @@
6250	8238	printid(stderr, /constrid__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 4LLU)));
6251	8239	// parameter-reference u64 constrid__ goes out of scope
6252	8240	// parameter tyuniont__ kind______ goes out of scope
6253		- state.addr = 18446744073709551277LLU; // 999999994r'''''''''''''''
	8241	+ state.addr = 18446744073709551144LLU; // 999999992m'''''''''''''''
6254	8242
6255	8243	break;
6256	8244	}
6257		- case 18446744073709551276LLU: // 999999994q'''''''''''''''
	8245	+ case 18446744073709551143LLU: // 999999992l'''''''''''''''
6258	8246	{
6259	8247	fprintf(stderr, "%s", "; 0 ");
6260	8248	{

		@@ -6265,7 +8253,7 @@
6265	8253	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6266	8254	}
6267	8255	// 1LLU
6268		- uint64_t return_to = 18446744073709551274LLU;
	8256	+ uint64_t return_to = 18446744073709551141LLU;
6269	8257	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6270	8258	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6271	8259	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -6275,13 +8263,13 @@
6275	8263
6276	8264	break;
6277	8265	}
6278		- case 18446744073709551274LLU: // 999999994o'''''''''''''''
	8266	+ case 18446744073709551141LLU: // 999999992j'''''''''''''''
6279	8267	{
6280		- state.addr = 18446744073709551275LLU; // 999999994p'''''''''''''''
	8268	+ state.addr = 18446744073709551142LLU; // 999999992k'''''''''''''''
6281	8269
6282	8270	break;
6283	8271	}
6284		- case 18446744073709551275LLU: // 999999994p'''''''''''''''
	8272	+ case 18446744073709551142LLU: // 999999992k'''''''''''''''
6285	8273	{
6286	8274	// parameter tyuniont__ kind______ goes out of scope
6287	8275	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference kind______ at 3

		@@ -6288,11 +8276,11 @@
6288	8276	heap.availilable_size_for_dynamic_objects += 0LLU;
6289	8277	heap.availilable_size_for_dynamic_objects += 0LLU;
6290	8278
6291		- state.addr = 18446744073709551273LLU; // 999999994n'''''''''''''''
	8279	+ state.addr = 18446744073709551140LLU; // 999999992i'''''''''''''''
6292	8280
6293	8281	break;
6294	8282	}
6295		- case 18446744073709551278LLU: // 999999994s'''''''''''''''
	8283	+ case 18446744073709551145LLU: // 999999992n'''''''''''''''
6296	8284	{
6297	8285
6298	8286	{

		@@ -6299,23 +8287,23 @@
6299	8287	fprintf(stderr, "%s\n", "reportdef UNKNOWN");
6300	8288	exit(-1);
6301	8289	}
6302		- state.addr = 18446744073709551273LLU; // 999999994n'''''''''''''''
	8290	+ state.addr = 18446744073709551140LLU; // 999999992i'''''''''''''''
6303	8291
6304	8292	break;
6305	8293	}
6306		- case 18446744073709551273LLU: // 999999994n'''''''''''''''
	8294	+ case 18446744073709551140LLU: // 999999992i'''''''''''''''
6307	8295	{
6308		- state.addr = 18446744073709551280LLU; // 999999994u'''''''''''''''
	8296	+ state.addr = 18446744073709551147LLU; // 999999992p'''''''''''''''
6309	8297
6310	8298	break;
6311	8299	}
6312		- case 18446744073709551280LLU: // 999999994u'''''''''''''''
	8300	+ case 18446744073709551147LLU: // 999999992p'''''''''''''''
6313	8301	{
6314		- state.addr = 18446744073709551289LLU; // 9999999943'''''''''''''''
	8302	+ state.addr = 18446744073709551156LLU; // 999999992y'''''''''''''''
6315	8303
6316	8304	break;
6317	8305	}
6318		- case 18446744073709551289LLU: // 9999999943'''''''''''''''
	8306	+ case 18446744073709551156LLU: // 999999992y'''''''''''''''
6319	8307	{
6320	8308	fprintf(stderr, "%s", "\n");
6321	8309	// parameter-reference typekind__ kind______ goes out of scope

		@@ -6342,11 +8330,11 @@
6342	8330	uint64_t arg = 0;
6343	8331	LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/address of current closure/, &arg);
6344	8332	}
6345		- state.addr = 18446744073709551272LLU; // 999999994m'''''''''''''''
	8333	+ state.addr = 18446744073709551139LLU; // 999999992h'''''''''''''''
6346	8334
6347	8335	break;
6348	8336	}
6349		- case 18446744073709551272LLU: // 999999994m'''''''''''''''
	8337	+ case 18446744073709551139LLU: // 999999992h'''''''''''''''
6350	8338	{
6351	8339	if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
6352	8340	{

		@@ -6353,7 +8341,7 @@
6353	8341	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 4
6354	8342	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 3
6355	8343	{
6356		- state.addr = 18446744073709551271LLU; // 999999994l'''''''''''''''
	8344	+ state.addr = 18446744073709551138LLU; // 999999992g'''''''''''''''
6357	8345
6358	8346	break;
6359	8347	}

		@@ -6372,7 +8360,7 @@
6372	8360	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6373	8361	}
6374	8362	// 2LLU
6375		- uint64_t return_to = 18446744073709551269LLU;
	8363	+ uint64_t return_to = 18446744073709551136LLU;
6376	8364	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6377	8365	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6378	8366	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -6382,21 +8370,21 @@
6382	8370
6383	8371	break;
6384	8372	}
6385		- case 18446744073709551269LLU: // 999999994j'''''''''''''''
	8373	+ case 18446744073709551136LLU: // 999999992e'''''''''''''''
6386	8374	{
6387		- state.addr = 18446744073709551270LLU; // 999999994k'''''''''''''''
	8375	+ state.addr = 18446744073709551137LLU; // 999999992f'''''''''''''''
6388	8376
6389	8377	break;
6390	8378	}
6391		- case 18446744073709551270LLU: // 999999994k'''''''''''''''
	8379	+ case 18446744073709551137LLU: // 999999992f'''''''''''''''
6392	8380	{
6393	8381	// parameter-reference typedef___ def_______ goes out of scope
6394	8382	// parameter-reference list<typedef___> typedefs__ goes out of scope
6395		- state.addr = 18446744073709551272LLU; // 999999994m'''''''''''''''
	8383	+ state.addr = 18446744073709551139LLU; // 999999992h'''''''''''''''
6396	8384
6397	8385	break;
6398	8386	}
6399		- case 18446744073709551271LLU: // 999999994l'''''''''''''''
	8387	+ case 18446744073709551138LLU: // 999999992g'''''''''''''''
6400	8388	{
6401	8389	// parameter-reference list<typedef___> typedefs__ goes out of scope
6402	8390	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typedefs__ at 2

		@@ -6415,27 +8403,27 @@
6415	8403	case 567600662901349312LLU: // defassert_
6416	8404	{
6417	8405
6418		- state.addr = /complete__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 3LLU)) ? 18446744073709551268LLU : 18446744073709551267LLU;
	8406	+ state.addr = /complete__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 3LLU)) ? 18446744073709551135LLU : 18446744073709551134LLU;
6419	8407
6420	8408	break;
6421	8409	}
6422		- case 18446744073709551268LLU: // 999999994i'''''''''''''''
	8410	+ case 18446744073709551135LLU: // 999999992d'''''''''''''''
6423	8411	{
6424	8412
6425		- state.addr = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 4LLU)) ? 18446744073709551266LLU : 18446744073709551265LLU;
	8413	+ state.addr = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 4LLU)) ? 18446744073709551133LLU : 18446744073709551132LLU;
6426	8414
6427	8415	break;
6428	8416	}
6429		- case 18446744073709551266LLU: // 999999994g'''''''''''''''
	8417	+ case 18446744073709551133LLU: // 999999992b'''''''''''''''
6430	8418	{
6431	8419	heap.availilable_size_for_dynamic_objects += 0LLU;
6432	8420	heap.availilable_size_for_dynamic_objects += 0LLU;
6433	8421
6434		- state.addr = 18446744073709551264LLU; // 999999994e'''''''''''''''
	8422	+ state.addr = 18446744073709551131LLU; // 999999992$'''''''''''''''
6435	8423
6436	8424	break;
6437	8425	}
6438		- case 18446744073709551265LLU: // 999999994f'''''''''''''''
	8426	+ case 18446744073709551132LLU: // 999999992a'''''''''''''''
6439	8427	{
6440	8428	fprintf(stderr, "%s", "function ");
6441	8429

		@@ -6450,40 +8438,40 @@
6450	8438	fprintf(stderr, "%s\n", "");
6451	8439	exit(-1);
6452	8440	}
6453		- state.addr = 18446744073709551264LLU; // 999999994e'''''''''''''''
	8441	+ state.addr = 18446744073709551131LLU; // 999999992$'''''''''''''''
6454	8442
6455	8443	break;
6456	8444	}
6457		- case 18446744073709551264LLU: // 999999994e'''''''''''''''
	8445	+ case 18446744073709551131LLU: // 999999992$'''''''''''''''
6458	8446	{
6459		- state.addr = 18446744073709551267LLU; // 999999994h'''''''''''''''
	8447	+ state.addr = 18446744073709551134LLU; // 999999992c'''''''''''''''
6460	8448
6461	8449	break;
6462	8450	}
6463		- case 18446744073709551267LLU: // 999999994h'''''''''''''''
	8451	+ case 18446744073709551134LLU: // 999999992c'''''''''''''''
6464	8452	{
6465	8453
6466		- state.addr = /finite____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) ? 18446744073709551263LLU : 18446744073709551262LLU;
	8454	+ state.addr = /finite____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) ? 18446744073709551130LLU : 18446744073709551129LLU;
6467	8455
6468	8456	break;
6469	8457	}
6470		- case 18446744073709551263LLU: // 999999994d'''''''''''''''
	8458	+ case 18446744073709551130LLU: // 999999992Z'''''''''''''''
6471	8459	{
6472	8460
6473		- state.addr = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 5LLU)) ? 18446744073709551261LLU : 18446744073709551260LLU;
	8461	+ state.addr = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 5LLU)) ? 18446744073709551128LLU : 18446744073709551127LLU;
6474	8462
6475	8463	break;
6476	8464	}
6477		- case 18446744073709551261LLU: // 999999994b'''''''''''''''
	8465	+ case 18446744073709551128LLU: // 999999992X'''''''''''''''
6478	8466	{
6479	8467	heap.availilable_size_for_dynamic_objects += 0LLU;
6480	8468	heap.availilable_size_for_dynamic_objects += 0LLU;
6481	8469
6482		- state.addr = 18446744073709551259LLU; // 999999994$'''''''''''''''
	8470	+ state.addr = 18446744073709551126LLU; // 999999992V'''''''''''''''
6483	8471
6484	8472	break;
6485	8473	}
6486		- case 18446744073709551260LLU: // 999999994a'''''''''''''''
	8474	+ case 18446744073709551127LLU: // 999999992W'''''''''''''''
6487	8475	{
6488	8476	fprintf(stderr, "%s", "function ");
6489	8477

		@@ -6497,40 +8485,40 @@
6497	8485	fprintf(stderr, "%s\n", "");
6498	8486	exit(-1);
6499	8487	}
6500		- state.addr = 18446744073709551259LLU; // 999999994$'''''''''''''''
	8488	+ state.addr = 18446744073709551126LLU; // 999999992V'''''''''''''''
6501	8489
6502	8490	break;
6503	8491	}
6504		- case 18446744073709551259LLU: // 999999994$'''''''''''''''
	8492	+ case 18446744073709551126LLU: // 999999992V'''''''''''''''
6505	8493	{
6506		- state.addr = 18446744073709551262LLU; // 999999994c'''''''''''''''
	8494	+ state.addr = 18446744073709551129LLU; // 999999992Y'''''''''''''''
6507	8495
6508	8496	break;
6509	8497	}
6510		- case 18446744073709551262LLU: // 999999994c'''''''''''''''
	8498	+ case 18446744073709551129LLU: // 999999992Y'''''''''''''''
6511	8499	{
6512	8500
6513		- state.addr = /safe______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 5LLU)) ? 18446744073709551258LLU : 18446744073709551257LLU;
	8501	+ state.addr = /safe______/access_heap(heap.data, LOCAL_ACCESS(heap.data, 6LLU, 5LLU)) ? 18446744073709551125LLU : 18446744073709551124LLU;
6514	8502
6515	8503	break;
6516	8504	}
6517		- case 18446744073709551258LLU: // 999999994Z'''''''''''''''
	8505	+ case 18446744073709551125LLU: // 999999992U'''''''''''''''
6518	8506	{
6519	8507
6520		- state.addr = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 6LLU)) ? 18446744073709551256LLU : 18446744073709551255LLU;
	8508	+ state.addr = /fn________/access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 6LLU)) ? 18446744073709551123LLU : 18446744073709551122LLU;
6521	8509
6522	8510	break;
6523	8511	}
6524		- case 18446744073709551256LLU: // 999999994X'''''''''''''''
	8512	+ case 18446744073709551123LLU: // 999999992S'''''''''''''''
6525	8513	{
6526	8514	heap.availilable_size_for_dynamic_objects += 0LLU;
6527	8515	heap.availilable_size_for_dynamic_objects += 0LLU;
6528	8516
6529		- state.addr = 18446744073709551254LLU; // 999999994V'''''''''''''''
	8517	+ state.addr = 18446744073709551121LLU; // 999999992Q'''''''''''''''
6530	8518
6531	8519	break;
6532	8520	}
6533		- case 18446744073709551255LLU: // 999999994W'''''''''''''''
	8521	+ case 18446744073709551122LLU: // 999999992R'''''''''''''''
6534	8522	{
6535	8523	fprintf(stderr, "%s", "function ");
6536	8524

		@@ -6544,17 +8532,17 @@
6544	8532	fprintf(stderr, "%s\n", "");
6545	8533	exit(-1);
6546	8534	}
6547		- state.addr = 18446744073709551254LLU; // 999999994V'''''''''''''''
	8535	+ state.addr = 18446744073709551121LLU; // 999999992Q'''''''''''''''
6548	8536
6549	8537	break;
6550	8538	}
6551		- case 18446744073709551254LLU: // 999999994V'''''''''''''''
	8539	+ case 18446744073709551121LLU: // 999999992Q'''''''''''''''
6552	8540	{
6553		- state.addr = 18446744073709551257LLU; // 999999994Y'''''''''''''''
	8541	+ state.addr = 18446744073709551124LLU; // 999999992T'''''''''''''''
6554	8542
6555	8543	break;
6556	8544	}
6557		- case 18446744073709551257LLU: // 999999994Y'''''''''''''''
	8545	+ case 18446744073709551124LLU: // 999999992T'''''''''''''''
6558	8546	{
6559	8547	// parameter-reference u64 safe______ goes out of scope
6560	8548	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference safe______ at 6

		@@ -6608,7 +8596,7 @@
6608	8596	LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6609	8597	}
6610	8598	// 6LLU
6611		- uint64_t return_to = 18446744073709551252LLU;
	8599	+ uint64_t return_to = 18446744073709551119LLU;
6612	8600	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6613	8601	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6614	8602	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -6618,13 +8606,13 @@
6618	8606
6619	8607	break;
6620	8608	}
6621		- case 18446744073709551252LLU: // 999999994T'''''''''''''''
	8609	+ case 18446744073709551119LLU: // 999999992O'''''''''''''''
6622	8610	{
6623		- state.addr = 18446744073709551253LLU; // 999999994U'''''''''''''''
	8611	+ state.addr = 18446744073709551120LLU; // 999999992P'''''''''''''''
6624	8612
6625	8613	break;
6626	8614	}
6627		- case 18446744073709551253LLU: // 999999994U'''''''''''''''
	8615	+ case 18446744073709551120LLU: // 999999992P'''''''''''''''
6628	8616	{
6629	8617	/defbodysz_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 10LLU, 8LLU)) = /fn________/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS_ADDR(heap.data, 10LLU, 1LLU), 3LLU));
6630	8618	/sizeonheap/access_heap(heap.data, LOCAL_ACCESS(heap.data, 10LLU, 9LLU)) = /fn________/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS_ADDR(heap.data, 10LLU, 1LLU), 2LLU));

		@@ -6636,11 +8624,11 @@
6636	8624	uint64_t arg = 0;
6637	8625	LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
6638	8626	}
6639		- state.addr = 18446744073709551251LLU; // 999999994S'''''''''''''''
	8627	+ state.addr = 18446744073709551118LLU; // 999999992N'''''''''''''''
6640	8628
6641	8629	break;
6642	8630	}
6643		- case 18446744073709551251LLU: // 999999994S'''''''''''''''
	8631	+ case 18446744073709551118LLU: // 999999992N'''''''''''''''
6644	8632	{
6645	8633	if(!*LOCAL_ACCESS(heap.data, 12LLU, 10LLU))
6646	8634	{

		@@ -6647,7 +8635,7 @@
6647	8635	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 12
6648	8636	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
6649	8637	{
6650		- state.addr = 18446744073709551250LLU; // 999999994R'''''''''''''''
	8638	+ state.addr = 18446744073709551117LLU; // 999999992M'''''''''''''''
6651	8639
6652	8640	break;
6653	8641	}

		@@ -6670,7 +8658,7 @@
6670	8658	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6671	8659	}
6672	8660	// 2LLU
6673		- uint64_t return_to = 18446744073709551248LLU;
	8661	+ uint64_t return_to = 18446744073709551115LLU;
6674	8662	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6675	8663	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6676	8664	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -6680,13 +8668,13 @@
6680	8668
6681	8669	break;
6682	8670	}
6683		- case 18446744073709551248LLU: // 999999994P'''''''''''''''
	8671	+ case 18446744073709551115LLU: // 999999992K'''''''''''''''
6684	8672	{
6685		- state.addr = 18446744073709551249LLU; // 999999994Q'''''''''''''''
	8673	+ state.addr = 18446744073709551116LLU; // 999999992L'''''''''''''''
6686	8674
6687	8675	break;
6688	8676	}
6689		- case 18446744073709551249LLU: // 999999994Q'''''''''''''''
	8677	+ case 18446744073709551116LLU: // 999999992L'''''''''''''''
6690	8678	{
6691	8679	{
6692	8680	uint64_t arg = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 13LLU, 11LLU), 1LLU));

		@@ -6705,11 +8693,11 @@
6705	8693	LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/address of current closure/, &arg);
6706	8694	}
6707	8695
6708		- state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 16LLU, 15LLU), &/resultpars/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 6LLU)), 4) ? 18446744073709551247LLU : 18446744073709551246LLU;
	8696	+ state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 16LLU, 15LLU), &/resultpars/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 6LLU)), 4) ? 18446744073709551114LLU : 18446744073709551113LLU;
6709	8697
6710	8698	break;
6711	8699	}
6712		- case 18446744073709551247LLU: // 999999994O'''''''''''''''
	8700	+ case 18446744073709551114LLU: // 999999992J'''''''''''''''
6713	8701	{
6714	8702	{
6715	8703	uint64_t arg = *LOCAL_ACCESS(heap.data, 16LLU, 15LLU);

		@@ -6724,7 +8712,7 @@
6724	8712	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6725	8713	}
6726	8714	// 1LLU
6727		- uint64_t return_to = 18446744073709551244LLU;
	8715	+ uint64_t return_to = 18446744073709551111LLU;
6728	8716	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6729	8717	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6730	8718	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -6734,13 +8722,13 @@
6734	8722
6735	8723	break;
6736	8724	}
6737		- case 18446744073709551244LLU: // 999999994L'''''''''''''''
	8725	+ case 18446744073709551111LLU: // 999999992G'''''''''''''''
6738	8726	{
6739		- state.addr = 18446744073709551245LLU; // 999999994M'''''''''''''''
	8727	+ state.addr = 18446744073709551112LLU; // 999999992H'''''''''''''''
6740	8728
6741	8729	break;
6742	8730	}
6743		- case 18446744073709551245LLU: // 999999994M'''''''''''''''
	8731	+ case 18446744073709551112LLU: // 999999992H'''''''''''''''
6744	8732	{
6745	8733	fprintf(stderr, "%s", "\n");
6746	8734

		@@ -6758,7 +8746,7 @@
6758	8746	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6759	8747	}
6760	8748	// 1LLU
6761		- uint64_t return_to = 18446744073709551243LLU;
	8749	+ uint64_t return_to = 18446744073709551110LLU;
6762	8750	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6763	8751	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6764	8752	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -6768,23 +8756,23 @@
6768	8756
6769	8757	break;
6770	8758	}
6771		- case 18446744073709551243LLU: // 999999994K'''''''''''''''
	8759	+ case 18446744073709551110LLU: // 999999992F'''''''''''''''
6772	8760	{
6773	8761	(void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 17
6774	8762	heap.availilable_size_for_dynamic_objects += 0LLU;
6775	8763	heap.availilable_size_for_dynamic_objects += 0LLU;
6776	8764
6777		- state.addr = 18446744073709551242LLU; // 999999994J'''''''''''''''
	8765	+ state.addr = 18446744073709551109LLU; // 999999992E'''''''''''''''
6778	8766
6779	8767	break;
6780	8768	}
6781		- case 18446744073709551246LLU: // 999999994N'''''''''''''''
	8769	+ case 18446744073709551113LLU: // 999999992I'''''''''''''''
6782	8770	{
6783		- state.addr = 18446744073709551242LLU; // 999999994J'''''''''''''''
	8771	+ state.addr = 18446744073709551109LLU; // 999999992E'''''''''''''''
6784	8772
6785	8773	break;
6786	8774	}
6787		- case 18446744073709551242LLU: // 999999994J'''''''''''''''
	8775	+ case 18446744073709551109LLU: // 999999992E'''''''''''''''
6788	8776	{
6789	8777	// variable resdest___ new_______ goes out of scope
6790	8778	// (uninitialized -> no destructor-call)

		@@ -6800,11 +8788,11 @@
6800	8788	(void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 13
6801	8789	// parameter-reference resdest___ par_______ goes out of scope
6802	8790	// parameter function__ fn________ goes out of scope
6803		- state.addr = 18446744073709551251LLU; // 999999994S'''''''''''''''
	8791	+ state.addr = 18446744073709551118LLU; // 999999992N'''''''''''''''
6804	8792
6805	8793	break;
6806	8794	}
6807		- case 18446744073709551250LLU: // 999999994R'''''''''''''''
	8795	+ case 18446744073709551117LLU: // 999999992M'''''''''''''''
6808	8796	{
6809	8797	{
6810	8798	uint64_t arg = /fn________/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, LOCAL_ACCESS_ADDR(heap.data, 10LLU, 1LLU), 1LLU));

		@@ -6814,11 +8802,11 @@
6814	8802	uint64_t arg = 0;
6815	8803	LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
6816	8804	}
6817		- state.addr = 18446744073709551241LLU; // 999999994I'''''''''''''''
	8805	+ state.addr = 18446744073709551108LLU; // 999999992D'''''''''''''''
6818	8806
6819	8807	break;
6820	8808	}
6821		- case 18446744073709551241LLU: // 999999994I'''''''''''''''
	8809	+ case 18446744073709551108LLU: // 999999992D'''''''''''''''
6822	8810	{
6823	8811	if(!*LOCAL_ACCESS(heap.data, 12LLU, 10LLU))
6824	8812	{

		@@ -6825,7 +8813,7 @@
6825	8813	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 12
6826	8814	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
6827	8815	{
6828		- state.addr = 18446744073709551240LLU; // 999999994H'''''''''''''''
	8816	+ state.addr = 18446744073709551107LLU; // 999999992C'''''''''''''''
6829	8817
6830	8818	break;
6831	8819	}

		@@ -6860,7 +8848,7 @@
6860	8848	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6861	8849	}
6862	8850	// 2LLU
6863		- uint64_t return_to = 18446744073709551238LLU;
	8851	+ uint64_t return_to = 18446744073709551105LLU;
6864	8852	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6865	8853	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6866	8854	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -6870,13 +8858,13 @@
6870	8858
6871	8859	break;
6872	8860	}
6873		- case 18446744073709551238LLU: // 999999994F'''''''''''''''
	8861	+ case 18446744073709551105LLU: // 999999992A'''''''''''''''
6874	8862	{
6875		- state.addr = 18446744073709551239LLU; // 999999994G'''''''''''''''
	8863	+ state.addr = 18446744073709551106LLU; // 999999992B'''''''''''''''
6876	8864
6877	8865	break;
6878	8866	}
6879		- case 18446744073709551239LLU: // 999999994G'''''''''''''''
	8867	+ case 18446744073709551106LLU: // 999999992B'''''''''''''''
6880	8868	{
6881	8869	{
6882	8870	uint64_t arg = 0LLU;

		@@ -6897,7 +8885,7 @@
6897	8885	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6898	8886	}
6899	8887	// 2LLU
6900		- uint64_t return_to = 18446744073709551236LLU;
	8888	+ uint64_t return_to = 18446744073709551103LLU;
6901	8889	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6902	8890	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6903	8891	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -6907,13 +8895,13 @@
6907	8895
6908	8896	break;
6909	8897	}
6910		- case 18446744073709551236LLU: // 999999994D'''''''''''''''
	8898	+ case 18446744073709551103LLU: // 9999999919'''''''''''''''
6911	8899	{
6912		- state.addr = 18446744073709551237LLU; // 999999994E'''''''''''''''
	8900	+ state.addr = 18446744073709551104LLU; // 999999992_'''''''''''''''
6913	8901
6914	8902	break;
6915	8903	}
6916		- case 18446744073709551237LLU: // 999999994E'''''''''''''''
	8904	+ case 18446744073709551104LLU: // 999999992_'''''''''''''''
6917	8905	{
6918	8906	{
6919	8907	uint64_t arg = 0LLU;

		@@ -6926,11 +8914,11 @@
6926	8914	LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/address of current closure/, &arg);
6927	8915	}
6928	8916
6929		- state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 18LLU, 17LLU), &/calleepars/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)), 6) ? 18446744073709551235LLU : 18446744073709551234LLU;
	8917	+ state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 18LLU, 17LLU), &/calleepars/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU)), 6) ? 18446744073709551102LLU : 18446744073709551101LLU;
6930	8918
6931	8919	break;
6932	8920	}
6933		- case 18446744073709551235LLU: // 999999994C'''''''''''''''
	8921	+ case 18446744073709551102LLU: // 9999999918'''''''''''''''
6934	8922	{
6935	8923	{
6936	8924	uint64_t arg = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU);

		@@ -6955,7 +8943,7 @@
6955	8943	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
6956	8944	}
6957	8945	// 1LLU
6958		- uint64_t return_to = 18446744073709551233LLU;
	8946	+ uint64_t return_to = 18446744073709551100LLU;
6959	8947	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
6960	8948	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
6961	8949	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -6965,23 +8953,23 @@
6965	8953
6966	8954	break;
6967	8955	}
6968		- case 18446744073709551233LLU: // 999999994A'''''''''''''''
	8956	+ case 18446744073709551100LLU: // 9999999916'''''''''''''''
6969	8957	{
6970	8958	(void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 19
6971	8959	heap.availilable_size_for_dynamic_objects += 0LLU;
6972	8960	heap.availilable_size_for_dynamic_objects += 0LLU;
6973	8961
6974		- state.addr = 18446744073709551232LLU; // 999999994_'''''''''''''''
	8962	+ state.addr = 18446744073709551099LLU; // 9999999915'''''''''''''''
6975	8963
6976	8964	break;
6977	8965	}
6978		- case 18446744073709551234LLU: // 999999994B'''''''''''''''
	8966	+ case 18446744073709551101LLU: // 9999999917'''''''''''''''
6979	8967	{
6980		- state.addr = 18446744073709551232LLU; // 999999994_'''''''''''''''
	8968	+ state.addr = 18446744073709551099LLU; // 9999999915'''''''''''''''
6981	8969
6982	8970	break;
6983	8971	}
6984		- case 18446744073709551232LLU: // 999999994_'''''''''''''''
	8972	+ case 18446744073709551099LLU: // 9999999915'''''''''''''''
6985	8973	{
6986	8974	// variable pardef____ new_______ goes out of scope
6987	8975	// (uninitialized -> no destructor-call)

		@@ -7003,11 +8991,11 @@
7003	8991	(void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 13
7004	8992	// parameter-reference pardef____ par_______ goes out of scope
7005	8993	// parameter function__ fn________ goes out of scope
7006		- state.addr = 18446744073709551241LLU; // 999999994I'''''''''''''''
	8994	+ state.addr = 18446744073709551108LLU; // 999999992D'''''''''''''''
7007	8995
7008	8996	break;
7009	8997	}
7010		- case 18446744073709551240LLU: // 999999994H'''''''''''''''
	8998	+ case 18446744073709551107LLU: // 999999992C'''''''''''''''
7011	8999	{
7012	9000	// parameter-reference u64 sizeonheap goes out of scope
7013	9001	(void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sizeonheap at 10

		@@ -7053,11 +9041,11 @@
7053	9041	uint64_t arg = 0;
7054	9042	LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/address of current closure/, &arg);
7055	9043	}
7056		- state.addr = 18446744073709551231LLU; // 9999999939'''''''''''''''
	9044	+ state.addr = 18446744073709551098LLU; // 9999999914'''''''''''''''
7057	9045
7058	9046	break;
7059	9047	}
7060		- case 18446744073709551231LLU: // 9999999939'''''''''''''''
	9048	+ case 18446744073709551098LLU: // 9999999914'''''''''''''''
7061	9049	{
7062	9050	if(!*LOCAL_ACCESS(heap.data, 13LLU, 11LLU))
7063	9051	{

		@@ -7064,7 +9052,7 @@
7064	9052	(void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 13
7065	9053	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 12
7066	9054	{
7067		- state.addr = 18446744073709551230LLU; // 9999999938'''''''''''''''
	9055	+ state.addr = 18446744073709551097LLU; // 9999999913'''''''''''''''
7068	9056
7069	9057	break;
7070	9058	}

		@@ -7076,13 +9064,13 @@
7076	9064	LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/address of current closure/, &arg);
7077	9065	}
7078	9066
7079		- /match_____/LOCAL_ACCESS(heap.data, 14LLU, 13LLU) = /id________/LOCAL_ACCESS(heap.data, 14LLU, 2LLU) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 14LLU, 12LLU), 0LLU));
	9067	+ /match_____/LOCAL_ACCESS(heap.data, 14LLU, 13LLU) = /id________/LOCAL_ACCESS(heap.data, 14LLU, 2LLU) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 14LLU, 12LLU), 0LLU));
7080	9068
7081		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 14LLU, 13LLU) ? 18446744073709551229LLU : 18446744073709551228LLU;
	9069	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 14LLU, 13LLU) ? 18446744073709551096LLU : 18446744073709551095LLU;
7082	9070
7083	9071	break;
7084	9072	}
7085		- case 18446744073709551229LLU: // 9999999937'''''''''''''''
	9073	+ case 18446744073709551096LLU: // 9999999912'''''''''''''''
7086	9074	{
7087	9075	/notfound__/*LOCAL_ACCESS(heap.data, 14LLU, 10LLU) = 0LLU;
7088	9076	{

		@@ -7093,7 +9081,7 @@
7093	9081	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7094	9082	}
7095	9083	{
7096		- uint64_t arg = /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 14LLU, 12LLU), 1LLU));
	9084	+ uint64_t arg = /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS(heap.data, 14LLU, 12LLU), 1LLU));
7097	9085	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7098	9086	}
7099	9087	{

		@@ -7129,7 +9117,7 @@
7129	9117	LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7130	9118	}
7131	9119	// 10LLU
7132		- uint64_t return_to = 18446744073709551226LLU;
	9120	+ uint64_t return_to = 18446744073709551093LLU;
7133	9121	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7134	9122	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7135	9123	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7139,19 +9127,19 @@
7139	9127
7140	9128	break;
7141	9129	}
7142		- case 18446744073709551226LLU: // 9999999934'''''''''''''''
	9130	+ case 18446744073709551093LLU: // 999999991z'''''''''''''''
7143	9131	{
7144		- state.addr = 18446744073709551227LLU; // 9999999935'''''''''''''''
	9132	+ state.addr = 18446744073709551094LLU; // 9999999910'''''''''''''''
7145	9133
7146	9134	break;
7147	9135	}
7148		- case 18446744073709551227LLU: // 9999999935'''''''''''''''
	9136	+ case 18446744073709551094LLU: // 9999999910'''''''''''''''
7149	9137	{
7150		- state.addr = 18446744073709551228LLU; // 9999999936'''''''''''''''
	9138	+ state.addr = 18446744073709551095LLU; // 9999999911'''''''''''''''
7151	9139
7152	9140	break;
7153	9141	}
7154		- case 18446744073709551228LLU: // 9999999936'''''''''''''''
	9142	+ case 18446744073709551095LLU: // 9999999911'''''''''''''''
7155	9143	{
7156	9144	// variable u64 match_____ goes out of scope
7157	9145	// emitted destructur for type u64

		@@ -7158,18 +9146,18 @@
7158	9146	(void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference match_____ at 14
7159	9147	// parameter-reference defidfn___ elem______ goes out of scope
7160	9148	// parameter-reference list<defidfn___> fndefs____ goes out of scope
7161		- state.addr = 18446744073709551231LLU; // 9999999939'''''''''''''''
	9149	+ state.addr = 18446744073709551098LLU; // 9999999914'''''''''''''''
7162	9150
7163	9151	break;
7164	9152	}
7165		- case 18446744073709551230LLU: // 9999999938'''''''''''''''
	9153	+ case 18446744073709551097LLU: // 9999999913'''''''''''''''
7166	9154	{
7167	9155
7168		- state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU) ? 18446744073709551225LLU : 18446744073709551224LLU;
	9156	+ state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU) ? 18446744073709551092LLU : 18446744073709551091LLU;
7169	9157
7170	9158	break;
7171	9159	}
7172		- case 18446744073709551225LLU: // 9999999933'''''''''''''''
	9160	+ case 18446744073709551092LLU: // 999999991y'''''''''''''''
7173	9161	{
7174	9162	{
7175	9163	uint64_t mainresult = heap.data[0].elem0;

		@@ -7183,7 +9171,7 @@
7183	9171	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7184	9172	}
7185	9173	// 2LLU
7186		- uint64_t return_to = 18446744073709551222LLU;
	9174	+ uint64_t return_to = 18446744073709551089LLU;
7187	9175	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7188	9176	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7189	9177	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7193,13 +9181,13 @@
7193	9181
7194	9182	break;
7195	9183	}
7196		- case 18446744073709551222LLU: // 9999999930'''''''''''''''
	9184	+ case 18446744073709551089LLU: // 999999991v'''''''''''''''
7197	9185	{
7198		- state.addr = 18446744073709551223LLU; // 9999999931'''''''''''''''
	9186	+ state.addr = 18446744073709551090LLU; // 999999991w'''''''''''''''
7199	9187
7200	9188	break;
7201	9189	}
7202		- case 18446744073709551223LLU: // 9999999931'''''''''''''''
	9190	+ case 18446744073709551090LLU: // 999999991w'''''''''''''''
7203	9191	{
7204	9192	{
7205	9193	uint64_t mainresult = heap.data[0].elem0;

		@@ -7209,7 +9197,7 @@
7209	9197	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7210	9198	}
7211	9199	// 1LLU
7212		- uint64_t return_to = 18446744073709551220LLU;
	9200	+ uint64_t return_to = 18446744073709551087LLU;
7213	9201	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7214	9202	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7215	9203	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7219,13 +9207,13 @@
7219	9207
7220	9208	break;
7221	9209	}
7222		- case 18446744073709551220LLU: // 999999993y'''''''''''''''
	9210	+ case 18446744073709551087LLU: // 999999991t'''''''''''''''
7223	9211	{
7224		- state.addr = 18446744073709551221LLU; // 999999993z'''''''''''''''
	9212	+ state.addr = 18446744073709551088LLU; // 999999991u'''''''''''''''
7225	9213
7226	9214	break;
7227	9215	}
7228		- case 18446744073709551221LLU: // 999999993z'''''''''''''''
	9216	+ case 18446744073709551088LLU: // 999999991u'''''''''''''''
7229	9217	{
7230	9218	fprintf(stderr, "%s", "no such function ");
7231	9219

		@@ -7235,11 +9223,11 @@
7235	9223	fprintf(stderr, "%s\n", "");
7236	9224	exit(-1);
7237	9225	}
7238		- state.addr = 18446744073709551224LLU; // 9999999932'''''''''''''''
	9226	+ state.addr = 18446744073709551091LLU; // 999999991x'''''''''''''''
7239	9227
7240	9228	break;
7241	9229	}
7242		- case 18446744073709551224LLU: // 9999999932'''''''''''''''
	9230	+ case 18446744073709551091LLU: // 999999991x'''''''''''''''
7243	9231	{
7244	9232	// variable u64 notfound__ goes out of scope
7245	9233	// emitted destructur for type u64

		@@ -7277,14 +9265,14 @@
7277	9265	case 861504794986191783LLU: // typetransl
7278	9266	{
7279	9267
7280		- state.addr = 861519017821270016LLU == heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 1LLU)].elem0 ? 18446744073709551219LLU : 18446744073709551218LLU;
	9268	+ state.addr = 861519017821270016LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem0 ? 18446744073709551086LLU : 18446744073709551085LLU;
7281	9269
7282	9270	break;
7283	9271	}
7284		- case 18446744073709551219LLU: // 999999993x'''''''''''''''
	9272	+ case 18446744073709551086LLU: // 999999991s'''''''''''''''
7285	9273	{
7286	9274	{
7287		- uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 1LLU)].elem1;
	9275	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem1;
7288	9276	LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
7289	9277	}
7290	9278	/defbodysz_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 6LLU)) = 0LLU;

		@@ -7297,11 +9285,11 @@
7297	9285	uint64_t arg = 0;
7298	9286	LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/address of current closure/, &arg);
7299	9287	}
7300		- state.addr = 18446744073709551217LLU; // 999999993v'''''''''''''''
	9288	+ state.addr = 18446744073709551084LLU; // 999999991q'''''''''''''''
7301	9289
7302	9290	break;
7303	9291	}
7304		- case 18446744073709551217LLU: // 999999993v'''''''''''''''
	9292	+ case 18446744073709551084LLU: // 999999991q'''''''''''''''
7305	9293	{
7306	9294	if(!*LOCAL_ACCESS(heap.data, 11LLU, 9LLU))
7307	9295	{

		@@ -7308,7 +9296,7 @@
7308	9296	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
7309	9297	(void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 10
7310	9298	{
7311		- state.addr = 18446744073709551216LLU; // 999999993u'''''''''''''''
	9299	+ state.addr = 18446744073709551083LLU; // 999999991p'''''''''''''''
7312	9300
7313	9301	break;
7314	9302	}

		@@ -7316,15 +9304,15 @@
7316	9304	/direct/LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = (LOCAL_ACCESS(heap.data, 11LLU, 9LLU) << 1) + 1LLU;
7317	9305	LOCAL_ACCESS(heap.data, 11LLU, 9LLU) = heap.data[LOCAL_ACCESS(heap.data, 11LLU, 9LLU)].elem0;
7318	9306	{
7319		- uint64_t arg = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 11LLU, 10LLU), 0LLU));
	9307	+ uint64_t arg = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 11LLU, 10LLU), 0LLU));
7320	9308	LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
7321	9309	}
7322	9310	{
7323		- uint64_t arg = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 12LLU, 10LLU), 2LLU));
	9311	+ uint64_t arg = 1LLU;
7324	9312	LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/address of current closure/, &arg);
7325	9313	}
7326	9314	{
7327		- uint64_t arg = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 13LLU, 10LLU), 4LLU));
	9315	+ uint64_t arg = 1LLU;
7328	9316	LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/address of current closure/, &arg);
7329	9317	}
7330	9318	{

		@@ -7339,11 +9327,11 @@
7339	9327	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7340	9328	}
7341	9329	{
7342		- uint64_t arg = /par_______/tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 15LLU, 10LLU), 1LLU);
	9330	+ uint64_t arg = /par_______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 15LLU, 10LLU), 1LLU);
7343	9331	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7344	9332	}
7345	9333	// 2LLU
7346		- uint64_t return_to = 18446744073709551214LLU;
	9334	+ uint64_t return_to = 18446744073709551081LLU;
7347	9335	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7348	9336	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7349	9337	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7353,13 +9341,13 @@
7353	9341
7354	9342	break;
7355	9343	}
7356		- case 18446744073709551214LLU: // 999999993s'''''''''''''''
	9344	+ case 18446744073709551081LLU: // 999999991n'''''''''''''''
7357	9345	{
7358		- state.addr = 18446744073709551215LLU; // 999999993t'''''''''''''''
	9346	+ state.addr = 18446744073709551082LLU; // 999999991o'''''''''''''''
7359	9347
7360	9348	break;
7361	9349	}
7362		- case 18446744073709551215LLU: // 999999993t'''''''''''''''
	9350	+ case 18446744073709551082LLU: // 999999991o'''''''''''''''
7363	9351	{
7364	9352	{
7365	9353	uint64_t arg = 0LLU;

		@@ -7379,11 +9367,11 @@
7379	9367	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
7380	9368	}
7381	9369
7382		- state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 17LLU, 16LLU), &/calleepars/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 5LLU)), 6) ? 18446744073709551213LLU : 18446744073709551212LLU;
	9370	+ state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 17LLU, 16LLU), &/calleepars/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 5LLU)), 6) ? 18446744073709551080LLU : 18446744073709551079LLU;
7383	9371
7384	9372	break;
7385	9373	}
7386		- case 18446744073709551213LLU: // 999999993r'''''''''''''''
	9374	+ case 18446744073709551080LLU: // 999999991m'''''''''''''''
7387	9375	{
7388	9376	{
7389	9377	uint64_t arg = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU);

		@@ -7408,7 +9396,7 @@
7408	9396	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7409	9397	}
7410	9398	// 1LLU
7411		- uint64_t return_to = 18446744073709551211LLU;
	9399	+ uint64_t return_to = 18446744073709551078LLU;
7412	9400	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7413	9401	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7414	9402	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7418,23 +9406,23 @@
7418	9406
7419	9407	break;
7420	9408	}
7421		- case 18446744073709551211LLU: // 999999993p'''''''''''''''
	9409	+ case 18446744073709551078LLU: // 999999991k'''''''''''''''
7422	9410	{
7423	9411	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 18
7424	9412	heap.availilable_size_for_dynamic_objects += 0LLU;
7425	9413	heap.availilable_size_for_dynamic_objects += 0LLU;
7426	9414
7427		- state.addr = 18446744073709551210LLU; // 999999993o'''''''''''''''
	9415	+ state.addr = 18446744073709551077LLU; // 999999991j'''''''''''''''
7428	9416
7429	9417	break;
7430	9418	}
7431		- case 18446744073709551212LLU: // 999999993q'''''''''''''''
	9419	+ case 18446744073709551079LLU: // 999999991l'''''''''''''''
7432	9420	{
7433		- state.addr = 18446744073709551210LLU; // 999999993o'''''''''''''''
	9421	+ state.addr = 18446744073709551077LLU; // 999999991j'''''''''''''''
7434	9422
7435	9423	break;
7436	9424	}
7437		- case 18446744073709551210LLU: // 999999993o'''''''''''''''
	9425	+ case 18446744073709551077LLU: // 999999991j'''''''''''''''
7438	9426	{
7439	9427	// variable pardef____ new_______ goes out of scope
7440	9428	// (uninitialized -> no destructor-call)

		@@ -7454,13 +9442,13 @@
7454	9442	// variable u64 id________ goes out of scope
7455	9443	// (uninitialized -> no destructor-call)
7456	9444	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 12
7457		- // parameter-reference pardef____ par_______ goes out of scope
	9445	+ // parameter-reference elemdef___ par_______ goes out of scope
7458	9446	// parameter tystruct__ constr____ goes out of scope
7459		- state.addr = 18446744073709551217LLU; // 999999993v'''''''''''''''
	9447	+ state.addr = 18446744073709551084LLU; // 999999991q'''''''''''''''
7460	9448
7461	9449	break;
7462	9450	}
7463		- case 18446744073709551216LLU: // 999999993u'''''''''''''''
	9451	+ case 18446744073709551083LLU: // 999999991p'''''''''''''''
7464	9452	{
7465	9453	{
7466	9454	uint64_t mainresult = heap.data[0].elem0;

		@@ -7474,7 +9462,7 @@
7474	9462	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7475	9463	}
7476	9464	// 2LLU
7477		- uint64_t return_to = 18446744073709551208LLU;
	9465	+ uint64_t return_to = 18446744073709551075LLU;
7478	9466	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7479	9467	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7480	9468	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7484,13 +9472,13 @@
7484	9472
7485	9473	break;
7486	9474	}
7487		- case 18446744073709551208LLU: // 999999993m'''''''''''''''
	9475	+ case 18446744073709551075LLU: // 999999991h'''''''''''''''
7488	9476	{
7489		- state.addr = 18446744073709551209LLU; // 999999993n'''''''''''''''
	9477	+ state.addr = 18446744073709551076LLU; // 999999991i'''''''''''''''
7490	9478
7491	9479	break;
7492	9480	}
7493		- case 18446744073709551209LLU: // 999999993n'''''''''''''''
	9481	+ case 18446744073709551076LLU: // 999999991i'''''''''''''''
7494	9482	{
7495	9483	/result____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 0LLU)) = 1LLU;
7496	9484	// parameter tystruct__ constr____ goes out of scope

		@@ -7498,21 +9486,21 @@
7498	9486	heap.availilable_size_for_dynamic_objects += 0LLU;
7499	9487	heap.availilable_size_for_dynamic_objects += 0LLU;
7500	9488
7501		- state.addr = 18446744073709551207LLU; // 999999993l'''''''''''''''
	9489	+ state.addr = 18446744073709551074LLU; // 999999991g'''''''''''''''
7502	9490
7503	9491	break;
7504	9492	}
7505		- case 18446744073709551218LLU: // 999999993w'''''''''''''''
	9493	+ case 18446744073709551085LLU: // 999999991r'''''''''''''''
7506	9494	{
7507	9495
7508		- state.addr = 861527391835906048LLU == heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 1LLU)].elem0 ? 18446744073709551206LLU : 18446744073709551205LLU;
	9496	+ state.addr = 861527391835906048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem0 ? 18446744073709551073LLU : 18446744073709551072LLU;
7509	9497
7510	9498	break;
7511	9499	}
7512		- case 18446744073709551206LLU: // 999999993k'''''''''''''''
	9500	+ case 18446744073709551073LLU: // 999999991f'''''''''''''''
7513	9501	{
7514	9502	{
7515		- uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 1LLU)].elem1;
	9503	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem1;
7516	9504	LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
7517	9505	}
7518	9506	/defbodysz_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 6LLU)) = 0LLU;

		@@ -7525,11 +9513,11 @@
7525	9513	uint64_t arg = 0;
7526	9514	LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/address of current closure/, &arg);
7527	9515	}
7528		- state.addr = 18446744073709551204LLU; // 999999993i'''''''''''''''
	9516	+ state.addr = 18446744073709551071LLU; // 999999991d'''''''''''''''
7529	9517
7530	9518	break;
7531	9519	}
7532		- case 18446744073709551204LLU: // 999999993i'''''''''''''''
	9520	+ case 18446744073709551071LLU: // 999999991d'''''''''''''''
7533	9521	{
7534	9522	if(!*LOCAL_ACCESS(heap.data, 11LLU, 9LLU))
7535	9523	{

		@@ -7536,7 +9524,7 @@
7536	9524	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
7537	9525	(void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 10
7538	9526	{
7539		- state.addr = 18446744073709551203LLU; // 999999993h'''''''''''''''
	9527	+ state.addr = 18446744073709551070LLU; // 999999991c'''''''''''''''
7540	9528
7541	9529	break;
7542	9530	}

		@@ -7544,15 +9532,15 @@
7544	9532	/direct/LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = (LOCAL_ACCESS(heap.data, 11LLU, 9LLU) << 1) + 1LLU;
7545	9533	LOCAL_ACCESS(heap.data, 11LLU, 9LLU) = heap.data[LOCAL_ACCESS(heap.data, 11LLU, 9LLU)].elem0;
7546	9534	{
7547		- uint64_t arg = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 11LLU, 10LLU), 0LLU));
	9535	+ uint64_t arg = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 11LLU, 10LLU), 0LLU));
7548	9536	LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
7549	9537	}
7550	9538	{
7551		- uint64_t arg = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 12LLU, 10LLU), 2LLU));
	9539	+ uint64_t arg = 1LLU;
7552	9540	LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/address of current closure/, &arg);
7553	9541	}
7554	9542	{
7555		- uint64_t arg = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 5LLU, LOCAL_ACCESS(heap.data, 13LLU, 10LLU), 4LLU));
	9543	+ uint64_t arg = 1LLU;
7556	9544	LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/address of current closure/, &arg);
7557	9545	}
7558	9546	{

		@@ -7567,11 +9555,11 @@
7567	9555	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7568	9556	}
7569	9557	{
7570		- uint64_t arg = /par_______/tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 15LLU, 10LLU), 1LLU);
	9558	+ uint64_t arg = /par_______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 15LLU, 10LLU), 1LLU);
7571	9559	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7572	9560	}
7573	9561	// 2LLU
7574		- uint64_t return_to = 18446744073709551201LLU;
	9562	+ uint64_t return_to = 18446744073709551068LLU;
7575	9563	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7576	9564	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7577	9565	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7581,13 +9569,13 @@
7581	9569
7582	9570	break;
7583	9571	}
7584		- case 18446744073709551201LLU: // 999999993f'''''''''''''''
	9572	+ case 18446744073709551068LLU: // 999999991a'''''''''''''''
7585	9573	{
7586		- state.addr = 18446744073709551202LLU; // 999999993g'''''''''''''''
	9574	+ state.addr = 18446744073709551069LLU; // 999999991b'''''''''''''''
7587	9575
7588	9576	break;
7589	9577	}
7590		- case 18446744073709551202LLU: // 999999993g'''''''''''''''
	9578	+ case 18446744073709551069LLU: // 999999991b'''''''''''''''
7591	9579	{
7592	9580	{
7593	9581	uint64_t arg = 0LLU;

		@@ -7607,11 +9595,11 @@
7607	9595	LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/address of current closure/, &arg);
7608	9596	}
7609	9597
7610		- state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 17LLU, 16LLU), &/calleepars/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 5LLU)), 6) ? 18446744073709551200LLU : 18446744073709551199LLU;
	9598	+ state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 17LLU, 16LLU), &/calleepars/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 5LLU)), 6) ? 18446744073709551067LLU : 18446744073709551066LLU;
7611	9599
7612	9600	break;
7613	9601	}
7614		- case 18446744073709551200LLU: // 999999993e'''''''''''''''
	9602	+ case 18446744073709551067LLU: // 999999991$'''''''''''''''
7615	9603	{
7616	9604	{
7617	9605	uint64_t arg = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU);

		@@ -7636,7 +9624,7 @@
7636	9624	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7637	9625	}
7638	9626	// 1LLU
7639		- uint64_t return_to = 18446744073709551198LLU;
	9627	+ uint64_t return_to = 18446744073709551065LLU;
7640	9628	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7641	9629	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7642	9630	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7646,23 +9634,23 @@
7646	9634
7647	9635	break;
7648	9636	}
7649		- case 18446744073709551198LLU: // 999999993c'''''''''''''''
	9637	+ case 18446744073709551065LLU: // 999999991Y'''''''''''''''
7650	9638	{
7651	9639	(void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 18
7652	9640	heap.availilable_size_for_dynamic_objects += 0LLU;
7653	9641	heap.availilable_size_for_dynamic_objects += 0LLU;
7654	9642
7655		- state.addr = 18446744073709551197LLU; // 999999993b'''''''''''''''
	9643	+ state.addr = 18446744073709551064LLU; // 999999991X'''''''''''''''
7656	9644
7657	9645	break;
7658	9646	}
7659		- case 18446744073709551199LLU: // 999999993d'''''''''''''''
	9647	+ case 18446744073709551066LLU: // 999999991Z'''''''''''''''
7660	9648	{
7661		- state.addr = 18446744073709551197LLU; // 999999993b'''''''''''''''
	9649	+ state.addr = 18446744073709551064LLU; // 999999991X'''''''''''''''
7662	9650
7663	9651	break;
7664	9652	}
7665		- case 18446744073709551197LLU: // 999999993b'''''''''''''''
	9653	+ case 18446744073709551064LLU: // 999999991X'''''''''''''''
7666	9654	{
7667	9655	// variable pardef____ new_______ goes out of scope
7668	9656	// (uninitialized -> no destructor-call)

		@@ -7682,13 +9670,13 @@
7682	9670	// variable u64 id________ goes out of scope
7683	9671	// (uninitialized -> no destructor-call)
7684	9672	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 12
7685		- // parameter-reference pardef____ par_______ goes out of scope
	9673	+ // parameter-reference elemdef___ par_______ goes out of scope
7686	9674	// parameter tyunionc__ constr____ goes out of scope
7687		- state.addr = 18446744073709551204LLU; // 999999993i'''''''''''''''
	9675	+ state.addr = 18446744073709551071LLU; // 999999991d'''''''''''''''
7688	9676
7689	9677	break;
7690	9678	}
7691		- case 18446744073709551203LLU: // 999999993h'''''''''''''''
	9679	+ case 18446744073709551070LLU: // 999999991c'''''''''''''''
7692	9680	{
7693	9681	{
7694	9682	uint64_t mainresult = heap.data[0].elem0;

		@@ -7702,7 +9690,7 @@
7702	9690	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7703	9691	}
7704	9692	// 2LLU
7705		- uint64_t return_to = 18446744073709551195LLU;
	9693	+ uint64_t return_to = 18446744073709551062LLU;
7706	9694	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7707	9695	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7708	9696	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7712,13 +9700,13 @@
7712	9700
7713	9701	break;
7714	9702	}
7715		- case 18446744073709551195LLU: // 999999993$'''''''''''''''
	9703	+ case 18446744073709551062LLU: // 999999991V'''''''''''''''
7716	9704	{
7717		- state.addr = 18446744073709551196LLU; // 999999993a'''''''''''''''
	9705	+ state.addr = 18446744073709551063LLU; // 999999991W'''''''''''''''
7718	9706
7719	9707	break;
7720	9708	}
7721		- case 18446744073709551196LLU: // 999999993a'''''''''''''''
	9709	+ case 18446744073709551063LLU: // 999999991W'''''''''''''''
7722	9710	{
7723	9711	/result____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 0LLU)) = 2LLU;
7724	9712	// parameter tyunionc__ constr____ goes out of scope

		@@ -7726,21 +9714,21 @@
7726	9714	heap.availilable_size_for_dynamic_objects += 0LLU;
7727	9715	heap.availilable_size_for_dynamic_objects += 0LLU;
7728	9716
7729		- state.addr = 18446744073709551194LLU; // 999999993Z'''''''''''''''
	9717	+ state.addr = 18446744073709551061LLU; // 999999991U'''''''''''''''
7730	9718
7731	9719	break;
7732	9720	}
7733		- case 18446744073709551205LLU: // 999999993j'''''''''''''''
	9721	+ case 18446744073709551072LLU: // 999999991e'''''''''''''''
7734	9722	{
7735	9723
7736		- state.addr = 861527391835975680LLU == heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 1LLU)].elem0 ? 18446744073709551193LLU : 18446744073709551192LLU;
	9724	+ state.addr = 861527391835975680LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem0 ? 18446744073709551060LLU : 18446744073709551059LLU;
7737	9725
7738	9726	break;
7739	9727	}
7740		- case 18446744073709551193LLU: // 999999993Y'''''''''''''''
	9728	+ case 18446744073709551060LLU: // 999999991T'''''''''''''''
7741	9729	{
7742	9730	{
7743		- uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 1LLU)].elem1;
	9731	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem1;
7744	9732	LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
7745	9733	}
7746	9734	/defbodysz_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 6LLU)) = 0LLU;

		@@ -7751,11 +9739,11 @@
7751	9739	heap.availilable_size_for_dynamic_objects += 0LLU;
7752	9740	heap.availilable_size_for_dynamic_objects += 0LLU;
7753	9741
7754		- state.addr = 18446744073709551191LLU; // 999999993W'''''''''''''''
	9742	+ state.addr = 18446744073709551058LLU; // 999999991R'''''''''''''''
7755	9743
7756	9744	break;
7757	9745	}
7758		- case 18446744073709551192LLU: // 999999993X'''''''''''''''
	9746	+ case 18446744073709551059LLU: // 999999991S'''''''''''''''
7759	9747	{
7760	9748
7761	9749	{

		@@ -7762,23 +9750,23 @@
7762	9750	fprintf(stderr, "%s\n", "typetransl UNKNOWN");
7763	9751	exit(-1);
7764	9752	}
7765		- state.addr = 18446744073709551191LLU; // 999999993W'''''''''''''''
	9753	+ state.addr = 18446744073709551058LLU; // 999999991R'''''''''''''''
7766	9754
7767	9755	break;
7768	9756	}
7769		- case 18446744073709551191LLU: // 999999993W'''''''''''''''
	9757	+ case 18446744073709551058LLU: // 999999991R'''''''''''''''
7770	9758	{
7771		- state.addr = 18446744073709551194LLU; // 999999993Z'''''''''''''''
	9759	+ state.addr = 18446744073709551061LLU; // 999999991U'''''''''''''''
7772	9760
7773	9761	break;
7774	9762	}
7775		- case 18446744073709551194LLU: // 999999993Z'''''''''''''''
	9763	+ case 18446744073709551061LLU: // 999999991U'''''''''''''''
7776	9764	{
7777		- state.addr = 18446744073709551207LLU; // 999999993l'''''''''''''''
	9765	+ state.addr = 18446744073709551074LLU; // 999999991g'''''''''''''''
7778	9766
7779	9767	break;
7780	9768	}
7781		- case 18446744073709551207LLU: // 999999993l'''''''''''''''
	9769	+ case 18446744073709551074LLU: // 999999991g'''''''''''''''
7782	9770	{
7783	9771	// parameter-reference u64 sizeonheap goes out of scope
7784	9772	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sizeonheap at 8

		@@ -7788,11 +9776,11 @@
7788	9776	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference calleepars at 6
7789	9777	// parameter-reference type______ retype____ goes out of scope
7790	9778	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference retype____ at 5
7791		- // parameter u64 id________ goes out of scope
	9779	+ // parameter-reference u64 id________ goes out of scope
7792	9780	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 4
7793		- // parameter u64 def_id____ goes out of scope
	9781	+ // parameter-reference u64 def_id____ goes out of scope
7794	9782	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference def_id____ at 3
7795		- // parameter typekind__ constr____ goes out of scope
	9783	+ // parameter-reference typekind__ constr____ goes out of scope
7796	9784	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference constr____ at 2
7797	9785	// parameter-reference u64 result____ goes out of scope
7798	9786	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 1

		@@ -7820,11 +9808,11 @@
7820	9808	uint64_t arg = 0;
7821	9809	LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/address of current closure/, &arg);
7822	9810	}
7823		- state.addr = 18446744073709551190LLU; // 999999993V'''''''''''''''
	9811	+ state.addr = 18446744073709551057LLU; // 999999991Q'''''''''''''''
7824	9812
7825	9813	break;
7826	9814	}
7827		- case 18446744073709551190LLU: // 999999993V'''''''''''''''
	9815	+ case 18446744073709551057LLU: // 999999991Q'''''''''''''''
7828	9816	{
7829	9817	if(!*LOCAL_ACCESS(heap.data, 11LLU, 9LLU))
7830	9818	{

		@@ -7831,7 +9819,7 @@
7831	9819	(void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
7832	9820	(void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 10
7833	9821	{
7834		- state.addr = 18446744073709551189LLU; // 999999993U'''''''''''''''
	9822	+ state.addr = 18446744073709551056LLU; // 999999991P'''''''''''''''
7835	9823
7836	9824	break;
7837	9825	}

		@@ -7845,11 +9833,11 @@
7845	9833
7846	9834	/match_____/LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = /id________/LOCAL_ACCESS(heap.data, 12LLU, 2LLU) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 12LLU, 10LLU), 0LLU));
7847	9835
7848		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 12LLU, 11LLU) ? 18446744073709551188LLU : 18446744073709551187LLU;
	9836	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 12LLU, 11LLU) ? 18446744073709551055LLU : 18446744073709551054LLU;
7849	9837
7850	9838	break;
7851	9839	}
7852		- case 18446744073709551188LLU: // 999999993T'''''''''''''''
	9840	+ case 18446744073709551055LLU: // 999999991O'''''''''''''''
7853	9841	{
7854	9842	/notfound__/*LOCAL_ACCESS(heap.data, 12LLU, 8LLU) = 0LLU;
7855	9843	{

		@@ -7860,15 +9848,15 @@
7860	9848	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7861	9849	}
7862	9850	{
7863		- uint64_t arg = /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 12LLU, 10LLU), 1LLU));
	9851	+ uint64_t arg = /elem______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 12LLU, 10LLU), 1LLU);
7864	9852	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7865	9853	}
7866	9854	{
7867		- uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 12LLU, 0LLU);
	9855	+ uint64_t arg = /def_id____/LOCAL_ACCESS_ADDR(heap.data, 12LLU, 0LLU);
7868	9856	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7869	9857	}
7870	9858	{
7871		- uint64_t arg = /id________/*LOCAL_ACCESS(heap.data, 12LLU, 2LLU);
	9859	+ uint64_t arg = /id________/LOCAL_ACCESS_ADDR(heap.data, 12LLU, 2LLU);
7872	9860	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7873	9861	}
7874	9862	{

		@@ -7888,7 +9876,7 @@
7888	9876	LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7889	9877	}
7890	9878	// 8LLU
7891		- uint64_t return_to = 18446744073709551185LLU;
	9879	+ uint64_t return_to = 18446744073709551052LLU;
7892	9880	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7893	9881	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7894	9882	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7898,19 +9886,19 @@
7898	9886
7899	9887	break;
7900	9888	}
7901		- case 18446744073709551185LLU: // 999999993Q'''''''''''''''
	9889	+ case 18446744073709551052LLU: // 999999991L'''''''''''''''
7902	9890	{
7903		- state.addr = 18446744073709551186LLU; // 999999993R'''''''''''''''
	9891	+ state.addr = 18446744073709551053LLU; // 999999991M'''''''''''''''
7904	9892
7905	9893	break;
7906	9894	}
7907		- case 18446744073709551186LLU: // 999999993R'''''''''''''''
	9895	+ case 18446744073709551053LLU: // 999999991M'''''''''''''''
7908	9896	{
7909		- state.addr = 18446744073709551187LLU; // 999999993S'''''''''''''''
	9897	+ state.addr = 18446744073709551054LLU; // 999999991N'''''''''''''''
7910	9898
7911	9899	break;
7912	9900	}
7913		- case 18446744073709551187LLU: // 999999993S'''''''''''''''
	9901	+ case 18446744073709551054LLU: // 999999991N'''''''''''''''
7914	9902	{
7915	9903	// variable u64 match_____ goes out of scope
7916	9904	// emitted destructur for type u64

		@@ -7917,18 +9905,18 @@
7917	9905	(void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference match_____ at 12
7918	9906	// parameter-reference typedef___ elem______ goes out of scope
7919	9907	// parameter-reference list<typedef___> typedefs__ goes out of scope
7920		- state.addr = 18446744073709551190LLU; // 999999993V'''''''''''''''
	9908	+ state.addr = 18446744073709551057LLU; // 999999991Q'''''''''''''''
7921	9909
7922	9910	break;
7923	9911	}
7924		- case 18446744073709551189LLU: // 999999993U'''''''''''''''
	9912	+ case 18446744073709551056LLU: // 999999991P'''''''''''''''
7925	9913	{
7926	9914
7927		- state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709551184LLU : 18446744073709551183LLU;
	9915	+ state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709551051LLU : 18446744073709551050LLU;
7928	9916
7929	9917	break;
7930	9918	}
7931		- case 18446744073709551184LLU: // 999999993P'''''''''''''''
	9919	+ case 18446744073709551051LLU: // 999999991K'''''''''''''''
7932	9920	{
7933	9921	{
7934	9922	uint64_t mainresult = heap.data[0].elem0;

		@@ -7942,7 +9930,7 @@
7942	9930	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7943	9931	}
7944	9932	// 2LLU
7945		- uint64_t return_to = 18446744073709551181LLU;
	9933	+ uint64_t return_to = 18446744073709551048LLU;
7946	9934	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7947	9935	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7948	9936	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7952,13 +9940,13 @@
7952	9940
7953	9941	break;
7954	9942	}
7955		- case 18446744073709551181LLU: // 999999993M'''''''''''''''
	9943	+ case 18446744073709551048LLU: // 999999991H'''''''''''''''
7956	9944	{
7957		- state.addr = 18446744073709551182LLU; // 999999993N'''''''''''''''
	9945	+ state.addr = 18446744073709551049LLU; // 999999991I'''''''''''''''
7958	9946
7959	9947	break;
7960	9948	}
7961		- case 18446744073709551182LLU: // 999999993N'''''''''''''''
	9949	+ case 18446744073709551049LLU: // 999999991I'''''''''''''''
7962	9950	{
7963	9951	{
7964	9952	uint64_t mainresult = heap.data[0].elem0;

		@@ -7968,7 +9956,7 @@
7968	9956	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
7969	9957	}
7970	9958	// 1LLU
7971		- uint64_t return_to = 18446744073709551179LLU;
	9959	+ uint64_t return_to = 18446744073709551046LLU;
7972	9960	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
7973	9961	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
7974	9962	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -7978,13 +9966,13 @@
7978	9966
7979	9967	break;
7980	9968	}
7981		- case 18446744073709551179LLU: // 999999993K'''''''''''''''
	9969	+ case 18446744073709551046LLU: // 999999991F'''''''''''''''
7982	9970	{
7983		- state.addr = 18446744073709551180LLU; // 999999993L'''''''''''''''
	9971	+ state.addr = 18446744073709551047LLU; // 999999991G'''''''''''''''
7984	9972
7985	9973	break;
7986	9974	}
7987		- case 18446744073709551180LLU: // 999999993L'''''''''''''''
	9975	+ case 18446744073709551047LLU: // 999999991G'''''''''''''''
7988	9976	{
7989	9977	fprintf(stderr, "%s", "no such type ");
7990	9978

		@@ -7994,11 +9982,11 @@
7994	9982	fprintf(stderr, "%s\n", "");
7995	9983	exit(-1);
7996	9984	}
7997		- state.addr = 18446744073709551183LLU; // 999999993O'''''''''''''''
	9985	+ state.addr = 18446744073709551050LLU; // 999999991J'''''''''''''''
7998	9986
7999	9987	break;
8000	9988	}
8001		- case 18446744073709551183LLU: // 999999993O'''''''''''''''
	9989	+ case 18446744073709551050LLU: // 999999991J'''''''''''''''
8002	9990	{
8003	9991	// variable u64 notfound__ goes out of scope
8004	9992	// emitted destructur for type u64

		@@ -8029,14 +10017,715 @@
8029	10017
8030	10018	break;
8031	10019	}
	10020	+ case 375116006239148967LLU: // TypeTransl
	10021	+ {
	10022	+
	10023	+ state.addr = 861519017821270016LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem0 ? 18446744073709551045LLU : 18446744073709551044LLU;
	10024	+
	10025	+ break;
	10026	+ }
	10027	+ case 18446744073709551045LLU: // 999999991E'''''''''''''''
	10028	+ {
	10029	+ {
	10030	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem1;
	10031	+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
	10032	+ }
	10033	+ /defbodysz_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 6LLU)) = 0LLU;
	10034	+ /sizeonheap/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 7LLU)) = /constr____/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU), 1LLU));
	10035	+ {
	10036	+ uint64_t arg = /constr____/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU), 0LLU));
	10037	+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/address of current closure/, &arg);
	10038	+ }
	10039	+ {
	10040	+ uint64_t arg = 0;
	10041	+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/address of current closure/, &arg);
	10042	+ }
	10043	+ state.addr = 18446744073709551043LLU; // 999999991C'''''''''''''''
	10044	+
	10045	+ break;
	10046	+ }
	10047	+ case 18446744073709551043LLU: // 999999991C'''''''''''''''
	10048	+ {
	10049	+ if(!*LOCAL_ACCESS(heap.data, 11LLU, 9LLU))
	10050	+ {
	10051	+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
	10052	+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 10
	10053	+ {
	10054	+ state.addr = 18446744073709551042LLU; // 999999991B'''''''''''''''
	10055	+
	10056	+ break;
	10057	+ }
	10058	+ }
	10059	+ /direct/LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = (LOCAL_ACCESS(heap.data, 11LLU, 9LLU) << 1) + 1LLU;
	10060	+ LOCAL_ACCESS(heap.data, 11LLU, 9LLU) = heap.data[LOCAL_ACCESS(heap.data, 11LLU, 9LLU)].elem0;
	10061	+ {
	10062	+ uint64_t arg = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 11LLU, 10LLU), 0LLU));
	10063	+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
	10064	+ }
	10065	+ {
	10066	+ uint64_t arg = 0LLU;
	10067	+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/address of current closure/, &arg);
	10068	+ }
	10069	+ {
	10070	+ uint64_t mainresult = heap.data[0].elem0;
	10071	+ heap.data[0].elem0 = 0;
	10072	+ {
	10073	+ uint64_t arg = /t_________/LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
	10074	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10075	+ }
	10076	+ {
	10077	+ uint64_t arg = /par_______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 13LLU, 10LLU), 1LLU);
	10078	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10079	+ }
	10080	+ // 2LLU
	10081	+ uint64_t return_to = 18446744073709551040LLU;
	10082	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	10083	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	10084	+ heap.data[0].elem1 = heap.data[0].elem0;
	10085	+ heap.data[0].elem0 = mainresult;
	10086	+ }
	10087	+ state.addr = 367395560426147840LLU; // TYPECOPY__
	10088	+
	10089	+ break;
	10090	+ }
	10091	+ case 18446744073709551040LLU: // 999999991_'''''''''''''''
	10092	+ {
	10093	+ state.addr = 18446744073709551041LLU; // 999999991A'''''''''''''''
	10094	+
	10095	+ break;
	10096	+ }
	10097	+ case 18446744073709551041LLU: // 999999991A'''''''''''''''
	10098	+ {
	10099	+ {
	10100	+ uint64_t arg = 0LLU;
	10101	+ tree_push_move(&heap, 0LLU, &arg, &*LOCAL_ACCESS(heap.data, 13LLU, 11LLU));
	10102	+ tree_push_move(&heap, 1LLU, &arg, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU));
	10103	+;
	10104	+ LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/address of current closure/, &arg);
	10105	+ }
	10106	+
	10107	+ state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 14LLU, 13LLU), &/calleepars/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 14LLU, 5LLU)), 3) ? 18446744073709551039LLU : 18446744073709551038LLU;
	10108	+
	10109	+ break;
	10110	+ }
	10111	+ case 18446744073709551039LLU: // 9999999909'''''''''''''''
	10112	+ {
	10113	+ {
	10114	+ uint64_t arg = *LOCAL_ACCESS(heap.data, 14LLU, 13LLU);
	10115	+ LOCAL_PUSH_MOVE(&heap, 14, &(heap.data[0].elem1)/address of current closure/, &arg);
	10116	+ }
	10117	+ fprintf(stderr, "%s", "pushing par ");
	10118	+
	10119	+ printid(stderr, /new_______/*access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS_ADDR(heap.data, 15LLU, 14LLU), 0LLU)));
	10120	+ fprintf(stderr, "%s", "\n");
	10121	+
	10122	+ {
	10123	+ fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap/dynamic in compiler, gettype - recompile compiler with increased heap-size");
	10124	+ exit(-1);
	10125	+ }
	10126	+ // variable elemdef___ new_______ goes out of scope
	10127	+ // emitted destructur for type elemdef___
	10128	+ {
	10129	+ uint64_t mainresult = heap.data[0].elem0;
	10130	+ heap.data[0].elem0 = 0;
	10131	+ {
	10132	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 15LLU, 14LLU);
	10133	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10134	+ }
	10135	+ // 1LLU
	10136	+ uint64_t return_to = 18446744073709551037LLU;
	10137	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	10138	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	10139	+ heap.data[0].elem1 = heap.data[0].elem0;
	10140	+ heap.data[0].elem0 = mainresult;
	10141	+ }
	10142	+ state.addr = 587581796494083780LLU; // elemdef_$D
	10143	+
	10144	+ break;
	10145	+ }
	10146	+ case 18446744073709551037LLU: // 9999999907'''''''''''''''
	10147	+ {
	10148	+ (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 15
	10149	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	10150	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	10151	+
	10152	+ state.addr = 18446744073709551036LLU; // 9999999906'''''''''''''''
	10153	+
	10154	+ break;
	10155	+ }
	10156	+ case 18446744073709551038LLU: // 9999999908'''''''''''''''
	10157	+ {
	10158	+ state.addr = 18446744073709551036LLU; // 9999999906'''''''''''''''
	10159	+
	10160	+ break;
	10161	+ }
	10162	+ case 18446744073709551036LLU: // 9999999906'''''''''''''''
	10163	+ {
	10164	+ // variable elemdef___ new_______ goes out of scope
	10165	+ // (uninitialized -> no destructor-call)
	10166	+ (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 14
	10167	+ // variable type______ t_________ goes out of scope
	10168	+ // (uninitialized -> no destructor-call)
	10169	+ (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference t_________ at 13
	10170	+ // variable u64 id________ goes out of scope
	10171	+ // (uninitialized -> no destructor-call)
	10172	+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 12
	10173	+ // parameter-reference elemdef___ par_______ goes out of scope
	10174	+ // parameter tystruct__ constr____ goes out of scope
	10175	+ state.addr = 18446744073709551043LLU; // 999999991C'''''''''''''''
	10176	+
	10177	+ break;
	10178	+ }
	10179	+ case 18446744073709551042LLU: // 999999991B'''''''''''''''
	10180	+ {
	10181	+ {
	10182	+ uint64_t mainresult = heap.data[0].elem0;
	10183	+ heap.data[0].elem0 = 0;
	10184	+ {
	10185	+ uint64_t arg = /retype____/*LOCAL_ACCESS(heap.data, 9LLU, 4LLU);
	10186	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10187	+ }
	10188	+ {
	10189	+ uint64_t arg = /constr____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU), 2LLU);
	10190	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10191	+ }
	10192	+ // 2LLU
	10193	+ uint64_t return_to = 18446744073709551034LLU;
	10194	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	10195	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	10196	+ heap.data[0].elem1 = heap.data[0].elem0;
	10197	+ heap.data[0].elem0 = mainresult;
	10198	+ }
	10199	+ state.addr = 861504776686223360LLU; // typecopy__
	10200	+
	10201	+ break;
	10202	+ }
	10203	+ case 18446744073709551034LLU: // 9999999904'''''''''''''''
	10204	+ {
	10205	+ state.addr = 18446744073709551035LLU; // 9999999905'''''''''''''''
	10206	+
	10207	+ break;
	10208	+ }
	10209	+ case 18446744073709551035LLU: // 9999999905'''''''''''''''
	10210	+ {
	10211	+ /result____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 0LLU)) = 1LLU;
	10212	+ // parameter tystruct__ constr____ goes out of scope
	10213	+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference constr____ at 9
	10214	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	10215	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	10216	+
	10217	+ state.addr = 18446744073709551033LLU; // 9999999903'''''''''''''''
	10218	+
	10219	+ break;
	10220	+ }
	10221	+ case 18446744073709551044LLU: // 999999991D'''''''''''''''
	10222	+ {
	10223	+
	10224	+ state.addr = 861527391835906048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem0 ? 18446744073709551032LLU : 18446744073709551031LLU;
	10225	+
	10226	+ break;
	10227	+ }
	10228	+ case 18446744073709551032LLU: // 9999999902'''''''''''''''
	10229	+ {
	10230	+ {
	10231	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem1;
	10232	+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
	10233	+ }
	10234	+ /defbodysz_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 6LLU)) = 0LLU;
	10235	+ /sizeonheap/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 7LLU)) = /constr____/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU), 1LLU));
	10236	+ {
	10237	+ uint64_t arg = /constr____/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU), 0LLU));
	10238	+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/address of current closure/, &arg);
	10239	+ }
	10240	+ {
	10241	+ uint64_t arg = 0;
	10242	+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/address of current closure/, &arg);
	10243	+ }
	10244	+ state.addr = 18446744073709551030LLU; // 9999999900'''''''''''''''
	10245	+
	10246	+ break;
	10247	+ }
	10248	+ case 18446744073709551030LLU: // 9999999900'''''''''''''''
	10249	+ {
	10250	+ if(!*LOCAL_ACCESS(heap.data, 11LLU, 9LLU))
	10251	+ {
	10252	+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
	10253	+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 10
	10254	+ {
	10255	+ state.addr = 18446744073709551029LLU; // 999999990z'''''''''''''''
	10256	+
	10257	+ break;
	10258	+ }
	10259	+ }
	10260	+ /direct/LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = (LOCAL_ACCESS(heap.data, 11LLU, 9LLU) << 1) + 1LLU;
	10261	+ LOCAL_ACCESS(heap.data, 11LLU, 9LLU) = heap.data[LOCAL_ACCESS(heap.data, 11LLU, 9LLU)].elem0;
	10262	+ {
	10263	+ uint64_t arg = /par_______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 11LLU, 10LLU), 0LLU));
	10264	+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
	10265	+ }
	10266	+ {
	10267	+ uint64_t arg = 0LLU;
	10268	+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/address of current closure/, &arg);
	10269	+ }
	10270	+ {
	10271	+ uint64_t mainresult = heap.data[0].elem0;
	10272	+ heap.data[0].elem0 = 0;
	10273	+ {
	10274	+ uint64_t arg = /t_________/LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
	10275	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10276	+ }
	10277	+ {
	10278	+ uint64_t arg = /par_______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 13LLU, 10LLU), 1LLU);
	10279	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10280	+ }
	10281	+ // 2LLU
	10282	+ uint64_t return_to = 18446744073709551027LLU;
	10283	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	10284	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	10285	+ heap.data[0].elem1 = heap.data[0].elem0;
	10286	+ heap.data[0].elem0 = mainresult;
	10287	+ }
	10288	+ state.addr = 367395560426147840LLU; // TYPECOPY__
	10289	+
	10290	+ break;
	10291	+ }
	10292	+ case 18446744073709551027LLU: // 999999990x'''''''''''''''
	10293	+ {
	10294	+ state.addr = 18446744073709551028LLU; // 999999990y'''''''''''''''
	10295	+
	10296	+ break;
	10297	+ }
	10298	+ case 18446744073709551028LLU: // 999999990y'''''''''''''''
	10299	+ {
	10300	+ {
	10301	+ uint64_t arg = 0LLU;
	10302	+ tree_push_move(&heap, 0LLU, &arg, &*LOCAL_ACCESS(heap.data, 13LLU, 11LLU));
	10303	+ tree_push_move(&heap, 1LLU, &arg, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU));
	10304	+;
	10305	+ LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/address of current closure/, &arg);
	10306	+ }
	10307	+
	10308	+ state.addr = !list_push_move(&heap, &/new_______/LOCAL_ACCESS(heap.data, 14LLU, 13LLU), &/calleepars/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 14LLU, 5LLU)), 3) ? 18446744073709551026LLU : 18446744073709551025LLU;
	10309	+
	10310	+ break;
	10311	+ }
	10312	+ case 18446744073709551026LLU: // 999999990w'''''''''''''''
	10313	+ {
	10314	+ {
	10315	+ uint64_t arg = *LOCAL_ACCESS(heap.data, 14LLU, 13LLU);
	10316	+ LOCAL_PUSH_MOVE(&heap, 14, &(heap.data[0].elem1)/address of current closure/, &arg);
	10317	+ }
	10318	+ fprintf(stderr, "%s", "pushing par ");
	10319	+
	10320	+ printid(stderr, /new_______/*access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS_ADDR(heap.data, 15LLU, 14LLU), 0LLU)));
	10321	+ fprintf(stderr, "%s", "\n");
	10322	+
	10323	+ {
	10324	+ fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap/dynamic in compiler, gettype - recompile compiler with increased heap-size");
	10325	+ exit(-1);
	10326	+ }
	10327	+ // variable elemdef___ new_______ goes out of scope
	10328	+ // emitted destructur for type elemdef___
	10329	+ {
	10330	+ uint64_t mainresult = heap.data[0].elem0;
	10331	+ heap.data[0].elem0 = 0;
	10332	+ {
	10333	+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 15LLU, 14LLU);
	10334	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10335	+ }
	10336	+ // 1LLU
	10337	+ uint64_t return_to = 18446744073709551024LLU;
	10338	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	10339	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	10340	+ heap.data[0].elem1 = heap.data[0].elem0;
	10341	+ heap.data[0].elem0 = mainresult;
	10342	+ }
	10343	+ state.addr = 587581796494083780LLU; // elemdef_$D
	10344	+
	10345	+ break;
	10346	+ }
	10347	+ case 18446744073709551024LLU: // 999999990u'''''''''''''''
	10348	+ {
	10349	+ (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 15
	10350	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	10351	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	10352	+
	10353	+ state.addr = 18446744073709551023LLU; // 999999990t'''''''''''''''
	10354	+
	10355	+ break;
	10356	+ }
	10357	+ case 18446744073709551025LLU: // 999999990v'''''''''''''''
	10358	+ {
	10359	+ state.addr = 18446744073709551023LLU; // 999999990t'''''''''''''''
	10360	+
	10361	+ break;
	10362	+ }
	10363	+ case 18446744073709551023LLU: // 999999990t'''''''''''''''
	10364	+ {
	10365	+ // variable elemdef___ new_______ goes out of scope
	10366	+ // (uninitialized -> no destructor-call)
	10367	+ (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference new_______ at 14
	10368	+ // variable type______ t_________ goes out of scope
	10369	+ // (uninitialized -> no destructor-call)
	10370	+ (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference t_________ at 13
	10371	+ // variable u64 id________ goes out of scope
	10372	+ // (uninitialized -> no destructor-call)
	10373	+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 12
	10374	+ // parameter-reference elemdef___ par_______ goes out of scope
	10375	+ // parameter tyunionc__ constr____ goes out of scope
	10376	+ state.addr = 18446744073709551030LLU; // 9999999900'''''''''''''''
	10377	+
	10378	+ break;
	10379	+ }
	10380	+ case 18446744073709551029LLU: // 999999990z'''''''''''''''
	10381	+ {
	10382	+ {
	10383	+ uint64_t mainresult = heap.data[0].elem0;
	10384	+ heap.data[0].elem0 = 0;
	10385	+ {
	10386	+ uint64_t arg = /retype____/*LOCAL_ACCESS(heap.data, 9LLU, 4LLU);
	10387	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10388	+ }
	10389	+ {
	10390	+ uint64_t arg = /constr____/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU), 2LLU);
	10391	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10392	+ }
	10393	+ // 2LLU
	10394	+ uint64_t return_to = 18446744073709551021LLU;
	10395	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	10396	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	10397	+ heap.data[0].elem1 = heap.data[0].elem0;
	10398	+ heap.data[0].elem0 = mainresult;
	10399	+ }
	10400	+ state.addr = 861504776686223360LLU; // typecopy__
	10401	+
	10402	+ break;
	10403	+ }
	10404	+ case 18446744073709551021LLU: // 999999990r'''''''''''''''
	10405	+ {
	10406	+ state.addr = 18446744073709551022LLU; // 999999990s'''''''''''''''
	10407	+
	10408	+ break;
	10409	+ }
	10410	+ case 18446744073709551022LLU: // 999999990s'''''''''''''''
	10411	+ {
	10412	+ /result____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 0LLU)) = 2LLU;
	10413	+ // parameter tyunionc__ constr____ goes out of scope
	10414	+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference constr____ at 9
	10415	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	10416	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	10417	+
	10418	+ state.addr = 18446744073709551020LLU; // 999999990q'''''''''''''''
	10419	+
	10420	+ break;
	10421	+ }
	10422	+ case 18446744073709551031LLU: // 9999999901'''''''''''''''
	10423	+ {
	10424	+
	10425	+ state.addr = 861527391835975680LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem0 ? 18446744073709551019LLU : 18446744073709551018LLU;
	10426	+
	10427	+ break;
	10428	+ }
	10429	+ case 18446744073709551019LLU: // 999999990p'''''''''''''''
	10430	+ {
	10431	+ {
	10432	+ uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 1LLU))].elem1;
	10433	+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
	10434	+ }
	10435	+ /defbodysz_/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 6LLU)) = 0LLU;
	10436	+ /sizeonheap/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 7LLU)) = /constr____/*access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU), 1LLU));
	10437	+ /result____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 0LLU)) = 3LLU;
	10438	+ // parameter tyuniont__ constr____ goes out of scope
	10439	+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference constr____ at 9
	10440	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	10441	+ heap.availilable_size_for_dynamic_objects += 0LLU;
	10442	+
	10443	+ state.addr = 18446744073709551017LLU; // 999999990n'''''''''''''''
	10444	+
	10445	+ break;
	10446	+ }
	10447	+ case 18446744073709551018LLU: // 999999990o'''''''''''''''
	10448	+ {
	10449	+
	10450	+ {
	10451	+ fprintf(stderr, "%s\n", "TypeTransl UNKNOWN");
	10452	+ exit(-1);
	10453	+ }
	10454	+ state.addr = 18446744073709551017LLU; // 999999990n'''''''''''''''
	10455	+
	10456	+ break;
	10457	+ }
	10458	+ case 18446744073709551017LLU: // 999999990n'''''''''''''''
	10459	+ {
	10460	+ state.addr = 18446744073709551020LLU; // 999999990q'''''''''''''''
	10461	+
	10462	+ break;
	10463	+ }
	10464	+ case 18446744073709551020LLU: // 999999990q'''''''''''''''
	10465	+ {
	10466	+ state.addr = 18446744073709551033LLU; // 9999999903'''''''''''''''
	10467	+
	10468	+ break;
	10469	+ }
	10470	+ case 18446744073709551033LLU: // 9999999903'''''''''''''''
	10471	+ {
	10472	+ // parameter-reference u64 sizeonheap goes out of scope
	10473	+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sizeonheap at 8
	10474	+ // parameter-reference u64 defbodysz_ goes out of scope
	10475	+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference defbodysz_ at 7
	10476	+ // parameter-reference list<elemdef___> calleepars goes out of scope
	10477	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference calleepars at 6
	10478	+ // parameter-reference type______ retype____ goes out of scope
	10479	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference retype____ at 5
	10480	+ // parameter-reference u64 id________ goes out of scope
	10481	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 4
	10482	+ // parameter-reference u64 def_id____ goes out of scope
	10483	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference def_id____ at 3
	10484	+ // parameter-reference typekind__ constr____ goes out of scope
	10485	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference constr____ at 2
	10486	+ // parameter-reference u64 result____ goes out of scope
	10487	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference result____ at 1
	10488	+
	10489	+ {
	10490	+ uint64_t baseinfo = heap.data[0].elem1;
	10491	+ struct pair pair = unpair(&heap, &baseinfo);
	10492	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	10493	+ state.addr = pair.elem1;
	10494	+ }
	10495	+
	10496	+ break;
	10497	+ }
	10498	+ case 621706743143170048LLU: // gettype2__
	10499	+ {
	10500	+ {
	10501	+ uint64_t arg = 1LLU;
	10502	+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/address of current closure/, &arg);
	10503	+ }
	10504	+ {
	10505	+ uint64_t arg = /typedefs__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 9LLU, 1LLU));
	10506	+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/address of current closure/, &arg);
	10507	+ }
	10508	+ {
	10509	+ uint64_t arg = 0;
	10510	+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/address of current closure/, &arg);
	10511	+ }
	10512	+ state.addr = 18446744073709551016LLU; // 999999990m'''''''''''''''
	10513	+
	10514	+ break;
	10515	+ }
	10516	+ case 18446744073709551016LLU: // 999999990m'''''''''''''''
	10517	+ {
	10518	+ if(!*LOCAL_ACCESS(heap.data, 11LLU, 9LLU))
	10519	+ {
	10520	+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 11
	10521	+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 10
	10522	+ {
	10523	+ state.addr = 18446744073709551015LLU; // 999999990l'''''''''''''''
	10524	+
	10525	+ break;
	10526	+ }
	10527	+ }
	10528	+ /direct/LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = (LOCAL_ACCESS(heap.data, 11LLU, 9LLU) << 1) + 1LLU;
	10529	+ LOCAL_ACCESS(heap.data, 11LLU, 9LLU) = heap.data[LOCAL_ACCESS(heap.data, 11LLU, 9LLU)].elem0;
	10530	+ {
	10531	+ uint64_t arg = 0LLU;
	10532	+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/address of current closure/, &arg);
	10533	+ }
	10534	+
	10535	+ /match_____/LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = /id________/LOCAL_ACCESS(heap.data, 12LLU, 2LLU) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 12LLU, 10LLU), 0LLU));
	10536	+
	10537	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 12LLU, 11LLU) ? 18446744073709551014LLU : 18446744073709551013LLU;
	10538	+
	10539	+ break;
	10540	+ }
	10541	+ case 18446744073709551014LLU: // 999999990k'''''''''''''''
	10542	+ {
	10543	+ /notfound__/*LOCAL_ACCESS(heap.data, 12LLU, 8LLU) = 0LLU;
	10544	+ {
	10545	+ uint64_t mainresult = heap.data[0].elem0;
	10546	+ heap.data[0].elem0 = 0;
	10547	+ {
	10548	+ uint64_t arg = /constr____/*LOCAL_ACCESS(heap.data, 12LLU, 7LLU);
	10549	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10550	+ }
	10551	+ {
	10552	+ uint64_t arg = /elem______/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 12LLU, 10LLU), 1LLU);
	10553	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10554	+ }
	10555	+ {
	10556	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 12LLU, 0LLU);
	10557	+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10558	+ }
	10559	+ {
	10560	+ uint64_t arg = /id________/LOCAL_ACCESS_ADDR(heap.data, 12LLU, 2LLU);
	10561	+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10562	+ }
	10563	+ {
	10564	+ uint64_t arg = /retype____/*LOCAL_ACCESS(heap.data, 12LLU, 3LLU);
	10565	+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10566	+ }
	10567	+ {
	10568	+ uint64_t arg = /calleepars/*LOCAL_ACCESS(heap.data, 12LLU, 4LLU);
	10569	+ LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10570	+ }
	10571	+ {
	10572	+ uint64_t arg = /calleesize/*LOCAL_ACCESS(heap.data, 12LLU, 5LLU);
	10573	+ LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10574	+ }
	10575	+ {
	10576	+ uint64_t arg = /sizeonheap/*LOCAL_ACCESS(heap.data, 12LLU, 6LLU);
	10577	+ LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10578	+ }
	10579	+ // 8LLU
	10580	+ uint64_t return_to = 18446744073709551011LLU;
	10581	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	10582	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	10583	+ heap.data[0].elem1 = heap.data[0].elem0;
	10584	+ heap.data[0].elem0 = mainresult;
	10585	+ }
	10586	+ state.addr = 375116006239148967LLU; // TypeTransl
	10587	+
	10588	+ break;
	10589	+ }
	10590	+ case 18446744073709551011LLU: // 999999990h'''''''''''''''
	10591	+ {
	10592	+ state.addr = 18446744073709551012LLU; // 999999990i'''''''''''''''
	10593	+
	10594	+ break;
	10595	+ }
	10596	+ case 18446744073709551012LLU: // 999999990i'''''''''''''''
	10597	+ {
	10598	+ state.addr = 18446744073709551013LLU; // 999999990j'''''''''''''''
	10599	+
	10600	+ break;
	10601	+ }
	10602	+ case 18446744073709551013LLU: // 999999990j'''''''''''''''
	10603	+ {
	10604	+ // variable u64 match_____ goes out of scope
	10605	+ // emitted destructur for type u64
	10606	+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference match_____ at 12
	10607	+ // parameter-reference typedef___ elem______ goes out of scope
	10608	+ // parameter-reference list<typedef___> typedefs__ goes out of scope
	10609	+ state.addr = 18446744073709551016LLU; // 999999990m'''''''''''''''
	10610	+
	10611	+ break;
	10612	+ }
	10613	+ case 18446744073709551015LLU: // 999999990l'''''''''''''''
	10614	+ {
	10615	+
	10616	+ state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709551010LLU : 18446744073709551009LLU;
	10617	+
	10618	+ break;
	10619	+ }
	10620	+ case 18446744073709551010LLU: // 999999990g'''''''''''''''
	10621	+ {
	10622	+ {
	10623	+ uint64_t mainresult = heap.data[0].elem0;
	10624	+ heap.data[0].elem0 = 0;
	10625	+ {
	10626	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 9LLU, 0LLU);
	10627	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10628	+ }
	10629	+ {
	10630	+ uint64_t arg = /typedefs__/*LOCAL_ACCESS(heap.data, 9LLU, 1LLU);
	10631	+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10632	+ }
	10633	+ // 2LLU
	10634	+ uint64_t return_to = 18446744073709551007LLU;
	10635	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	10636	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	10637	+ heap.data[0].elem1 = heap.data[0].elem0;
	10638	+ heap.data[0].elem0 = mainresult;
	10639	+ }
	10640	+ state.addr = 819847183518878446LLU; // reporttyps
	10641	+
	10642	+ break;
	10643	+ }
	10644	+ case 18446744073709551007LLU: // 999999990d'''''''''''''''
	10645	+ {
	10646	+ state.addr = 18446744073709551008LLU; // 999999990e'''''''''''''''
	10647	+
	10648	+ break;
	10649	+ }
	10650	+ case 18446744073709551008LLU: // 999999990e'''''''''''''''
	10651	+ {
	10652	+ {
	10653	+ uint64_t mainresult = heap.data[0].elem0;
	10654	+ heap.data[0].elem0 = 0;
	10655	+ {
	10656	+ uint64_t arg = /def_id____/*LOCAL_ACCESS(heap.data, 9LLU, 0LLU);
	10657	+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
	10658	+ }
	10659	+ // 1LLU
	10660	+ uint64_t return_to = 18446744073709551005LLU;
	10661	+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
	10662	+ access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
	10663	+ heap.data[0].elem1 = heap.data[0].elem0;
	10664	+ heap.data[0].elem0 = mainresult;
	10665	+ }
	10666	+ state.addr = 819847183515949359LLU; // reportinit
	10667	+
	10668	+ break;
	10669	+ }
	10670	+ case 18446744073709551005LLU: // 999999990b'''''''''''''''
	10671	+ {
	10672	+ state.addr = 18446744073709551006LLU; // 999999990c'''''''''''''''
	10673	+
	10674	+ break;
	10675	+ }
	10676	+ case 18446744073709551006LLU: // 999999990c'''''''''''''''
	10677	+ {
	10678	+ fprintf(stderr, "%s", "no such type ");
	10679	+
	10680	+ printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 9LLU, 2LLU));
	10681	+
	10682	+ {
	10683	+ fprintf(stderr, "%s\n", "");
	10684	+ exit(-1);
	10685	+ }
	10686	+ state.addr = 18446744073709551009LLU; // 999999990f'''''''''''''''
	10687	+
	10688	+ break;
	10689	+ }
	10690	+ case 18446744073709551009LLU: // 999999990f'''''''''''''''
	10691	+ {
	10692	+ // variable u64 notfound__ goes out of scope
	10693	+ // emitted destructur for type u64
	10694	+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference notfound__ at 9
	10695	+ // parameter-reference u64 constr____ goes out of scope
	10696	+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference constr____ at 8
	10697	+ // parameter-reference u64 sizeonheap goes out of scope
	10698	+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sizeonheap at 7
	10699	+ // parameter-reference u64 calleesize goes out of scope
	10700	+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference calleesize at 6
	10701	+ // parameter-reference list<elemdef___> calleepars goes out of scope
	10702	+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference calleepars at 5
	10703	+ // parameter-reference type______ retype____ goes out of scope
	10704	+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference retype____ at 4
	10705	+ // parameter u64 id________ goes out of scope
	10706	+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference id________ at 3
	10707	+ // parameter-reference list<typedef___> typedefs__ goes out of scope
	10708	+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference typedefs__ at 2
	10709	+ // parameter-reference u64 def_id____ goes out of scope
	10710	+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference def_id____ at 1
	10711	+
	10712	+ {
	10713	+ uint64_t baseinfo = heap.data[0].elem1;
	10714	+ struct pair pair = unpair(&heap, &baseinfo);
	10715	+ access_heap(heap.data, 1/memory root*/) = pair.elem0;
	10716	+ state.addr = pair.elem1;
	10717	+ }
	10718	+
	10719	+ break;
	10720	+ }
8032	10721	case 839030777314450343LLU: // sizetransl
8033	10722	{
8034	10723
8035		- state.addr = 861519017821270016LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU))].elem0 ? 18446744073709551178LLU : 18446744073709551177LLU;
	10724	+ state.addr = 861519017821270016LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU))].elem0 ? 18446744073709551004LLU : 18446744073709551003LLU;
8036	10725
8037	10726	break;
8038	10727	}
8039		- case 18446744073709551178LLU: // 999999993J'''''''''''''''
	10728	+ case 18446744073709551004LLU: // 999999990a'''''''''''''''
8040	10729	{
8041	10730	{
8042	10731	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU))].elem1;

		@@ -8048,18 +10737,18 @@
8048	10737	heap.availilable_size_for_dynamic_objects += 0LLU;
8049	10738	heap.availilable_size_for_dynamic_objects += 0LLU;
8050	10739
8051		- state.addr = 18446744073709551176LLU; // 999999993H'''''''''''''''
	10740	+ state.addr = 18446744073709551002LLU; // 999999990Z'''''''''''''''
8052	10741
8053	10742	break;
8054	10743	}
8055		- case 18446744073709551177LLU: // 999999993I'''''''''''''''
	10744	+ case 18446744073709551003LLU: // 999999990$'''''''''''''''
8056	10745	{
8057	10746
8058		- state.addr = 861527391835906048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU))].elem0 ? 18446744073709551175LLU : 18446744073709551174LLU;
	10747	+ state.addr = 861527391835906048LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU))].elem0 ? 18446744073709551001LLU : 18446744073709551000LLU;
8059	10748
8060	10749	break;
8061	10750	}
8062		- case 18446744073709551175LLU: // 999999993G'''''''''''''''
	10751	+ case 18446744073709551001LLU: // 999999990Y'''''''''''''''
8063	10752	{
8064	10753	{
8065	10754	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU))].elem1;

		@@ -8071,18 +10760,18 @@
8071	10760	heap.availilable_size_for_dynamic_objects += 0LLU;
8072	10761	heap.availilable_size_for_dynamic_objects += 0LLU;
8073	10762
8074		- state.addr = 18446744073709551173LLU; // 999999993E'''''''''''''''
	10763	+ state.addr = 18446744073709550999LLU; // 999999990W'''''''''''''''
8075	10764
8076	10765	break;
8077	10766	}
8078		- case 18446744073709551174LLU: // 999999993F'''''''''''''''
	10767	+ case 18446744073709551000LLU: // 999999990X'''''''''''''''
8079	10768	{
8080	10769
8081		- state.addr = 861527391835975680LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU))].elem0 ? 18446744073709551172LLU : 18446744073709551171LLU;
	10770	+ state.addr = 861527391835975680LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU))].elem0 ? 18446744073709550998LLU : 18446744073709550997LLU;
8082	10771
8083	10772	break;
8084	10773	}
8085		- case 18446744073709551172LLU: // 999999993D'''''''''''''''
	10774	+ case 18446744073709550998LLU: // 999999990V'''''''''''''''
8086	10775	{
8087	10776	{
8088	10777	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU))].elem1;

		@@ -8094,11 +10783,11 @@
8094	10783	heap.availilable_size_for_dynamic_objects += 0LLU;
8095	10784	heap.availilable_size_for_dynamic_objects += 0LLU;
8096	10785
8097		- state.addr = 18446744073709551170LLU; // 999999993B'''''''''''''''
	10786	+ state.addr = 18446744073709550996LLU; // 999999990T'''''''''''''''
8098	10787
8099	10788	break;
8100	10789	}
8101		- case 18446744073709551171LLU: // 999999993C'''''''''''''''
	10790	+ case 18446744073709550997LLU: // 999999990U'''''''''''''''
8102	10791	{
8103	10792
8104	10793	{

		@@ -8105,23 +10794,23 @@
8105	10794	fprintf(stderr, "%s\n", "sizetransl UNKNOWN");
8106	10795	exit(-1);
8107	10796	}
8108		- state.addr = 18446744073709551170LLU; // 999999993B'''''''''''''''
	10797	+ state.addr = 18446744073709550996LLU; // 999999990T'''''''''''''''
8109	10798
8110	10799	break;
8111	10800	}
8112		- case 18446744073709551170LLU: // 999999993B'''''''''''''''
	10801	+ case 18446744073709550996LLU: // 999999990T'''''''''''''''
8113	10802	{
8114		- state.addr = 18446744073709551173LLU; // 999999993E'''''''''''''''
	10803	+ state.addr = 18446744073709550999LLU; // 999999990W'''''''''''''''
8115	10804
8116	10805	break;
8117	10806	}
8118		- case 18446744073709551173LLU: // 999999993E'''''''''''''''
	10807	+ case 18446744073709550999LLU: // 999999990W'''''''''''''''
8119	10808	{
8120		- state.addr = 18446744073709551176LLU; // 999999993H'''''''''''''''
	10809	+ state.addr = 18446744073709551002LLU; // 999999990Z'''''''''''''''
8121	10810
8122	10811	break;
8123	10812	}
8124		- case 18446744073709551176LLU: // 999999993H'''''''''''''''
	10813	+ case 18446744073709551002LLU: // 999999990Z'''''''''''''''
8125	10814	{
8126	10815	// parameter-reference u64 sizeonheap goes out of scope
8127	10816	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sizeonheap at 2

		@@ -8151,11 +10840,11 @@
8151	10840	uint64_t arg = 0;
8152	10841	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
8153	10842	}
8154		- state.addr = 18446744073709551169LLU; // 999999993A'''''''''''''''
	10843	+ state.addr = 18446744073709550995LLU; // 999999990S'''''''''''''''
8155	10844
8156	10845	break;
8157	10846	}
8158		- case 18446744073709551169LLU: // 999999993A'''''''''''''''
	10847	+ case 18446744073709550995LLU: // 999999990S'''''''''''''''
8159	10848	{
8160	10849	if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
8161	10850	{

		@@ -8162,7 +10851,7 @@
8162	10851	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
8163	10852	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
8164	10853	{
8165		- state.addr = 18446744073709551168LLU; // 999999993_'''''''''''''''
	10854	+ state.addr = 18446744073709550994LLU; // 999999990R'''''''''''''''
8166	10855
8167	10856	break;
8168	10857	}

		@@ -8176,11 +10865,11 @@
8176	10865
8177	10866	/match_____/LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 2LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 8LLU, 6LLU), 0LLU));
8178	10867
8179		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551167LLU : 18446744073709551166LLU;
	10868	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550993LLU : 18446744073709550992LLU;
8180	10869
8181	10870	break;
8182	10871	}
8183		- case 18446744073709551167LLU: // 9999999929'''''''''''''''
	10872	+ case 18446744073709550993LLU: // 999999990Q'''''''''''''''
8184	10873	{
8185	10874	/notfound__/*LOCAL_ACCESS(heap.data, 8LLU, 4LLU) = 0LLU;
8186	10875	{

		@@ -8195,7 +10884,7 @@
8195	10884	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8196	10885	}
8197	10886	// 2LLU
8198		- uint64_t return_to = 18446744073709551164LLU;
	10887	+ uint64_t return_to = 18446744073709550990LLU;
8199	10888	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8200	10889	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8201	10890	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -8205,19 +10894,19 @@
8205	10894
8206	10895	break;
8207	10896	}
8208		- case 18446744073709551164LLU: // 9999999926'''''''''''''''
	10897	+ case 18446744073709550990LLU: // 999999990N'''''''''''''''
8209	10898	{
8210		- state.addr = 18446744073709551165LLU; // 9999999927'''''''''''''''
	10899	+ state.addr = 18446744073709550991LLU; // 999999990O'''''''''''''''
8211	10900
8212	10901	break;
8213	10902	}
8214		- case 18446744073709551165LLU: // 9999999927'''''''''''''''
	10903	+ case 18446744073709550991LLU: // 999999990O'''''''''''''''
8215	10904	{
8216		- state.addr = 18446744073709551166LLU; // 9999999928'''''''''''''''
	10905	+ state.addr = 18446744073709550992LLU; // 999999990P'''''''''''''''
8217	10906
8218	10907	break;
8219	10908	}
8220		- case 18446744073709551166LLU: // 9999999928'''''''''''''''
	10909	+ case 18446744073709550992LLU: // 999999990P'''''''''''''''
8221	10910	{
8222	10911	// variable u64 match_____ goes out of scope
8223	10912	// emitted destructur for type u64

		@@ -8224,18 +10913,18 @@
8224	10913	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference match_____ at 8
8225	10914	// parameter-reference typedef___ elem______ goes out of scope
8226	10915	// parameter-reference list<typedef___> typedefs__ goes out of scope
8227		- state.addr = 18446744073709551169LLU; // 999999993A'''''''''''''''
	10916	+ state.addr = 18446744073709550995LLU; // 999999990S'''''''''''''''
8228	10917
8229	10918	break;
8230	10919	}
8231		- case 18446744073709551168LLU: // 999999993_'''''''''''''''
	10920	+ case 18446744073709550994LLU: // 999999990R'''''''''''''''
8232	10921	{
8233	10922
8234		- state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551163LLU : 18446744073709551162LLU;
	10923	+ state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709550989LLU : 18446744073709550988LLU;
8235	10924
8236	10925	break;
8237	10926	}
8238		- case 18446744073709551163LLU: // 9999999925'''''''''''''''
	10927	+ case 18446744073709550989LLU: // 999999990M'''''''''''''''
8239	10928	{
8240	10929	{
8241	10930	uint64_t mainresult = heap.data[0].elem0;

		@@ -8249,7 +10938,7 @@
8249	10938	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8250	10939	}
8251	10940	// 2LLU
8252		- uint64_t return_to = 18446744073709551160LLU;
	10941	+ uint64_t return_to = 18446744073709550986LLU;
8253	10942	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8254	10943	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8255	10944	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -8259,13 +10948,13 @@
8259	10948
8260	10949	break;
8261	10950	}
8262		- case 18446744073709551160LLU: // 9999999922'''''''''''''''
	10951	+ case 18446744073709550986LLU: // 999999990J'''''''''''''''
8263	10952	{
8264		- state.addr = 18446744073709551161LLU; // 9999999923'''''''''''''''
	10953	+ state.addr = 18446744073709550987LLU; // 999999990K'''''''''''''''
8265	10954
8266	10955	break;
8267	10956	}
8268		- case 18446744073709551161LLU: // 9999999923'''''''''''''''
	10957	+ case 18446744073709550987LLU: // 999999990K'''''''''''''''
8269	10958	{
8270	10959	{
8271	10960	uint64_t mainresult = heap.data[0].elem0;

		@@ -8275,7 +10964,7 @@
8275	10964	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8276	10965	}
8277	10966	// 1LLU
8278		- uint64_t return_to = 18446744073709551158LLU;
	10967	+ uint64_t return_to = 18446744073709550984LLU;
8279	10968	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8280	10969	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8281	10970	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -8285,13 +10974,13 @@
8285	10974
8286	10975	break;
8287	10976	}
8288		- case 18446744073709551158LLU: // 9999999920'''''''''''''''
	10977	+ case 18446744073709550984LLU: // 999999990H'''''''''''''''
8289	10978	{
8290		- state.addr = 18446744073709551159LLU; // 9999999921'''''''''''''''
	10979	+ state.addr = 18446744073709550985LLU; // 999999990I'''''''''''''''
8291	10980
8292	10981	break;
8293	10982	}
8294		- case 18446744073709551159LLU: // 9999999921'''''''''''''''
	10983	+ case 18446744073709550985LLU: // 999999990I'''''''''''''''
8295	10984	{
8296	10985	fprintf(stderr, "%s", "no such type ");
8297	10986

		@@ -8301,11 +10990,11 @@
8301	10990	fprintf(stderr, "%s\n", "");
8302	10991	exit(-1);
8303	10992	}
8304		- state.addr = 18446744073709551162LLU; // 9999999924'''''''''''''''
	10993	+ state.addr = 18446744073709550988LLU; // 999999990L'''''''''''''''
8305	10994
8306	10995	break;
8307	10996	}
8308		- case 18446744073709551162LLU: // 9999999924'''''''''''''''
	10997	+ case 18446744073709550988LLU: // 999999990L'''''''''''''''
8309	10998	{
8310	10999	// variable u64 notfound__ goes out of scope
8311	11000	// emitted destructur for type u64

		@@ -8342,11 +11031,11 @@
8342	11031	uint64_t arg = 0;
8343	11032	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
8344	11033	}
8345		- state.addr = 18446744073709551157LLU; // 999999992z'''''''''''''''
	11034	+ state.addr = 18446744073709550983LLU; // 999999990G'''''''''''''''
8346	11035
8347	11036	break;
8348	11037	}
8349		- case 18446744073709551157LLU: // 999999992z'''''''''''''''
	11038	+ case 18446744073709550983LLU: // 999999990G'''''''''''''''
8350	11039	{
8351	11040	if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
8352	11041	{

		@@ -8353,7 +11042,7 @@
8353	11042	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
8354	11043	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
8355	11044	{
8356		- state.addr = 18446744073709551156LLU; // 999999992y'''''''''''''''
	11045	+ state.addr = 18446744073709550982LLU; // 999999990F'''''''''''''''
8357	11046
8358	11047	break;
8359	11048	}

		@@ -8367,19 +11056,19 @@
8367	11056
8368	11057	/match_____/LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /id________/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 2LLU)) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 8LLU, 6LLU), 0LLU));
8369	11058
8370		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551155LLU : 18446744073709551154LLU;
	11059	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550981LLU : 18446744073709550980LLU;
8371	11060
8372	11061	break;
8373	11062	}
8374		- case 18446744073709551155LLU: // 999999992x'''''''''''''''
	11063	+ case 18446744073709550981LLU: // 999999990E'''''''''''''''
8375	11064	{
8376	11065	/notfound__/*LOCAL_ACCESS(heap.data, 8LLU, 4LLU) = 0LLU;
8377	11066	/calleesize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 8LLU, 3LLU)) = /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 8LLU, 6LLU), 1LLU));
8378		- state.addr = 18446744073709551154LLU; // 999999992w'''''''''''''''
	11067	+ state.addr = 18446744073709550980LLU; // 999999990D'''''''''''''''
8379	11068
8380	11069	break;
8381	11070	}
8382		- case 18446744073709551154LLU: // 999999992w'''''''''''''''
	11071	+ case 18446744073709550980LLU: // 999999990D'''''''''''''''
8383	11072	{
8384	11073	// variable u64 match_____ goes out of scope
8385	11074	// emitted destructur for type u64

		@@ -8386,18 +11075,18 @@
8386	11075	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference match_____ at 8
8387	11076	// parameter-reference destr_____ elem______ goes out of scope
8388	11077	// parameter-reference list<destr_____> destrs____ goes out of scope
8389		- state.addr = 18446744073709551157LLU; // 999999992z'''''''''''''''
	11078	+ state.addr = 18446744073709550983LLU; // 999999990G'''''''''''''''
8390	11079
8391	11080	break;
8392	11081	}
8393		- case 18446744073709551156LLU: // 999999992y'''''''''''''''
	11082	+ case 18446744073709550982LLU: // 999999990F'''''''''''''''
8394	11083	{
8395	11084
8396		- state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551153LLU : 18446744073709551152LLU;
	11085	+ state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709550979LLU : 18446744073709550978LLU;
8397	11086
8398	11087	break;
8399	11088	}
8400		- case 18446744073709551153LLU: // 999999992v'''''''''''''''
	11089	+ case 18446744073709550979LLU: // 999999990C'''''''''''''''
8401	11090	{
8402	11091	{
8403	11092	uint64_t mainresult = heap.data[0].elem0;

		@@ -8407,7 +11096,7 @@
8407	11096	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8408	11097	}
8409	11098	// 1LLU
8410		- uint64_t return_to = 18446744073709551150LLU;
	11099	+ uint64_t return_to = 18446744073709550976LLU;
8411	11100	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8412	11101	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8413	11102	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -8417,13 +11106,13 @@
8417	11106
8418	11107	break;
8419	11108	}
8420		- case 18446744073709551150LLU: // 999999992s'''''''''''''''
	11109	+ case 18446744073709550976LLU: // 999999990_'''''''''''''''
8421	11110	{
8422		- state.addr = 18446744073709551151LLU; // 999999992t'''''''''''''''
	11111	+ state.addr = 18446744073709550977LLU; // 999999990A'''''''''''''''
8423	11112
8424	11113	break;
8425	11114	}
8426		- case 18446744073709551151LLU: // 999999992t'''''''''''''''
	11115	+ case 18446744073709550977LLU: // 999999990A'''''''''''''''
8427	11116	{
8428	11117	fprintf(stderr, "%s", "no such function ");
8429	11118

		@@ -8433,11 +11122,11 @@
8433	11122	fprintf(stderr, "%s\n", "");
8434	11123	exit(-1);
8435	11124	}
8436		- state.addr = 18446744073709551152LLU; // 999999992u'''''''''''''''
	11125	+ state.addr = 18446744073709550978LLU; // 999999990B'''''''''''''''
8437	11126
8438	11127	break;
8439	11128	}
8440		- case 18446744073709551152LLU: // 999999992u'''''''''''''''
	11129	+ case 18446744073709550978LLU: // 999999990B'''''''''''''''
8441	11130	{
8442	11131	// variable u64 notfound__ goes out of scope
8443	11132	// emitted destructur for type u64

		@@ -8463,11 +11152,11 @@
8463	11152	case 367395578726114508LLU: // TYPETRANSL
8464	11153	{
8465	11154
8466		- state.addr = 861527391835975680LLU == heap.data[*LOCAL_ACCESS(heap.data, 4LLU, 1LLU)].elem0 ? 18446744073709551149LLU : 18446744073709551148LLU;
	11155	+ state.addr = 861527391835975680LLU == heap.data[*LOCAL_ACCESS(heap.data, 4LLU, 1LLU)].elem0 ? 18446744073709550975LLU : 18446744073709550974LLU;
8467	11156
8468	11157	break;
8469	11158	}
8470		- case 18446744073709551149LLU: // 999999992r'''''''''''''''
	11159	+ case 18446744073709550975LLU: // 99999999z9'''''''''''''''
8471	11160	{
8472	11161	{
8473	11162	uint64_t arg = heap.data[*LOCAL_ACCESS(heap.data, 4LLU, 1LLU)].elem1;

		@@ -8482,11 +11171,11 @@
8482	11171	uint64_t arg = 0;
8483	11172	LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/address of current closure/, &arg);
8484	11173	}
8485		- state.addr = 18446744073709551147LLU; // 999999992p'''''''''''''''
	11174	+ state.addr = 18446744073709550973LLU; // 99999999z7'''''''''''''''
8486	11175
8487	11176	break;
8488	11177	}
8489		- case 18446744073709551147LLU: // 999999992p'''''''''''''''
	11178	+ case 18446744073709550973LLU: // 99999999z7'''''''''''''''
8490	11179	{
8491	11180	if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU))
8492	11181	{

		@@ -8493,7 +11182,7 @@
8493	11182	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
8494	11183	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 6
8495	11184	{
8496		- state.addr = 18446744073709551146LLU; // 999999992o'''''''''''''''
	11185	+ state.addr = 18446744073709550972LLU; // 99999999z6'''''''''''''''
8497	11186
8498	11187	break;
8499	11188	}

		@@ -8505,11 +11194,11 @@
8505	11194	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
8506	11195	}
8507	11196
8508		- state.addr = !list_push_move(&heap, &/tmp_______/LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &/constrs___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 2LLU)), 1) ? 18446744073709551145LLU : 18446744073709551144LLU;
	11197	+ state.addr = !list_push_move(&heap, &/tmp_______/LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &/constrs___/access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 2LLU)), 1) ? 18446744073709550971LLU : 18446744073709550970LLU;
8509	11198
8510	11199	break;
8511	11200	}
8512		- case 18446744073709551145LLU: // 999999992n'''''''''''''''
	11201	+ case 18446744073709550971LLU: // 99999999z5'''''''''''''''
8513	11202	{
8514	11203	{
8515	11204	uint64_t arg = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU);

		@@ -8530,17 +11219,17 @@
8530	11219	heap.availilable_size_for_dynamic_objects += 0LLU;
8531	11220	heap.availilable_size_for_dynamic_objects += 0LLU;
8532	11221
8533		- state.addr = 18446744073709551143LLU; // 999999992l'''''''''''''''
	11222	+ state.addr = 18446744073709550969LLU; // 99999999z3'''''''''''''''
8534	11223
8535	11224	break;
8536	11225	}
8537		- case 18446744073709551144LLU: // 999999992m'''''''''''''''
	11226	+ case 18446744073709550970LLU: // 99999999z4'''''''''''''''
8538	11227	{
8539		- state.addr = 18446744073709551143LLU; // 999999992l'''''''''''''''
	11228	+ state.addr = 18446744073709550969LLU; // 99999999z3'''''''''''''''
8540	11229
8541	11230	break;
8542	11231	}
8543		- case 18446744073709551143LLU: // 999999992l'''''''''''''''
	11232	+ case 18446744073709550969LLU: // 99999999z3'''''''''''''''
8544	11233	{
8545	11234	// variable u64 tmp_______ goes out of scope
8546	11235	// (uninitialized -> no destructor-call)

		@@ -8547,11 +11236,11 @@
8547	11236	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference tmp_______ at 8
8548	11237	// parameter-reference u64 constr____ goes out of scope
8549	11238	// parameter tyuniont__ kind______ goes out of scope
8550		- state.addr = 18446744073709551147LLU; // 999999992p'''''''''''''''
	11239	+ state.addr = 18446744073709550973LLU; // 99999999z7'''''''''''''''
8551	11240
8552	11241	break;
8553	11242	}
8554		- case 18446744073709551146LLU: // 999999992o'''''''''''''''
	11243	+ case 18446744073709550972LLU: // 99999999z6'''''''''''''''
8555	11244	{
8556	11245	// parameter tyuniont__ kind______ goes out of scope
8557	11246	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference kind______ at 5

		@@ -8558,11 +11247,11 @@
8558	11247	heap.availilable_size_for_dynamic_objects += 0LLU;
8559	11248	heap.availilable_size_for_dynamic_objects += 0LLU;
8560	11249
8561		- state.addr = 18446744073709551142LLU; // 999999992k'''''''''''''''
	11250	+ state.addr = 18446744073709550968LLU; // 99999999z2'''''''''''''''
8562	11251
8563	11252	break;
8564	11253	}
8565		- case 18446744073709551148LLU: // 999999992q'''''''''''''''
	11254	+ case 18446744073709550974LLU: // 99999999z8'''''''''''''''
8566	11255	{
8567	11256
8568	11257	printid(stderr, /id________/*LOCAL_ACCESS(heap.data, 4LLU, 0LLU));

		@@ -8572,11 +11261,11 @@
8572	11261	fprintf(stderr, "%s\n", "");
8573	11262	exit(-1);
8574	11263	}
8575		- state.addr = 18446744073709551142LLU; // 999999992k'''''''''''''''
	11264	+ state.addr = 18446744073709550968LLU; // 99999999z2'''''''''''''''
8576	11265
8577	11266	break;
8578	11267	}
8579		- case 18446744073709551142LLU: // 999999992k'''''''''''''''
	11268	+ case 18446744073709550968LLU: // 99999999z2'''''''''''''''
8580	11269	{
8581	11270	// parameter-reference u64 sizeonheap goes out of scope
8582	11271	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference sizeonheap at 4

		@@ -8610,11 +11299,11 @@
8610	11299	uint64_t arg = 0;
8611	11300	LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/address of current closure/, &arg);
8612	11301	}
8613		- state.addr = 18446744073709551141LLU; // 999999992j'''''''''''''''
	11302	+ state.addr = 18446744073709550967LLU; // 99999999z1'''''''''''''''
8614	11303
8615	11304	break;
8616	11305	}
8617		- case 18446744073709551141LLU: // 999999992j'''''''''''''''
	11306	+ case 18446744073709550967LLU: // 99999999z1'''''''''''''''
8618	11307	{
8619	11308	if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
8620	11309	{

		@@ -8621,7 +11310,7 @@
8621	11310	(void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 8
8622	11311	(void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE temporary reference at 7
8623	11312	{
8624		- state.addr = 18446744073709551140LLU; // 999999992i'''''''''''''''
	11313	+ state.addr = 18446744073709550966LLU; // 99999999z0'''''''''''''''
8625	11314
8626	11315	break;
8627	11316	}

		@@ -8629,11 +11318,11 @@
8629	11318	/direct/LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU;
8630	11319	LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0;
8631	11320
8632		- state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551139LLU : 18446744073709551138LLU;
	11321	+ state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709550965LLU : 18446744073709550964LLU;
8633	11322
8634	11323	break;
8635	11324	}
8636		- case 18446744073709551139LLU: // 999999992h'''''''''''''''
	11325	+ case 18446744073709550965LLU: // 99999999zz'''''''''''''''
8637	11326	{
8638	11327	{
8639	11328	uint64_t arg = 0LLU;

		@@ -8642,11 +11331,11 @@
8642	11331
8643	11332	/match_____/LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = /id________/LOCAL_ACCESS(heap.data, 9LLU, 2LLU) == /elem______/access_heap(heap.data, tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS(heap.data, 9LLU, 7LLU), 0LLU));
8644	11333
8645		- state.addr = /match_____/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709551137LLU : 18446744073709551136LLU;
	11334	+ state.addr = /match_____/*LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550963LLU : 18446744073709550962LLU;
8646	11335
8647	11336	break;
8648	11337	}
8649		- case 18446744073709551137LLU: // 999999992f'''''''''''''''
	11338	+ case 18446744073709550963LLU: // 99999999zx'''''''''''''''
8650	11339	{
8651	11340	/notfound__/*LOCAL_ACCESS(heap.data, 9LLU, 5LLU) = 0LLU;
8652	11341	{

		@@ -8669,7 +11358,7 @@
8669	11358	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8670	11359	}
8671	11360	// 4LLU
8672		- uint64_t return_to = 18446744073709551134LLU;
	11361	+ uint64_t return_to = 18446744073709550960LLU;
8673	11362	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8674	11363	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8675	11364	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -8679,43 +11368,43 @@
8679	11368
8680	11369	break;
8681	11370	}
8682		- case 18446744073709551134LLU: // 999999992c'''''''''''''''
	11371	+ case 18446744073709550960LLU: // 99999999zu'''''''''''''''
8683	11372	{
8684		- state.addr = 18446744073709551135LLU; // 999999992d'''''''''''''''
	11373	+ state.addr = 18446744073709550961LLU; // 99999999zv'''''''''''''''
8685	11374
8686	11375	break;
8687	11376	}
8688		- case 18446744073709551135LLU: // 999999992d'''''''''''''''
	11377	+ case 18446744073709550961LLU: // 99999999zv'''''''''''''''
8689	11378	{
8690		- state.addr = 18446744073709551136LLU; // 999999992e'''''''''''''''
	11379	+ state.addr = 18446744073709550962LLU; // 99999999zw'''''''''''''''
8691	11380
8692	11381	break;
8693	11382	}
8694		- case 18446744073709551136LLU: // 999999992e'''''''''''''''
	11383	+ case 18446744073709550962LLU: // 99999999zw'''''''''''''''
8695	11384	{
8696	11385	// variable u64 match_____ goes out of scope
8697	11386	// emitted destructur for type u64
8698	11387	(void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference match_____ at 9
8699		- state.addr = 18446744073709551138LLU; // 999999992g'''''''''''''''
	11388	+ state.addr = 18446744073709550964LLU; // 99999999zy'''''''''''''''
8700	11389
8701	11390	break;
8702	11391	}
8703		- case 18446744073709551138LLU: // 999999992g'''''''''''''''
	11392	+ case 18446744073709550964LLU: // 99999999zy'''''''''''''''
8704	11393	{
8705	11394	// parameter-reference typedef___ elem______ goes out of scope
8706	11395	// parameter-reference list<typedef___> typedefs__ goes out of scope
8707		- state.addr = 18446744073709551141LLU; // 999999992j'''''''''''''''
	11396	+ state.addr = 18446744073709550967LLU; // 99999999z1'''''''''''''''
8708	11397
8709	11398	break;
8710	11399	}
8711		- case 18446744073709551140LLU: // 999999992i'''''''''''''''
	11400	+ case 18446744073709550966LLU: // 99999999z0'''''''''''''''
8712	11401	{
8713	11402
8714		- state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551133LLU : 18446744073709551132LLU;
	11403	+ state.addr = /notfound__/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550959LLU : 18446744073709550958LLU;
8715	11404
8716	11405	break;
8717	11406	}
8718		- case 18446744073709551133LLU: // 999999992b'''''''''''''''
	11407	+ case 18446744073709550959LLU: // 99999999zt'''''''''''''''
8719	11408	{
8720	11409	{
8721	11410	uint64_t mainresult = heap.data[0].elem0;

		@@ -8725,7 +11414,7 @@
8725	11414	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8726	11415	}
8727	11416	// 1LLU
8728		- uint64_t return_to = 18446744073709551130LLU;
	11417	+ uint64_t return_to = 18446744073709550956LLU;
8729	11418	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8730	11419	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8731	11420	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -8735,13 +11424,13 @@
8735	11424
8736	11425	break;
8737	11426	}
8738		- case 18446744073709551130LLU: // 999999992Z'''''''''''''''
	11427	+ case 18446744073709550956LLU: // 99999999zq'''''''''''''''
8739	11428	{
8740		- state.addr = 18446744073709551131LLU; // 999999992$'''''''''''''''
	11429	+ state.addr = 18446744073709550957LLU; // 99999999zr'''''''''''''''
8741	11430
8742	11431	break;
8743	11432	}
8744		- case 18446744073709551131LLU: // 999999992$'''''''''''''''
	11433	+ case 18446744073709550957LLU: // 99999999zr'''''''''''''''
8745	11434	{
8746	11435	fprintf(stderr, "%s", "no such union-type ");
8747	11436

		@@ -8751,11 +11440,11 @@
8751	11440	fprintf(stderr, "%s\n", "");
8752	11441	exit(-1);
8753	11442	}
8754		- state.addr = 18446744073709551132LLU; // 999999992a'''''''''''''''
	11443	+ state.addr = 18446744073709550958LLU; // 99999999zs'''''''''''''''
8755	11444
8756	11445	break;
8757	11446	}
8758		- case 18446744073709551132LLU: // 999999992a'''''''''''''''
	11447	+ case 18446744073709550958LLU: // 99999999zs'''''''''''''''
8759	11448	{
8760	11449	// variable u64 notfound__ goes out of scope
8761	11450	// emitted destructur for type u64

		@@ -8793,7 +11482,7 @@
8793	11482	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8794	11483	}
8795	11484	// 1LLU
8796		- uint64_t return_to = 18446744073709551128LLU;
	11485	+ uint64_t return_to = 18446744073709550954LLU;
8797	11486	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8798	11487	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8799	11488	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -8803,13 +11492,13 @@
8803	11492
8804	11493	break;
8805	11494	}
8806		- case 18446744073709551128LLU: // 999999992X'''''''''''''''
	11495	+ case 18446744073709550954LLU: // 99999999zo'''''''''''''''
8807	11496	{
8808		- state.addr = 18446744073709551129LLU; // 999999992Y'''''''''''''''
	11497	+ state.addr = 18446744073709550955LLU; // 99999999zp'''''''''''''''
8809	11498
8810	11499	break;
8811	11500	}
8812		- case 18446744073709551129LLU: // 999999992Y'''''''''''''''
	11501	+ case 18446744073709550955LLU: // 99999999zp'''''''''''''''
8813	11502	{
8814	11503	// parameter-reference pardef____ par_______ goes out of scope
8815	11504	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference par_______ at 1

		@@ -8874,7 +11563,7 @@
8874	11563	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8875	11564	}
8876	11565	// 4LLU
8877		- uint64_t return_to = 18446744073709551126LLU;
	11566	+ uint64_t return_to = 18446744073709550952LLU;
8878	11567	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8879	11568	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8880	11569	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -8884,13 +11573,13 @@
8884	11573
8885	11574	break;
8886	11575	}
8887		- case 18446744073709551126LLU: // 999999992V'''''''''''''''
	11576	+ case 18446744073709550952LLU: // 99999999zm'''''''''''''''
8888	11577	{
8889		- state.addr = 18446744073709551127LLU; // 999999992W'''''''''''''''
	11578	+ state.addr = 18446744073709550953LLU; // 99999999zn'''''''''''''''
8890	11579
8891	11580	break;
8892	11581	}
8893		- case 18446744073709551127LLU: // 999999992W'''''''''''''''
	11582	+ case 18446744073709550953LLU: // 99999999zn'''''''''''''''
8894	11583	{
8895	11584	{
8896	11585	uint64_t mainresult = heap.data[0].elem0;

		@@ -8900,7 +11589,7 @@
8900	11589	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8901	11590	}
8902	11591	// 1LLU
8903		- uint64_t return_to = 18446744073709551124LLU;
	11592	+ uint64_t return_to = 18446744073709550950LLU;
8904	11593	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8905	11594	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8906	11595	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -8910,13 +11599,13 @@
8910	11599
8911	11600	break;
8912	11601	}
8913		- case 18446744073709551124LLU: // 999999992T'''''''''''''''
	11602	+ case 18446744073709550950LLU: // 99999999zk'''''''''''''''
8914	11603	{
8915		- state.addr = 18446744073709551125LLU; // 999999992U'''''''''''''''
	11604	+ state.addr = 18446744073709550951LLU; // 99999999zl'''''''''''''''
8916	11605
8917	11606	break;
8918	11607	}
8919		- case 18446744073709551125LLU: // 999999992U'''''''''''''''
	11608	+ case 18446744073709550951LLU: // 99999999zl'''''''''''''''
8920	11609	{
8921	11610	// variable u64 index_____ goes out of scope
8922	11611	// emitted destructur for type u64

		@@ -8963,7 +11652,7 @@
8963	11652	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8964	11653	}
8965	11654	// 4LLU
8966		- uint64_t return_to = 18446744073709551122LLU;
	11655	+ uint64_t return_to = 18446744073709550948LLU;
8967	11656	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8968	11657	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8969	11658	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -8973,13 +11662,13 @@
8973	11662
8974	11663	break;
8975	11664	}
8976		- case 18446744073709551122LLU: // 999999992R'''''''''''''''
	11665	+ case 18446744073709550948LLU: // 99999999zi'''''''''''''''
8977	11666	{
8978		- state.addr = 18446744073709551123LLU; // 999999992S'''''''''''''''
	11667	+ state.addr = 18446744073709550949LLU; // 99999999zj'''''''''''''''
8979	11668
8980	11669	break;
8981	11670	}
8982		- case 18446744073709551123LLU: // 999999992S'''''''''''''''
	11671	+ case 18446744073709550949LLU: // 99999999zj'''''''''''''''
8983	11672	{
8984	11673	fprintf(stdout, "%s", "*LOCAL_ACCESS(heap.data, ");
8985	11674	{

		@@ -8990,7 +11679,7 @@
8990	11679	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
8991	11680	}
8992	11681	// 1LLU
8993		- uint64_t return_to = 18446744073709551120LLU;
	11682	+ uint64_t return_to = 18446744073709550946LLU;
8994	11683	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
8995	11684	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
8996	11685	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9000,13 +11689,13 @@
9000	11689
9001	11690	break;
9002	11691	}
9003		- case 18446744073709551120LLU: // 999999992P'''''''''''''''
	11692	+ case 18446744073709550946LLU: // 99999999zg'''''''''''''''
9004	11693	{
9005		- state.addr = 18446744073709551121LLU; // 999999992Q'''''''''''''''
	11694	+ state.addr = 18446744073709550947LLU; // 99999999zh'''''''''''''''
9006	11695
9007	11696	break;
9008	11697	}
9009		- case 18446744073709551121LLU: // 999999992Q'''''''''''''''
	11698	+ case 18446744073709550947LLU: // 99999999zh'''''''''''''''
9010	11699	{
9011	11700	fprintf(stdout, "%s", ", ");
9012	11701	{

		@@ -9017,7 +11706,7 @@
9017	11706	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9018	11707	}
9019	11708	// 1LLU
9020		- uint64_t return_to = 18446744073709551118LLU;
	11709	+ uint64_t return_to = 18446744073709550944LLU;
9021	11710	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9022	11711	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9023	11712	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9027,13 +11716,13 @@
9027	11716
9028	11717	break;
9029	11718	}
9030		- case 18446744073709551118LLU: // 999999992N'''''''''''''''
	11719	+ case 18446744073709550944LLU: // 99999999ze'''''''''''''''
9031	11720	{
9032		- state.addr = 18446744073709551119LLU; // 999999992O'''''''''''''''
	11721	+ state.addr = 18446744073709550945LLU; // 99999999zf'''''''''''''''
9033	11722
9034	11723	break;
9035	11724	}
9036		- case 18446744073709551119LLU: // 999999992O'''''''''''''''
	11725	+ case 18446744073709550945LLU: // 99999999zf'''''''''''''''
9037	11726	{
9038	11727	fprintf(stdout, "%s", ")");
9039	11728	// variable u64 size______ goes out of scope

		@@ -9083,7 +11772,7 @@
9083	11772	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9084	11773	}
9085	11774	// 4LLU
9086		- uint64_t return_to = 18446744073709551116LLU;
	11775	+ uint64_t return_to = 18446744073709550942LLU;
9087	11776	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9088	11777	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9089	11778	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9093,13 +11782,13 @@
9093	11782
9094	11783	break;
9095	11784	}
9096		- case 18446744073709551116LLU: // 999999992L'''''''''''''''
	11785	+ case 18446744073709550942LLU: // 99999999zc'''''''''''''''
9097	11786	{
9098		- state.addr = 18446744073709551117LLU; // 999999992M'''''''''''''''
	11787	+ state.addr = 18446744073709550943LLU; // 99999999zd'''''''''''''''
9099	11788
9100	11789	break;
9101	11790	}
9102		- case 18446744073709551117LLU: // 999999992M'''''''''''''''
	11791	+ case 18446744073709550943LLU: // 99999999zd'''''''''''''''
9103	11792	{
9104	11793	fprintf(stdout, "%s", "access_heap(heap.data, LOCAL_ACCESS(heap.data, ");
9105	11794	{

		@@ -9110,7 +11799,7 @@
9110	11799	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9111	11800	}
9112	11801	// 1LLU
9113		- uint64_t return_to = 18446744073709551114LLU;
	11802	+ uint64_t return_to = 18446744073709550940LLU;
9114	11803	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9115	11804	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9116	11805	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9120,13 +11809,13 @@
9120	11809
9121	11810	break;
9122	11811	}
9123		- case 18446744073709551114LLU: // 999999992J'''''''''''''''
	11812	+ case 18446744073709550940LLU: // 99999999za'''''''''''''''
9124	11813	{
9125		- state.addr = 18446744073709551115LLU; // 999999992K'''''''''''''''
	11814	+ state.addr = 18446744073709550941LLU; // 99999999zb'''''''''''''''
9126	11815
9127	11816	break;
9128	11817	}
9129		- case 18446744073709551115LLU: // 999999992K'''''''''''''''
	11818	+ case 18446744073709550941LLU: // 99999999zb'''''''''''''''
9130	11819	{
9131	11820	fprintf(stdout, "%s", ", ");
9132	11821	{

		@@ -9137,7 +11826,7 @@
9137	11826	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9138	11827	}
9139	11828	// 1LLU
9140		- uint64_t return_to = 18446744073709551112LLU;
	11829	+ uint64_t return_to = 18446744073709550938LLU;
9141	11830	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9142	11831	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9143	11832	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9147,13 +11836,13 @@
9147	11836
9148	11837	break;
9149	11838	}
9150		- case 18446744073709551112LLU: // 999999992H'''''''''''''''
	11839	+ case 18446744073709550938LLU: // 99999999zZ'''''''''''''''
9151	11840	{
9152		- state.addr = 18446744073709551113LLU; // 999999992I'''''''''''''''
	11841	+ state.addr = 18446744073709550939LLU; // 99999999z$'''''''''''''''
9153	11842
9154	11843	break;
9155	11844	}
9156		- case 18446744073709551113LLU: // 999999992I'''''''''''''''
	11845	+ case 18446744073709550939LLU: // 99999999z$'''''''''''''''
9157	11846	{
9158	11847	fprintf(stdout, "%s", "))");
9159	11848	// variable u64 size______ goes out of scope

		@@ -9203,7 +11892,7 @@
9203	11892	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9204	11893	}
9205	11894	// 4LLU
9206		- uint64_t return_to = 18446744073709551110LLU;
	11895	+ uint64_t return_to = 18446744073709550936LLU;
9207	11896	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9208	11897	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9209	11898	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9213,13 +11902,13 @@
9213	11902
9214	11903	break;
9215	11904	}
9216		- case 18446744073709551110LLU: // 999999992F'''''''''''''''
	11905	+ case 18446744073709550936LLU: // 99999999zX'''''''''''''''
9217	11906	{
9218		- state.addr = 18446744073709551111LLU; // 999999992G'''''''''''''''
	11907	+ state.addr = 18446744073709550937LLU; // 99999999zY'''''''''''''''
9219	11908
9220	11909	break;
9221	11910	}
9222		- case 18446744073709551111LLU: // 999999992G'''''''''''''''
	11911	+ case 18446744073709550937LLU: // 99999999zY'''''''''''''''
9223	11912	{
9224	11913	fprintf(stdout, "%s", "LOCAL_ACCESS_ADDR(heap.data, ");
9225	11914	{

		@@ -9230,7 +11919,7 @@
9230	11919	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9231	11920	}
9232	11921	// 1LLU
9233		- uint64_t return_to = 18446744073709551108LLU;
	11922	+ uint64_t return_to = 18446744073709550934LLU;
9234	11923	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9235	11924	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9236	11925	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9240,13 +11929,13 @@
9240	11929
9241	11930	break;
9242	11931	}
9243		- case 18446744073709551108LLU: // 999999992D'''''''''''''''
	11932	+ case 18446744073709550934LLU: // 99999999zV'''''''''''''''
9244	11933	{
9245		- state.addr = 18446744073709551109LLU; // 999999992E'''''''''''''''
	11934	+ state.addr = 18446744073709550935LLU; // 99999999zW'''''''''''''''
9246	11935
9247	11936	break;
9248	11937	}
9249		- case 18446744073709551109LLU: // 999999992E'''''''''''''''
	11938	+ case 18446744073709550935LLU: // 99999999zW'''''''''''''''
9250	11939	{
9251	11940	fprintf(stdout, "%s", ", ");
9252	11941	{

		@@ -9257,7 +11946,7 @@
9257	11946	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9258	11947	}
9259	11948	// 1LLU
9260		- uint64_t return_to = 18446744073709551106LLU;
	11949	+ uint64_t return_to = 18446744073709550932LLU;
9261	11950	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9262	11951	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9263	11952	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9267,13 +11956,13 @@
9267	11956
9268	11957	break;
9269	11958	}
9270		- case 18446744073709551106LLU: // 999999992B'''''''''''''''
	11959	+ case 18446744073709550932LLU: // 99999999zT'''''''''''''''
9271	11960	{
9272		- state.addr = 18446744073709551107LLU; // 999999992C'''''''''''''''
	11961	+ state.addr = 18446744073709550933LLU; // 99999999zU'''''''''''''''
9273	11962
9274	11963	break;
9275	11964	}
9276		- case 18446744073709551107LLU: // 999999992C'''''''''''''''
	11965	+ case 18446744073709550933LLU: // 99999999zU'''''''''''''''
9277	11966	{
9278	11967	fprintf(stdout, "%s", ")");
9279	11968	// variable u64 size______ goes out of scope

		@@ -9323,7 +12012,7 @@
9323	12012	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9324	12013	}
9325	12014	// 4LLU
9326		- uint64_t return_to = 18446744073709551104LLU;
	12015	+ uint64_t return_to = 18446744073709550930LLU;
9327	12016	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9328	12017	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9329	12018	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9333,13 +12022,13 @@
9333	12022
9334	12023	break;
9335	12024	}
9336		- case 18446744073709551104LLU: // 999999992_'''''''''''''''
	12025	+ case 18446744073709550930LLU: // 99999999zR'''''''''''''''
9337	12026	{
9338		- state.addr = 18446744073709551105LLU; // 999999992A'''''''''''''''
	12027	+ state.addr = 18446744073709550931LLU; // 99999999zS'''''''''''''''
9339	12028
9340	12029	break;
9341	12030	}
9342		- case 18446744073709551105LLU: // 999999992A'''''''''''''''
	12031	+ case 18446744073709550931LLU: // 99999999zS'''''''''''''''
9343	12032	{
9344	12033	fprintf(stdout, "%s", "*LOCAL_ACCESS(heap.data, ");
9345	12034	{

		@@ -9350,7 +12039,7 @@
9350	12039	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9351	12040	}
9352	12041	// 1LLU
9353		- uint64_t return_to = 18446744073709551102LLU;
	12042	+ uint64_t return_to = 18446744073709550928LLU;
9354	12043	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9355	12044	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9356	12045	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9360,13 +12049,13 @@
9360	12049
9361	12050	break;
9362	12051	}
9363		- case 18446744073709551102LLU: // 9999999918'''''''''''''''
	12052	+ case 18446744073709550928LLU: // 99999999zP'''''''''''''''
9364	12053	{
9365		- state.addr = 18446744073709551103LLU; // 9999999919'''''''''''''''
	12054	+ state.addr = 18446744073709550929LLU; // 99999999zQ'''''''''''''''
9366	12055
9367	12056	break;
9368	12057	}
9369		- case 18446744073709551103LLU: // 9999999919'''''''''''''''
	12058	+ case 18446744073709550929LLU: // 99999999zQ'''''''''''''''
9370	12059	{
9371	12060	fprintf(stdout, "%s", ", ");
9372	12061	{

		@@ -9377,7 +12066,7 @@
9377	12066	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9378	12067	}
9379	12068	// 1LLU
9380		- uint64_t return_to = 18446744073709551100LLU;
	12069	+ uint64_t return_to = 18446744073709550926LLU;
9381	12070	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9382	12071	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9383	12072	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9387,13 +12076,13 @@
9387	12076
9388	12077	break;
9389	12078	}
9390		- case 18446744073709551100LLU: // 9999999916'''''''''''''''
	12079	+ case 18446744073709550926LLU: // 99999999zN'''''''''''''''
9391	12080	{
9392		- state.addr = 18446744073709551101LLU; // 9999999917'''''''''''''''
	12081	+ state.addr = 18446744073709550927LLU; // 99999999zO'''''''''''''''
9393	12082
9394	12083	break;
9395	12084	}
9396		- case 18446744073709551101LLU: // 9999999917'''''''''''''''
	12085	+ case 18446744073709550927LLU: // 99999999zO'''''''''''''''
9397	12086	{
9398	12087	fprintf(stdout, "%s", ")");
9399	12088	// variable u64 size______ goes out of scope

		@@ -9420,11 +12109,11 @@
9420	12109	case 587881341690314752LLU: // emitarg___
9421	12110	{
9422	12111
9423		- state.addr = /INDIRECT__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 4LLU)) ? 18446744073709551099LLU : 18446744073709551098LLU;
	12112	+ state.addr = /INDIRECT__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 4LLU)) ? 18446744073709550925LLU : 18446744073709550924LLU;
9424	12113
9425	12114	break;
9426	12115	}
9427		- case 18446744073709551099LLU: // 9999999915'''''''''''''''
	12116	+ case 18446744073709550925LLU: // 99999999zM'''''''''''''''
9428	12117	{
9429	12118	{
9430	12119	uint64_t mainresult = heap.data[0].elem0;

		@@ -9446,7 +12135,7 @@
9446	12135	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9447	12136	}
9448	12137	// 4LLU
9449		- uint64_t return_to = 18446744073709551096LLU;
	12138	+ uint64_t return_to = 18446744073709550922LLU;
9450	12139	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9451	12140	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9452	12141	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9456,22 +12145,22 @@
9456	12145
9457	12146	break;
9458	12147	}
9459		- case 18446744073709551096LLU: // 9999999912'''''''''''''''
	12148	+ case 18446744073709550922LLU: // 99999999zJ'''''''''''''''
9460	12149	{
9461		- state.addr = 18446744073709551097LLU; // 9999999913'''''''''''''''
	12150	+ state.addr = 18446744073709550923LLU; // 99999999zK'''''''''''''''
9462	12151
9463	12152	break;
9464	12153	}
9465		- case 18446744073709551097LLU: // 9999999913'''''''''''''''
	12154	+ case 18446744073709550923LLU: // 99999999zK'''''''''''''''
9466	12155	{
9467	12156	heap.availilable_size_for_dynamic_objects += 0LLU;
9468	12157	heap.availilable_size_for_dynamic_objects += 0LLU;
9469	12158
9470		- state.addr = 18446744073709551095LLU; // 9999999911'''''''''''''''
	12159	+ state.addr = 18446744073709550921LLU; // 99999999zI'''''''''''''''
9471	12160
9472	12161	break;
9473	12162	}
9474		- case 18446744073709551098LLU: // 9999999914'''''''''''''''
	12163	+ case 18446744073709550924LLU: // 99999999zL'''''''''''''''
9475	12164	{
9476	12165	{
9477	12166	uint64_t mainresult = heap.data[0].elem0;

		@@ -9493,7 +12182,7 @@
9493	12182	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9494	12183	}
9495	12184	// 4LLU
9496		- uint64_t return_to = 18446744073709551093LLU;
	12185	+ uint64_t return_to = 18446744073709550919LLU;
9497	12186	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9498	12187	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9499	12188	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9503,19 +12192,19 @@
9503	12192
9504	12193	break;
9505	12194	}
9506		- case 18446744073709551093LLU: // 999999991z'''''''''''''''
	12195	+ case 18446744073709550919LLU: // 99999999zG'''''''''''''''
9507	12196	{
9508		- state.addr = 18446744073709551094LLU; // 9999999910'''''''''''''''
	12197	+ state.addr = 18446744073709550920LLU; // 99999999zH'''''''''''''''
9509	12198
9510	12199	break;
9511	12200	}
9512		- case 18446744073709551094LLU: // 9999999910'''''''''''''''
	12201	+ case 18446744073709550920LLU: // 99999999zH'''''''''''''''
9513	12202	{
9514		- state.addr = 18446744073709551095LLU; // 9999999911'''''''''''''''
	12203	+ state.addr = 18446744073709550921LLU; // 99999999zI'''''''''''''''
9515	12204
9516	12205	break;
9517	12206	}
9518		- case 18446744073709551095LLU: // 9999999911'''''''''''''''
	12207	+ case 18446744073709550921LLU: // 99999999zI'''''''''''''''
9519	12208	{
9520	12209	// parameter-reference u64 INDIRECT__ goes out of scope
9521	12210	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 5

		@@ -9540,11 +12229,11 @@
9540	12229	case 587881357514113024LLU: // emitpar___
9541	12230	{
9542	12231
9543		- state.addr = /INDIRECT__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 4LLU)) ? 18446744073709551092LLU : 18446744073709551091LLU;
	12232	+ state.addr = /INDIRECT__/access_heap(heap.data, LOCAL_ACCESS(heap.data, 5LLU, 4LLU)) ? 18446744073709550918LLU : 18446744073709550917LLU;
9544	12233
9545	12234	break;
9546	12235	}
9547		- case 18446744073709551092LLU: // 999999991y'''''''''''''''
	12236	+ case 18446744073709550918LLU: // 99999999zF'''''''''''''''
9548	12237	{
9549	12238	{
9550	12239	uint64_t mainresult = heap.data[0].elem0;

		@@ -9566,7 +12255,7 @@
9566	12255	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9567	12256	}
9568	12257	// 4LLU
9569		- uint64_t return_to = 18446744073709551089LLU;
	12258	+ uint64_t return_to = 18446744073709550915LLU;
9570	12259	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9571	12260	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9572	12261	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9576,22 +12265,22 @@
9576	12265
9577	12266	break;
9578	12267	}
9579		- case 18446744073709551089LLU: // 999999991v'''''''''''''''
	12268	+ case 18446744073709550915LLU: // 99999999zC'''''''''''''''
9580	12269	{
9581		- state.addr = 18446744073709551090LLU; // 999999991w'''''''''''''''
	12270	+ state.addr = 18446744073709550916LLU; // 99999999zD'''''''''''''''
9582	12271
9583	12272	break;
9584	12273	}
9585		- case 18446744073709551090LLU: // 999999991w'''''''''''''''
	12274	+ case 18446744073709550916LLU: // 99999999zD'''''''''''''''
9586	12275	{
9587	12276	heap.availilable_size_for_dynamic_objects += 0LLU;
9588	12277	heap.availilable_size_for_dynamic_objects += 0LLU;
9589	12278
9590		- state.addr = 18446744073709551088LLU; // 999999991u'''''''''''''''
	12279	+ state.addr = 18446744073709550914LLU; // 99999999zB'''''''''''''''
9591	12280
9592	12281	break;
9593	12282	}
9594		- case 18446744073709551091LLU: // 999999991x'''''''''''''''
	12283	+ case 18446744073709550917LLU: // 99999999zE'''''''''''''''
9595	12284	{
9596	12285	{
9597	12286	uint64_t mainresult = heap.data[0].elem0;

		@@ -9613,7 +12302,7 @@
9613	12302	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9614	12303	}
9615	12304	// 4LLU
9616		- uint64_t return_to = 18446744073709551086LLU;
	12305	+ uint64_t return_to = 18446744073709550912LLU;
9617	12306	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9618	12307	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9619	12308	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9623,19 +12312,19 @@
9623	12312
9624	12313	break;
9625	12314	}
9626		- case 18446744073709551086LLU: // 999999991s'''''''''''''''
	12315	+ case 18446744073709550912LLU: // 99999999z_'''''''''''''''
9627	12316	{
9628		- state.addr = 18446744073709551087LLU; // 999999991t'''''''''''''''
	12317	+ state.addr = 18446744073709550913LLU; // 99999999zA'''''''''''''''
9629	12318
9630	12319	break;
9631	12320	}
9632		- case 18446744073709551087LLU: // 999999991t'''''''''''''''
	12321	+ case 18446744073709550913LLU: // 99999999zA'''''''''''''''
9633	12322	{
9634		- state.addr = 18446744073709551088LLU; // 999999991u'''''''''''''''
	12323	+ state.addr = 18446744073709550914LLU; // 99999999zB'''''''''''''''
9635	12324
9636	12325	break;
9637	12326	}
9638		- case 18446744073709551088LLU: // 999999991u'''''''''''''''
	12327	+ case 18446744073709550914LLU: // 99999999zB'''''''''''''''
9639	12328	{
9640	12329	// parameter-reference u64 INDIRECT__ goes out of scope
9641	12330	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference INDIRECT__ at 5

		@@ -9668,7 +12357,7 @@
9668	12357	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9669	12358	}
9670	12359	// 1LLU
9671		- uint64_t return_to = 18446744073709551084LLU;
	12360	+ uint64_t return_to = 18446744073709550910LLU;
9672	12361	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9673	12362	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9674	12363	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9678,13 +12367,13 @@
9678	12367
9679	12368	break;
9680	12369	}
9681		- case 18446744073709551084LLU: // 999999991q'''''''''''''''
	12370	+ case 18446744073709550910LLU: // 99999999y8'''''''''''''''
9682	12371	{
9683		- state.addr = 18446744073709551085LLU; // 999999991r'''''''''''''''
	12372	+ state.addr = 18446744073709550911LLU; // 99999999y9'''''''''''''''
9684	12373
9685	12374	break;
9686	12375	}
9687		- case 18446744073709551085LLU: // 999999991r'''''''''''''''
	12376	+ case 18446744073709550911LLU: // 99999999y9'''''''''''''''
9688	12377	{
9689	12378	fprintf(stdout, "%s", ": // ");
9690	12379

		@@ -9728,7 +12417,7 @@
9728	12417	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9729	12418	}
9730	12419	// 1LLU
9731		- uint64_t return_to = 18446744073709551082LLU;
	12420	+ uint64_t return_to = 18446744073709550908LLU;
9732	12421	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9733	12422	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9734	12423	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9738,13 +12427,13 @@
9738	12427
9739	12428	break;
9740	12429	}
9741		- case 18446744073709551082LLU: // 999999991o'''''''''''''''
	12430	+ case 18446744073709550908LLU: // 99999999y6'''''''''''''''
9742	12431	{
9743		- state.addr = 18446744073709551083LLU; // 999999991p'''''''''''''''
	12432	+ state.addr = 18446744073709550909LLU; // 99999999y7'''''''''''''''
9744	12433
9745	12434	break;
9746	12435	}
9747		- case 18446744073709551083LLU: // 999999991p'''''''''''''''
	12436	+ case 18446744073709550909LLU: // 99999999y7'''''''''''''''
9748	12437	{
9749	12438	fprintf(stdout, "%s", "; // ");
9750	12439

		@@ -9755,7 +12444,7 @@
9755	12444	uint64_t mainresult = heap.data[0].elem0;
9756	12445	heap.data[0].elem0 = 0;
9757	12446	// 0LLU
9758		- uint64_t return_to = 18446744073709551080LLU;
	12447	+ uint64_t return_to = 18446744073709550906LLU;
9759	12448	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9760	12449	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9761	12450	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9765,13 +12454,13 @@
9765	12454
9766	12455	break;
9767	12456	}
9768		- case 18446744073709551080LLU: // 999999991m'''''''''''''''
	12457	+ case 18446744073709550906LLU: // 99999999y4'''''''''''''''
9769	12458	{
9770		- state.addr = 18446744073709551081LLU; // 999999991n'''''''''''''''
	12459	+ state.addr = 18446744073709550907LLU; // 99999999y5'''''''''''''''
9771	12460
9772	12461	break;
9773	12462	}
9774		- case 18446744073709551081LLU: // 999999991n'''''''''''''''
	12463	+ case 18446744073709550907LLU: // 99999999y5'''''''''''''''
9775	12464	{
9776	12465	// parameter u64 label_____ goes out of scope
9777	12466	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference label_____ at 1

		@@ -9796,7 +12485,7 @@
9796	12485	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9797	12486	}
9798	12487	// 1LLU
9799		- uint64_t return_to = 18446744073709551078LLU;
	12488	+ uint64_t return_to = 18446744073709550904LLU;
9800	12489	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9801	12490	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9802	12491	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9806,13 +12495,13 @@
9806	12495
9807	12496	break;
9808	12497	}
9809		- case 18446744073709551078LLU: // 999999991k'''''''''''''''
	12498	+ case 18446744073709550904LLU: // 99999999y2'''''''''''''''
9810	12499	{
9811		- state.addr = 18446744073709551079LLU; // 999999991l'''''''''''''''
	12500	+ state.addr = 18446744073709550905LLU; // 99999999y3'''''''''''''''
9812	12501
9813	12502	break;
9814	12503	}
9815		- case 18446744073709551079LLU: // 999999991l'''''''''''''''
	12504	+ case 18446744073709550905LLU: // 99999999y3'''''''''''''''
9816	12505	{
9817	12506	// parameter u64 label_____ goes out of scope
9818	12507	(void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference label_____ at 1

		@@ -9871,7 +12560,7 @@
9871	12560	LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9872	12561	}
9873	12562	// 4LLU
9874		- uint64_t return_to = 18446744073709551075LLU;
	12563	+ uint64_t return_to = 18446744073709550901LLU;
9875	12564	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9876	12565	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9877	12566	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9881,20 +12570,20 @@
9881	12570
9882	12571	break;
9883	12572	}
9884		- case 18446744073709551075LLU: // 999999991h'''''''''''''''
	12573	+ case 18446744073709550901LLU: // 99999999yz'''''''''''''''
9885	12574	{
9886		- state.addr = 18446744073709551076LLU; // 999999991i'''''''''''''''
	12575	+ state.addr = 18446744073709550902LLU; // 99999999y0'''''''''''''''
9887	12576
9888	12577	break;
9889	12578	}
9890		- case 18446744073709551076LLU: // 999999991i'''''''''''''''
	12579	+ case 18446744073709550902LLU: // 99999999y0'''''''''''''''
9891	12580	{
9892	12581
9893		- state.addr = /varidx____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551074LLU : 18446744073709551073LLU;
	12582	+ state.addr = /varidx____/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709550900LLU : 18446744073709550899LLU;
9894	12583
9895	12584	break;
9896	12585	}
9897		- case 18446744073709551074LLU: // 999999991g'''''''''''''''
	12586	+ case 18446744073709550900LLU: // 99999999yy'''''''''''''''
9898	12587	{
9899	12588	fprintf(stderr, "%s", "INTERNAL COMPILER ERROR in emitleave: not all arguments released (remainsize ");
9900	12589	{

		@@ -9905,7 +12594,7 @@
9905	12594	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
9906	12595	}
9907	12596	// 1LLU
9908		- uint64_t return_to = 18446744073709551071LLU;
	12597	+ uint64_t return_to = 18446744073709550897LLU;
9909	12598	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9910	12599	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9911	12600	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9915,13 +12604,13 @@
9915	12604
9916	12605	break;
9917	12606	}
9918		- case 18446744073709551071LLU: // 999999991d'''''''''''''''
	12607	+ case 18446744073709550897LLU: // 99999999yv'''''''''''''''
9919	12608	{
9920		- state.addr = 18446744073709551072LLU; // 999999991e'''''''''''''''
	12609	+ state.addr = 18446744073709550898LLU; // 99999999yw'''''''''''''''
9921	12610
9922	12611	break;
9923	12612	}
9924		- case 18446744073709551072LLU: // 999999991e'''''''''''''''
	12613	+ case 18446744073709550898LLU: // 99999999yw'''''''''''''''
9925	12614	{
9926	12615	fprintf(stderr, "%s", ")");
9927	12616

		@@ -9929,26 +12618,26 @@
9929	12618	fprintf(stderr, "%s\n", "");
9930	12619	exit(-1);
9931	12620	}
9932		- state.addr = 18446744073709551073LLU; // 999999991f'''''''''''''''
	12621	+ state.addr = 18446744073709550899LLU; // 99999999yx'''''''''''''''
9933	12622
9934	12623	break;
9935	12624	}
9936		- case 18446744073709551073LLU: // 999999991f'''''''''''''''
	12625	+ case 18446744073709550899LLU: // 99999999yx'''''''''''''''
9937	12626	{
9938	12627	// variable u64 varidx____ goes out of scope
9939	12628	// emitted destructur for type u64
9940	12629	(void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference varidx____ at 4
9941		- state.addr = 18446744073709551077LLU; // 999999991j'''''''''''''''
	12630	+ state.addr = 18446744073709550903LLU; // 99999999y1'''''''''''''''
9942	12631
9943	12632	break;
9944	12633	}
9945		- case 18446744073709551077LLU: // 999999991j'''''''''''''''
	12634	+ case 18446744073709550903LLU: // 99999999y1'''''''''''''''
9946	12635	{
9947	12636	{
9948	12637	uint64_t mainresult = heap.data[0].elem0;
9949	12638	heap.data[0].elem0 = 0;
9950	12639	// 0LLU
9951		- uint64_t return_to = 18446744073709551069LLU;
	12640	+ uint64_t return_to = 18446744073709550895LLU;
9952	12641	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9953	12642	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9954	12643	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9958,19 +12647,19 @@
9958	12647
9959	12648	break;
9960	12649	}
9961		- case 18446744073709551069LLU: // 999999991b'''''''''''''''
	12650	+ case 18446744073709550895LLU: // 99999999yt'''''''''''''''
9962	12651	{
9963		- state.addr = 18446744073709551070LLU; // 999999991c'''''''''''''''
	12652	+ state.addr = 18446744073709550896LLU; // 99999999yu'''''''''''''''
9964	12653
9965	12654	break;
9966	12655	}
9967		- case 18446744073709551070LLU: // 999999991c'''''''''''''''
	12656	+ case 18446744073709550896LLU: // 99999999yu'''''''''''''''
9968	12657	{
9969	12658	{
9970	12659	uint64_t mainresult = heap.data[0].elem0;
9971	12660	heap.data[0].elem0 = 0;
9972	12661	// 0LLU
9973		- uint64_t return_to = 18446744073709551067LLU;
	12662	+ uint64_t return_to = 18446744073709550893LLU;
9974	12663	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
9975	12664	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
9976	12665	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -9980,13 +12669,13 @@
9980	12669
9981	12670	break;
9982	12671	}
9983		- case 18446744073709551067LLU: // 999999991$'''''''''''''''
	12672	+ case 18446744073709550893LLU: // 99999999yr'''''''''''''''
9984	12673	{
9985		- state.addr = 18446744073709551068LLU; // 999999991a'''''''''''''''
	12674	+ state.addr = 18446744073709550894LLU; // 99999999ys'''''''''''''''
9986	12675
9987	12676	break;
9988	12677	}
9989		- case 18446744073709551068LLU: // 999999991a'''''''''''''''
	12678	+ case 18446744073709550894LLU: // 99999999ys'''''''''''''''
9990	12679	{
9991	12680	// parameter-reference u64 remainsize goes out of scope
9992	12681	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference remainsize at 3

		@@ -10014,7 +12703,7 @@
10014	12703	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10015	12704	}
10016	12705	// 1LLU
10017		- uint64_t return_to = 18446744073709551065LLU;
	12706	+ uint64_t return_to = 18446744073709550891LLU;
10018	12707	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10019	12708	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10020	12709	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10024,13 +12713,13 @@
10024	12713
10025	12714	break;
10026	12715	}
10027		- case 18446744073709551065LLU: // 999999991Y'''''''''''''''
	12716	+ case 18446744073709550891LLU: // 99999999yp'''''''''''''''
10028	12717	{
10029		- state.addr = 18446744073709551066LLU; // 999999991Z'''''''''''''''
	12718	+ state.addr = 18446744073709550892LLU; // 99999999yq'''''''''''''''
10030	12719
10031	12720	break;
10032	12721	}
10033		- case 18446744073709551066LLU: // 999999991Z'''''''''''''''
	12722	+ case 18446744073709550892LLU: // 99999999yq'''''''''''''''
10034	12723	{
10035	12724	{
10036	12725	uint64_t mainresult = heap.data[0].elem0;

		@@ -10040,7 +12729,7 @@
10040	12729	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10041	12730	}
10042	12731	// 1LLU
10043		- uint64_t return_to = 18446744073709551063LLU;
	12732	+ uint64_t return_to = 18446744073709550889LLU;
10044	12733	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10045	12734	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10046	12735	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10050,13 +12739,13 @@
10050	12739
10051	12740	break;
10052	12741	}
10053		- case 18446744073709551063LLU: // 999999991W'''''''''''''''
	12742	+ case 18446744073709550889LLU: // 99999999yn'''''''''''''''
10054	12743	{
10055		- state.addr = 18446744073709551064LLU; // 999999991X'''''''''''''''
	12744	+ state.addr = 18446744073709550890LLU; // 99999999yo'''''''''''''''
10056	12745
10057	12746	break;
10058	12747	}
10059		- case 18446744073709551064LLU: // 999999991X'''''''''''''''
	12748	+ case 18446744073709550890LLU: // 99999999yo'''''''''''''''
10060	12749	{
10061	12750	// parameter-reference u64 label1____ goes out of scope
10062	12751	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference label1____ at 2

		@@ -10094,7 +12783,7 @@
10094	12783	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10095	12784	}
10096	12785	// 2LLU
10097		- uint64_t return_to = 18446744073709551061LLU;
	12786	+ uint64_t return_to = 18446744073709550887LLU;
10098	12787	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10099	12788	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10100	12789	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10104,13 +12793,13 @@
10104	12793
10105	12794	break;
10106	12795	}
10107		- case 18446744073709551061LLU: // 999999991U'''''''''''''''
	12796	+ case 18446744073709550887LLU: // 99999999yl'''''''''''''''
10108	12797	{
10109		- state.addr = 18446744073709551062LLU; // 999999991V'''''''''''''''
	12798	+ state.addr = 18446744073709550888LLU; // 99999999ym'''''''''''''''
10110	12799
10111	12800	break;
10112	12801	}
10113		- case 18446744073709551062LLU: // 999999991V'''''''''''''''
	12802	+ case 18446744073709550888LLU: // 99999999ym'''''''''''''''
10114	12803	{
10115	12804	// variable u64 label1____ goes out of scope
10116	12805	// emitted destructur for type u64

		@@ -10133,11 +12822,11 @@
10133	12822	case 550426420023820288LLU: // checkmem__
10134	12823	{
10135	12824
10136		- state.addr = /remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) ? 18446744073709551060LLU : 18446744073709551059LLU;
	12825	+ state.addr = /remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) ? 18446744073709550886LLU : 18446744073709550885LLU;
10137	12826
10138	12827	break;
10139	12828	}
10140		- case 18446744073709551060LLU: // 999999991T'''''''''''''''
	12829	+ case 18446744073709550886LLU: // 99999999yk'''''''''''''''
10141	12830	{
10142	12831
10143	12832	--/remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU));

		@@ -10144,11 +12833,11 @@
10144	12833	heap.availilable_size_for_dynamic_objects += 0LLU;
10145	12834	heap.availilable_size_for_dynamic_objects += 0LLU;
10146	12835
10147		- state.addr = 18446744073709551058LLU; // 999999991R'''''''''''''''
	12836	+ state.addr = 18446744073709550884LLU; // 99999999yi'''''''''''''''
10148	12837
10149	12838	break;
10150	12839	}
10151		- case 18446744073709551059LLU: // 999999991S'''''''''''''''
	12840	+ case 18446744073709550885LLU: // 99999999yj'''''''''''''''
10152	12841	{
10153	12842	{
10154	12843	uint64_t mainresult = heap.data[0].elem0;

		@@ -10158,7 +12847,7 @@
10158	12847	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10159	12848	}
10160	12849	// 1LLU
10161		- uint64_t return_to = 18446744073709551056LLU;
	12850	+ uint64_t return_to = 18446744073709550882LLU;
10162	12851	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10163	12852	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10164	12853	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10168,13 +12857,13 @@
10168	12857
10169	12858	break;
10170	12859	}
10171		- case 18446744073709551056LLU: // 999999991P'''''''''''''''
	12860	+ case 18446744073709550882LLU: // 99999999yg'''''''''''''''
10172	12861	{
10173		- state.addr = 18446744073709551057LLU; // 999999991Q'''''''''''''''
	12862	+ state.addr = 18446744073709550883LLU; // 99999999yh'''''''''''''''
10174	12863
10175	12864	break;
10176	12865	}
10177		- case 18446744073709551057LLU: // 999999991Q'''''''''''''''
	12866	+ case 18446744073709550883LLU: // 99999999yh'''''''''''''''
10178	12867	{
10179	12868	fprintf(stderr, "%s", "out of memory");
10180	12869

		@@ -10182,11 +12871,11 @@
10182	12871	fprintf(stderr, "%s\n", "");
10183	12872	exit(-1);
10184	12873	}
10185		- state.addr = 18446744073709551058LLU; // 999999991R'''''''''''''''
	12874	+ state.addr = 18446744073709550884LLU; // 99999999yi'''''''''''''''
10186	12875
10187	12876	break;
10188	12877	}
10189		- case 18446744073709551058LLU: // 999999991R'''''''''''''''
	12878	+ case 18446744073709550884LLU: // 99999999yi'''''''''''''''
10190	12879	{
10191	12880	// parameter-reference u64 remainsize goes out of scope
10192	12881	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference remainsize at 2

		@@ -10205,11 +12894,11 @@
10205	12894	case 550426420023822623LLU: // checkmemid
10206	12895	{
10207	12896
10208		- state.addr = /remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) ? 18446744073709551055LLU : 18446744073709551054LLU;
	12897	+ state.addr = /remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) ? 18446744073709550881LLU : 18446744073709550880LLU;
10209	12898
10210	12899	break;
10211	12900	}
10212		- case 18446744073709551055LLU: // 999999991O'''''''''''''''
	12901	+ case 18446744073709550881LLU: // 99999999yf'''''''''''''''
10213	12902	{
10214	12903
10215	12904	--/remainsize/access_heap(heap.data, LOCAL_ACCESS(heap.data, 3LLU, 1LLU));

		@@ -10216,11 +12905,11 @@
10216	12905	heap.availilable_size_for_dynamic_objects += 0LLU;
10217	12906	heap.availilable_size_for_dynamic_objects += 0LLU;
10218	12907
10219		- state.addr = 18446744073709551053LLU; // 999999991M'''''''''''''''
	12908	+ state.addr = 18446744073709550879LLU; // 99999999yd'''''''''''''''
10220	12909
10221	12910	break;
10222	12911	}
10223		- case 18446744073709551054LLU: // 999999991N'''''''''''''''
	12912	+ case 18446744073709550880LLU: // 99999999ye'''''''''''''''
10224	12913	{
10225	12914	{
10226	12915	uint64_t mainresult = heap.data[0].elem0;

		@@ -10230,7 +12919,7 @@
10230	12919	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10231	12920	}
10232	12921	// 1LLU
10233		- uint64_t return_to = 18446744073709551051LLU;
	12922	+ uint64_t return_to = 18446744073709550877LLU;
10234	12923	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10235	12924	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10236	12925	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10240,13 +12929,13 @@
10240	12929
10241	12930	break;
10242	12931	}
10243		- case 18446744073709551051LLU: // 999999991K'''''''''''''''
	12932	+ case 18446744073709550877LLU: // 99999999yb'''''''''''''''
10244	12933	{
10245		- state.addr = 18446744073709551052LLU; // 999999991L'''''''''''''''
	12934	+ state.addr = 18446744073709550878LLU; // 99999999yc'''''''''''''''
10246	12935
10247	12936	break;
10248	12937	}
10249		- case 18446744073709551052LLU: // 999999991L'''''''''''''''
	12938	+ case 18446744073709550878LLU: // 99999999yc'''''''''''''''
10250	12939	{
10251	12940	fprintf(stderr, "%s", "out of memory calling ");
10252	12941

		@@ -10256,11 +12945,11 @@
10256	12945	fprintf(stderr, "%s\n", "");
10257	12946	exit(-1);
10258	12947	}
10259		- state.addr = 18446744073709551053LLU; // 999999991M'''''''''''''''
	12948	+ state.addr = 18446744073709550879LLU; // 99999999yd'''''''''''''''
10260	12949
10261	12950	break;
10262	12951	}
10263		- case 18446744073709551053LLU: // 999999991M'''''''''''''''
	12952	+ case 18446744073709550879LLU: // 99999999yd'''''''''''''''
10264	12953	{
10265	12954	// parameter-reference u64 target____ goes out of scope
10266	12955	(void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference target____ at 3

		@@ -10327,7 +13016,7 @@
10327	13016	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10328	13017	}
10329	13018	// 3LLU
10330		- uint64_t return_to = 18446744073709551049LLU;
	13019	+ uint64_t return_to = 18446744073709550875LLU;
10331	13020	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10332	13021	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10333	13022	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10337,13 +13026,13 @@
10337	13026
10338	13027	break;
10339	13028	}
10340		- case 18446744073709551049LLU: // 999999991I'''''''''''''''
	13029	+ case 18446744073709550875LLU: // 99999999y$'''''''''''''''
10341	13030	{
10342		- state.addr = 18446744073709551050LLU; // 999999991J'''''''''''''''
	13031	+ state.addr = 18446744073709550876LLU; // 99999999ya'''''''''''''''
10343	13032
10344	13033	break;
10345	13034	}
10346		- case 18446744073709551050LLU: // 999999991J'''''''''''''''
	13035	+ case 18446744073709550876LLU: // 99999999ya'''''''''''''''
10347	13036	{
10348	13037	fprintf(stdout, "%s", ", &(heap.data[0].elem0)/address of closure-in-construction/, &arg);\n");
10349	13038	fprintf(stdout, "%s", " }\n");

		@@ -10363,7 +13052,7 @@
10363	13052	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10364	13053	}
10365	13054	// 3LLU
10366		- uint64_t return_to = 18446744073709551047LLU;
	13055	+ uint64_t return_to = 18446744073709550873LLU;
10367	13056	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10368	13057	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10369	13058	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10373,13 +13062,13 @@
10373	13062
10374	13063	break;
10375	13064	}
10376		- case 18446744073709551047LLU: // 999999991G'''''''''''''''
	13065	+ case 18446744073709550873LLU: // 99999999yY'''''''''''''''
10377	13066	{
10378		- state.addr = 18446744073709551048LLU; // 999999991H'''''''''''''''
	13067	+ state.addr = 18446744073709550874LLU; // 99999999yZ'''''''''''''''
10379	13068
10380	13069	break;
10381	13070	}
10382		- case 18446744073709551048LLU: // 999999991H'''''''''''''''
	13071	+ case 18446744073709550874LLU: // 99999999yZ'''''''''''''''
10383	13072	{
10384	13073	// parameter-reference u64 remainsize goes out of scope
10385	13074	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference remainsize at 5

		@@ -10407,7 +13096,7 @@
10407	13096	uint64_t mainresult = heap.data[0].elem0;
10408	13097	heap.data[0].elem0 = 0;
10409	13098	// 0LLU
10410		- uint64_t return_to = 18446744073709551045LLU;
	13099	+ uint64_t return_to = 18446744073709550871LLU;
10411	13100	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10412	13101	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10413	13102	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10417,13 +13106,13 @@
10417	13106
10418	13107	break;
10419	13108	}
10420		- case 18446744073709551045LLU: // 999999991E'''''''''''''''
	13109	+ case 18446744073709550871LLU: // 99999999yW'''''''''''''''
10421	13110	{
10422		- state.addr = 18446744073709551046LLU; // 999999991F'''''''''''''''
	13111	+ state.addr = 18446744073709550872LLU; // 99999999yX'''''''''''''''
10423	13112
10424	13113	break;
10425	13114	}
10426		- case 18446744073709551046LLU: // 999999991F'''''''''''''''
	13115	+ case 18446744073709550872LLU: // 99999999yX'''''''''''''''
10427	13116	{
10428	13117	{
10429	13118	uint64_t mainresult = heap.data[0].elem0;

		@@ -10433,7 +13122,7 @@
10433	13122	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10434	13123	}
10435	13124	// 1LLU
10436		- uint64_t return_to = 18446744073709551043LLU;
	13125	+ uint64_t return_to = 18446744073709550869LLU;
10437	13126	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10438	13127	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10439	13128	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10443,13 +13132,13 @@
10443	13132
10444	13133	break;
10445	13134	}
10446		- case 18446744073709551043LLU: // 999999991C'''''''''''''''
	13135	+ case 18446744073709550869LLU: // 99999999yU'''''''''''''''
10447	13136	{
10448		- state.addr = 18446744073709551044LLU; // 999999991D'''''''''''''''
	13137	+ state.addr = 18446744073709550870LLU; // 99999999yV'''''''''''''''
10449	13138
10450	13139	break;
10451	13140	}
10452		- case 18446744073709551044LLU: // 999999991D'''''''''''''''
	13141	+ case 18446744073709550870LLU: // 99999999yV'''''''''''''''
10453	13142	{
10454	13143	{
10455	13144	uint64_t mainresult = heap.data[0].elem0;

		@@ -10475,7 +13164,7 @@
10475	13164	LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10476	13165	}
10477	13166	// 5LLU
10478		- uint64_t return_to = 18446744073709551041LLU;
	13167	+ uint64_t return_to = 18446744073709550867LLU;
10479	13168	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10480	13169	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10481	13170	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10485,13 +13174,13 @@
10485	13174
10486	13175	break;
10487	13176	}
10488		- case 18446744073709551041LLU: // 999999991A'''''''''''''''
	13177	+ case 18446744073709550867LLU: // 99999999yS'''''''''''''''
10489	13178	{
10490		- state.addr = 18446744073709551042LLU; // 999999991B'''''''''''''''
	13179	+ state.addr = 18446744073709550868LLU; // 99999999yT'''''''''''''''
10491	13180
10492	13181	break;
10493	13182	}
10494		- case 18446744073709551042LLU: // 999999991B'''''''''''''''
	13183	+ case 18446744073709550868LLU: // 99999999yT'''''''''''''''
10495	13184	{
10496	13185	// parameter-reference u64 value_____ goes out of scope
10497	13186	(void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference value_____ at 6

		@@ -10534,7 +13223,7 @@
10534	13223	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10535	13224	}
10536	13225	// 3LLU
10537		- uint64_t return_to = 18446744073709551039LLU;
	13226	+ uint64_t return_to = 18446744073709550865LLU;
10538	13227	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10539	13228	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10540	13229	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10544,13 +13233,13 @@
10544	13233
10545	13234	break;
10546	13235	}
10547		- case 18446744073709551039LLU: // 9999999909'''''''''''''''
	13236	+ case 18446744073709550865LLU: // 99999999yQ'''''''''''''''
10548	13237	{
10549		- state.addr = 18446744073709551040LLU; // 999999991_'''''''''''''''
	13238	+ state.addr = 18446744073709550866LLU; // 99999999yR'''''''''''''''
10550	13239
10551	13240	break;
10552	13241	}
10553		- case 18446744073709551040LLU: // 999999991_'''''''''''''''
	13242	+ case 18446744073709550866LLU: // 99999999yR'''''''''''''''
10554	13243	{
10555	13244	fprintf(stdout, "%s", "\n");
10556	13245	fprintf(stdout, "%s", " uint64_t return_to = ");

		@@ -10562,7 +13251,7 @@
10562	13251	LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10563	13252	}
10564	13253	// 1LLU
10565		- uint64_t return_to = 18446744073709551037LLU;
	13254	+ uint64_t return_to = 18446744073709550863LLU;
10566	13255	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10567	13256	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10568	13257	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10572,13 +13261,13 @@
10572	13261
10573	13262	break;
10574	13263	}
10575		- case 18446744073709551037LLU: // 9999999907'''''''''''''''
	13264	+ case 18446744073709550863LLU: // 99999999yO'''''''''''''''
10576	13265	{
10577		- state.addr = 18446744073709551038LLU; // 9999999908'''''''''''''''
	13266	+ state.addr = 18446744073709550864LLU; // 99999999yP'''''''''''''''
10578	13267
10579	13268	break;
10580	13269	}
10581		- case 18446744073709551038LLU: // 9999999908'''''''''''''''
	13270	+ case 18446744073709550864LLU: // 99999999yP'''''''''''''''
10582	13271	{
10583	13272	fprintf(stdout, "%s", ";\n");
10584	13273	fprintf(stdout, "%s", " uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);\n");

		@@ -10599,7 +13288,7 @@
10599	13288	LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10600	13289	}
10601	13290	// 3LLU
10602		- uint64_t return_to = 18446744073709551035LLU;
	13291	+ uint64_t return_to = 18446744073709550861LLU;
10603	13292	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10604	13293	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10605	13294	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10609,13 +13298,13 @@
10609	13298
10610	13299	break;
10611	13300	}
10612		- case 18446744073709551035LLU: // 9999999905'''''''''''''''
	13301	+ case 18446744073709550861LLU: // 99999999yM'''''''''''''''
10613	13302	{
10614		- state.addr = 18446744073709551036LLU; // 9999999906'''''''''''''''
	13303	+ state.addr = 18446744073709550862LLU; // 99999999yN'''''''''''''''
10615	13304
10616	13305	break;
10617	13306	}
10618		- case 18446744073709551036LLU: // 9999999906'''''''''''''''
	13307	+ case 18446744073709550862LLU: // 99999999yN'''''''''''''''
10619	13308	{
10620	13309	fprintf(stdout, "%s", ", 0/address of closure-in-construction/, 0)) = baseinfo;\n");
10621	13310	fprintf(stdout, "%s", " heap.data[0].elem1 = heap.data[0].elem0;\n");

		@@ -10633,7 +13322,7 @@
10633	13322	LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/address of closure-in-construction/, &arg);
10634	13323	}
10635	13324	// 2LLU
10636		- uint64_t return_to = 18446744073709551033LLU;
	13325	+ uint64_t return_to = 18446744073709550859LLU;
10637	13326	uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/memory root/, &return_to);
10638	13327	access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/address of closure-in-construction*/, 0)) = baseinfo;
10639	13328	heap.data[0].elem1 = heap.data[0].elem0;

		@@ -10643,13 +13332,13 @@
10643	13332
10644	13333	break;
10645	13334	}
10646		- case 18446744073709551033LLU: // 9999999903'''''''''''''''
	13335	+ case 18446744073709550859LLU: // 99999999yK'''''''''''''''
10647	13336	{
10648		- state.addr = 18446744073709551034LLU; // 9999999904'''''''''''''''
	13337	+ state.addr = 18446744073709550860LLU; // 99999999yL'''''''''''''''
10649	13338
10650	13339	break;
10651	13340	}
10652		- case 18446744073709551034LLU: // 9999999904'''''''''''''''
	13341	+ case 18446744073709550860LLU: // 99999999yL'''''''''''''''
10653	13342	{
10654	13343	// parameter-reference u64 remainsize goes out of scope
10655	13344	(void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference remainsize at 5

		@@ -10674,11 +13363,11 @@
10674	13363	case 661681486948204544LLU: // isu64_____
10675	13364	{
10676	13365
10677		- state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551032LLU : 18446744073709551031LLU;
	13366	+ state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709550858LLU : 18446744073709550857LLU;
10678	13367
10679	13368	break;
10680	13369	}
10681		- case 18446744073709551032LLU: // 9999999902'''''''''''''''
	13370	+ case 18446744073709550858LLU: // 99999999yJ'''''''''''''''
10682	13371	{
10683	13372	{
10684	13373	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -10690,18 +13379,18 @@
10690	13379	heap.availilable_size_for_dynamic_objects += 0LLU;
10691	13380	heap.availilable_size_for_dynamic_objects += 0LLU;
10692	13381
10693		- state.addr = 18446744073709551030LLU; // 9999999900'''''''''''''''
	13382	+ state.addr = 18446744073709550856LLU; // 99999999yH'''''''''''''''
10694	13383
10695	13384	break;
10696	13385	}
10697		- case 18446744073709551031LLU: // 9999999901'''''''''''''''
	13386	+ case 18446744073709550857LLU: // 99999999yI'''''''''''''''
10698	13387	{
10699	13388	/result____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 0LLU;
10700		- state.addr = 18446744073709551030LLU; // 9999999900'''''''''''''''
	13389	+ state.addr = 18446744073709550856LLU; // 99999999yH'''''''''''''''
10701	13390
10702	13391	break;
10703	13392	}
10704		- case 18446744073709551030LLU: // 9999999900'''''''''''''''
	13393	+ case 18446744073709550856LLU: // 99999999yH'''''''''''''''
10705	13394	{
10706	13395	// parameter-reference type______ type______ goes out of scope
10707	13396	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 2

		@@ -10720,11 +13409,11 @@
10720	13409	case 661640243165790208LLU: // islist____
10721	13410	{
10722	13411
10723		- state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551029LLU : 18446744073709551028LLU;
	13412	+ state.addr = 861504786250002432LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709550855LLU : 18446744073709550854LLU;
10724	13413
10725	13414	break;
10726	13415	}
10727		- case 18446744073709551029LLU: // 999999990z'''''''''''''''
	13416	+ case 18446744073709550855LLU: // 99999999yG'''''''''''''''
10728	13417	{
10729	13418	{
10730	13419	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -10736,18 +13425,18 @@
10736	13425	heap.availilable_size_for_dynamic_objects += 0LLU;
10737	13426	heap.availilable_size_for_dynamic_objects += 0LLU;
10738	13427
10739		- state.addr = 18446744073709551027LLU; // 999999990x'''''''''''''''
	13428	+ state.addr = 18446744073709550853LLU; // 99999999yE'''''''''''''''
10740	13429
10741	13430	break;
10742	13431	}
10743		- case 18446744073709551028LLU: // 999999990y'''''''''''''''
	13432	+ case 18446744073709550854LLU: // 99999999yF'''''''''''''''
10744	13433	{
10745	13434	/result____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 0LLU;
10746		- state.addr = 18446744073709551027LLU; // 999999990x'''''''''''''''
	13435	+ state.addr = 18446744073709550853LLU; // 99999999yE'''''''''''''''
10747	13436
10748	13437	break;
10749	13438	}
10750		- case 18446744073709551027LLU: // 999999990x'''''''''''''''
	13439	+ case 18446744073709550853LLU: // 99999999yE'''''''''''''''
10751	13440	{
10752	13441	// parameter-reference type______ type______ goes out of scope
10753	13442	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 2

		@@ -10766,11 +13455,11 @@
10766	13455	case 661592616156004352LLU: // isatom____
10767	13456	{
10768	13457
10769		- state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551026LLU : 18446744073709551025LLU;
	13458	+ state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709550852LLU : 18446744073709550851LLU;
10770	13459
10771	13460	break;
10772	13461	}
10773		- case 18446744073709551026LLU: // 999999990w'''''''''''''''
	13462	+ case 18446744073709550852LLU: // 99999999yD'''''''''''''''
10774	13463	{
10775	13464	{
10776	13465	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -10782,18 +13471,18 @@
10782	13471	heap.availilable_size_for_dynamic_objects += 0LLU;
10783	13472	heap.availilable_size_for_dynamic_objects += 0LLU;
10784	13473
10785		- state.addr = 18446744073709551024LLU; // 999999990u'''''''''''''''
	13474	+ state.addr = 18446744073709550850LLU; // 99999999yB'''''''''''''''
10786	13475
10787	13476	break;
10788	13477	}
10789		- case 18446744073709551025LLU: // 999999990v'''''''''''''''
	13478	+ case 18446744073709550851LLU: // 99999999yC'''''''''''''''
10790	13479	{
10791	13480	/result____/access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 0LLU;
10792		- state.addr = 18446744073709551024LLU; // 999999990u'''''''''''''''
	13481	+ state.addr = 18446744073709550850LLU; // 99999999yB'''''''''''''''
10793	13482
10794	13483	break;
10795	13484	}
10796		- case 18446744073709551024LLU: // 999999990u'''''''''''''''
	13485	+ case 18446744073709550850LLU: // 99999999yB'''''''''''''''
10797	13486	{
10798	13487	// parameter-reference type______ type______ goes out of scope
10799	13488	(void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/address of current closure/); // RELEASE reference type______ at 2

		@@ -10812,11 +13501,11 @@
10812	13501	case 661658442972266496LLU: // isprim____
10813	13502	{
10814	13503
10815		- state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709551023LLU : 18446744073709551022LLU;
	13504	+ state.addr = 861504796319285248LLU == heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 ? 18446744073709550849LLU : 18446744073709550848LLU;
10816	13505
10817	13506	break;
10818	13507	}
10819		- case 18446744073709551023LLU: // 999999990t'''''''''''''''
	13508	+ case 18446744073709550849LLU: // 99999999yA'''''''''''''''
10820	13509	{
10821	13510	{
10822	13511	uint64_t arg = heap.data[access_heap(heap.data, LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem1;

		@@ -10828,18 +13517,18 @@
10828	13517	heap.availilable_size_for_dynamic_objects += 0LLU;
10829	13518	heap.availilable_size_for_dynamic_objects += 0LLU;
10830	13519
10831		- state.addr = 18446744073709551021LLU; // 999999990r'''''''''''''''
	13520	+ state.addr = 18446744073709550847LLU; // 99999999x9''''''''''

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

Show on old repository browser