OSDN > 브라 우즈 소프트웨어 > Software Development > Compilers > JPL > SCM > SVN > Commit

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revision	411 (tree)
Time	2019-01-18 09:53:18
Author	jakobthomsen

Log Message

cleanup & paths in for

Change Summary

modified: trunk/pragmatic/SDL_tests/SDL_GL_octree/SDL_GL_octree.c (diff)
modified: trunk/pragmatic/SDL_tests/SDL_GL_octree/SDL_GL_octree_compiled.c (diff)
modified: trunk/pragmatic/compiler.compiled.c (diff)
modified: trunk/pragmatic/compiler.source.c (diff)
modified: trunk/pragmatic/memory_tests/mem_tests.c (diff)
modified: trunk/pragmatic/memory_tests/mem_tests_compiled.c (diff)

Incremental Difference

--- trunk/pragmatic/SDL_tests/SDL_GL_octree/SDL_GL_octree.c (revision 410)

+++ trunk/pragmatic/SDL_tests/SDL_GL_octree/SDL_GL_octree.c (revision 411)

		@@ -1369,14 +1369,14 @@
1369	1369	unit QuarterSphereSolid$(mut OcTree ot, u8 level)
1370	1370	{
1371	1371	let u64 size = OcSize(level);
1372		- let u64 x = OcSize(level);
1373		- let u64 y = OcSize(level);
1374		- let u64 z = OcSize(level);
1375		- for x x
	1372	+ let u64 sx = OcSize(level);
	1373	+ let u64 sy = OcSize(level);
	1374	+ let u64 sz = OcSize(level);
	1375	+ for sx x
1376	1376	{
1377		- for y y
	1377	+ for sy y
1378	1378	{
1379		- for z z
	1379	+ for sz z
1380	1380	{
1381	1381	if lss<u64>(add<u64>(mul<u64>(x, x), add<u64>(mul<u64>(y, y), mul<u64>(z, z))), mul<u64>(size, size)) then
1382	1382	{

		@@ -1390,14 +1390,14 @@
1390	1390	unit QuarterSphereHollow$(mut OcTree ot, u8 level)
1391	1391	{
1392	1392	let u64 size = OcSize(level);
1393		- let u64 x = OcSize(level);
1394		- let u64 y = OcSize(level);
1395		- let u64 z = OcSize(level);
1396		- for x x
	1393	+ let u64 sx = OcSize(level);
	1394	+ let u64 sy = OcSize(level);
	1395	+ let u64 sz = OcSize(level);
	1396	+ for sx x
1397	1397	{
1398		- for y y
	1398	+ for sy y
1399	1399	{
1400		- for z z
	1400	+ for sz z
1401	1401	{
1402	1402	if lss<u64>(add<u64>(mul<u64>(x, x), add<u64>(mul<u64>(y, y), mul<u64>(z, z))), mul<u64>(size, size)) then
1403	1403	{

		@@ -1417,14 +1417,14 @@
1417	1417	let u64 halfsize = shiftr<u64>(size, 1);
1418	1418	let u64 halfsize1 = sub<u64>(halfsize, 1);
1419	1419	let mut OcTree ot = OcLeaf(0);
1420		- let u64 x = OcSize(level);
1421		- let u64 y = OcSize(level);
1422		- let u64 z = OcSize(level);
1423		- for x x
	1420	+ let u64 sx = OcSize(level);
	1421	+ let u64 sy = OcSize(level);
	1422	+ let u64 sz = OcSize(level);
	1423	+ for sx x
1424	1424	{
1425		- for y y
	1425	+ for sy y
1426	1426	{
1427		- for z z
	1427	+ for sz z
1428	1428	{
1429	1429	let i64 dx = sub<i64>(i64<u64>(x), i64<u64>(halfsize));
1430	1430	let i64 dy = sub<i64>(i64<u64>(y), i64<u64>(halfsize));

		@@ -1446,14 +1446,14 @@
1446	1446	unit Corner$(mut OcTree ot, u8 level)
1447	1447	{
1448	1448	//let u64 size = OcSize(level);
1449		- let u64 x = OcSize(level);
1450		- let u64 y = OcSize(level);
1451		- let u64 z = OcSize(level);
1452		- for x x
	1449	+ let u64 sx = OcSize(level);
	1450	+ let u64 sy = OcSize(level);
	1451	+ let u64 sz = OcSize(level);
	1452	+ for sx x
1453	1453	{
1454		- for y y
	1454	+ for sy y
1455	1455	{
1456		- for z z
	1456	+ for sz z
1457	1457	{
1458	1458	//if equ<u64>(z, 0) then
1459	1459	if or(equ<u64>(z, 0), or(equ<u64>(y, 0), equ<u64>(x, 0))) then

--- trunk/pragmatic/SDL_tests/SDL_GL_octree/SDL_GL_octree_compiled.c (revision 410)

+++ trunk/pragmatic/SDL_tests/SDL_GL_octree/SDL_GL_octree_compiled.c (revision 411)

		@@ -5464,30 +5464,30 @@
5464	5464	{
5465	5465	OcSize(&_size, &*level);
5466	5466	}
5467		- uint64_t _x; memset(&_x, 0, sizeof(uint64_t));
	5467	+ uint64_t _sx; memset(&_sx, 0, sizeof(uint64_t));
5468	5468	{
5469		- OcSize(&_x, &*level);
	5469	+ OcSize(&_sx, &*level);
5470	5470	}
5471		- uint64_t _y; memset(&_y, 0, sizeof(uint64_t));
	5471	+ uint64_t _sy; memset(&_sy, 0, sizeof(uint64_t));
5472	5472	{
5473		- OcSize(&_y, &*level);
	5473	+ OcSize(&_sy, &*level);
5474	5474	}
5475		- uint64_t _z; memset(&_z, 0, sizeof(uint64_t));
	5475	+ uint64_t _sz; memset(&_sz, 0, sizeof(uint64_t));
5476	5476	{
5477		- OcSize(&_z, &*level);
	5477	+ OcSize(&_sz, &*level);
5478	5478	}
5479	5479	{
5480		- uint64_t _1 = _x;
	5480	+ uint64_t _1 = _sx;
5481	5481	uint64_t *x = &_1;
5482	5482	while((*x)--)
5483	5483	{
5484	5484	{
5485		- uint64_t _2 = _y;
	5485	+ uint64_t _2 = _sy;
5486	5486	uint64_t *y = &_2;
5487	5487	while((*y)--)
5488	5488	{
5489	5489	{
5490		- uint64_t _3 = _z;
	5490	+ uint64_t _3 = _sz;
5491	5491	uint64_t *z = &_3;
5492	5492	while((*z)--)
5493	5493	{

		@@ -5555,9 +5555,9 @@
5555	5555	}
5556	5556	}
5557	5557	}
5558		- _IGNORE_(_z);
5559		- _IGNORE_(_y);
5560		- _IGNORE_(_x);
	5558	+ _IGNORE_(_sz);
	5559	+ _IGNORE_(_sy);
	5560	+ _IGNORE_(_sx);
5561	5561	_IGNORE_(_size);
5562	5562	}
5563	5563	}

		@@ -5569,30 +5569,30 @@
5569	5569	{
5570	5570	OcSize(&_size, &*level);
5571	5571	}
5572		- uint64_t _x; memset(&_x, 0, sizeof(uint64_t));
	5572	+ uint64_t _sx; memset(&_sx, 0, sizeof(uint64_t));
5573	5573	{
5574		- OcSize(&_x, &*level);
	5574	+ OcSize(&_sx, &*level);
5575	5575	}
5576		- uint64_t _y; memset(&_y, 0, sizeof(uint64_t));
	5576	+ uint64_t _sy; memset(&_sy, 0, sizeof(uint64_t));
5577	5577	{
5578		- OcSize(&_y, &*level);
	5578	+ OcSize(&_sy, &*level);
5579	5579	}
5580		- uint64_t _z; memset(&_z, 0, sizeof(uint64_t));
	5580	+ uint64_t _sz; memset(&_sz, 0, sizeof(uint64_t));
5581	5581	{
5582		- OcSize(&_z, &*level);
	5582	+ OcSize(&_sz, &*level);
5583	5583	}
5584	5584	{
5585		- uint64_t _1 = _x;
	5585	+ uint64_t _1 = _sx;
5586	5586	uint64_t *x = &_1;
5587	5587	while((*x)--)
5588	5588	{
5589	5589	{
5590		- uint64_t _2 = _y;
	5590	+ uint64_t _2 = _sy;
5591	5591	uint64_t *y = &_2;
5592	5592	while((*y)--)
5593	5593	{
5594	5594	{
5595		- uint64_t _3 = _z;
	5595	+ uint64_t _3 = _sz;
5596	5596	uint64_t *z = &_3;
5597	5597	while((*z)--)
5598	5598	{

		@@ -5713,9 +5713,9 @@
5713	5713	}
5714	5714	}
5715	5715	}
5716		- _IGNORE_(_z);
5717		- _IGNORE_(_y);
5718		- _IGNORE_(_x);
	5716	+ _IGNORE_(_sz);
	5717	+ _IGNORE_(_sy);
	5718	+ _IGNORE_(_sx);
5719	5719	_IGNORE_(_size);
5720	5720	}
5721	5721	}

		@@ -5748,30 +5748,30 @@
5748	5748	OcLeaf(&_ot, &_1);
5749	5749	_IGNORE_(_1);
5750	5750	}
5751		- uint64_t _x; memset(&_x, 0, sizeof(uint64_t));
	5751	+ uint64_t _sx; memset(&_sx, 0, sizeof(uint64_t));
5752	5752	{
5753		- OcSize(&_x, &*level);
	5753	+ OcSize(&_sx, &*level);
5754	5754	}
5755		- uint64_t _y; memset(&_y, 0, sizeof(uint64_t));
	5755	+ uint64_t _sy; memset(&_sy, 0, sizeof(uint64_t));
5756	5756	{
5757		- OcSize(&_y, &*level);
	5757	+ OcSize(&_sy, &*level);
5758	5758	}
5759		- uint64_t _z; memset(&_z, 0, sizeof(uint64_t));
	5759	+ uint64_t _sz; memset(&_sz, 0, sizeof(uint64_t));
5760	5760	{
5761		- OcSize(&_z, &*level);
	5761	+ OcSize(&_sz, &*level);
5762	5762	}
5763	5763	{
5764		- uint64_t _1 = _x;
	5764	+ uint64_t _1 = _sx;
5765	5765	uint64_t *x = &_1;
5766	5766	while((*x)--)
5767	5767	{
5768	5768	{
5769		- uint64_t _2 = _y;
	5769	+ uint64_t _2 = _sy;
5770	5770	uint64_t *y = &_2;
5771	5771	while((*y)--)
5772	5772	{
5773	5773	{
5774		- uint64_t _3 = _z;
	5774	+ uint64_t _3 = _sz;
5775	5775	uint64_t *z = &_3;
5776	5776	while((*z)--)
5777	5777	{

		@@ -5932,9 +5932,9 @@
5932	5932	}
5933	5933	}
5934	5934	OcTree$copy(&*_0, &_ot);
5935		- _IGNORE_(_z);
5936		- _IGNORE_(_y);
5937		- _IGNORE_(_x);
	5935	+ _IGNORE_(_sz);
	5936	+ _IGNORE_(_sy);
	5937	+ _IGNORE_(_sx);
5938	5938	OcTree$dest(&_ot);
5939	5939	_IGNORE_(_halfsize1);
5940	5940	_IGNORE_(_halfsize);

		@@ -5945,30 +5945,30 @@
5945	5945	void Corner$(void const _0, struct OcTree const ot, const uint8_t *const level)
5946	5946	{
5947	5947	{
5948		- uint64_t _x; memset(&_x, 0, sizeof(uint64_t));
	5948	+ uint64_t _sx; memset(&_sx, 0, sizeof(uint64_t));
5949	5949	{
5950		- OcSize(&_x, &*level);
	5950	+ OcSize(&_sx, &*level);
5951	5951	}
5952		- uint64_t _y; memset(&_y, 0, sizeof(uint64_t));
	5952	+ uint64_t _sy; memset(&_sy, 0, sizeof(uint64_t));
5953	5953	{
5954		- OcSize(&_y, &*level);
	5954	+ OcSize(&_sy, &*level);
5955	5955	}
5956		- uint64_t _z; memset(&_z, 0, sizeof(uint64_t));
	5956	+ uint64_t _sz; memset(&_sz, 0, sizeof(uint64_t));
5957	5957	{
5958		- OcSize(&_z, &*level);
	5958	+ OcSize(&_sz, &*level);
5959	5959	}
5960	5960	{
5961		- uint64_t _1 = _x;
	5961	+ uint64_t _1 = _sx;
5962	5962	uint64_t *x = &_1;
5963	5963	while((*x)--)
5964	5964	{
5965	5965	{
5966		- uint64_t _2 = _y;
	5966	+ uint64_t _2 = _sy;
5967	5967	uint64_t *y = &_2;
5968	5968	while((*y)--)
5969	5969	{
5970	5970	{
5971		- uint64_t _3 = _z;
	5971	+ uint64_t _3 = _sz;
5972	5972	uint64_t *z = &_3;
5973	5973	while((*z)--)
5974	5974	{

		@@ -6035,9 +6035,9 @@
6035	6035	}
6036	6036	}
6037	6037	}
6038		- _IGNORE_(_z);
6039		- _IGNORE_(_y);
6040		- _IGNORE_(_x);
	6038	+ _IGNORE_(_sz);
	6039	+ _IGNORE_(_sy);
	6040	+ _IGNORE_(_sx);
6041	6041	}
6042	6042	}
6043	6043

--- trunk/pragmatic/compiler.compiled.c (revision 410)

+++ trunk/pragmatic/compiler.compiled.c (revision 411)

		@@ -25303,943 +25303,955 @@
25303	25303	break;
25304	25304	}
25305	25305	}
25306		- struct stack/nonempty_string/ _to; memset(&_to, 0, sizeof(struct stack/nonempty_string/));
25307	25306	{
25308		- ParseIdOrGap$(&_to, &streams, &txtpos, &*level);
25309		- }
25310		- {
25311		- struct nonempty_string _8; memset(&_8, 0, sizeof(struct nonempty_string));
25312		- const struct stack/nonempty_string/ *_9 = &(_to);
25313		- if(!(*_9).size)
25314		- {
25315		- {
25316		- GenVar$(&_8, &*tmpnr);
25317		- }
	25307	+ struct qtypepureid _8; memset(&_8, 0, sizeof(struct qtypepureid));
	25308	+ qtypepureid$copy(&_8, &(*container));
	25309	+ struct qtypepureid *container = &_8;
	25310	+ /idpath ip/ {
	25311	+ struct idpath _9; memset(&_9, 0, sizeof(struct idpath));
	25312	+ struct stack/structdef/ _10 = &(state).structs;
	25313	+ ParsePath$(&_9, &streams, &txtpos, &level, &sp, &_10, &tmpnr, &*container);
	25314	+ idpath$dest(&_9);
25318	25315	}
25319		- else
	25316	+ struct stack/nonempty_string/ _to; memset(&_to, 0, sizeof(struct stack/nonempty_string/));
25320	25317	{
25321		- const struct nonempty_string to = (_9).data;
25322		- nonempty_string$copy(&_8, &(*to));
	25318	+ ParseIdOrGap$(&_to, &streams, &txtpos, &*level);
25323	25319	}
25324		- const struct nonempty_string *id = &_8;
25325		- struct type_pure _containertype; memset(&_containertype, 0, sizeof(struct type_pure));
25326		- type_pure$copy(&_containertype, &(*container).qt.type);
25327		- const struct type_pure *_10 = &(_containertype);
25328		- switch((*_10).type)
25329	25320	{
25330		- case 0: // struct stack/type_pure_normal/ type_pure_normal:
	25321	+ struct nonempty_string _9; memset(&_9, 0, sizeof(struct nonempty_string));
	25322	+ const struct stack/nonempty_string/ *_10 = &(_to);
	25323	+ if(!(*_10).size)
25331	25324	{
25332		- const struct type_pure_normal containertype = ((_10).type_pure_normal).data;
25333	25325	{
25334		- bool _13;
	25326	+ GenVar$(&_9, &*tmpnr);
	25327	+ }
	25328	+ }
	25329	+ else
	25330	+ {
	25331	+ const struct nonempty_string to = (_10).data;
	25332	+ nonempty_string$copy(&_9, &(*to));
	25333	+ }
	25334	+ const struct nonempty_string *id = &_9;
	25335	+ struct type_pure _containertype; memset(&_containertype, 0, sizeof(struct type_pure));
	25336	+ type_pure$copy(&_containertype, &(*container).qt.type);
	25337	+ const struct type_pure *_11 = &(_containertype);
	25338	+ switch((*_11).type)
	25339	+ {
	25340	+ case 0: // struct stack/type_pure_normal/ type_pure_normal:
	25341	+ {
	25342	+ const struct type_pure_normal containertype = ((_11).type_pure_normal).data;
25335	25343	{
25336		- const struct type_pure_prim _14 = &(containertype).prim;
25337		- ispurestructprim(&_13, &*_14);
25338		- }
25339		- if(_13)
25340		- {
25341		- bool _15;
	25344	+ bool _14;
25342	25345	{
25343		- bool _16; memset(&_16, 0, sizeof(bool));
	25346	+ const struct type_pure_prim _15 = &(containertype).prim;
	25347	+ ispurestructprim(&_14, &*_15);
	25348	+ }
	25349	+ if(_14)
	25350	+ {
	25351	+ bool _16;
25344	25352	{
25345		- struct string _17; memset(&_17, 0, sizeof(struct string));
25346		- init$fromliteral(&_17, "StreamIn", 8);
25347		- struct string _18; memset(&_18, 0, sizeof(struct string));
	25353	+ bool _17; memset(&_17, 0, sizeof(bool));
25348	25354	{
25349		- const struct nonempty_string _19 = &(containertype).prim.name;
25350		- nonempty_to_string(&_18, &*_19);
	25355	+ struct string _18; memset(&_18, 0, sizeof(struct string));
	25356	+ init$fromliteral(&_18, "StreamIn", 8);
	25357	+ struct string _19; memset(&_19, 0, sizeof(struct string));
	25358	+ {
	25359	+ const struct nonempty_string _20 = &(containertype).prim.name;
	25360	+ nonempty_to_string(&_19, &*_20);
	25361	+ }
	25362	+ strequ(&_17, &_18, &_19);
	25363	+ string$dest(&_19);
	25364	+ string$dest(&_18);
25351	25365	}
25352		- strequ(&_16, &_17, &_18);
25353		- string$dest(&_18);
25354		- string$dest(&_17);
	25366	+ not(&_16, &_17);
	25367	+ _IGNORE_(_17);
25355	25368	}
25356		- not(&_15, &_16);
25357		- _IGNORE_(_16);
25358		- }
25359		- if(_15)
25360		- {
	25369	+ if(_16)
25361	25370	{
25362		- const struct StreamOut _17 = &(streams).err;
25363		- struct string _18; memset(&_18, 0, sizeof(struct string));
25364		- init$fromliteral(&_18, "can't iterate over struct ", 26);
25365		- PutStr(0 /* _16 /, &_17, &_18);
25366		- string$dest(&_18);
	25371	+ {
	25372	+ const struct StreamOut _18 = &(streams).err;
	25373	+ struct string _19; memset(&_19, 0, sizeof(struct string));
	25374	+ init$fromliteral(&_19, "can't iterate over struct ", 26);
	25375	+ PutStr(0 /* _17 /, &_18, &_19);
	25376	+ string$dest(&_19);
	25377	+ }
	25378	+ {
	25379	+ const struct StreamOut _19 = &(streams).err;
	25380	+ const struct type_pure_prim _20 = &(containertype).prim;
	25381	+ EPrTypePurePrim(0 /* _18 /, &_19, &*_20);
	25382	+ }
	25383	+ {
	25384	+ const struct StreamOut _20 = &(streams).err;
	25385	+ Fail$(0 /* _19 /, &_20, &*txtpos);
	25386	+ }
25367	25387	}
	25388	+ else
25368	25389	{
25369		- const struct StreamOut _18 = &(streams).err;
25370		- const struct type_pure_prim _19 = &(containertype).prim;
25371		- EPrTypePurePrim(0 /* _17 /, &_18, &*_19);
	25390	+ {
	25391	+ struct nonempty_string _18; memset(&_18, 0, sizeof(struct nonempty_string));
	25392	+ {
	25393	+ uint8_t _19; memset(&_19, 0, sizeof(uint8_t));
	25394	+ _19 = 95;
	25395	+ struct string _20; memset(&_20, 0, sizeof(struct string));
	25396	+ {
	25397	+ nonempty_to_string(&_20, &*id);
	25398	+ }
	25399	+ nonempty_string(&_18, &_19, &_20);
	25400	+ string$dest(&_20);
	25401	+ _IGNORE_(_19);
	25402	+ }
	25403	+ ParseForBlockStream$(0 /* _17 /, &streams, &txtpos, &state, &level, &sp, &tmpnr, &totality, &action, &self, &reduced_ids, &container, &_18);
	25404	+ nonempty_string$dest(&_18);
	25405	+ }
25372	25406	}
25373		- {
25374		- const struct StreamOut _19 = &(streams).err;
25375		- Fail$(0 /* _18 /, &_19, &*txtpos);
25376		- }
25377	25407	}
25378	25408	else
25379	25409	{
25380	25410	{
25381		- struct nonempty_string _17; memset(&_17, 0, sizeof(struct nonempty_string));
	25411	+ struct type_pure _16; memset(&_16, 0, sizeof(struct type_pure));
25382	25412	{
25383		- uint8_t _18; memset(&_18, 0, sizeof(uint8_t));
25384		- _18 = 95;
25385		- struct string _19; memset(&_19, 0, sizeof(struct string));
25386		- {
25387		- nonempty_to_string(&_19, &*id);
25388		- }
25389		- nonempty_string(&_17, &_18, &_19);
25390		- string$dest(&_19);
25391		- _IGNORE_(_18);
	25413	+ const struct type_pure_prim _17 = &(containertype).prim;
	25414	+ type_pure_normal(&_16, &*_17);
25392	25415	}
25393		- ParseForBlockStream$(0 /* _16 /, &streams, &txtpos, &state, &level, &sp, &tmpnr, &totality, &action, &self, &reduced_ids, &container, &_17);
25394		- nonempty_string$dest(&_17);
	25416	+ struct string _17; memset(&_17, 0, sizeof(struct string));
	25417	+ {
	25418	+ nonempty_to_string(&_17, &*id);
	25419	+ }
	25420	+ ParseForBlock$(0 /* _15 /, &streams, &txtpos, &state, &level, &sp, &tmpnr, &totality, &action, &self, &reduced_ids, &_16, &container, &_17);
	25421	+ string$dest(&_17);
	25422	+ type_pure$dest(&_16);
25395	25423	}
25396	25424	}
25397	25425	}
25398		- else
	25426	+ break;
	25427	+ }
	25428	+ case 1: // struct stack/type_pure_wrapped/ type_pure_wrapped:
	25429	+ {
	25430	+ const struct type_pure_wrapped containertype = ((_11).type_pure_wrapped).data;
25399	25431	{
	25432	+ struct qtypepureid _const_container; memset(&_const_container, 0, sizeof(struct qtypepureid));
25400	25433	{
25401		- struct type_pure _15; memset(&_15, 0, sizeof(struct type_pure));
	25434	+ struct qtypepure _14; memset(&_14, 0, sizeof(struct qtypepure));
25402	25435	{
25403		- const struct type_pure_prim _16 = &(containertype).prim;
25404		- type_pure_normal(&_15, &*_16);
	25436	+ struct type_pure _15; memset(&_15, 0, sizeof(struct type_pure));
	25437	+ {
	25438	+ const struct container_type _16 = &(containertype).which;
	25439	+ const struct type_pure_prim _17 = &(containertype).subtype;
	25440	+ type_pure_wrapped(&_15, &_16, &_17);
	25441	+ }
	25442	+ constqtp(&_14, &_15);
	25443	+ type_pure$dest(&_15);
25405	25444	}
25406		- struct string _16; memset(&_16, 0, sizeof(struct string));
	25445	+ struct nonempty_string _15; memset(&_15, 0, sizeof(struct nonempty_string));
25407	25446	{
25408		- nonempty_to_string(&_16, &*id);
	25447	+ uint8_t _16; memset(&_16, 0, sizeof(uint8_t));
	25448	+ _16 = 42;
	25449	+ struct string _17; memset(&_17, 0, sizeof(struct string));
	25450	+ {
	25451	+ struct nonempty_string _18; memset(&_18, 0, sizeof(struct nonempty_string));
	25452	+ {
	25453	+ GenVar$(&_18, &*tmpnr);
	25454	+ }
	25455	+ nonempty_to_string(&_17, &_18);
	25456	+ nonempty_string$dest(&_18);
	25457	+ }
	25458	+ nonempty_string(&_15, &_16, &_17);
	25459	+ string$dest(&_17);
	25460	+ _IGNORE_(_16);
25409	25461	}
25410		- ParseForBlock$(0 /* _14 /, &streams, &txtpos, &state, &level, &sp, &tmpnr, &totality, &action, &self, &reduced_ids, &_15, &container, &_16);
25411		- string$dest(&_16);
25412		- type_pure$dest(&_15);
	25462	+ qtypepureid(&_const_container, &_14, &_15);
	25463	+ nonempty_string$dest(&_15);
	25464	+ qtypepure$dest(&_14);
25413	25465	}
25414		- }
25415		- }
25416		- break;
25417		- }
25418		- case 1: // struct stack/type_pure_wrapped/ type_pure_wrapped:
25419		- {
25420		- const struct type_pure_wrapped containertype = ((_10).type_pure_wrapped).data;
25421		- {
25422		- struct qtypepureid _const_container; memset(&_const_container, 0, sizeof(struct qtypepureid));
25423		- {
25424		- struct qtypepure _13; memset(&_13, 0, sizeof(struct qtypepure));
25425	25466	{
25426		- struct type_pure _14; memset(&_14, 0, sizeof(struct type_pure));
25427		- {
25428		- const struct container_type _15 = &(containertype).which;
25429		- const struct type_pure_prim _16 = &(containertype).subtype;
25430		- type_pure_wrapped(&_14, &_15, &_16);
25431		- }
25432		- constqtp(&_13, &_14);
25433		- type_pure$dest(&_14);
	25467	+ const struct StreamOut _15 = &(streams).out;
	25468	+ Indent(0 /* _14 /, &_15, &*level);
25434	25469	}
25435		- struct nonempty_string _14; memset(&_14, 0, sizeof(struct nonempty_string));
25436	25470	{
25437		- uint8_t _15; memset(&_15, 0, sizeof(uint8_t));
25438		- _15 = 42;
25439		- struct string _16; memset(&_16, 0, sizeof(struct string));
	25471	+ const struct StreamOut _16 = &(streams).out;
	25472	+ EmitQTPI(0 /* _15 /, &_16, &_const_container);
	25473	+ }
	25474	+ {
	25475	+ const struct StreamOut _17 = &(streams).out;
	25476	+ struct string _18; memset(&_18, 0, sizeof(struct string));
	25477	+ init$fromliteral(&_18, " = &(", 5);
	25478	+ PutStr(0 /* _16 /, &_17, &_18);
	25479	+ string$dest(&_18);
	25480	+ }
	25481	+ {
	25482	+ const struct StreamOut _18 = &(streams).out;
	25483	+ struct string _19; memset(&_19, 0, sizeof(struct string));
25440	25484	{
25441		- struct nonempty_string _17; memset(&_17, 0, sizeof(struct nonempty_string));
25442		- {
25443		- GenVar$(&_17, &*tmpnr);
25444		- }
25445		- nonempty_to_string(&_16, &_17);
25446		- nonempty_string$dest(&_17);
	25485	+ struct nonempty_string _20 = &(container).id;
	25486	+ nonempty_to_string(&_19, &*_20);
25447	25487	}
25448		- nonempty_string(&_14, &_15, &_16);
25449		- string$dest(&_16);
25450		- _IGNORE_(_15);
	25488	+ PutStr(0 /* _17 /, &_18, &_19);
	25489	+ string$dest(&_19);
25451	25490	}
25452		- qtypepureid(&_const_container, &_13, &_14);
25453		- nonempty_string$dest(&_14);
25454		- qtypepure$dest(&_13);
25455		- }
25456		- {
25457		- const struct StreamOut _14 = &(streams).out;
25458		- Indent(0 /* _13 /, &_14, &*level);
25459		- }
25460		- {
25461		- const struct StreamOut _15 = &(streams).out;
25462		- EmitQTPI(0 /* _14 /, &_15, &_const_container);
25463		- }
25464		- {
25465		- const struct StreamOut _16 = &(streams).out;
25466		- struct string _17; memset(&_17, 0, sizeof(struct string));
25467		- init$fromliteral(&_17, " = &(", 5);
25468		- PutStr(0 /* _15 /, &_16, &_17);
25469		- string$dest(&_17);
25470		- }
25471		- {
25472		- const struct StreamOut _17 = &(streams).out;
25473		- struct string _18; memset(&_18, 0, sizeof(struct string));
25474	25491	{
25475		- const struct nonempty_string _19 = &(container).id;
25476		- nonempty_to_string(&_18, &*_19);
	25492	+ const struct StreamOut _19 = &(streams).out;
	25493	+ struct string _20; memset(&_20, 0, sizeof(struct string));
	25494	+ init$fromliteral(&_20, ");", 2);
	25495	+ PutStrLn(0 /* _18 /, &_19, &_20);
	25496	+ string$dest(&_20);
25477	25497	}
25478		- PutStr(0 /* _16 /, &_17, &_18);
25479		- string$dest(&_18);
25480		- }
25481		- {
25482		- const struct StreamOut _18 = &(streams).out;
25483		- struct string _19; memset(&_19, 0, sizeof(struct string));
25484		- init$fromliteral(&_19, ");", 2);
25485		- PutStrLn(0 /* _17 /, &_18, &_19);
25486		- string$dest(&_19);
25487		- }
25488		- struct container_type _aw; memset(&_aw, 0, sizeof(struct container_type));
25489		- container_type$copy(&_aw, &(*containertype).which);
25490		- const struct container_type *_18 = &(_aw);
25491		- switch((*_18).type)
25492		- {
25493		- case 0: // void container_stack:
	25498	+ struct container_type _aw; memset(&_aw, 0, sizeof(struct container_type));
	25499	+ container_type$copy(&_aw, &(*containertype).which);
	25500	+ const struct container_type *_19 = &(_aw);
	25501	+ switch((*_19).type)
25494	25502	{
	25503	+ case 0: // void container_stack:
25495	25504	{
25496		- struct nonempty_string _counter; memset(&_counter, 0, sizeof(struct nonempty_string));
25497	25505	{
25498		- GenVar$(&_counter, &*tmpnr);
25499		- }
25500		- {
25501		- const struct StreamOut _21 = &(streams).out;
25502		- Indent(0 /* _20 /, &_21, &*level);
25503		- }
25504		- {
25505		- const struct StreamOut _22 = &(streams).out;
25506		- struct string _23; memset(&_23, 0, sizeof(struct string));
25507		- init$fromliteral(&_23, "for(", 4);
25508		- PutStr(0 /* _21 /, &_22, &_23);
25509		- string$dest(&_23);
25510		- }
25511		- {
25512		- const struct StreamOut _23 = &(streams).out;
25513		- struct type_pure _24; memset(&_24, 0, sizeof(struct type_pure));
	25506	+ struct nonempty_string _counter; memset(&_counter, 0, sizeof(struct nonempty_string));
25514	25507	{
25515		- struct nonempty_string _25; memset(&_25, 0, sizeof(struct nonempty_string));
25516		- {
25517		- uint8_t _26; memset(&_26, 0, sizeof(uint8_t));
25518		- _26 = 117;
25519		- struct string _27; memset(&_27, 0, sizeof(struct string));
25520		- init$fromliteral(&_27, "64", 2);
25521		- nonempty_string(&_25, &_26, &_27);
25522		- string$dest(&_27);
25523		- _IGNORE_(_26);
25524		- }
25525		- type_pure_normal2(&_24, &_25);
25526		- nonempty_string$dest(&_25);
	25508	+ GenVar$(&_counter, &*tmpnr);
25527	25509	}
25528		- PrTypePure(0 /* _22 /, &_23, &_24);
25529		- type_pure$dest(&_24);
25530		- }
25531		- {
25532		- const struct StreamOut _24 = &(streams).out;
25533		- struct string _25; memset(&_25, 0, sizeof(struct string));
25534		- init$fromliteral(&_25, " ", 1);
25535		- PutStr(0 /* _23 /, &_24, &_25);
25536		- string$dest(&_25);
25537		- }
25538		- {
25539		- const struct StreamOut _25 = &(streams).out;
25540		- struct string _26; memset(&_26, 0, sizeof(struct string));
25541	25510	{
25542		- nonempty_to_string(&_26, &_counter);
	25511	+ const struct StreamOut _22 = &(streams).out;
	25512	+ Indent(0 /* _21 /, &_22, &*level);
25543	25513	}
25544		- PutStr(0 /* _24 /, &_25, &_26);
25545		- string$dest(&_26);
25546		- }
25547		- {
25548		- const struct StreamOut _26 = &(streams).out;
25549		- struct string _27; memset(&_27, 0, sizeof(struct string));
25550		- init$fromliteral(&_27, " = 0; ", 6);
25551		- PutStr(0 /* _25 /, &_26, &_27);
25552		- string$dest(&_27);
25553		- }
25554		- {
25555		- const struct StreamOut _27 = &(streams).out;
25556		- struct string _28; memset(&_28, 0, sizeof(struct string));
25557	25514	{
25558		- nonempty_to_string(&_28, &_counter);
	25515	+ const struct StreamOut _23 = &(streams).out;
	25516	+ struct string _24; memset(&_24, 0, sizeof(struct string));
	25517	+ init$fromliteral(&_24, "for(", 4);
	25518	+ PutStr(0 /* _22 /, &_23, &_24);
	25519	+ string$dest(&_24);
25559	25520	}
25560		- PutStr(0 /* _26 /, &_27, &_28);
25561		- string$dest(&_28);
25562		- }
25563		- {
25564		- const struct StreamOut _28 = &(streams).out;
25565		- struct string _29; memset(&_29, 0, sizeof(struct string));
25566		- init$fromliteral(&_29, " < (", 4);
25567		- PutStr(0 /* _27 /, &_28, &_29);
25568		- string$dest(&_29);
25569		- }
25570		- {
25571		- const struct StreamOut _29 = &(streams).out;
25572		- struct string _30; memset(&_30, 0, sizeof(struct string));
25573	25521	{
25574		- const struct nonempty_string *_31 = &(_const_container).id;
25575		- nonempty_to_string(&_30, &*_31);
25576		- }
25577		- PutStr(0 /* _28 /, &_29, &_30);
25578		- string$dest(&_30);
25579		- }
25580		- {
25581		- const struct StreamOut _30 = &(streams).out;
25582		- struct string _31; memset(&_31, 0, sizeof(struct string));
25583		- init$fromliteral(&_31, ").fill; ++", 10);
25584		- PutStr(0 /* _29 /, &_30, &_31);
25585		- string$dest(&_31);
25586		- }
25587		- {
25588		- const struct StreamOut _31 = &(streams).out;
25589		- struct string _32; memset(&_32, 0, sizeof(struct string));
25590		- {
25591		- nonempty_to_string(&_32, &_counter);
25592		- }
25593		- PutStr(0 /* _30 /, &_31, &_32);
25594		- string$dest(&_32);
25595		- }
25596		- {
25597		- const struct StreamOut _32 = &(streams).out;
25598		- struct string _33; memset(&_33, 0, sizeof(struct string));
25599		- init$fromliteral(&_33, ")", 1);
25600		- PutStrLn(0 /* _31 /, &_32, &_33);
25601		- string$dest(&_33);
25602		- }
25603		- {
25604		- uint8_t _33; memset(&_33, 0, sizeof(uint8_t));
25605		- _33 = 123;
25606		- AssertGet$(0 /* _32 /, &streams, &txtpos, &level, &_33);
25607		- _IGNORE_(_33);
25608		- }
25609		- {
25610		- const struct StreamOut _34 = &(streams).out;
25611		- Indent(0 /* _33 /, &_34, &*level);
25612		- }
25613		- {
25614		- const struct StreamOut _35 = &(streams).out;
25615		- struct string _36; memset(&_36, 0, sizeof(struct string));
25616		- init$fromliteral(&_36, "{", 1);
25617		- PutStrLn(0 /* _34 /, &_35, &_36);
25618		- string$dest(&_36);
25619		- }
25620		- {
25621		- {
25622		- scope_open(0 /* _36 /, &sp);
25623		- }
25624		- struct qtypepureid _mut_elem; memset(&_mut_elem, 0, sizeof(struct qtypepureid));
25625		- {
25626		- struct qtypepure _37; memset(&_37, 0, sizeof(struct qtypepure));
	25522	+ const struct StreamOut _24 = &(streams).out;
	25523	+ struct type_pure _25; memset(&_25, 0, sizeof(struct type_pure));
25627	25524	{
25628		- const struct type_mode _38 = &(container).qt.qualifier;
25629		- struct type_pure _39; memset(&_39, 0, sizeof(struct type_pure));
	25525	+ struct nonempty_string _26; memset(&_26, 0, sizeof(struct nonempty_string));
25630	25526	{
25631		- const struct type_pure_prim _40 = &(containertype).subtype;
25632		- type_pure_normal(&_39, &*_40);
	25527	+ uint8_t _27; memset(&_27, 0, sizeof(uint8_t));
	25528	+ _27 = 117;
	25529	+ struct string _28; memset(&_28, 0, sizeof(struct string));
	25530	+ init$fromliteral(&_28, "64", 2);
	25531	+ nonempty_string(&_26, &_27, &_28);
	25532	+ string$dest(&_28);
	25533	+ _IGNORE_(_27);
25633	25534	}
25634		- qtypepure(&_37, &*_38, &_39);
25635		- type_pure$dest(&_39);
	25535	+ type_pure_normal2(&_25, &_26);
	25536	+ nonempty_string$dest(&_26);
25636	25537	}
25637		- struct nonempty_string _38; memset(&_38, 0, sizeof(struct nonempty_string));
25638		- {
25639		- uint8_t _39; memset(&_39, 0, sizeof(uint8_t));
25640		- _39 = 42;
25641		- struct string _40; memset(&_40, 0, sizeof(struct string));
25642		- {
25643		- nonempty_to_string(&_40, &*id);
25644		- }
25645		- nonempty_string(&_38, &_39, &_40);
25646		- string$dest(&_40);
25647		- _IGNORE_(_39);
25648		- }
25649		- qtypepureid(&_mut_elem, &_37, &_38);
25650		- nonempty_string$dest(&_38);
25651		- qtypepure$dest(&_37);
	25538	+ PrTypePure(0 /* _23 /, &_24, &_25);
	25539	+ type_pure$dest(&_25);
25652	25540	}
25653	25541	{
25654		- const struct StreamOut _38 = &(streams).out;
25655		- uint64_t _39; memset(&_39, 0, sizeof(uint64_t));
	25542	+ const struct StreamOut _25 = &(streams).out;
	25543	+ struct string _26; memset(&_26, 0, sizeof(struct string));
	25544	+ init$fromliteral(&_26, " ", 1);
	25545	+ PutStr(0 /* _24 /, &_25, &_26);
	25546	+ string$dest(&_26);
	25547	+ }
	25548	+ {
	25549	+ const struct StreamOut _26 = &(streams).out;
	25550	+ struct string _27; memset(&_27, 0, sizeof(struct string));
25656	25551	{
25657		- uint64_t _40; memset(&_40, 0, sizeof(uint64_t));
25658		- _40 = 1;
25659		- _39 = *level + _40;
25660		- _IGNORE_(_40);
	25552	+ nonempty_to_string(&_27, &_counter);
25661	25553	}
25662		- Indent(0 /* _37 /, &_38, &_39);
25663		- _IGNORE_(_39);
	25554	+ PutStr(0 /* _25 /, &_26, &_27);
	25555	+ string$dest(&_27);
25664	25556	}
25665	25557	{
25666		- const struct StreamOut _39 = &(streams).out;
25667		- EmitQTPI(0 /* _38 /, &_39, &_mut_elem);
	25558	+ const struct StreamOut _27 = &(streams).out;
	25559	+ struct string _28; memset(&_28, 0, sizeof(struct string));
	25560	+ init$fromliteral(&_28, " = 0; ", 6);
	25561	+ PutStr(0 /* _26 /, &_27, &_28);
	25562	+ string$dest(&_28);
25668	25563	}
25669	25564	{
25670		- const struct StreamOut _40 = &(streams).out;
25671		- struct string _41; memset(&_41, 0, sizeof(struct string));
25672		- init$fromliteral(&_41, " = &((", 6);
25673		- PutStr(0 /* _39 /, &_40, &_41);
25674		- string$dest(&_41);
	25565	+ const struct StreamOut _28 = &(streams).out;
	25566	+ struct string _29; memset(&_29, 0, sizeof(struct string));
	25567	+ {
	25568	+ nonempty_to_string(&_29, &_counter);
	25569	+ }
	25570	+ PutStr(0 /* _27 /, &_28, &_29);
	25571	+ string$dest(&_29);
25675	25572	}
25676	25573	{
25677		- const struct StreamOut _41 = &(streams).out;
25678		- const struct type_pure *_42 = &(_mut_elem).qt.type;
25679		- PrTypePure(0 /* _40 /, &_41, &*_42);
	25574	+ const struct StreamOut _29 = &(streams).out;
	25575	+ struct string _30; memset(&_30, 0, sizeof(struct string));
	25576	+ init$fromliteral(&_30, " < (", 4);
	25577	+ PutStr(0 /* _28 /, &_29, &_30);
	25578	+ string$dest(&_30);
25680	25579	}
25681	25580	{
25682		- const struct StreamOut _42 = &(streams).out;
25683		- struct string _43; memset(&_43, 0, sizeof(struct string));
25684		- init$fromliteral(&_43, " *)((", 5);
25685		- PutStr(0 /* _41 /, &_42, &_43);
25686		- string$dest(&_43);
25687		- }
25688		- {
25689		- const struct StreamOut _43 = &(streams).out;
25690		- struct string _44; memset(&_44, 0, sizeof(struct string));
	25581	+ const struct StreamOut _30 = &(streams).out;
	25582	+ struct string _31; memset(&_31, 0, sizeof(struct string));
25691	25583	{
25692		- const struct nonempty_string *_45 = &(_const_container).id;
25693		- nonempty_to_string(&_44, &*_45);
	25584	+ const struct nonempty_string *_32 = &(_const_container).id;
	25585	+ nonempty_to_string(&_31, &*_32);
25694	25586	}
25695		- PutStr(0 /* _42 /, &_43, &_44);
25696		- string$dest(&_44);
	25587	+ PutStr(0 /* _29 /, &_30, &_31);
	25588	+ string$dest(&_31);
25697	25589	}
25698	25590	{
25699		- const struct StreamOut _44 = &(streams).out;
25700		- struct string _45; memset(&_45, 0, sizeof(struct string));
25701		- init$fromliteral(&_45, ").data))[", 9);
25702		- PutStr(0 /* _43 /, &_44, &_45);
25703		- string$dest(&_45);
	25591	+ const struct StreamOut _31 = &(streams).out;
	25592	+ struct string _32; memset(&_32, 0, sizeof(struct string));
	25593	+ init$fromliteral(&_32, ").fill; ++", 10);
	25594	+ PutStr(0 /* _30 /, &_31, &_32);
	25595	+ string$dest(&_32);
25704	25596	}
25705	25597	{
25706		- const struct StreamOut _45 = &(streams).out;
25707		- struct string _46; memset(&_46, 0, sizeof(struct string));
	25598	+ const struct StreamOut _32 = &(streams).out;
	25599	+ struct string _33; memset(&_33, 0, sizeof(struct string));
25708	25600	{
25709		- nonempty_to_string(&_46, &_counter);
	25601	+ nonempty_to_string(&_33, &_counter);
25710	25602	}
25711		- PutStr(0 /* _44 /, &_45, &_46);
25712		- string$dest(&_46);
	25603	+ PutStr(0 /* _31 /, &_32, &_33);
	25604	+ string$dest(&_33);
25713	25605	}
25714	25606	{
25715		- const struct StreamOut _46 = &(streams).out;
25716		- struct string _47; memset(&_47, 0, sizeof(struct string));
25717		- init$fromliteral(&_47, "];", 2);
25718		- PutStrLn(0 /* _45 /, &_46, &_47);
25719		- string$dest(&_47);
	25607	+ const struct StreamOut _33 = &(streams).out;
	25608	+ struct string _34; memset(&_34, 0, sizeof(struct string));
	25609	+ init$fromliteral(&_34, ")", 1);
	25610	+ PutStrLn(0 /* _32 /, &_33, &_34);
	25611	+ string$dest(&_34);
25720	25612	}
25721	25613	{
25722		- struct stack/var/ _47 = &(sp).current.elems;
25723		- struct var _48; memset(&_48, 0, sizeof(struct var));
25724		- {
25725		- varinit(&_48, &_mut_elem);
25726		- }
25727		- push(0 /* _46 /, &_47, &_48, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 5104);
25728		- var$dest(&_48);
	25614	+ uint8_t _34; memset(&_34, 0, sizeof(uint8_t));
	25615	+ _34 = 123;
	25616	+ AssertGet$(0 /* _33 /, &streams, &txtpos, &level, &_34);
	25617	+ _IGNORE_(_34);
25729	25618	}
25730	25619	{
25731		- uint64_t _48; memset(&_48, 0, sizeof(uint64_t));
	25620	+ const struct StreamOut _35 = &(streams).out;
	25621	+ Indent(0 /* _34 /, &_35, &*level);
	25622	+ }
	25623	+ {
	25624	+ const struct StreamOut _36 = &(streams).out;
	25625	+ struct string _37; memset(&_37, 0, sizeof(struct string));
	25626	+ init$fromliteral(&_37, "{", 1);
	25627	+ PutStrLn(0 /* _35 /, &_36, &_37);
	25628	+ string$dest(&_37);
	25629	+ }
	25630	+ {
25732	25631	{
25733		- uint64_t _49; memset(&_49, 0, sizeof(uint64_t));
25734		- _49 = 1;
25735		- _48 = *level + _49;
25736		- _IGNORE_(_49);
	25632	+ scope_open(0 /* _37 /, &sp);
25737	25633	}
25738		- struct stack/qtypepureid/ _49; memset(&_49, 0, sizeof(struct stack/qtypepureid/));
	25634	+ struct qtypepureid _mut_elem; memset(&_mut_elem, 0, sizeof(struct qtypepureid));
25739	25635	{
25740		- empty(&_49, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 5105);
	25636	+ struct qtypepure _38; memset(&_38, 0, sizeof(struct qtypepure));
	25637	+ {
	25638	+ struct type_mode _39 = &(container).qt.qualifier;
	25639	+ struct type_pure _40; memset(&_40, 0, sizeof(struct type_pure));
	25640	+ {
	25641	+ const struct type_pure_prim _41 = &(containertype).subtype;
	25642	+ type_pure_normal(&_40, &*_41);
	25643	+ }
	25644	+ qtypepure(&_38, &*_39, &_40);
	25645	+ type_pure$dest(&_40);
	25646	+ }
	25647	+ struct nonempty_string _39; memset(&_39, 0, sizeof(struct nonempty_string));
	25648	+ {
	25649	+ uint8_t _40; memset(&_40, 0, sizeof(uint8_t));
	25650	+ _40 = 42;
	25651	+ struct string _41; memset(&_41, 0, sizeof(struct string));
	25652	+ {
	25653	+ nonempty_to_string(&_41, &*id);
	25654	+ }
	25655	+ nonempty_string(&_39, &_40, &_41);
	25656	+ string$dest(&_41);
	25657	+ _IGNORE_(_40);
	25658	+ }
	25659	+ qtypepureid(&_mut_elem, &_38, &_39);
	25660	+ nonempty_string$dest(&_39);
	25661	+ qtypepure$dest(&_38);
25741	25662	}
25742		- ParseBlockRaw$(0 /* _47 /, &streams, &txtpos, &state, &_48, &sp, &tmpnr, &_49, &totality, &action, &self, &reduced_ids);
25743		- free$(&_49, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest);
25744		- _IGNORE_(_48);
25745		- }
25746		- bool _49;
25747		- {
25748		- struct stack/var/ _50 = &(sp).current.elems;
25749		- struct string _51; memset(&_51, 0, sizeof(struct string));
25750	25663	{
25751		- uint8_t _52; memset(&_52, 0, sizeof(uint8_t));
25752		- _52 = 42;
25753		- struct string _53; memset(&_53, 0, sizeof(struct string));
	25664	+ const struct StreamOut _39 = &(streams).out;
	25665	+ uint64_t _40; memset(&_40, 0, sizeof(uint64_t));
25754	25666	{
25755		- nonempty_to_string(&_53, &*id);
	25667	+ uint64_t _41; memset(&_41, 0, sizeof(uint64_t));
	25668	+ _41 = 1;
	25669	+ _40 = *level + _41;
	25670	+ _IGNORE_(_41);
25756	25671	}
25757		- preapp(&_51, &_52, &_53);
25758		- string$dest(&_53);
25759		- _IGNORE_(_52);
	25672	+ Indent(0 /* _38 /, &_39, &_40);
	25673	+ _IGNORE_(_40);
25760	25674	}
25761		- find_var_report_unused_and_mark_used(&_49, &*_50, &_51);
25762		- string$dest(&_51);
25763		- }
25764		- if(_49)
25765		- {
25766	25675	{
25767		- const struct StreamOut _51 = &(streams).out;
25768		- uint64_t _52; memset(&_52, 0, sizeof(uint64_t));
	25676	+ const struct StreamOut _40 = &(streams).out;
	25677	+ EmitQTPI(0 /* _39 /, &_40, &_mut_elem);
	25678	+ }
	25679	+ {
	25680	+ const struct StreamOut _41 = &(streams).out;
	25681	+ struct string _42; memset(&_42, 0, sizeof(struct string));
	25682	+ init$fromliteral(&_42, " = &((", 6);
	25683	+ PutStr(0 /* _40 /, &_41, &_42);
	25684	+ string$dest(&_42);
	25685	+ }
	25686	+ {
	25687	+ const struct StreamOut _42 = &(streams).out;
	25688	+ const struct type_pure *_43 = &(_mut_elem).qt.type;
	25689	+ PrTypePure(0 /* _41 /, &_42, &*_43);
	25690	+ }
	25691	+ {
	25692	+ const struct StreamOut _43 = &(streams).out;
	25693	+ struct string _44; memset(&_44, 0, sizeof(struct string));
	25694	+ init$fromliteral(&_44, " *)((", 5);
	25695	+ PutStr(0 /* _42 /, &_43, &_44);
	25696	+ string$dest(&_44);
	25697	+ }
	25698	+ {
	25699	+ const struct StreamOut _44 = &(streams).out;
	25700	+ struct string _45; memset(&_45, 0, sizeof(struct string));
25769	25701	{
25770		- uint64_t _53; memset(&_53, 0, sizeof(uint64_t));
25771		- _53 = 1;
25772		- _52 = *level + _53;
25773		- _IGNORE_(_53);
	25702	+ const struct nonempty_string *_46 = &(_const_container).id;
	25703	+ nonempty_to_string(&_45, &*_46);
25774	25704	}
25775		- Indent(0 /* _50 /, &_51, &_52);
25776		- _IGNORE_(_52);
	25705	+ PutStr(0 /* _43 /, &_44, &_45);
	25706	+ string$dest(&_45);
25777	25707	}
25778	25708	{
25779		- const struct StreamOut _52 = &(streams).out;
25780		- struct string _53; memset(&_53, 0, sizeof(struct string));
25781		- init$fromliteral(&_53, "__SUPPRESS_WARNING_UNUSED_VARIABLE__(&", 38);
25782		- PutStr(0 /* _51 /, &_52, &_53);
25783		- string$dest(&_53);
	25709	+ const struct StreamOut _45 = &(streams).out;
	25710	+ struct string _46; memset(&_46, 0, sizeof(struct string));
	25711	+ init$fromliteral(&_46, ").data))[", 9);
	25712	+ PutStr(0 /* _44 /, &_45, &_46);
	25713	+ string$dest(&_46);
25784	25714	}
25785	25715	{
25786		- const struct StreamOut _53 = &(streams).out;
25787		- struct string _54; memset(&_54, 0, sizeof(struct string));
	25716	+ const struct StreamOut _46 = &(streams).out;
	25717	+ struct string _47; memset(&_47, 0, sizeof(struct string));
25788	25718	{
25789		- const struct nonempty_string *_55 = &(_mut_elem).id;
25790		- nonempty_to_string(&_54, &*_55);
	25719	+ nonempty_to_string(&_47, &_counter);
25791	25720	}
25792		- PutStr(0 /* _52 /, &_53, &_54);
25793		- string$dest(&_54);
	25721	+ PutStr(0 /* _45 /, &_46, &_47);
	25722	+ string$dest(&_47);
25794	25723	}
25795	25724	{
25796		- const struct StreamOut _54 = &(streams).out;
25797		- struct string _55; memset(&_55, 0, sizeof(struct string));
25798		- init$fromliteral(&_55, ");", 2);
25799		- PutStrLn(0 /* _53 /, &_54, &_55);
25800		- string$dest(&_55);
	25725	+ const struct StreamOut _47 = &(streams).out;
	25726	+ struct string _48; memset(&_48, 0, sizeof(struct string));
	25727	+ init$fromliteral(&_48, "];", 2);
	25728	+ PutStrLn(0 /* _46 /, &_47, &_48);
	25729	+ string$dest(&_48);
25801	25730	}
	25731	+ {
	25732	+ struct stack/var/ _48 = &(sp).current.elems;
	25733	+ struct var _49; memset(&_49, 0, sizeof(struct var));
	25734	+ {
	25735	+ varinit(&_49, &_mut_elem);
	25736	+ }
	25737	+ push(0 /* _47 /, &_48, &_49, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 5107);
	25738	+ var$dest(&_49);
	25739	+ }
	25740	+ {
	25741	+ uint64_t _49; memset(&_49, 0, sizeof(uint64_t));
	25742	+ {
	25743	+ uint64_t _50; memset(&_50, 0, sizeof(uint64_t));
	25744	+ _50 = 1;
	25745	+ _49 = *level + _50;
	25746	+ _IGNORE_(_50);
	25747	+ }
	25748	+ struct stack/qtypepureid/ _50; memset(&_50, 0, sizeof(struct stack/qtypepureid/));
	25749	+ {
	25750	+ empty(&_50, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 5108);
	25751	+ }
	25752	+ ParseBlockRaw$(0 /* _48 /, &streams, &txtpos, &state, &_49, &sp, &tmpnr, &_50, &totality, &action, &self, &reduced_ids);
	25753	+ free$(&_50, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest);
	25754	+ _IGNORE_(_49);
	25755	+ }
	25756	+ bool _50;
	25757	+ {
	25758	+ struct stack/var/ _51 = &(sp).current.elems;
	25759	+ struct string _52; memset(&_52, 0, sizeof(struct string));
	25760	+ {
	25761	+ uint8_t _53; memset(&_53, 0, sizeof(uint8_t));
	25762	+ _53 = 42;
	25763	+ struct string _54; memset(&_54, 0, sizeof(struct string));
	25764	+ {
	25765	+ nonempty_to_string(&_54, &*id);
	25766	+ }
	25767	+ preapp(&_52, &_53, &_54);
	25768	+ string$dest(&_54);
	25769	+ _IGNORE_(_53);
	25770	+ }
	25771	+ find_var_report_unused_and_mark_used(&_50, &*_51, &_52);
	25772	+ string$dest(&_52);
	25773	+ }
	25774	+ if(_50)
	25775	+ {
	25776	+ {
	25777	+ const struct StreamOut _52 = &(streams).out;
	25778	+ uint64_t _53; memset(&_53, 0, sizeof(uint64_t));
	25779	+ {
	25780	+ uint64_t _54; memset(&_54, 0, sizeof(uint64_t));
	25781	+ _54 = 1;
	25782	+ _53 = *level + _54;
	25783	+ _IGNORE_(_54);
	25784	+ }
	25785	+ Indent(0 /* _51 /, &_52, &_53);
	25786	+ _IGNORE_(_53);
	25787	+ }
	25788	+ {
	25789	+ const struct StreamOut _53 = &(streams).out;
	25790	+ struct string _54; memset(&_54, 0, sizeof(struct string));
	25791	+ init$fromliteral(&_54, "__SUPPRESS_WARNING_UNUSED_VARIABLE__(&", 38);
	25792	+ PutStr(0 /* _52 /, &_53, &_54);
	25793	+ string$dest(&_54);
	25794	+ }
	25795	+ {
	25796	+ const struct StreamOut _54 = &(streams).out;
	25797	+ struct string _55; memset(&_55, 0, sizeof(struct string));
	25798	+ {
	25799	+ const struct nonempty_string *_56 = &(_mut_elem).id;
	25800	+ nonempty_to_string(&_55, &*_56);
	25801	+ }
	25802	+ PutStr(0 /* _53 /, &_54, &_55);
	25803	+ string$dest(&_55);
	25804	+ }
	25805	+ {
	25806	+ const struct StreamOut _55 = &(streams).out;
	25807	+ struct string _56; memset(&_56, 0, sizeof(struct string));
	25808	+ init$fromliteral(&_56, ");", 2);
	25809	+ PutStrLn(0 /* _54 /, &_55, &_56);
	25810	+ string$dest(&_56);
	25811	+ }
	25812	+ }
	25813	+ {
	25814	+ const struct StreamOut _52 = &(streams).err;
	25815	+ AssertUsedThenCloseScope$(0 /* _51 /, &_52, &txtpos, &sp);
	25816	+ }
	25817	+ qtypepureid$dest(&_mut_elem);
25802	25818	}
25803	25819	{
25804		- const struct StreamOut _51 = &(streams).err;
25805		- AssertUsedThenCloseScope$(0 /* _50 /, &_51, &txtpos, &sp);
	25820	+ uint8_t _38; memset(&_38, 0, sizeof(uint8_t));
	25821	+ _38 = 125;
	25822	+ AssertGet$(0 /* _37 /, &streams, &txtpos, &level, &_38);
	25823	+ _IGNORE_(_38);
25806	25824	}
25807		- qtypepureid$dest(&_mut_elem);
25808		- }
25809		- {
25810		- uint8_t _37; memset(&_37, 0, sizeof(uint8_t));
25811		- _37 = 125;
25812		- AssertGet$(0 /* _36 /, &streams, &txtpos, &level, &_37);
25813		- _IGNORE_(_37);
25814		- }
25815		- {
25816		- const struct StreamOut _38 = &(streams).out;
25817		- Indent(0 /* _37 /, &_38, &*level);
25818		- }
25819		- {
25820		- const struct StreamOut _39 = &(streams).out;
25821		- struct string _40; memset(&_40, 0, sizeof(struct string));
25822		- init$fromliteral(&_40, "}", 1);
25823		- PutStrLn(0 /* _38 /, &_39, &_40);
25824		- string$dest(&_40);
25825		- }
25826		- nonempty_string$dest(&_counter);
25827		- }
25828		- break;
25829		- }
25830		- case 1: // void container_stack_of_mut:
25831		- {
25832		- {
25833		- struct nonempty_string _counter; memset(&_counter, 0, sizeof(struct nonempty_string));
25834		- {
25835		- GenVar$(&_counter, &*tmpnr);
25836		- }
25837		- {
25838		- const struct StreamOut _22 = &(streams).out;
25839		- Indent(0 /* _21 /, &_22, &*level);
25840		- }
25841		- {
25842		- const struct StreamOut _23 = &(streams).out;
25843		- struct string _24; memset(&_24, 0, sizeof(struct string));
25844		- init$fromliteral(&_24, "for(", 4);
25845		- PutStr(0 /* _22 /, &_23, &_24);
25846		- string$dest(&_24);
25847		- }
25848		- {
25849		- const struct StreamOut _24 = &(streams).out;
25850		- struct type_pure _25; memset(&_25, 0, sizeof(struct type_pure));
25851	25825	{
25852		- struct nonempty_string _26; memset(&_26, 0, sizeof(struct nonempty_string));
25853		- {
25854		- uint8_t _27; memset(&_27, 0, sizeof(uint8_t));
25855		- _27 = 117;
25856		- struct string _28; memset(&_28, 0, sizeof(struct string));
25857		- init$fromliteral(&_28, "64", 2);
25858		- nonempty_string(&_26, &_27, &_28);
25859		- string$dest(&_28);
25860		- _IGNORE_(_27);
25861		- }
25862		- type_pure_normal2(&_25, &_26);
25863		- nonempty_string$dest(&_26);
	25826	+ const struct StreamOut _39 = &(streams).out;
	25827	+ Indent(0 /* _38 /, &_39, &*level);
25864	25828	}
25865		- PrTypePure(0 /* _23 /, &_24, &_25);
25866		- type_pure$dest(&_25);
25867		- }
25868		- {
25869		- const struct StreamOut _25 = &(streams).out;
25870		- struct string _26; memset(&_26, 0, sizeof(struct string));
25871		- init$fromliteral(&_26, " ", 1);
25872		- PutStr(0 /* _24 /, &_25, &_26);
25873		- string$dest(&_26);
25874		- }
25875		- {
25876		- const struct StreamOut _26 = &(streams).out;
25877		- struct string _27; memset(&_27, 0, sizeof(struct string));
25878	25829	{
25879		- nonempty_to_string(&_27, &_counter);
	25830	+ const struct StreamOut _40 = &(streams).out;
	25831	+ struct string _41; memset(&_41, 0, sizeof(struct string));
	25832	+ init$fromliteral(&_41, "}", 1);
	25833	+ PutStrLn(0 /* _39 /, &_40, &_41);
	25834	+ string$dest(&_41);
25880	25835	}
25881		- PutStr(0 /* _25 /, &_26, &_27);
25882		- string$dest(&_27);
	25836	+ nonempty_string$dest(&_counter);
25883	25837	}
	25838	+ break;
	25839	+ }
	25840	+ case 1: // void container_stack_of_mut:
	25841	+ {
25884	25842	{
25885		- const struct StreamOut _27 = &(streams).out;
25886		- struct string _28; memset(&_28, 0, sizeof(struct string));
25887		- init$fromliteral(&_28, " = 0; ", 6);
25888		- PutStr(0 /* _26 /, &_27, &_28);
25889		- string$dest(&_28);
25890		- }
25891		- {
25892		- const struct StreamOut _28 = &(streams).out;
25893		- struct string _29; memset(&_29, 0, sizeof(struct string));
	25843	+ struct nonempty_string _counter; memset(&_counter, 0, sizeof(struct nonempty_string));
25894	25844	{
25895		- nonempty_to_string(&_29, &_counter);
	25845	+ GenVar$(&_counter, &*tmpnr);
25896	25846	}
25897		- PutStr(0 /* _27 /, &_28, &_29);
25898		- string$dest(&_29);
25899		- }
25900		- {
25901		- const struct StreamOut _29 = &(streams).out;
25902		- struct string _30; memset(&_30, 0, sizeof(struct string));
25903		- init$fromliteral(&_30, " < (", 4);
25904		- PutStr(0 /* _28 /, &_29, &_30);
25905		- string$dest(&_30);
25906		- }
25907		- {
25908		- const struct StreamOut _30 = &(streams).out;
25909		- struct string _31; memset(&_31, 0, sizeof(struct string));
25910	25847	{
25911		- const struct nonempty_string *_32 = &(_const_container).id;
25912		- nonempty_to_string(&_31, &*_32);
	25848	+ const struct StreamOut _23 = &(streams).out;
	25849	+ Indent(0 /* _22 /, &_23, &*level);
25913	25850	}
25914		- PutStr(0 /* _29 /, &_30, &_31);
25915		- string$dest(&_31);
25916		- }
25917		- {
25918		- const struct StreamOut _31 = &(streams).out;
25919		- struct string _32; memset(&_32, 0, sizeof(struct string));
25920		- init$fromliteral(&_32, ").fill; ++", 10);
25921		- PutStr(0 /* _30 /, &_31, &_32);
25922		- string$dest(&_32);
25923		- }
25924		- {
25925		- const struct StreamOut _32 = &(streams).out;
25926		- struct string _33; memset(&_33, 0, sizeof(struct string));
25927	25851	{
25928		- nonempty_to_string(&_33, &_counter);
	25852	+ const struct StreamOut _24 = &(streams).out;
	25853	+ struct string _25; memset(&_25, 0, sizeof(struct string));
	25854	+ init$fromliteral(&_25, "for(", 4);
	25855	+ PutStr(0 /* _23 /, &_24, &_25);
	25856	+ string$dest(&_25);
25929	25857	}
25930		- PutStr(0 /* _31 /, &_32, &_33);
25931		- string$dest(&_33);
25932		- }
25933		- {
25934		- const struct StreamOut _33 = &(streams).out;
25935		- struct string _34; memset(&_34, 0, sizeof(struct string));
25936		- init$fromliteral(&_34, ")", 1);
25937		- PutStrLn(0 /* _32 /, &_33, &_34);
25938		- string$dest(&_34);
25939		- }
25940		- {
25941		- uint8_t _34; memset(&_34, 0, sizeof(uint8_t));
25942		- _34 = 123;
25943		- AssertGet$(0 /* _33 /, &streams, &txtpos, &level, &_34);
25944		- _IGNORE_(_34);
25945		- }
25946		- {
25947		- const struct StreamOut _35 = &(streams).out;
25948		- Indent(0 /* _34 /, &_35, &*level);
25949		- }
25950		- {
25951		- const struct StreamOut _36 = &(streams).out;
25952		- struct string _37; memset(&_37, 0, sizeof(struct string));
25953		- init$fromliteral(&_37, "{", 1);
25954		- PutStrLn(0 /* _35 /, &_36, &_37);
25955		- string$dest(&_37);
25956		- }
25957		- {
25958	25858	{
25959		- scope_open(0 /* _37 /, &sp);
25960		- }
25961		- struct qtypepureid _mut_elem; memset(&_mut_elem, 0, sizeof(struct qtypepureid));
25962		- {
25963		- struct qtypepure _38; memset(&_38, 0, sizeof(struct qtypepure));
	25859	+ const struct StreamOut _25 = &(streams).out;
	25860	+ struct type_pure _26; memset(&_26, 0, sizeof(struct type_pure));
25964	25861	{
25965		- struct type_pure _39; memset(&_39, 0, sizeof(struct type_pure));
	25862	+ struct nonempty_string _27; memset(&_27, 0, sizeof(struct nonempty_string));
25966	25863	{
25967		- const struct type_pure_prim _40 = &(containertype).subtype;
25968		- type_pure_normal(&_39, &*_40);
	25864	+ uint8_t _28; memset(&_28, 0, sizeof(uint8_t));
	25865	+ _28 = 117;
	25866	+ struct string _29; memset(&_29, 0, sizeof(struct string));
	25867	+ init$fromliteral(&_29, "64", 2);
	25868	+ nonempty_string(&_27, &_28, &_29);
	25869	+ string$dest(&_29);
	25870	+ _IGNORE_(_28);
25969	25871	}
25970		- mutqtp(&_38, &_39);
25971		- type_pure$dest(&_39);
	25872	+ type_pure_normal2(&_26, &_27);
	25873	+ nonempty_string$dest(&_27);
25972	25874	}
25973		- struct nonempty_string _39; memset(&_39, 0, sizeof(struct nonempty_string));
25974		- {
25975		- uint8_t _40; memset(&_40, 0, sizeof(uint8_t));
25976		- _40 = 42;
25977		- struct string _41; memset(&_41, 0, sizeof(struct string));
25978		- {
25979		- nonempty_to_string(&_41, &*id);
25980		- }
25981		- nonempty_string(&_39, &_40, &_41);
25982		- string$dest(&_41);
25983		- _IGNORE_(_40);
25984		- }
25985		- qtypepureid(&_mut_elem, &_38, &_39);
25986		- nonempty_string$dest(&_39);
25987		- qtypepure$dest(&_38);
	25875	+ PrTypePure(0 /* _24 /, &_25, &_26);
	25876	+ type_pure$dest(&_26);
25988	25877	}
25989	25878	{
25990		- const struct StreamOut _39 = &(streams).out;
25991		- uint64_t _40; memset(&_40, 0, sizeof(uint64_t));
	25879	+ const struct StreamOut _26 = &(streams).out;
	25880	+ struct string _27; memset(&_27, 0, sizeof(struct string));
	25881	+ init$fromliteral(&_27, " ", 1);
	25882	+ PutStr(0 /* _25 /, &_26, &_27);
	25883	+ string$dest(&_27);
	25884	+ }
	25885	+ {
	25886	+ const struct StreamOut _27 = &(streams).out;
	25887	+ struct string _28; memset(&_28, 0, sizeof(struct string));
25992	25888	{
25993		- uint64_t _41; memset(&_41, 0, sizeof(uint64_t));
25994		- _41 = 1;
25995		- _40 = *level + _41;
25996		- _IGNORE_(_41);
	25889	+ nonempty_to_string(&_28, &_counter);
25997	25890	}
25998		- Indent(0 /* _38 /, &_39, &_40);
25999		- _IGNORE_(_40);
	25891	+ PutStr(0 /* _26 /, &_27, &_28);
	25892	+ string$dest(&_28);
26000	25893	}
26001	25894	{
26002		- const struct StreamOut _40 = &(streams).out;
26003		- EmitQTPI(0 /* _39 /, &_40, &_mut_elem);
	25895	+ const struct StreamOut _28 = &(streams).out;
	25896	+ struct string _29; memset(&_29, 0, sizeof(struct string));
	25897	+ init$fromliteral(&_29, " = 0; ", 6);
	25898	+ PutStr(0 /* _27 /, &_28, &_29);
	25899	+ string$dest(&_29);
26004	25900	}
26005	25901	{
26006		- const struct StreamOut _41 = &(streams).out;
26007		- struct string _42; memset(&_42, 0, sizeof(struct string));
26008		- init$fromliteral(&_42, " = &((", 6);
26009		- PutStr(0 /* _40 /, &_41, &_42);
26010		- string$dest(&_42);
	25902	+ const struct StreamOut _29 = &(streams).out;
	25903	+ struct string _30; memset(&_30, 0, sizeof(struct string));
	25904	+ {
	25905	+ nonempty_to_string(&_30, &_counter);
	25906	+ }
	25907	+ PutStr(0 /* _28 /, &_29, &_30);
	25908	+ string$dest(&_30);
26011	25909	}
26012	25910	{
26013		- const struct StreamOut _42 = &(streams).out;
26014		- const struct type_pure *_43 = &(_mut_elem).qt.type;
26015		- PrTypePure(0 /* _41 /, &_42, &*_43);
	25911	+ const struct StreamOut _30 = &(streams).out;
	25912	+ struct string _31; memset(&_31, 0, sizeof(struct string));
	25913	+ init$fromliteral(&_31, " < (", 4);
	25914	+ PutStr(0 /* _29 /, &_30, &_31);
	25915	+ string$dest(&_31);
26016	25916	}
26017	25917	{
26018		- const struct StreamOut _43 = &(streams).out;
26019		- struct string _44; memset(&_44, 0, sizeof(struct string));
26020		- init$fromliteral(&_44, " *)((", 5);
26021		- PutStr(0 /* _42 /, &_43, &_44);
26022		- string$dest(&_44);
26023		- }
26024		- {
26025		- const struct StreamOut _44 = &(streams).out;
26026		- struct string _45; memset(&_45, 0, sizeof(struct string));
	25918	+ const struct StreamOut _31 = &(streams).out;
	25919	+ struct string _32; memset(&_32, 0, sizeof(struct string));
26027	25920	{
26028		- const struct nonempty_string *_46 = &(_const_container).id;
26029		- nonempty_to_string(&_45, &*_46);
	25921	+ const struct nonempty_string *_33 = &(_const_container).id;
	25922	+ nonempty_to_string(&_32, &*_33);
26030	25923	}
26031		- PutStr(0 /* _43 /, &_44, &_45);
26032		- string$dest(&_45);
	25924	+ PutStr(0 /* _30 /, &_31, &_32);
	25925	+ string$dest(&_32);
26033	25926	}
26034	25927	{
26035		- const struct StreamOut _45 = &(streams).out;
26036		- struct string _46; memset(&_46, 0, sizeof(struct string));
26037		- init$fromliteral(&_46, ").data))[", 9);
26038		- PutStr(0 /* _44 /, &_45, &_46);
26039		- string$dest(&_46);
	25928	+ const struct StreamOut _32 = &(streams).out;
	25929	+ struct string _33; memset(&_33, 0, sizeof(struct string));
	25930	+ init$fromliteral(&_33, ").fill; ++", 10);
	25931	+ PutStr(0 /* _31 /, &_32, &_33);
	25932	+ string$dest(&_33);
26040	25933	}
26041	25934	{
26042		- const struct StreamOut _46 = &(streams).out;
26043		- struct string _47; memset(&_47, 0, sizeof(struct string));
	25935	+ const struct StreamOut _33 = &(streams).out;
	25936	+ struct string _34; memset(&_34, 0, sizeof(struct string));
26044	25937	{
26045		- nonempty_to_string(&_47, &_counter);
	25938	+ nonempty_to_string(&_34, &_counter);
26046	25939	}
26047		- PutStr(0 /* _45 /, &_46, &_47);
26048		- string$dest(&_47);
	25940	+ PutStr(0 /* _32 /, &_33, &_34);
	25941	+ string$dest(&_34);
26049	25942	}
26050	25943	{
26051		- const struct StreamOut _47 = &(streams).out;
26052		- struct string _48; memset(&_48, 0, sizeof(struct string));
26053		- init$fromliteral(&_48, "];", 2);
26054		- PutStrLn(0 /* _46 /, &_47, &_48);
26055		- string$dest(&_48);
	25944	+ const struct StreamOut _34 = &(streams).out;
	25945	+ struct string _35; memset(&_35, 0, sizeof(struct string));
	25946	+ init$fromliteral(&_35, ")", 1);
	25947	+ PutStrLn(0 /* _33 /, &_34, &_35);
	25948	+ string$dest(&_35);
26056	25949	}
26057	25950	{
26058		- struct stack/var/ _48 = &(sp).current.elems;
26059		- struct var _49; memset(&_49, 0, sizeof(struct var));
26060		- {
26061		- varinit(&_49, &_mut_elem);
26062		- }
26063		- push(0 /* _47 /, &_48, &_49, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 5133);
26064		- var$dest(&_49);
	25951	+ uint8_t _35; memset(&_35, 0, sizeof(uint8_t));
	25952	+ _35 = 123;
	25953	+ AssertGet$(0 /* _34 /, &streams, &txtpos, &level, &_35);
	25954	+ _IGNORE_(_35);
26065	25955	}
26066	25956	{
26067		- uint64_t _49; memset(&_49, 0, sizeof(uint64_t));
	25957	+ const struct StreamOut _36 = &(streams).out;
	25958	+ Indent(0 /* _35 /, &_36, &*level);
	25959	+ }
	25960	+ {
	25961	+ const struct StreamOut _37 = &(streams).out;
	25962	+ struct string _38; memset(&_38, 0, sizeof(struct string));
	25963	+ init$fromliteral(&_38, "{", 1);
	25964	+ PutStrLn(0 /* _36 /, &_37, &_38);
	25965	+ string$dest(&_38);
	25966	+ }
	25967	+ {
26068	25968	{
26069		- uint64_t _50; memset(&_50, 0, sizeof(uint64_t));
26070		- _50 = 1;
26071		- _49 = *level + _50;
26072		- _IGNORE_(_50);
	25969	+ scope_open(0 /* _38 /, &sp);
26073	25970	}
26074		- struct stack/qtypepureid/ _50; memset(&_50, 0, sizeof(struct stack/qtypepureid/));
	25971	+ struct qtypepureid _mut_elem; memset(&_mut_elem, 0, sizeof(struct qtypepureid));
26075	25972	{
26076		- empty(&_50, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 5134);
	25973	+ struct qtypepure _39; memset(&_39, 0, sizeof(struct qtypepure));
	25974	+ {
	25975	+ struct type_pure _40; memset(&_40, 0, sizeof(struct type_pure));
	25976	+ {
	25977	+ const struct type_pure_prim _41 = &(containertype).subtype;
	25978	+ type_pure_normal(&_40, &*_41);
	25979	+ }
	25980	+ mutqtp(&_39, &_40);
	25981	+ type_pure$dest(&_40);
	25982	+ }
	25983	+ struct nonempty_string _40; memset(&_40, 0, sizeof(struct nonempty_string));
	25984	+ {
	25985	+ uint8_t _41; memset(&_41, 0, sizeof(uint8_t));
	25986	+ _41 = 42;
	25987	+ struct string _42; memset(&_42, 0, sizeof(struct string));
	25988	+ {
	25989	+ nonempty_to_string(&_42, &*id);
	25990	+ }
	25991	+ nonempty_string(&_40, &_41, &_42);
	25992	+ string$dest(&_42);
	25993	+ _IGNORE_(_41);
	25994	+ }
	25995	+ qtypepureid(&_mut_elem, &_39, &_40);
	25996	+ nonempty_string$dest(&_40);
	25997	+ qtypepure$dest(&_39);
26077	25998	}
26078		- ParseBlockRaw$(0 /* _48 /, &streams, &txtpos, &state, &_49, &sp, &tmpnr, &_50, &totality, &action, &self, &reduced_ids);
26079		- free$(&_50, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest);
26080		- _IGNORE_(_49);
26081		- }
26082		- bool _50;
26083		- {
26084		- struct stack/var/ _51 = &(sp).current.elems;
26085		- struct string _52; memset(&_52, 0, sizeof(struct string));
26086	25999	{
26087		- uint8_t _53; memset(&_53, 0, sizeof(uint8_t));
26088		- _53 = 42;
26089		- struct string _54; memset(&_54, 0, sizeof(struct string));
	26000	+ const struct StreamOut _40 = &(streams).out;
	26001	+ uint64_t _41; memset(&_41, 0, sizeof(uint64_t));
26090	26002	{
26091		- nonempty_to_string(&_54, &*id);
	26003	+ uint64_t _42; memset(&_42, 0, sizeof(uint64_t));
	26004	+ _42 = 1;
	26005	+ _41 = *level + _42;
	26006	+ _IGNORE_(_42);
26092	26007	}
26093		- preapp(&_52, &_53, &_54);
26094		- string$dest(&_54);
26095		- _IGNORE_(_53);
	26008	+ Indent(0 /* _39 /, &_40, &_41);
	26009	+ _IGNORE_(_41);
26096	26010	}
26097		- find_var_report_unused_and_mark_used(&_50, &*_51, &_52);
26098		- string$dest(&_52);
26099		- }
26100		- if(_50)
26101		- {
26102	26011	{
26103		- const struct StreamOut _52 = &(streams).out;
26104		- uint64_t _53; memset(&_53, 0, sizeof(uint64_t));
	26012	+ const struct StreamOut _41 = &(streams).out;
	26013	+ EmitQTPI(0 /* _40 /, &_41, &_mut_elem);
	26014	+ }
	26015	+ {
	26016	+ const struct StreamOut _42 = &(streams).out;
	26017	+ struct string _43; memset(&_43, 0, sizeof(struct string));
	26018	+ init$fromliteral(&_43, " = &((", 6);
	26019	+ PutStr(0 /* _41 /, &_42, &_43);
	26020	+ string$dest(&_43);
	26021	+ }
	26022	+ {
	26023	+ const struct StreamOut _43 = &(streams).out;
	26024	+ const struct type_pure *_44 = &(_mut_elem).qt.type;
	26025	+ PrTypePure(0 /* _42 /, &_43, &*_44);
	26026	+ }
	26027	+ {
	26028	+ const struct StreamOut _44 = &(streams).out;
	26029	+ struct string _45; memset(&_45, 0, sizeof(struct string));
	26030	+ init$fromliteral(&_45, " *)((", 5);
	26031	+ PutStr(0 /* _43 /, &_44, &_45);
	26032	+ string$dest(&_45);
	26033	+ }
	26034	+ {
	26035	+ const struct StreamOut _45 = &(streams).out;
	26036	+ struct string _46; memset(&_46, 0, sizeof(struct string));
26105	26037	{
26106		- uint64_t _54; memset(&_54, 0, sizeof(uint64_t));
26107		- _54 = 1;
26108		- _53 = *level + _54;
26109		- _IGNORE_(_54);
	26038	+ const struct nonempty_string *_47 = &(_const_container).id;
	26039	+ nonempty_to_string(&_46, &*_47);
26110	26040	}
26111		- Indent(0 /* _51 /, &_52, &_53);
26112		- _IGNORE_(_53);
	26041	+ PutStr(0 /* _44 /, &_45, &_46);
	26042	+ string$dest(&_46);
26113	26043	}
26114	26044	{
26115		- const struct StreamOut _53 = &(streams).out;
26116		- struct string _54; memset(&_54, 0, sizeof(struct string));
26117		- init$fromliteral(&_54, "__SUPPRESS_WARNING_UNUSED_VARIABLE__(&", 38);
26118		- PutStr(0 /* _52 /, &_53, &_54);
26119		- string$dest(&_54);
	26045	+ const struct StreamOut _46 = &(streams).out;
	26046	+ struct string _47; memset(&_47, 0, sizeof(struct string));
	26047	+ init$fromliteral(&_47, ").data))[", 9);
	26048	+ PutStr(0 /* _45 /, &_46, &_47);
	26049	+ string$dest(&_47);
26120	26050	}
26121	26051	{
26122		- const struct StreamOut _54 = &(streams).out;
26123		- struct string _55; memset(&_55, 0, sizeof(struct string));
	26052	+ const struct StreamOut _47 = &(streams).out;
	26053	+ struct string _48; memset(&_48, 0, sizeof(struct string));
26124	26054	{
26125		- const struct nonempty_string *_56 = &(_mut_elem).id;
26126		- nonempty_to_string(&_55, &*_56);
	26055	+ nonempty_to_string(&_48, &_counter);
26127	26056	}
26128		- PutStr(0 /* _53 /, &_54, &_55);
26129		- string$dest(&_55);
	26057	+ PutStr(0 /* _46 /, &_47, &_48);
	26058	+ string$dest(&_48);
26130	26059	}
26131	26060	{
26132		- const struct StreamOut _55 = &(streams).out;
26133		- struct string _56; memset(&_56, 0, sizeof(struct string));
26134		- init$fromliteral(&_56, ");", 2);
26135		- PutStrLn(0 /* _54 /, &_55, &_56);
26136		- string$dest(&_56);
	26061	+ const struct StreamOut _48 = &(streams).out;
	26062	+ struct string _49; memset(&_49, 0, sizeof(struct string));
	26063	+ init$fromliteral(&_49, "];", 2);
	26064	+ PutStrLn(0 /* _47 /, &_48, &_49);
	26065	+ string$dest(&_49);
26137	26066	}
	26067	+ {
	26068	+ struct stack/var/ _49 = &(sp).current.elems;
	26069	+ struct var _50; memset(&_50, 0, sizeof(struct var));
	26070	+ {
	26071	+ varinit(&_50, &_mut_elem);
	26072	+ }
	26073	+ push(0 /* _48 /, &_49, &_50, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 5136);
	26074	+ var$dest(&_50);
	26075	+ }
	26076	+ {
	26077	+ uint64_t _50; memset(&_50, 0, sizeof(uint64_t));
	26078	+ {
	26079	+ uint64_t _51; memset(&_51, 0, sizeof(uint64_t));
	26080	+ _51 = 1;
	26081	+ _50 = *level + _51;
	26082	+ _IGNORE_(_51);
	26083	+ }
	26084	+ struct stack/qtypepureid/ _51; memset(&_51, 0, sizeof(struct stack/qtypepureid/));
	26085	+ {
	26086	+ empty(&_51, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 5137);
	26087	+ }
	26088	+ ParseBlockRaw$(0 /* _49 /, &streams, &txtpos, &state, &_50, &sp, &tmpnr, &_51, &totality, &action, &self, &reduced_ids);
	26089	+ free$(&_51, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest);
	26090	+ _IGNORE_(_50);
	26091	+ }
	26092	+ bool _51;
	26093	+ {
	26094	+ struct stack/var/ _52 = &(sp).current.elems;
	26095	+ struct string _53; memset(&_53, 0, sizeof(struct string));
	26096	+ {
	26097	+ uint8_t _54; memset(&_54, 0, sizeof(uint8_t));
	26098	+ _54 = 42;
	26099	+ struct string _55; memset(&_55, 0, sizeof(struct string));
	26100	+ {
	26101	+ nonempty_to_string(&_55, &*id);
	26102	+ }
	26103	+ preapp(&_53, &_54, &_55);
	26104	+ string$dest(&_55);
	26105	+ _IGNORE_(_54);
	26106	+ }
	26107	+ find_var_report_unused_and_mark_used(&_51, &*_52, &_53);
	26108	+ string$dest(&_53);
	26109	+ }
	26110	+ if(_51)
	26111	+ {
	26112	+ {
	26113	+ const struct StreamOut _53 = &(streams).out;
	26114	+ uint64_t _54; memset(&_54, 0, sizeof(uint64_t));
	26115	+ {
	26116	+ uint64_t _55; memset(&_55, 0, sizeof(uint64_t));
	26117	+ _55 = 1;
	26118	+ _54 = *level + _55;
	26119	+ _IGNORE_(_55);
	26120	+ }
	26121	+ Indent(0 /* _52 /, &_53, &_54);
	26122	+ _IGNORE_(_54);
	26123	+ }
	26124	+ {
	26125	+ const struct StreamOut _54 = &(streams).out;
	26126	+ struct string _55; memset(&_55, 0, sizeof(struct string));
	26127	+ init$fromliteral(&_55, "__SUPPRESS_WARNING_UNUSED_VARIABLE__(&", 38);
	26128	+ PutStr(0 /* _53 /, &_54, &_55);
	26129	+ string$dest(&_55);
	26130	+ }
	26131	+ {
	26132	+ const struct StreamOut _55 = &(streams).out;
	26133	+ struct string _56; memset(&_56, 0, sizeof(struct string));
	26134	+ {
	26135	+ const struct nonempty_string *_57 = &(_mut_elem).id;
	26136	+ nonempty_to_string(&_56, &*_57);
	26137	+ }
	26138	+ PutStr(0 /* _54 /, &_55, &_56);
	26139	+ string$dest(&_56);
	26140	+ }
	26141	+ {
	26142	+ const struct StreamOut _56 = &(streams).out;
	26143	+ struct string _57; memset(&_57, 0, sizeof(struct string));
	26144	+ init$fromliteral(&_57, ");", 2);
	26145	+ PutStrLn(0 /* _55 /, &_56, &_57);
	26146	+ string$dest(&_57);
	26147	+ }
	26148	+ }
	26149	+ {
	26150	+ const struct StreamOut _53 = &(streams).err;
	26151	+ AssertUsedThenCloseScope$(0 /* _52 /, &_53, &txtpos, &sp);
	26152	+ }
	26153	+ qtypepureid$dest(&_mut_elem);
26138	26154	}
26139	26155	{
26140		- const struct StreamOut _52 = &(streams).err;
26141		- AssertUsedThenCloseScope$(0 /* _51 /, &_52, &txtpos, &sp);
	26156	+ uint8_t _39; memset(&_39, 0, sizeof(uint8_t));
	26157	+ _39 = 125;
	26158	+ AssertGet$(0 /* _38 /, &streams, &txtpos, &level, &_39);
	26159	+ _IGNORE_(_39);
26142	26160	}
26143		- qtypepureid$dest(&_mut_elem);
	26161	+ {
	26162	+ const struct StreamOut _40 = &(streams).out;
	26163	+ Indent(0 /* _39 /, &_40, &*level);
	26164	+ }
	26165	+ {
	26166	+ const struct StreamOut _41 = &(streams).out;
	26167	+ struct string _42; memset(&_42, 0, sizeof(struct string));
	26168	+ init$fromliteral(&_42, "}", 1);
	26169	+ PutStrLn(0 /* _40 /, &_41, &_42);
	26170	+ string$dest(&_42);
	26171	+ }
	26172	+ nonempty_string$dest(&_counter);
26144	26173	}
26145		- {
26146		- uint8_t _38; memset(&_38, 0, sizeof(uint8_t));
26147		- _38 = 125;
26148		- AssertGet$(0 /* _37 /, &streams, &txtpos, &level, &_38);
26149		- _IGNORE_(_38);
26150		- }
26151		- {
26152		- const struct StreamOut _39 = &(streams).out;
26153		- Indent(0 /* _38 /, &_39, &*level);
26154		- }
26155		- {
26156		- const struct StreamOut _40 = &(streams).out;
26157		- struct string _41; memset(&_41, 0, sizeof(struct string));
26158		- init$fromliteral(&_41, "}", 1);
26159		- PutStrLn(0 /* _39 /, &_40, &_41);
26160		- string$dest(&_41);
26161		- }
26162		- nonempty_string$dest(&_counter);
	26174	+ break;
26163	26175	}
26164		- break;
26165		- }
26166		- case 2: // void container_opt:
26167		- {
	26176	+ case 2: // void container_opt:
26168	26177	{
26169	26178	{
26170		- const struct StreamOut _23 = &(streams).err;
26171		- struct string _24; memset(&_24, 0, sizeof(struct string));
26172		- init$fromliteral(&_24, "for construct not implemented for ", 34);
26173		- PutStr(0 /* _22 /, &_23, &_24);
26174		- string$dest(&_24);
26175		- }
26176		- {
26177		- const struct StreamOut _24 = &(streams).err;
26178		- struct type_pure _25; memset(&_25, 0, sizeof(struct type_pure));
26179	26179	{
26180		- const struct container_type _26 = &(containertype).which;
26181		- const struct type_pure_prim _27 = &(containertype).subtype;
26182		- type_pure_wrapped(&_25, &_26, &_27);
	26180	+ const struct StreamOut _24 = &(streams).err;
	26181	+ struct string _25; memset(&_25, 0, sizeof(struct string));
	26182	+ init$fromliteral(&_25, "for construct not implemented for ", 34);
	26183	+ PutStr(0 /* _23 /, &_24, &_25);
	26184	+ string$dest(&_25);
26183	26185	}
26184		- EPrTypePure(0 /* _23 /, &_24, &_25);
26185		- type_pure$dest(&_25);
	26186	+ {
	26187	+ const struct StreamOut _25 = &(streams).err;
	26188	+ struct type_pure _26; memset(&_26, 0, sizeof(struct type_pure));
	26189	+ {
	26190	+ const struct container_type _27 = &(containertype).which;
	26191	+ const struct type_pure_prim _28 = &(containertype).subtype;
	26192	+ type_pure_wrapped(&_26, &_27, &_28);
	26193	+ }
	26194	+ EPrTypePure(0 /* _24 /, &_25, &_26);
	26195	+ type_pure$dest(&_26);
	26196	+ }
	26197	+ {
	26198	+ const struct StreamOut _26 = &(streams).err;
	26199	+ Fail$(0 /* _25 /, &_26, &*txtpos);
	26200	+ }
26186	26201	}
26187		- {
26188		- const struct StreamOut _25 = &(streams).err;
26189		- Fail$(0 /* _24 /, &_25, &*txtpos);
26190		- }
	26202	+ break;
26191	26203	}
26192		- break;
26193		- }
26194		- case 3: // void container_box:
26195		- {
	26204	+ case 3: // void container_box:
26196	26205	{
26197	26206	{
26198		- const struct StreamOut _24 = &(streams).err;
26199		- struct string _25; memset(&_25, 0, sizeof(struct string));
26200		- init$fromliteral(&_25, "for construct not implemented for ", 34);
26201		- PutStr(0 /* _23 /, &_24, &_25);
26202		- string$dest(&_25);
26203		- }
26204		- {
26205		- const struct StreamOut _25 = &(streams).err;
26206		- struct type_pure _26; memset(&_26, 0, sizeof(struct type_pure));
26207	26207	{
26208		- const struct container_type _27 = &(containertype).which;
26209		- const struct type_pure_prim _28 = &(containertype).subtype;
26210		- type_pure_wrapped(&_26, &_27, &_28);
	26208	+ const struct StreamOut _25 = &(streams).err;
	26209	+ struct string _26; memset(&_26, 0, sizeof(struct string));
	26210	+ init$fromliteral(&_26, "for construct not implemented for ", 34);
	26211	+ PutStr(0 /* _24 /, &_25, &_26);
	26212	+ string$dest(&_26);
26211	26213	}
26212		- EPrTypePure(0 /* _24 /, &_25, &_26);
26213		- type_pure$dest(&_26);
	26214	+ {
	26215	+ const struct StreamOut _26 = &(streams).err;
	26216	+ struct type_pure _27; memset(&_27, 0, sizeof(struct type_pure));
	26217	+ {
	26218	+ const struct container_type _28 = &(containertype).which;
	26219	+ const struct type_pure_prim _29 = &(containertype).subtype;
	26220	+ type_pure_wrapped(&_27, &_28, &_29);
	26221	+ }
	26222	+ EPrTypePure(0 /* _25 /, &_26, &_27);
	26223	+ type_pure$dest(&_27);
	26224	+ }
	26225	+ {
	26226	+ const struct StreamOut _27 = &(streams).err;
	26227	+ Fail$(0 /* _26 /, &_27, &*txtpos);
	26228	+ }
26214	26229	}
26215		- {
26216		- const struct StreamOut _26 = &(streams).err;
26217		- Fail$(0 /* _25 /, &_26, &*txtpos);
26218		- }
	26230	+ break;
26219	26231	}
26220		- break;
	26232	+ default:
	26233	+ {
	26234	+ fprintf(stderr, "INTERNAL ERROR IN SWITCH");
	26235	+ break;
	26236	+ }
26221	26237	}
26222		- default:
26223		- {
26224		- fprintf(stderr, "INTERNAL ERROR IN SWITCH");
26225		- break;
26226		- }
	26238	+ container_type$dest(&_aw);
	26239	+ qtypepureid$dest(&_const_container);
26227	26240	}
26228		- container_type$dest(&_aw);
26229		- qtypepureid$dest(&_const_container);
	26241	+ break;
26230	26242	}
26231		- break;
	26243	+ default:
	26244	+ {
	26245	+ fprintf(stderr, "INTERNAL ERROR IN SWITCH");
	26246	+ break;
	26247	+ }
26232	26248	}
26233		- default:
26234		- {
26235		- fprintf(stderr, "INTERNAL ERROR IN SWITCH");
26236		- break;
	26249	+ type_pure$dest(&_containertype);
	26250	+ nonempty_string$dest(&_9);
26237	26251	}
	26252	+ free$(&_to, sizeof(struct nonempty_string), (void ()(void ))nonempty_string$dest);
	26253	+ qtypepureid$dest(&_8);
26238	26254	}
26239		- type_pure$dest(&_containertype);
26240		- nonempty_string$dest(&_8);
26241		- }
26242		- free$(&_to, sizeof(struct nonempty_string), (void ()(void ))nonempty_string$dest);
26243	26255	type_mode$dest(&_q);
26244	26256	}
26245	26257	}

		@@ -26346,7 +26358,7 @@
26346	26358	}
26347	26359	struct stack/qtypepureid/ _12; memset(&_12, 0, sizeof(struct stack/qtypepureid/));
26348	26360	{
26349		- solid(&_12, &_condition, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 5173);
	26361	+ solid(&_12, &_condition, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 5176);
26350	26362	}
26351	26363	struct string _13; memset(&_13, 0, sizeof(struct string));
26352	26364	{

		@@ -26434,7 +26446,7 @@
26434	26446	}
26435	26447	struct stack/qtypepureid/ _19; memset(&_19, 0, sizeof(struct stack/qtypepureid/));
26436	26448	{
26437		- empty(&_19, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 5180);
	26449	+ empty(&_19, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 5183);
26438	26450	}
26439	26451	ParseBlock$(0 /* _17 /, &streams, &txtpos, &state, &_18, &sp, &tmpnr, &_19, &totality, &action, &self, &reduced_ids);
26440	26452	free$(&_19, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest);

		@@ -26513,7 +26525,7 @@
26513	26525	{
26514	26526	struct stack/qtypepureid/ _6; memset(&_6, 0, sizeof(struct stack/qtypepureid/));
26515	26527	{
26516		- empty(&_6, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 5201);
	26528	+ empty(&_6, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 5204);
26517	26529	}
26518	26530	bool _7; memset(&_7, 0, sizeof(bool));
26519	26531	_7 = 0;

		@@ -27695,7 +27707,7 @@
27695	27707	_IGNORE_(_3);
27696	27708	}
27697	27709	{
27698		- push(0 /* _3 /, &elems, &_ti, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 5504);
	27710	+ push(0 /* _3 /, &elems, &_ti, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 5507);
27699	27711	}
27700	27712	{
27701	27713	uint64_t _5; memset(&_5, 0, sizeof(uint64_t));

		@@ -28373,7 +28385,7 @@
28373	28385	const struct nonempty_string _6 = &(c).id;
28374	28386	typepureid(&_4, &_5, &_6);
28375	28387	}
28376		- push(0 /* _3 /, &extracted, &_4, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 5638);
	28388	+ push(0 /* _3 /, &extracted, &_4, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 5641);
28377	28389	typepureid$dest(&_4);
28378	28390	}
28379	28391	}

		@@ -30628,11 +30640,11 @@
30628	30640	{
30629	30641	struct qtype _decl_; memset(&_decl_, 0, sizeof(struct qtype));
30630	30642	{
30631		- at_get$(&_decl_, &decl, &idx, sizeof(struct qtype), (void ()(void ))qtype$dest, (void ()(void , const void *))qtype$copy, 5943);
	30643	+ at_get$(&_decl_, &decl, &idx, sizeof(struct qtype), (void ()(void ))qtype$dest, (void ()(void , const void *))qtype$copy, 5946);
30632	30644	}
30633	30645	struct qtype _def_; memset(&_def_, 0, sizeof(struct qtype));
30634	30646	{
30635		- at_get$(&_def_, &def, &idx, sizeof(struct qtype), (void ()(void ))qtype$dest, (void ()(void , const void *))qtype$copy, 5944);
	30647	+ at_get$(&_def_, &def, &idx, sizeof(struct qtype), (void ()(void ))qtype$dest, (void ()(void , const void *))qtype$copy, 5947);
30636	30648	}
30637	30649	bool _4;
30638	30650	{

		@@ -30904,7 +30916,7 @@
30904	30916	{
30905	30917	STRUCT(&_6, &*elems);
30906	30918	}
30907		- solid(&_5, &_6, sizeof(struct flavour), (void ()(void ))flavour$dest, (void ()(void , const void *))flavour$copy, 6009);
	30919	+ solid(&_5, &_6, sizeof(struct flavour), (void ()(void ))flavour$dest, (void ()(void , const void *))flavour$copy, 6012);
30908	30920	flavour$dest(&_6);
30909	30921	}
30910	30922	structdef(&_4, &_5, &id, &used);

		@@ -31557,7 +31569,7 @@
31557	31569	{
31558	31570	struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
31559	31571	{
31560		- at_get$(&_cur, &elems, &idx, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 6128);
	31572	+ at_get$(&_cur, &elems, &idx, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 6131);
31561	31573	}
31562	31574	{
31563	31575	uint64_t _4; memset(&_4, 0, sizeof(uint64_t));

		@@ -31658,7 +31670,7 @@
31658	31670	{
31659	31671	struct typepureid _cur; memset(&_cur, 0, sizeof(struct typepureid));
31660	31672	{
31661		- at_get$(&_cur, &elems, &idx, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 6144);
	31673	+ at_get$(&_cur, &elems, &idx, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 6147);
31662	31674	}
31663	31675	{
31664	31676	struct qtype _4; memset(&_4, 0, sizeof(struct qtype));

		@@ -31731,7 +31743,7 @@
31731	31743	{
31732	31744	struct constr _c; memset(&_c, 0, sizeof(struct constr));
31733	31745	{
31734		- at_get$(&_c, &constrs, &idx, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void *))constr$copy, 6158);
	31746	+ at_get$(&_c, &constrs, &idx, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void *))constr$copy, 6161);
31735	31747	}
31736	31748	bool _4;
31737	31749	{

		@@ -31799,11 +31811,11 @@
31799	31811	}
31800	31812	struct typepureid _elem; memset(&_elem, 0, sizeof(struct typepureid));
31801	31813	{
31802		- at_get$(&_elem, &_elems, &idx, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void ))typepureid$copy, 6175);
	31814	+ at_get$(&_elem, &_elems, &idx, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void ))typepureid$copy, 6178);
31803	31815	}
31804	31816	struct constr _constr; memset(&_constr, 0, sizeof(struct constr));
31805	31817	{
31806		- at_get$(&_constr, &constrs, &idx, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void *))constr$copy, 6177);
	31818	+ at_get$(&_constr, &constrs, &idx, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void *))constr$copy, 6180);
31807	31819	}
31808	31820	struct type_pure _type; memset(&_type, 0, sizeof(struct type_pure));
31809	31821	{

		@@ -32268,7 +32280,7 @@
32268	32280	{
32269	32281	DATA(&_8, &*constrs);
32270	32282	}
32271		- solid(&_7, &_8, sizeof(struct flavour), (void ()(void ))flavour$dest, (void ()(void , const void *))flavour$copy, 6221);
	32283	+ solid(&_7, &_8, sizeof(struct flavour), (void ()(void ))flavour$dest, (void ()(void , const void *))flavour$copy, 6224);
32272	32284	flavour$dest(&_8);
32273	32285	}
32274	32286	structdef(&_6, &_7, &id, &used);

		@@ -32459,7 +32471,7 @@
32459	32471	_IGNORE_(_3);
32460	32472	}
32461	32473	{
32462		- push(0 /* _3 /, &elems, &_ti, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 6263);
	32474	+ push(0 /* _3 /, &elems, &_ti, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 6266);
32463	32475	}
32464	32476	{
32465	32477	uint64_t _5; memset(&_5, 0, sizeof(uint64_t));

		@@ -32691,7 +32703,7 @@
32691	32703	}
32692	32704	}
32693	32705	{
32694		- push(0 /* _10 /, &constrs, &_c, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void *))constr$copy, 6317);
	32706	+ push(0 /* _10 /, &constrs, &_c, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void *))constr$copy, 6320);
32695	32707	}
32696	32708	bool _12;
32697	32709	{

		@@ -32770,7 +32782,7 @@
32770	32782	}
32771	32783	}
32772	32784
32773		-void EmitGenericArgsId$(void const _0, const struct Streams const streams, const struct stack/qtypepureid/ *const content)
	32785	+void EmitGenericArgsId$(void const _0, const struct Streams const streams, const struct stack/qtypepureid/ *const args)
32774	32786	{
32775	32787	{
32776	32788	{

		@@ -32794,10 +32806,10 @@
32794	32806	PutStr(0 /* _2 /, &_3, &_4);
32795	32807	string$dest(&_4);
32796	32808	}
32797		- const struct stack/qtypepureid/ _3 = &(content);
	32809	+ const struct stack/qtypepureid/ _3 = &(args);
32798	32810	for(uint64_t _4 = 0; _4 < (*_3).fill; ++_4)
32799	32811	{
32800		- const struct qtypepureid elem = &((struct qtypepureid )((*_3).data))[_4];
	32812	+ const struct qtypepureid arg = &((struct qtypepureid )((*_3).data))[_4];
32801	32813	{
32802	32814	const struct StreamOut _6 = &(streams).out;
32803	32815	struct string _7; memset(&_7, 0, sizeof(struct string));

		@@ -32809,7 +32821,7 @@
32809	32821	const struct StreamOut _7 = &(streams).out;
32810	32822	struct string _8; memset(&_8, 0, sizeof(struct string));
32811	32823	{
32812		- const struct nonempty_string _9 = &(elem).id;
	32824	+ const struct nonempty_string _9 = &(arg).id;
32813	32825	nonempty_to_string(&_8, &*_9);
32814	32826	}
32815	32827	PutStr(0 /* _6 /, &_7, &_8);

		@@ -32873,7 +32885,7 @@
32873	32885	const struct stack/qtypepure/ _5 = &(parids);
32874	32886	for(uint64_t _6 = 0; _6 < (*_5).fill; ++_6)
32875	32887	{
32876		- const struct qtypepure elem = &((struct qtypepure )((*_5).data))[_6];
	32888	+ const struct qtypepure parid = &((struct qtypepure )((*_5).data))[_6];
32877	32889	{
32878	32890	const struct StreamOut _8 = &(streams).out;
32879	32891	struct string _9; memset(&_9, 0, sizeof(struct string));

		@@ -32887,7 +32899,7 @@
32887	32899	{
32888	32900	GenVar$(&_8, &_parnr);
32889	32901	}
32890		- qtypepureid(&_par, &*elem, &_8);
	32902	+ qtypepureid(&_par, &*parid, &_8);
32891	32903	nonempty_string$dest(&_8);
32892	32904	}
32893	32905	{

		@@ -32969,16 +32981,16 @@
32969	32981	}
32970	32982	}
32971	32983
32972		-void AttachGenericIds$(struct stack/qtypepureid/ const _0, const struct stack/qtypepure/ const content)
	32984	+void AttachGenericIds$(struct stack/qtypepureid/ const _0, const struct stack/qtypepure/ const ids)
32973	32985	{
32974	32986	{
32975	32987	uint64_t _nr; memset(&_nr, 0, sizeof(uint64_t));
32976	32988	_nr = 0;
32977	32989	struct stack/qtypepureid/ _qtpis; memset(&_qtpis, 0, sizeof(struct stack/qtypepureid/));
32978		- const struct stack/qtypepure/ _1 = &(content);
	32990	+ const struct stack/qtypepure/ _1 = &(ids);
32979	32991	for(uint64_t _2 = 0; _2 < (*_1).fill; ++_2)
32980	32992	{
32981		- const struct qtypepure elem = &((struct qtypepure )((*_1).data))[_2];
	32993	+ const struct qtypepure id = &((struct qtypepure )((*_1).data))[_2];
32982	32994	{
32983	32995	struct qtypepureid _4; memset(&_4, 0, sizeof(struct qtypepureid));
32984	32996	{

		@@ -32986,10 +32998,10 @@
32986	32998	{
32987	32999	GenPar$(&_5, &_nr);
32988	33000	}
32989		- qtypepureid(&_4, &*elem, &_5);
	33001	+ qtypepureid(&_4, &*id, &_5);
32990	33002	nonempty_string$dest(&_5);
32991	33003	}
32992		- push(0 /* _3 /, &_qtpis, &_4, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void ))qtypepureid$copy, 6418);
	33004	+ push(0 /* _3 /, &_qtpis, &_4, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void ))qtypepureid$copy, 6421);
32993	33005	qtypepureid$dest(&_4);
32994	33006	}
32995	33007	}

		@@ -33019,7 +33031,7 @@
33019	33031	qtypepureid(&_4, &_5, &*_6);
33020	33032	qtypepure$dest(&_5);
33021	33033	}
33022		- push(0 /* _3 /, &_qtpis, &_4, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void ))qtypepureid$copy, 6429);
	33034	+ push(0 /* _3 /, &_qtpis, &_4, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void ))qtypepureid$copy, 6432);
33023	33035	qtypepureid$dest(&_4);
33024	33036	}
33025	33037	}

		@@ -33238,8 +33250,6 @@
33238	33250	const struct type_mode _1 = &(par).qt.qualifier;
33239	33251	attachQualifier(&_content, &elems, &_1);
33240	33252	}
33241		- struct stack/qtypepureid/ _content_; memset(&_content_, 0, sizeof(struct stack/qtypepureid/));
33242		- clone$(&_content_, &(_content), sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy);
33243	33253	const struct stack/qtypepureid/ *_1 = &(_content);
33244	33254	for(uint64_t _2 = 0; _2 < (*_1).fill; ++_2)
33245	33255	{

		@@ -33423,13 +33433,13 @@
33423	33433	ReducedId(&_19, &*_20, &_21);
33424	33434	string$dest(&_21);
33425	33435	}
33426		- push(0 /* _18 /, &reduced_ids, &_19, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 6472);
	33436	+ push(0 /* _18 /, &reduced_ids, &_19, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 6474);
33427	33437	ReducedId$dest(&_19);
33428	33438	}
33429	33439	}
33430	33440	}
33431	33441	{
33432		- ParseMatch$(0 /* _16 /, &streams, &txtpos, &structs, &level, &sp, &tmpnr, &_elem, &casenr, &ti, &_content_, &usedids, &*reduced_ids);
	33442	+ ParseMatch$(0 /* _16 /, &streams, &txtpos, &structs, &level, &sp, &tmpnr, &_elem, &casenr, &ti, &_content, &usedids, &*reduced_ids);
33433	33443	}
33434	33444	free$(&_redid, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest);
33435	33445	qtypepureid$dest(&_elem);

		@@ -33436,7 +33446,6 @@
33436	33446	nonempty_string$dest(&_parid);
33437	33447	}
33438	33448	}
33439		- free$(&_content_, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest);
33440	33449	free$(&_content, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest);
33441	33450	_IGNORE_(_first);
33442	33451	}

		@@ -33517,7 +33526,7 @@
33517	33526	{
33518	33527	nonempty_to_string(&_8, &_parid);
33519	33528	}
33520		- push(0 /* _7 /, &usedids, &_8, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 6504);
	33529	+ push(0 /* _7 /, &usedids, &_8, sizeof(struct string), (void ()(void ))string$dest, (void ()(void , const void *))string$copy, 6506);
33521	33530	string$dest(&_8);
33522	33531	}
33523	33532	struct qtypepureid _qti; memset(&_qti, 0, sizeof(struct qtypepureid));

		@@ -33608,7 +33617,7 @@
33608	33617	ReducedId(&_18, &*_19, &_20);
33609	33618	string$dest(&_20);
33610	33619	}
33611		- push(0 /* _17 /, &reduced_ids, &_18, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 6514);
	33620	+ push(0 /* _17 /, &reduced_ids, &_18, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 6516);
33612	33621	ReducedId$dest(&_18);
33613	33622	}
33614	33623	}

		@@ -33619,7 +33628,7 @@
33619	33628	{
33620	33629	varinit(&_17, &_qti);
33621	33630	}
33622		- push(0 /* _15 /, &_16, &_17, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 6518);
	33631	+ push(0 /* _15 /, &_16, &_17, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 6520);
33623	33632	var$dest(&_17);
33624	33633	}
33625	33634	free$(&_redids, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest);

		@@ -33965,7 +33974,7 @@
33965	33974	struct typepureid _elem; memset(&_elem, 0, sizeof(struct typepureid));
33966	33975	{
33967	33976	const struct stack/typepureid/ _35 = &(f).elems;
33968		- at_get$(&_elem, &_35, &idx, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 6580);
	33977	+ at_get$(&_elem, &_35, &idx, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 6582);
33969	33978	}
33970	33979	{
33971	33980	struct qtypepureid _35; memset(&_35, 0, sizeof(struct qtypepureid));

		@@ -34045,7 +34054,7 @@
34045	34054	struct stack/qtypepureid/ _43; memset(&_43, 0, sizeof(struct stack/qtypepureid/));
34046	34055	struct stack/qtypepureid/ *parids = &_43;
34047	34056	{
34048		- push(0 /* _44 /, &parids, &elem, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void ))qtypepureid$copy, 6585);
	34057	+ push(0 /* _44 /, &parids, &elem, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void ))qtypepureid$copy, 6587);
34049	34058	}
34050	34059	{
34051	34060	ParseMatch$(0 /* _45 /, &streams, &txtpos, &structs, &level, &sp, &tmpnr, &elem, &casenr, &ti, &parids, &usedids, &*reduced_ids);

		@@ -34253,7 +34262,7 @@
34253	34262	struct constr _constr; memset(&_constr, 0, sizeof(struct constr));
34254	34263	{
34255	34264	const struct stack/constr/ _37 = &(f).constrs;
34256		- at_get$(&_constr, &_37, &idx, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void *))constr$copy, 6611);
	34265	+ at_get$(&_constr, &_37, &idx, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void *))constr$copy, 6613);
34257	34266	}
34258	34267	struct qtypepureid _sub; memset(&_sub, 0, sizeof(struct qtypepureid));
34259	34268	{

		@@ -34344,7 +34353,7 @@
34344	34353	ReducedId(&_45, &*_46, &_47);
34345	34354	string$dest(&_47);
34346	34355	}
34347		- push(0 /* _44 /, &reduced_ids, &_45, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 6614);
	34356	+ push(0 /* _44 /, &reduced_ids, &_45, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 6616);
34348	34357	ReducedId$dest(&_45);
34349	34358	}
34350	34359	struct stack/typepureid/ _elems; memset(&_elems, 0, sizeof(struct stack/typepureid/));

		@@ -34755,7 +34764,7 @@
34755	34764	struct stack/qtypepureid/ _35; memset(&_35, 0, sizeof(struct stack/qtypepureid/));
34756	34765	struct stack/qtypepureid/ *parids = &_35;
34757	34766	{
34758		- push(0 /* _36 /, &parids, &_elem, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 6660);
	34767	+ push(0 /* _36 /, &parids, &_elem, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 6662);
34759	34768	}
34760	34769	{
34761	34770	struct ReducedId _38; memset(&_38, 0, sizeof(struct ReducedId));

		@@ -34769,7 +34778,7 @@
34769	34778	ReducedId(&_38, &*_39, &_40);
34770	34779	string$dest(&_40);
34771	34780	}
34772		- push(0 /* _37 /, &reduced_ids, &_38, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 6661);
	34781	+ push(0 /* _37 /, &reduced_ids, &_38, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 6663);
34773	34782	ReducedId$dest(&_38);
34774	34783	}
34775	34784	{

		@@ -35048,7 +35057,7 @@
35048	35057	{
35049	35058	struct stack/par/ _2; memset(&_2, 0, sizeof(struct stack/par/));
35050	35059	{
35051		- stack(&_2, sizeof(struct par), (void ()(void ))par$dest, (void ()(void , const void *))par$copy, 6712);
	35060	+ stack(&_2, sizeof(struct par), (void ()(void ))par$dest, (void ()(void , const void *))par$copy, 6714);
35052	35061	}
35053	35062	pscope(&_1, &_2);
35054	35063	free$(&_2, sizeof(struct par), (void ()(void ))par$dest);

		@@ -35055,13 +35064,13 @@
35055	35064	}
35056	35065	struct stack/vscope/ _2; memset(&_2, 0, sizeof(struct stack/vscope/));
35057	35066	{
35058		- stack(&_2, sizeof(struct vscope), (void ()(void ))vscope$dest, (void ()(void , const void *))vscope$copy, 6712);
	35067	+ stack(&_2, sizeof(struct vscope), (void ()(void ))vscope$dest, (void ()(void , const void *))vscope$copy, 6714);
35059	35068	}
35060	35069	struct vscope _3; memset(&_3, 0, sizeof(struct vscope));
35061	35070	{
35062	35071	struct stack/var/ _4; memset(&_4, 0, sizeof(struct stack/var/));
35063	35072	{
35064		- stack(&_4, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 6712);
	35073	+ stack(&_4, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 6714);
35065	35074	}
35066	35075	vscope(&_3, &_4);
35067	35076	free$(&_4, sizeof(struct var), (void ()(void ))var$dest);

		@@ -35167,7 +35176,7 @@
35167	35176	{
35168	35177	struct stack/flavour/ _8; memset(&_8, 0, sizeof(struct stack/flavour/));
35169	35178	{
35170		- /UNION/ empty(&_8, sizeof(struct flavour), (void ()(void ))flavour$dest, (void ()(void , const void *))flavour$copy, 6743);
	35179	+ /UNION/ empty(&_8, sizeof(struct flavour), (void ()(void ))flavour$dest, (void ()(void , const void *))flavour$copy, 6745);
35171	35180	}
35172	35181	bool _9; memset(&_9, 0, sizeof(bool));
35173	35182	_9 = 0;

		@@ -35177,7 +35186,7 @@
35177	35186	}
35178	35187	{
35179	35188	struct stack/structdef/ _9 = &(state).structs;
35180		- push(0 /* _8 /, &_9, &_strdecl, sizeof(struct structdef), (void ()(void ))structdef$dest, (void ()(void , const void *))structdef$copy, 6744);
	35189	+ push(0 /* _8 /, &_9, &_strdecl, sizeof(struct structdef), (void ()(void ))structdef$dest, (void ()(void , const void *))structdef$copy, 6746);
35181	35190	}
35182	35191	{
35183	35192	const struct StreamOut _10 = &(streams).out;

		@@ -35355,7 +35364,7 @@
35355	35364	{
35356	35365	struct stack/flavour/ _9; memset(&_9, 0, sizeof(struct stack/flavour/));
35357	35366	{
35358		- /STRUCT/ empty(&_9, sizeof(struct flavour), (void ()(void ))flavour$dest, (void ()(void , const void *))flavour$copy, 6792);
	35367	+ /STRUCT/ empty(&_9, sizeof(struct flavour), (void ()(void ))flavour$dest, (void ()(void , const void *))flavour$copy, 6794);
35359	35368	}
35360	35369	bool _10; memset(&_10, 0, sizeof(bool));
35361	35370	_10 = 0;

		@@ -35365,7 +35374,7 @@
35365	35374	}
35366	35375	{
35367	35376	struct stack/structdef/ _10 = &(state).structs;
35368		- push(0 /* _9 /, &_10, &_strdecl, sizeof(struct structdef), (void ()(void ))structdef$dest, (void ()(void , const void *))structdef$copy, 6793);
	35377	+ push(0 /* _9 /, &_10, &_strdecl, sizeof(struct structdef), (void ()(void ))structdef$dest, (void ()(void , const void *))structdef$copy, 6795);
35369	35378	}
35370	35379	{
35371	35380	const struct StreamOut _11 = &(streams).err;

		@@ -35543,7 +35552,7 @@
35543	35552	{
35544	35553	struct stack/flavour/ _8; memset(&_8, 0, sizeof(struct stack/flavour/));
35545	35554	{
35546		- /STRUCT/ empty(&_8, sizeof(struct flavour), (void ()(void ))flavour$dest, (void ()(void , const void *))flavour$copy, 6841);
	35555	+ /STRUCT/ empty(&_8, sizeof(struct flavour), (void ()(void ))flavour$dest, (void ()(void , const void *))flavour$copy, 6843);
35547	35556	}
35548	35557	bool _9; memset(&_9, 0, sizeof(bool));
35549	35558	_9 = 0;

		@@ -35553,7 +35562,7 @@
35553	35562	}
35554	35563	{
35555	35564	struct stack/structdef/ _9 = &(state).structs;
35556		- push(0 /* _8 /, &_9, &_strdecl, sizeof(struct structdef), (void ()(void ))structdef$dest, (void ()(void , const void *))structdef$copy, 6842);
	35565	+ push(0 /* _8 /, &_9, &_strdecl, sizeof(struct structdef), (void ()(void ))structdef$dest, (void ()(void , const void *))structdef$copy, 6844);
35557	35566	}
35558	35567	{
35559	35568	const struct StreamOut _10 = &(streams).out;

		@@ -35733,7 +35742,7 @@
35733	35742	{
35734	35743	struct stack/qtypepure/ _parids; memset(&_parids, 0, sizeof(struct stack/qtypepure/));
35735	35744	{
35736		- push(0 /* _11 /, &_parids, &_parqt, sizeof(struct qtypepure), (void ()(void ))qtypepure$dest, (void ()(void , const void ))qtypepure$copy, 6876);
	35745	+ push(0 /* _11 /, &_parids, &_parqt, sizeof(struct qtypepure), (void ()(void ))qtypepure$dest, (void ()(void , const void ))qtypepure$copy, 6878);
35737	35746	}
35738	35747	while(1)
35739	35748	{

		@@ -35780,7 +35789,7 @@
35780	35789	_IGNORE_(_15);
35781	35790	}
35782	35791	{
35783		- push(0 /* _15 /, &_parids, &_par, sizeof(struct qtypepure), (void ()(void ))qtypepure$dest, (void ()(void , const void ))qtypepure$copy, 6882);
	35792	+ push(0 /* _15 /, &_parids, &_par, sizeof(struct qtypepure), (void ()(void ))qtypepure$dest, (void ()(void , const void ))qtypepure$copy, 6884);
35784	35793	}
35785	35794	qtypepure$dest(&_par);
35786	35795	}

		@@ -35822,7 +35831,7 @@
35822	35831	uint8_t _13; memset(&_13, 0, sizeof(uint8_t));
35823	35832	{
35824	35833	struct stack/u8/ _14 = &(parid).data;
35825		- pop$(&_13, &_14, sizeof(uint8_t), 0/DEST/, 0/COPY*/, 6896);
	35834	+ pop$(&_13, &_14, sizeof(uint8_t), 0/DEST/, 0/COPY*/, 6898);
35826	35835	}
35827	35836	nonempty_string(&_12, &_13, &*parid);
35828	35837	_IGNORE_(_13);

		@@ -35882,7 +35891,7 @@
35882	35891	{
35883	35892	qtypepureid(&_20, &_parqt, &*parid);
35884	35893	}
35885		- push(0 /* _19 /, &_parids, &_20, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void ))qtypepureid$copy, 6906);
	35894	+ push(0 /* _19 /, &_parids, &_20, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void ))qtypepureid$copy, 6908);
35886	35895	qtypepureid$dest(&_20);
35887	35896	}
35888	35897	while(1)

		@@ -35930,7 +35939,7 @@
35930	35939	_IGNORE_(_23);
35931	35940	}
35932	35941	{
35933		- push(0 /* _23 /, &_parids, &_par, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void ))qtypepureid$copy, 6913);
	35942	+ push(0 /* _23 /, &_parids, &_par, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void ))qtypepureid$copy, 6915);
35934	35943	}
35935	35944	qtypepureid$dest(&_par);
35936	35945	}

		@@ -36024,7 +36033,7 @@
36024	36033	{
36025	36034	struct stack/qtypepureid/ _16; memset(&_16, 0, sizeof(struct stack/qtypepureid/));
36026	36035	{
36027		- stack(&_16, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 6935);
	36036	+ stack(&_16, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 6937);
36028	36037	}
36029	36038	fnpartypeids(&_15, &_16);
36030	36039	free$(&_16, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest);

		@@ -36135,7 +36144,7 @@
36135	36144	{
36136	36145	struct stack/qtypepureid/ _14; memset(&_14, 0, sizeof(struct stack/qtypepureid/));
36137	36146	{
36138		- stack(&_14, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 6951);
	36147	+ stack(&_14, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 6953);
36139	36148	}
36140	36149	fnpartypeids(&_13, &_14);
36141	36150	free$(&_14, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest);

		@@ -36161,41 +36170,40 @@
36161	36170	const struct fnpartypes ps = ((_7).fnpartypes).data;
36162	36171	{
36163	36172	{
36164		- struct stack/qtypepure/ _prps; memset(&_prps, 0, sizeof(struct stack/qtypepure/));
36165		- clone$(&_prps, &(ps).qts, sizeof(struct qtypepure), (void ()(void ))qtypepure$dest, (void ()(void , const void ))qtypepure$copy);
36166	36173	struct stack/qtype/ _pars; memset(&_pars, 0, sizeof(struct stack/qtype/));
36167		- const struct stack/qtypepure/ *_10 = &(_prps);
36168		- for(uint64_t _11 = 0; _11 < (*_10).fill; ++_11)
	36174	+ const struct stack/qtypepure/ _10 = &(ps).qts;
	36175	+ const struct stack/qtypepure/ _11 = &(_10);
	36176	+ for(uint64_t _12 = 0; _12 < (*_11).fill; ++_12)
36169	36177	{
36170		- const struct qtypepure prp = &((struct qtypepure )((*_10).data))[_11];
	36178	+ const struct qtypepure par = &((struct qtypepure )((*_11).data))[_12];
36171	36179	{
36172		- struct qtype _13; memset(&_13, 0, sizeof(struct qtype));
	36180	+ struct qtype _14; memset(&_14, 0, sizeof(struct qtype));
36173	36181	{
36174		- const struct type_mode _14 = &(prp).qualifier;
36175		- struct type _15; memset(&_15, 0, sizeof(struct type));
	36182	+ const struct type_mode _15 = &(par).qualifier;
	36183	+ struct type _16; memset(&_16, 0, sizeof(struct type));
36176	36184	{
36177		- const struct type_pure _16 = &(prp).type;
36178		- Expand(&_15, &*_16);
	36185	+ const struct type_pure _17 = &(par).type;
	36186	+ Expand(&_16, &*_17);
36179	36187	}
36180		- qtype(&_13, &*_14, &_15);
36181		- type$dest(&_15);
	36188	+ qtype(&_14, &*_15, &_16);
	36189	+ type$dest(&_16);
36182	36190	}
36183		- push(0 /* _12 /, &_pars, &_13, sizeof(struct qtype), (void ()(void ))qtype$dest, (void ()(void , const void ))qtype$copy, 6964);
36184		- qtype$dest(&_13);
	36191	+ push(0 /* _13 /, &_pars, &_14, sizeof(struct qtype), (void ()(void ))qtype$dest, (void ()(void , const void ))qtype$copy, 6965);
	36192	+ qtype$dest(&_14);
36185	36193	}
36186	36194	}
36187	36195	struct stack/def/ _cur; memset(&_cur, 0, sizeof(struct stack/def/));
36188	36196	{
36189		- struct stack/def/ _12 = &(state).defs;
36190		- struct string _13; memset(&_13, 0, sizeof(struct string));
	36197	+ struct stack/def/ _13 = &(state).defs;
	36198	+ struct string _14; memset(&_14, 0, sizeof(struct string));
36191	36199	{
36192		- nonempty_to_string(&_13, &_id);
	36200	+ nonempty_to_string(&_14, &_id);
36193	36201	}
36194		- findFnDef(&_cur, &*_12, &_13);
36195		- string$dest(&_13);
	36202	+ findFnDef(&_cur, &*_13, &_14);
	36203	+ string$dest(&_14);
36196	36204	}
36197		- const struct stack/def/ *_12 = &(_cur);
36198		- if(!(*_12).size)
	36205	+ const struct stack/def/ *_13 = &(_cur);
	36206	+ if(!(*_13).size)
36199	36207	{
36200	36208	{
36201	36209	}

		@@ -36202,28 +36210,19 @@
36202	36210	}
36203	36211	else
36204	36212	{
36205		- const struct def cur = (_12).data;
	36213	+ const struct def cur = (_13).data;
36206	36214	{
36207		- bool _16;
	36215	+ bool _17;
36208	36216	{
36209		- const bool _17 = &(cur).partial;
36210		- not(&_16, &*_17);
	36217	+ const bool _18 = &(cur).partial;
	36218	+ not(&_17, &*_18);
36211	36219	}
36212		- if(_16)
	36220	+ if(_17)
36213	36221	{
36214	36222	{
36215		- const struct StreamOut _18 = &(streams).err;
36216		- struct string _19; memset(&_19, 0, sizeof(struct string));
36217		- init$fromliteral(&_19, "redeclaration/redefinition of function ", 39);
36218		- PutStr(0 /* _17 /, &_18, &_19);
36219		- string$dest(&_19);
36220		- }
36221		- {
36222	36223	const struct StreamOut _19 = &(streams).err;
36223	36224	struct string _20; memset(&_20, 0, sizeof(struct string));
36224		- {
36225		- nonempty_to_string(&_20, &_id);
36226		- }
	36225	+ init$fromliteral(&_20, "redeclaration/redefinition of function ", 39);
36227	36226	PutStr(0 /* _18 /, &_19, &_20);
36228	36227	string$dest(&_20);
36229	36228	}

		@@ -36230,45 +36229,45 @@
36230	36229	{
36231	36230	const struct StreamOut _20 = &(streams).err;
36232	36231	struct string _21; memset(&_21, 0, sizeof(struct string));
36233		- init$fromliteral(&_21, " - non-partial functions must be defined at most once", 53);
	36232	+ {
	36233	+ nonempty_to_string(&_21, &_id);
	36234	+ }
36234	36235	PutStr(0 /* _19 /, &_20, &_21);
36235	36236	string$dest(&_21);
36236	36237	}
36237	36238	{
36238	36239	const struct StreamOut _21 = &(streams).err;
36239		- Fail$(0 /* _20 /, &_21, &*txtpos);
	36240	+ struct string _22; memset(&_22, 0, sizeof(struct string));
	36241	+ init$fromliteral(&_22, " - non-partial functions must be defined at most once", 53);
	36242	+ PutStr(0 /* _20 /, &_21, &_22);
	36243	+ string$dest(&_22);
36240	36244	}
	36245	+ {
	36246	+ const struct StreamOut _22 = &(streams).err;
	36247	+ Fail$(0 /* _21 /, &_22, &*txtpos);
	36248	+ }
36241	36249	}
36242		- bool _18;
	36250	+ bool _19;
36243	36251	{
36244		- bool _19; memset(&_19, 0, sizeof(bool));
	36252	+ bool _20; memset(&_20, 0, sizeof(bool));
36245	36253	{
36246		- const struct type _20 = &(cur).re;
36247		- struct type _21; memset(&_21, 0, sizeof(struct type));
	36254	+ const struct type _21 = &(cur).re;
	36255	+ struct type _22; memset(&_22, 0, sizeof(struct type));
36248	36256	{
36249		- Expand(&_21, &_retype);
	36257	+ Expand(&_22, &_retype);
36250	36258	}
36251		- typeequ(&_19, &*_20, &_21);
36252		- type$dest(&_21);
	36259	+ typeequ(&_20, &*_21, &_22);
	36260	+ type$dest(&_22);
36253	36261	}
36254		- not(&_18, &_19);
36255		- _IGNORE_(_19);
	36262	+ not(&_19, &_20);
	36263	+ _IGNORE_(_20);
36256	36264	}
36257		- if(_18)
	36265	+ if(_19)
36258	36266	{
36259	36267	{
36260		- const struct StreamOut _20 = &(streams).err;
36261		- struct string _21; memset(&_21, 0, sizeof(struct string));
36262		- init$fromliteral(&_21, "redeclaration of function ", 26);
36263		- PutStr(0 /* _19 /, &_20, &_21);
36264		- string$dest(&_21);
36265		- }
36266		- {
36267	36268	const struct StreamOut _21 = &(streams).err;
36268	36269	struct string _22; memset(&_22, 0, sizeof(struct string));
36269		- {
36270		- nonempty_to_string(&_22, &_id);
36271		- }
	36270	+ init$fromliteral(&_22, "redeclaration of function ", 26);
36272	36271	PutStr(0 /* _20 /, &_21, &_22);
36273	36272	string$dest(&_22);
36274	36273	}

		@@ -36275,49 +36274,58 @@
36275	36274	{
36276	36275	const struct StreamOut _22 = &(streams).err;
36277	36276	struct string _23; memset(&_23, 0, sizeof(struct string));
36278		- init$fromliteral(&_23, " with differing return-type: previously ", 40);
	36277	+ {
	36278	+ nonempty_to_string(&_23, &_id);
	36279	+ }
36279	36280	PutStr(0 /* _21 /, &_22, &_23);
36280	36281	string$dest(&_23);
36281	36282	}
36282	36283	{
36283	36284	const struct StreamOut _23 = &(streams).err;
36284		- const struct type _24 = &(cur).re;
36285		- EPrType(0 /* _22 /, &_23, &*_24);
	36285	+ struct string _24; memset(&_24, 0, sizeof(struct string));
	36286	+ init$fromliteral(&_24, " with differing return-type: previously ", 40);
	36287	+ PutStr(0 /* _22 /, &_23, &_24);
	36288	+ string$dest(&_24);
36286	36289	}
36287	36290	{
36288	36291	const struct StreamOut _24 = &(streams).err;
36289		- struct string _25; memset(&_25, 0, sizeof(struct string));
36290		- init$fromliteral(&_25, ", currently ", 12);
36291		- PutStr(0 /* _23 /, &_24, &_25);
36292		- string$dest(&_25);
	36292	+ const struct type _25 = &(cur).re;
	36293	+ EPrType(0 /* _23 /, &_24, &*_25);
36293	36294	}
36294	36295	{
36295	36296	const struct StreamOut _25 = &(streams).err;
36296		- EPrTypePure(0 /* _24 /, &_25, &_retype);
	36297	+ struct string _26; memset(&_26, 0, sizeof(struct string));
	36298	+ init$fromliteral(&_26, ", currently ", 12);
	36299	+ PutStr(0 /* _24 /, &_25, &_26);
	36300	+ string$dest(&_26);
36297	36301	}
36298	36302	{
36299	36303	const struct StreamOut _26 = &(streams).err;
36300		- Fail$(0 /* _25 /, &_26, &*txtpos);
	36304	+ EPrTypePure(0 /* _25 /, &_26, &_retype);
36301	36305	}
	36306	+ {
	36307	+ const struct StreamOut _27 = &(streams).err;
	36308	+ Fail$(0 /* _26 /, &_27, &*txtpos);
	36309	+ }
36302	36310	}
36303	36311	else
36304	36312	{
36305		- bool _19;
	36313	+ bool _20;
36306	36314	{
36307	36315	struct fnstat _c; memset(&_c, 0, sizeof(struct fnstat));
36308	36316	fnstat$copy(&_c, &(*cur).fnstat);
36309		- bool _20; memset(&_20, 0, sizeof(bool));
36310		- const struct fnstat *_21 = &(_c);
36311		- switch((*_21).type)
	36317	+ bool _21; memset(&_21, 0, sizeof(bool));
	36318	+ const struct fnstat *_22 = &(_c);
	36319	+ switch((*_22).type)
36312	36320	{
36313	36321	case 0: // void declared:
36314	36322	{
36315		- _20 = 0;
	36323	+ _21 = 0;
36316	36324	break;
36317	36325	}
36318	36326	case 1: // void defined:
36319	36327	{
36320		- _20 = 1;
	36328	+ _21 = 1;
36321	36329	break;
36322	36330	}
36323	36331	default:

		@@ -36326,122 +36334,121 @@
36326	36334	break;
36327	36335	}
36328	36336	}
36329		- _19 = _20;
36330		- _IGNORE_(_20);
	36337	+ _20 = _21;
	36338	+ _IGNORE_(_21);
36331	36339	fnstat$dest(&_c);
36332	36340	}
36333		- if(_19)
	36341	+ if(_20)
36334	36342	{
36335	36343	{
36336		- const struct StreamOut _21 = &(streams).err;
36337		- struct string _22; memset(&_22, 0, sizeof(struct string));
36338		- init$fromliteral(&_22, "redefinition of function ", 25);
36339		- PutStr(0 /* _20 /, &_21, &_22);
36340		- string$dest(&_22);
36341		- }
36342		- {
36343	36344	const struct StreamOut _22 = &(streams).err;
36344	36345	struct string _23; memset(&_23, 0, sizeof(struct string));
36345		- {
36346		- nonempty_to_string(&_23, &_id);
36347		- }
	36346	+ init$fromliteral(&_23, "redefinition of function ", 25);
36348	36347	PutStr(0 /* _21 /, &_22, &_23);
36349	36348	string$dest(&_23);
36350	36349	}
36351	36350	{
36352	36351	const struct StreamOut _23 = &(streams).err;
36353		- Fail$(0 /* _22 /, &_23, &*txtpos);
	36352	+ struct string _24; memset(&_24, 0, sizeof(struct string));
	36353	+ {
	36354	+ nonempty_to_string(&_24, &_id);
	36355	+ }
	36356	+ PutStr(0 /* _22 /, &_23, &_24);
	36357	+ string$dest(&_24);
36354	36358	}
	36359	+ {
	36360	+ const struct StreamOut _24 = &(streams).err;
	36361	+ Fail$(0 /* _23 /, &_24, &*txtpos);
	36362	+ }
36355	36363	}
36356	36364	}
36357	36365	{
36358		- const struct StreamOut _21 = &(streams).err;
36359		- struct typeid _22; memset(&_22, 0, sizeof(struct typeid));
	36366	+ const struct StreamOut _22 = &(streams).err;
	36367	+ struct typeid _23; memset(&_23, 0, sizeof(struct typeid));
36360	36368	{
36361		- struct type _23; memset(&_23, 0, sizeof(struct type));
	36369	+ struct type _24; memset(&_24, 0, sizeof(struct type));
36362	36370	{
36363		- Expand(&_23, &_retype);
	36371	+ Expand(&_24, &_retype);
36364	36372	}
36365		- typeid(&_22, &_23, &_id);
36366		- type$dest(&_23);
	36373	+ typeid(&_23, &_24, &_id);
	36374	+ type$dest(&_24);
36367	36375	}
36368		- const struct stack/qtype/ _23 = &(cur).pars;
36369		- uint64_t _24; memset(&_24, 0, sizeof(uint64_t));
36370		- _24 = 0;
36371		- ParChk$(0 /* _20 /, &_21, &txtpos, &_22, &_23, &_pars, &_24);
36372		- _IGNORE_(_24);
36373		- typeid$dest(&_22);
	36376	+ const struct stack/qtype/ _24 = &(cur).pars;
	36377	+ uint64_t _25; memset(&_25, 0, sizeof(uint64_t));
	36378	+ _25 = 0;
	36379	+ ParChk$(0 /* _21 /, &_22, &txtpos, &_23, &_24, &_pars, &_25);
	36380	+ _IGNORE_(_25);
	36381	+ typeid$dest(&_23);
36374	36382	}
36375	36383	}
36376	36384	}
36377	36385	{
36378		- struct stack/def/ _16 = &(state).defs;
36379		- struct def _17; memset(&_17, 0, sizeof(struct def));
	36386	+ struct stack/def/ _17 = &(state).defs;
	36387	+ struct def _18; memset(&_18, 0, sizeof(struct def));
36380	36388	{
36381		- struct focus _18; memset(&_18, 0, sizeof(struct focus));
	36389	+ struct focus _19; memset(&_19, 0, sizeof(struct focus));
36382	36390	{
36383		- general(&_18);
	36391	+ general(&_19);
36384	36392	}
36385		- struct type _19; memset(&_19, 0, sizeof(struct type));
	36393	+ struct type _20; memset(&_20, 0, sizeof(struct type));
36386	36394	{
36387		- Expand(&_19, &_retype);
	36395	+ Expand(&_20, &_retype);
36388	36396	}
36389		- struct fnstat _20; memset(&_20, 0, sizeof(struct fnstat));
	36397	+ struct fnstat _21; memset(&_21, 0, sizeof(struct fnstat));
36390	36398	{
36391		- defined(&_20);
	36399	+ defined(&_21);
36392	36400	}
36393		- definit(&_17, &_18, &_19, &_id, &_20, &_pars);
36394		- fnstat$dest(&_20);
36395		- type$dest(&_19);
36396		- focus$dest(&_18);
	36401	+ definit(&_18, &_19, &_20, &_id, &_21, &_pars);
	36402	+ fnstat$dest(&_21);
	36403	+ type$dest(&_20);
	36404	+ focus$dest(&_19);
36397	36405	}
36398		- declfin(0 /* _15 /, &_16, &_17);
36399		- def$dest(&_17);
	36406	+ declfin(0 /* _16 /, &_17, &_18);
	36407	+ def$dest(&_18);
36400	36408	}
36401	36409	{
36402		- const struct StreamOut _17 = &(streams).out;
36403		- struct string _18; memset(&_18, 0, sizeof(struct string));
36404		- init$fromliteral(&_18, "", 0);
36405		- PutStrLn(0 /* _16 /, &_17, &_18);
36406		- string$dest(&_18);
36407		- }
36408		- {
36409	36410	const struct StreamOut _18 = &(streams).out;
36410	36411	struct string _19; memset(&_19, 0, sizeof(struct string));
36411		- init$fromliteral(&_19, "void ", 5);
36412		- PutStr(0 /* _17 /, &_18, &_19);
	36412	+ init$fromliteral(&_19, "", 0);
	36413	+ PutStrLn(0 /* _17 /, &_18, &_19);
36413	36414	string$dest(&_19);
36414	36415	}
36415	36416	{
36416	36417	const struct StreamOut _19 = &(streams).out;
36417	36418	struct string _20; memset(&_20, 0, sizeof(struct string));
36418		- {
36419		- nonempty_to_string(&_20, &_id);
36420		- }
	36419	+ init$fromliteral(&_20, "void ", 5);
36421	36420	PutStr(0 /* _18 /, &_19, &_20);
36422	36421	string$dest(&_20);
36423	36422	}
36424	36423	{
36425		- const struct stack/qtypepure/ _20 = &(ps).qts;
36426		- EmitGenericParams$(0 /* _19 /, &streams, &_retype, &*_20, &_sp);
	36424	+ const struct StreamOut _20 = &(streams).out;
	36425	+ struct string _21; memset(&_21, 0, sizeof(struct string));
	36426	+ {
	36427	+ nonempty_to_string(&_21, &_id);
	36428	+ }
	36429	+ PutStr(0 /* _19 /, &_20, &_21);
	36430	+ string$dest(&_21);
36427	36431	}
36428	36432	{
36429		- const struct StreamOut _21 = &(streams).out;
36430		- struct string _22; memset(&_22, 0, sizeof(struct string));
36431		- init$fromliteral(&_22, ";", 1);
36432		- PutStrLn(0 /* _20 /, &_21, &_22);
36433		- string$dest(&_22);
	36433	+ const struct stack/qtypepure/ _21 = &(ps).qts;
	36434	+ EmitGenericParams$(0 /* _20 /, &streams, &_retype, &*_21, &_sp);
36434	36435	}
36435	36436	{
36436	36437	const struct StreamOut _22 = &(streams).out;
36437	36438	struct string _23; memset(&_23, 0, sizeof(struct string));
36438		- init$fromliteral(&_23, "", 0);
	36439	+ init$fromliteral(&_23, ";", 1);
36439	36440	PutStrLn(0 /* _21 /, &_22, &_23);
36440	36441	string$dest(&_23);
36441	36442	}
	36443	+ {
	36444	+ const struct StreamOut _23 = &(streams).out;
	36445	+ struct string _24; memset(&_24, 0, sizeof(struct string));
	36446	+ init$fromliteral(&_24, "", 0);
	36447	+ PutStrLn(0 /* _22 /, &_23, &_24);
	36448	+ string$dest(&_24);
	36449	+ }
36442	36450	free$(&_cur, sizeof(struct def), (void ()(void ))def$dest);
36443	36451	free$(&_pars, sizeof(struct qtype), (void ()(void ))qtype$dest);
36444		- free$(&_prps, sizeof(struct qtypepure), (void ()(void ))qtypepure$dest);
36445	36452	}
36446	36453	struct stack/qtypepureid/ _parids; memset(&_parids, 0, sizeof(struct stack/qtypepureid/));
36447	36454	{

		@@ -36485,7 +36492,7 @@
36485	36492	{
36486	36493	struct stack/par/ _15; memset(&_15, 0, sizeof(struct stack/par/));
36487	36494	{
36488		- stack(&_15, sizeof(struct par), (void ()(void ))par$dest, (void ()(void , const void *))par$copy, 7025);
	36495	+ stack(&_15, sizeof(struct par), (void ()(void ))par$dest, (void ()(void , const void *))par$copy, 7026);
36489	36496	}
36490	36497	pscope(&_14, &_15);
36491	36498	free$(&_15, sizeof(struct par), (void ()(void ))par$dest);

		@@ -36492,13 +36499,13 @@
36492	36499	}
36493	36500	struct stack/vscope/ _15; memset(&_15, 0, sizeof(struct stack/vscope/));
36494	36501	{
36495		- stack(&_15, sizeof(struct vscope), (void ()(void ))vscope$dest, (void ()(void , const void *))vscope$copy, 7025);
	36502	+ stack(&_15, sizeof(struct vscope), (void ()(void ))vscope$dest, (void ()(void , const void *))vscope$copy, 7026);
36496	36503	}
36497	36504	struct vscope _16; memset(&_16, 0, sizeof(struct vscope));
36498	36505	{
36499	36506	struct stack/var/ _17; memset(&_17, 0, sizeof(struct stack/var/));
36500	36507	{
36501		- stack(&_17, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 7025);
	36508	+ stack(&_17, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 7026);
36502	36509	}
36503	36510	vscope(&_16, &_17);
36504	36511	free$(&_17, sizeof(struct var), (void ()(void ))var$dest);

		@@ -37484,7 +37491,7 @@
37484	37491	varinit(&_56, &_57);
37485	37492	qtypepureid$dest(&_57);
37486	37493	}
37487		- push(0 /* _54 /, &_55, &_56, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 7210);
	37494	+ push(0 /* _54 /, &_55, &_56, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 7211);
37488	37495	var$dest(&_56);
37489	37496	}
37490	37497	{

		@@ -37574,7 +37581,7 @@
37574	37581	varinit(&_67, &_68);
37575	37582	qtypepureid$dest(&_68);
37576	37583	}
37577		- push(0 /* _65 /, &_66, &_67, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 7218);
	37584	+ push(0 /* _65 /, &_66, &_67, sizeof(struct var), (void ()(void ))var$dest, (void ()(void , const void *))var$copy, 7219);
37578	37585	var$dest(&_67);
37579	37586	}
37580	37587	{

		@@ -37647,7 +37654,7 @@
37647	37654	}
37648	37655	struct stack/ReducedId/ _30; memset(&_30, 0, sizeof(struct stack/ReducedId/));
37649	37656	{
37650		- stack(&_30, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 7226);
	37657	+ stack(&_30, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 7227);
37651	37658	}
37652	37659	ParseExpr2$(0 /* _28 /, &streams, &txtpos, &state, &_level, &_sp, &_tmpnr, &_store, &_totality, &_action, &_29, &_30);
37653	37660	free$(&_30, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest);

		@@ -37690,7 +37697,7 @@
37690	37697	qtypepureid(&_30, &_31, &*_32);
37691	37698	qtypepure$dest(&_31);
37692	37699	}
37693		- solid(&_29, &_30, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 7232);
	37700	+ solid(&_29, &_30, sizeof(struct qtypepureid), (void ()(void ))qtypepureid$dest, (void ()(void , const void *))qtypepureid$copy, 7233);
37694	37701	qtypepureid$dest(&_30);
37695	37702	}
37696	37703	struct string _30; memset(&_30, 0, sizeof(struct string));

		@@ -37699,7 +37706,7 @@
37699	37706	}
37700	37707	struct stack/ReducedId/ _31; memset(&_31, 0, sizeof(struct stack/ReducedId/));
37701	37708	{
37702		- stack(&_31, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 7232);
	37709	+ stack(&_31, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest, (void ()(void , const void *))ReducedId$copy, 7233);
37703	37710	}
37704	37711	ParseBlock$(0 /* _28 /, &streams, &txtpos, &state, &_level, &_sp, &_tmpnr, &_29, &_totality, &_action, &_30, &_31);
37705	37712	free$(&_31, sizeof(struct ReducedId), (void ()(void ))ReducedId$dest);

		@@ -38052,11 +38059,11 @@
38052	38059	{
38053	38060	struct stack/def/ _1; memset(&_1, 0, sizeof(struct stack/def/));
38054	38061	{
38055		- stack(&_1, sizeof(struct def), (void ()(void ))def$dest, (void ()(void , const void *))def$copy, 7323);
	38062	+ stack(&_1, sizeof(struct def), (void ()(void ))def$dest, (void ()(void , const void *))def$copy, 7324);
38056	38063	}
38057	38064	struct stack/structdef/ _2; memset(&_2, 0, sizeof(struct stack/structdef/));
38058	38065	{
38059		- stack(&_2, sizeof(struct structdef), (void ()(void ))structdef$dest, (void ()(void , const void *))structdef$copy, 7323);
	38066	+ stack(&_2, sizeof(struct structdef), (void ()(void ))structdef$dest, (void ()(void , const void *))structdef$copy, 7324);
38060	38067	}
38061	38068	state(&_state, &_1, &_2);
38062	38069	free$(&_2, sizeof(struct structdef), (void ()(void ))structdef$dest);

		@@ -38561,7 +38568,7 @@
38561	38568	nonempty_string$dest(&_5);
38562	38569	type_pure$dest(&_4);
38563	38570	}
38564		- push(0 /* _2 /, &_elems, &_3, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void ))typepureid$copy, 7791);
	38571	+ push(0 /* _2 /, &_elems, &_3, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void ))typepureid$copy, 7792);
38565	38572	typepureid$dest(&_3);
38566	38573	}
38567	38574	{

		@@ -38606,7 +38613,7 @@
38606	38613	}
38607	38614	struct stack/typepureid/ _7; memset(&_7, 0, sizeof(struct stack/typepureid/));
38608	38615	{
38609		- stack(&_7, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 7796);
	38616	+ stack(&_7, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 7797);
38610	38617	}
38611	38618	constr(&_4, &_5, &_6, &_7);
38612	38619	free$(&_7, sizeof(struct typepureid), (void ()(void ))typepureid$dest);

		@@ -38613,7 +38620,7 @@
38613	38620	nonempty_string$dest(&_6);
38614	38621	type_pure$dest(&_5);
38615	38622	}
38616		- push(0 /* _3 /, &_constrs, &_4, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void ))constr$copy, 7796);
	38623	+ push(0 /* _3 /, &_constrs, &_4, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void ))constr$copy, 7797);
38617	38624	constr$dest(&_4);
38618	38625	}
38619	38626	{

		@@ -38635,7 +38642,7 @@
38635	38642	}
38636	38643	struct stack/typepureid/ _8; memset(&_8, 0, sizeof(struct stack/typepureid/));
38637	38644	{
38638		- stack(&_8, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 7797);
	38645	+ stack(&_8, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 7798);
38639	38646	}
38640	38647	constr(&_5, &_6, &_7, &_8);
38641	38648	free$(&_8, sizeof(struct typepureid), (void ()(void ))typepureid$dest);

		@@ -38642,7 +38649,7 @@
38642	38649	nonempty_string$dest(&_7);
38643	38650	type_pure$dest(&_6);
38644	38651	}
38645		- push(0 /* _4 /, &_constrs, &_5, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void ))constr$copy, 7797);
	38652	+ push(0 /* _4 /, &_constrs, &_5, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void ))constr$copy, 7798);
38646	38653	constr$dest(&_5);
38647	38654	}
38648	38655	{

		@@ -38664,7 +38671,7 @@
38664	38671	}
38665	38672	struct stack/typepureid/ _9; memset(&_9, 0, sizeof(struct stack/typepureid/));
38666	38673	{
38667		- stack(&_9, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 7798);
	38674	+ stack(&_9, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void *))typepureid$copy, 7799);
38668	38675	}
38669	38676	constr(&_6, &_7, &_8, &_9);
38670	38677	free$(&_9, sizeof(struct typepureid), (void ()(void ))typepureid$dest);

		@@ -38671,7 +38678,7 @@
38671	38678	nonempty_string$dest(&_8);
38672	38679	type_pure$dest(&_7);
38673	38680	}
38674		- push(0 /* _5 /, &_constrs, &_6, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void ))constr$copy, 7798);
	38681	+ push(0 /* _5 /, &_constrs, &_6, sizeof(struct constr), (void ()(void ))constr$dest, (void ()(void , const void ))constr$copy, 7799);
38675	38682	constr$dest(&_6);
38676	38683	}
38677	38684	{

		@@ -43691,7 +43698,7 @@
43691	43698	nonempty_string$dest(&_66);
43692	43699	type_pure$dest(&_65);
43693	43700	}
43694		- push(0 /* _63 /, &_elems, &_64, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void ))typepureid$copy, 8588);
	43701	+ push(0 /* _63 /, &_elems, &_64, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void ))typepureid$copy, 8589);
43695	43702	typepureid$dest(&_64);
43696	43703	}
43697	43704	{

		@@ -43715,7 +43722,7 @@
43715	43722	nonempty_string$dest(&_67);
43716	43723	type_pure$dest(&_66);
43717	43724	}
43718		- push(0 /* _64 /, &_elems, &_65, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void ))typepureid$copy, 8589);
	43725	+ push(0 /* _64 /, &_elems, &_65, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void ))typepureid$copy, 8590);
43719	43726	typepureid$dest(&_65);
43720	43727	}
43721	43728	{

		@@ -43739,7 +43746,7 @@
43739	43746	nonempty_string$dest(&_68);
43740	43747	type_pure$dest(&_67);
43741	43748	}
43742		- push(0 /* _65 /, &_elems, &_66, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void ))typepureid$copy, 8590);
	43749	+ push(0 /* _65 /, &_elems, &_66, sizeof(struct typepureid), (void ()(void ))typepureid$dest, (void ()(void , const void ))typepureid$copy, 8591);
43743	43750	typepureid$dest(&_66);
43744	43751	}
43745	43752	{

		@@ -43764,7 +43771,7 @@
43764	43771	nonempty_string$dest(&_70);
43765	43772	flavour$dest(&_69);
43766	43773	}
43767		- push(0 /* _66 /, &_67, &_68, sizeof(struct structdef), (void ()(void ))structdef$dest, (void ()(void , const void *))structdef$copy, 8591);
	43774	+ push(0 /* _66 /, &_67, &_68, sizeof(struct structdef), (void ()(void ))structdef$dest, (void ()(void , const void *))structdef$copy, 8592);
43768	43775	structdef$dest(&_68);
43769	43776	}
43770	43777	free$(&_elems, sizeof(struct typepureid), (void ()(void ))typepureid$dest);

--- trunk/pragmatic/compiler.source.c (revision 410)

+++ trunk/pragmatic/compiler.source.c (revision 411)

		@@ -5044,6 +5044,9 @@
5044	5044	push<var>(sp.current.elems, varhide(nonempty_string('*', nonempty_to_string(id)), txtpos));
5045	5045	};
5046	5046
	5047	+ let mut qtypepureid container = container;
	5048	+ let _ /idpath ip/ = ParsePath$(streams, txtpos, level, sp, state.structs, tmpnr, container);
	5049	+
5047	5050	let opt<nonempty_string> to = ParseIdOrGap$(streams, txtpos, level);
5048	5051	let nonempty_string id =
5049	5052	switch to

		@@ -6354,15 +6357,15 @@
6354	6357	// Put(streams.out, ')');
6355	6358	//}
6356	6359
6357		-unit EmitGenericArgsId$(Streams streams, stack<qtypepureid> content)
	6360	+unit EmitGenericArgsId$(Streams streams, stack<qtypepureid> args)
6358	6361	{
6359	6362	Put(streams.out, '(');
6360	6363
6361	6364	PutStr(streams.out, nonempty_to_string(resid()));
6362	6365
6363		- for content elem
	6366	+ for args arg
6364	6367	{
6365		- PutStr(streams.out, ", &("); PutStr(streams.out, nonempty_to_string(elem.id)); PutStr(streams.out, ")");
	6368	+ PutStr(streams.out, ", &("); PutStr(streams.out, nonempty_to_string(arg.id)); PutStr(streams.out, ")");
6366	6369	};
6367	6370
6368	6371	Put(streams.out, ')');

		@@ -6377,12 +6380,12 @@
6377	6380
6378	6381	// Emit parameters
6379	6382	let mut u64 parnr = 0;
6380		- for parids elem
	6383	+ for parids parid
6381	6384	{
6382	6385	PutStr(streams.out, ", ");
6383	6386
6384	6387	//let qtypepureid par = qtypepureid(elem, preapp('_', GenId$(size<match>(parmatches), ""))); // NOTE: parameters start at 1 (0 reserved for result)
6385		- let qtypepureid par = qtypepureid(elem, GenVar$(parnr)); // NOTE: GenVar PRE-increments number, so parameters start at 1 (0 reserved for result)
	6388	+ let qtypepureid par = qtypepureid(parid, GenVar$(parnr)); // NOTE: GenVar PRE-increments number, so parameters start at 1 (0 reserved for result)
6386	6389	ParEmitGeneric(streams.out, sp, par);
6387	6390	};
6388	6391

		@@ -6410,13 +6413,13 @@
6410	6413	PutStr(streams.out, name); Put(streams.out, '$'); Print<u64>(streams.out, casenr); EmitGenericArgsId$(streams, parids); PutStrLn(streams.out, ";");
6411	6414	}
6412	6415
6413		-stack<qtypepureid> AttachGenericIds$(stack<qtypepure> content)
	6416	+stack<qtypepureid> AttachGenericIds$(stack<qtypepure> ids)
6414	6417	{
6415	6418	let mut u64 nr = 0;
6416	6419	let mut stack<qtypepureid> qtpis;
6417		- for content elem
	6420	+ for ids id
6418	6421	{
6419		- push<qtypepureid>(qtpis, qtypepureid(elem, GenPar$(nr))); // pre-increment: start counting from 1 since 0 is reserved for result
	6422	+ push<qtypepureid>(qtpis, qtypepureid(id, GenPar$(nr))); // pre-increment: start counting from 1 since 0 is reserved for result
6420	6423	};
6421	6424	result
6422	6425	qtpis

		@@ -6443,7 +6446,6 @@
6443	6446	{
6444	6447	let mut bool first = 1;
6445	6448	let stack<qtypepureid> content = attachQualifier(elems, par.qt.qualifier);
6446		- let stack<qtypepureid> content_ = content;
6447	6449	for content econtent
6448	6450	{
6449	6451	if first then

		@@ -6474,7 +6476,7 @@
6474	6476	};
6475	6477	};
6476	6478
6477		- ParseMatch$(streams, txtpos, structs, level, sp, tmpnr, elem, casenr, ti, content_, usedids, reduced_ids);
	6479	+ ParseMatch$(streams, txtpos, structs, level, sp, tmpnr, elem, casenr, ti, content, usedids, reduced_ids);
6478	6480	};
6479	6481	};
6480	6482	}

		@@ -6958,11 +6960,10 @@
6958	6960	case fnpartypes: // pattern-matching function definition syntax
6959	6961	{
6960	6962	{
6961		- let stack<qtypepure> prps = ps.qts;
6962	6963	let mut stack<qtype> pars;
6963		- for prps prp
	6964	+ for ps.qts par
6964	6965	{
6965		- push<qtype>(pars, qtype(prp.qualifier, Expand(prp.type)));
	6966	+ push<qtype>(pars, qtype(par.qualifier, Expand(par.type)));
6966	6967	};
6967	6968
6968	6969	let opt<def> cur = findFnDef(state.defs, nonempty_to_string(id));

--- trunk/pragmatic/memory_tests/mem_tests.c (revision 410)

+++ trunk/pragmatic/memory_tests/mem_tests.c (revision 411)

		@@ -584,14 +584,14 @@
584	584	}
585	585	term: size<string>(s);
586	586
587		-unit TestIterateStream(StreamIn in, StreamOut out)
	587	+unit TestIterateStream(Streams streams)
588	588	{
589		- PutStrLn(out, "Test iterate stream-in");
590		- for in c
	589	+ PutStrLn(streams.out, "Test iterate stream-in");
	590	+ for streams.in c
591	591	{
592		- Put(out, c);
	592	+ Put(streams.out, c);
593	593	};
594		- PutStrLn(out, ".");
	594	+ PutStrLn(streams.out, ".");
595	595	}
596	596
597	597	unit TestNestedLoop(StreamOut out)

		@@ -696,7 +696,7 @@
696	696	Print<stack<string>>(streams.out, orig);
697	697	PutStrLn(streams.out, "");
698	698
699		- TestIterateStream(streams.in, streams.out);
	699	+ TestIterateStream(streams);
700	700
701	701	TestNestedLoop(streams.out);
702	702

--- trunk/pragmatic/memory_tests/mem_tests_compiled.c (revision 410)

+++ trunk/pragmatic/memory_tests/mem_tests_compiled.c (revision 411)

		@@ -3852,27 +3852,31 @@
3852	3852	}
3853	3853	}
3854	3854
3855		-void TestIterateStream(void const _0, const struct StreamIn const in, const struct StreamOut *const out)
	3855	+void TestIterateStream(void const _0, const struct Streams const streams)
3856	3856	{
3857	3857	{
3858	3858	{
3859		- struct string _2; memset(&_2, 0, sizeof(struct string));
3860		- init$fromliteral(&_2, "Test iterate stream-in", 22);
3861		- PutStrLn(0 /* _1 /, &out, &_2);
3862		- string$dest(&_2);
	3859	+ const struct StreamOut _2 = &(streams).out;
	3860	+ struct string _3; memset(&_3, 0, sizeof(struct string));
	3861	+ init$fromliteral(&_3, "Test iterate stream-in", 22);
	3862	+ PutStrLn(0 /* _1 /, &_2, &_3);
	3863	+ string$dest(&_3);
3863	3864	}
3864		- for(int _2 = getc((in).f); _2 >= 0; _2 = getc((in).f))
	3865	+ const struct StreamIn _2 = &(streams).in;
	3866	+ for(int _3 = getc((_2).f); _3 >= 0; _3 = getc((_2).f))
3865	3867	{
3866		- const uint8_t _c = (uint8_t)_2;
	3868	+ const uint8_t _c = (uint8_t)_3;
3867	3869	{
3868		- Put(0 /* _3 /, &out, &_c);
	3870	+ const struct StreamOut _5 = &(streams).out;
	3871	+ Put(0 /* _4 /, &_5, &_c);
3869	3872	}
3870	3873	}
3871	3874	{
3872		- struct string _4; memset(&_4, 0, sizeof(struct string));
3873		- init$fromliteral(&_4, ".", 1);
3874		- PutStrLn(0 /* _3 /, &out, &_4);
3875		- string$dest(&_4);
	3875	+ const struct StreamOut _5 = &(streams).out;
	3876	+ struct string _6; memset(&_6, 0, sizeof(struct string));
	3877	+ init$fromliteral(&_6, ".", 1);
	3878	+ PutStrLn(0 /* _4 /, &_5, &_6);
	3879	+ string$dest(&_6);
3876	3880	}
3877	3881	}
3878	3882	}

		@@ -5177,9 +5181,7 @@
5177	5181	string$dest(&_24);
5178	5182	}
5179	5183	{
5180		- const struct StreamIn _24 = &(streams).in;
5181		- const struct StreamOut _25 = &(streams).out;
5182		- TestIterateStream(0 /* _23 /, &_24, &*_25);
	5184	+ TestIterateStream(0 /* _23 /, &streams);
5183	5185	}
5184	5186	{
5185	5187	const struct StreamOut _25 = &(streams).out;

Show on old repository browser