WebSVN – tendra.SVN – Blame – /trunk/src/producers/cpp/syntax/syntax5.c

Rev	Author	Line No.	Line
2	7u83	1	`/*`
		2	`* Automatically generated from the files:`
7	7u83	3	`* syntax.sid`
2	7u83	4	`* and`
7	7u83	5	`* syntax.act`
2	7u83	6	`* by:`
		7	`* sid`
		8	`*/`
		9
		10	`/* BEGINNING OF HEADER */`
		11
		12	`#define __SID_SPLIT`
		13
		14	`/*`
		15	`Crown Copyright (c) 1997, 1998`
		16
		17	`This TenDRA(r) Computer Program is subject to Copyright`
		18	`owned by the United Kingdom Secretary of State for Defence`
		19	`acting through the Defence Evaluation and Research Agency`
		20	`(DERA). It is made available to Recipients with a`
		21	`royalty-free licence for its use, reproduction, transfer`
		22	`to other parties and amendment for any purpose not excluding`
		23	`product development provided that any such use et cetera`
		24	`shall be deemed to be acceptance of the following conditions:-`
		25
		26	`(1) Its Recipients shall ensure that this Notice is`
		27	`reproduced upon any copies or amended versions of it;`
		28
		29	`(2) Any amended version of it shall be clearly marked to`
		30	`show both the nature of and the organisation responsible`
		31	`for the relevant amendment or amendments;`
		32
		33	`(3) Its onward transfer from a recipient to another`
		34	`party shall be deemed to be that party's acceptance of`
		35	`these conditions;`
		36
		37	`(4) DERA gives no warranty or assurance as to its`
		38	`quality or suitability for any purpose and DERA accepts`
		39	`no liability whatsoever in relation to any use to which`
		40	`it may be put.`
		41	`*/`
		42
		43
		44	`#include "config.h"`
		45	`#include "c_types.h"`
		46	`#include "ctype_ops.h"`
		47	`#include "exp_ops.h"`
		48	`#include "hashid_ops.h"`
		49	`#include "id_ops.h"`
		50	`#include "nspace_ops.h"`
		51	`#include "type_ops.h"`
		52	`#include "error.h"`
		53	`#include "catalog.h"`
		54	`#include "option.h"`
		55	`#include "access.h"`
		56	`#include "allocate.h"`
		57	`#include "assign.h"`
		58	`#include "basetype.h"`
		59	`#include "cast.h"`
		60	`#include "chktype.h"`
		61	`#include "class.h"`
		62	`#include "constant.h"`
		63	`#include "construct.h"`
		64	`#include "convert.h"`
		65	`#include "declare.h"`
		66	`#include "derive.h"`
		67	`#include "dump.h"`
		68	`#include "exception.h"`
		69	`#include "expression.h"`
		70	`#include "function.h"`
		71	`#include "hash.h"`
		72	`#include "identifier.h"`
		73	`#include "initialise.h"`
		74	`#include "inttype.h"`
		75	`#include "label.h"`
		76	`#include "lex.h"`
		77	`#include "literal.h"`
		78	`#include "member.h"`
		79	`#include "namespace.h"`
		80	`#include "parse.h"`
		81	`#include "pragma.h"`
		82	`#include "predict.h"`
		83	`#include "preproc.h"`
		84	`#include "redeclare.h"`
		85	`#include "rewrite.h"`
		86	`#include "statement.h"`
		87	`#include "symbols.h"`
		88	`#include "template.h"`
		89	`#include "tokdef.h"`
		90	`#include "token.h"`
		91	`#include "typeid.h"`
		92	`#include "variable.h"`
		93
		94
		95	`/*`
		96	`COMPOUND TYPE ALIASES`
		97
		98	`These are the aliases for the compound types used in the parser.`
		99	`*/`
		100
		101	`typedef LIST ( EXP ) SID_LIST_EXP ;`
		102	`typedef LIST ( TYPE ) SID_LIST_TYPE ;`
		103
		104
		105	`/*`
		106	`FUNCTION DECLARATIONS`
		107
		108	`The function declarations are included at this point so that the`
		109	`type definitions are in scope.`
		110	`*/`
		111
		112	`#include "syntax.h"`
		113
		114
		115	`/*`
		116	`COMPILATION MODE`
		117
		118	`The output of sid is automatically generated. Hence it is not`
		119	`necessarily appropriate to apply the same level of checking to this`
		120	`as to the rest of the program. These pragmas describe the relaxations`
		121	`allowed for the sid output.`
		122	`*/`
		123
		124	`#if FS_TENDRA`
		125	`#pragma TenDRA begin`
		126	`#pragma TenDRA const conditional allow`
		127	`#pragma TenDRA unreachable code allow`
		128	`#pragma TenDRA variable analysis off`
		129	`#endif`
		130
		131
		132
		133	`void`
7	7u83	134	`ZR500(SID_LIST_EXP *ZO497)`
2	7u83	135	`{`
		136	`SID_LIST_EXP ZI497;`
		137
		138	`switch (CURRENT_TERMINAL) {`
		139	`case 1: case 2: case 3: case 5: case 6:`
		140	`case 7: case 8: case 9: case 17: case 18:`
		141	`case 19: case 20: case 21: case 22: case 23:`
		142	`case 25: case 33: case 43: case 59: case 61:`
		143	`case 62: case 65: case 69: case 71: case 78:`
		144	`case 83: case 85: case 97: case 102: case 106:`
		145	`case 110: case 111: case 114: case 115: case 116:`
		146	`case 122: case 123: case 127: case 130: case 131:`
		147	`case 132: case 135: case 140: case 141: case 145:`
		148	`case 146: case 148: case 149: case 150: case 152:`
		149	`case 156: case 170: case 184: case 205: case 209:`
		150	`case 285: case 298: case 329:`
		151	`{`
		152	`ZR498 (&ZI497);`
		153	`if ((CURRENT_TERMINAL) == 354) {`
		154	`RESTORE_LEXER;`
		155	`goto ZL1;`
		156	`}`
		157	`}`
		158	`break;`
		159	`default:`
		160	`{`
		161	`{`
		162
		163	`(ZI497) = NULL_list ( EXP ) ;`
		164	`}`
		165	`}`
		166	`break;`
		167	`case 354:`
		168	`return;`
		169	`}`
		170	`goto ZL0;`
		171	`ZL1:;`
		172	`SAVE_LEXER (354);`
		173	`return;`
		174	`ZL0:;`
		175	`*ZO497 = ZI497;`
		176	`}`
		177
		178	`void`
7	7u83	179	`ZR1216(EXP ZI1214, EXP *ZO1215)`
2	7u83	180	`{`
		181	`EXP ZI1215;`
		182
		183	`ZL2_1216:;`
		184	`switch (CURRENT_TERMINAL) {`
		185	`case 48: case 63:`
		186	`{`
		187	`int ZI450;`
		188	`EXP ZI456;`
		189	`EXP ZI431;`
		190
		191	`{`
		192	`(ZI450) = crt_lex_token ;`
		193	`}`
		194	`ZR616 ();`
		195	`ZR614 (&ZI456);`
		196	`if ((CURRENT_TERMINAL) == 354) {`
		197	`RESTORE_LEXER;`
		198	`goto ZL1;`
		199	`}`
		200	`{`
		201
		202	`/* op will be in its primary form */`
		203	`(ZI431) = make_equality_exp ( (ZI450), (ZI1214), (ZI456) ) ;`
		204	`}`
		205	`ZI1214 = ZI431;`
		206	`goto ZL2_1216;`
		207	`}`
		208	`/UNREACHED/`
		209	`default:`
		210	`{`
		211	`ZI1215 = ZI1214;`
		212	`}`
		213	`break;`
		214	`case 354:`
		215	`return;`
		216	`}`
		217	`goto ZL0;`
		218	`ZL1:;`
		219	`SAVE_LEXER (354);`
		220	`return;`
		221	`ZL0:;`
		222	`*ZO1215 = ZI1215;`
		223	`}`
		224
		225	`void`
7	7u83	226	`ZR628(EXP *ZO1195)`
2	7u83	227	`{`
		228	`EXP ZI1195;`
		229
		230	`if ((CURRENT_TERMINAL) == 354) {`
		231	`return;`
		232	`}`
		233	`{`
		234	`EXP ZI431;`
		235
		236	`ZR626 (&ZI431);`
		237	`ZR1196 (ZI431, &ZI1195);`
		238	`if ((CURRENT_TERMINAL) == 354) {`
		239	`RESTORE_LEXER;`
		240	`goto ZL1;`
		241	`}`
		242	`}`
		243	`goto ZL0;`
		244	`ZL1:;`
		245	`SAVE_LEXER (354);`
		246	`return;`
		247	`ZL0:;`
		248	`*ZO1195 = ZI1195;`
		249	`}`
		250
		251	`void`
7	7u83	252	`ZR752(EXP *ZO431)`
2	7u83	253	`{`
		254	`EXP ZI431;`
		255
		256	`switch (CURRENT_TERMINAL) {`
		257	`case 95:`
		258	`{`
		259	`int ZI670;`
		260
		261	`ADVANCE_LEXER;`
		262	`{`
		263
		264	`(ZI670) = unreached_code ;`
		265	`if ( (ZI670) ) {`
		266	`if ( !unreached_last ) {`
		267	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		268	`unreached_last = 1 ;`
		269	`}`
		270	`} else {`
		271	`unreached_last = 0 ;`
		272	`}`
		273	`}`
		274	`{`
		275
		276	`(ZI431) = make_break_stmt () ;`
		277	`}`
		278	`{`
		279
		280	`unreached_fall = 1 ;`
		281	`}`
		282	`ZR418 ();`
		283	`if ((CURRENT_TERMINAL) == 354) {`
		284	`RESTORE_LEXER;`
		285	`goto ZL1;`
		286	`}`
		287	`}`
		288	`break;`
		289	`case 99:`
		290	`{`
		291	`int ZI670;`
		292
		293	`ADVANCE_LEXER;`
		294	`{`
		295
		296	`(ZI670) = unreached_code ;`
		297	`if ( (ZI670) ) {`
		298	`if ( !unreached_last ) {`
		299	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		300	`unreached_last = 1 ;`
		301	`}`
		302	`} else {`
		303	`unreached_last = 0 ;`
		304	`}`
		305	`}`
		306	`{`
		307
		308	`(ZI431) = make_continue_stmt () ;`
		309	`}`
		310	`{`
		311
		312	`unreached_fall = 1 ;`
		313	`}`
		314	`ZR418 ();`
		315	`if ((CURRENT_TERMINAL) == 354) {`
		316	`RESTORE_LEXER;`
		317	`goto ZL1;`
		318	`}`
		319	`}`
		320	`break;`
		321	`case 108:`
		322	`{`
		323	`int ZI670;`
		324
		325	`ADVANCE_LEXER;`
		326	`{`
		327
		328	`(ZI670) = unreached_code ;`
		329	`if ( (ZI670) ) {`
		330	`if ( !unreached_last ) {`
		331	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		332	`unreached_last = 1 ;`
		333	`}`
		334	`} else {`
		335	`unreached_last = 0 ;`
		336	`}`
		337	`}`
		338	`ZR751 (&ZI431);`
		339	`if ((CURRENT_TERMINAL) == 354) {`
		340	`RESTORE_LEXER;`
		341	`goto ZL1;`
		342	`}`
		343	`{`
		344
		345	`unreached_fall = 1 ;`
		346	`}`
		347	`ZR418 ();`
		348	`if ((CURRENT_TERMINAL) == 354) {`
		349	`RESTORE_LEXER;`
		350	`goto ZL1;`
		351	`}`
		352	`}`
		353	`break;`
		354	`case 113:`
		355	`{`
		356	`int ZI670;`
		357	`EXP ZI493;`
		358
		359	`ADVANCE_LEXER;`
		360	`{`
		361
		362	`(ZI670) = unreached_code ;`
		363	`if ( (ZI670) ) {`
		364	`if ( !unreached_last ) {`
		365	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		366	`unreached_last = 1 ;`
		367	`}`
		368	`} else {`
		369	`unreached_last = 0 ;`
		370	`}`
		371	`}`
		372	`{`
		373	`switch (CURRENT_TERMINAL) {`
		374	`case 1: case 2: case 3: case 5: case 6:`
		375	`case 7: case 8: case 9: case 17: case 18:`
		376	`case 19: case 20: case 21: case 22: case 23:`
		377	`case 25: case 33: case 43: case 59: case 61:`
		378	`case 62: case 65: case 69: case 71: case 78:`
		379	`case 83: case 85: case 97: case 102: case 106:`
		380	`case 110: case 111: case 114: case 115: case 116:`
		381	`case 122: case 123: case 127: case 130: case 131:`
		382	`case 132: case 135: case 140: case 141: case 145:`
		383	`case 146: case 148: case 149: case 150: case 152:`
		384	`case 156: case 170: case 184: case 205: case 209:`
		385	`case 285: case 297: case 298: case 323: case 329:`
		386	`case 345:`
		387	`{`
		388	`ZR491 (&ZI493);`
		389	`if ((CURRENT_TERMINAL) == 354) {`
		390	`RESTORE_LEXER;`
		391	`goto ZL1;`
		392	`}`
		393	`}`
		394	`break;`
		395	`default:`
		396	`{`
		397	`{`
		398
		399	`(ZI493) = NULL_exp ;`
		400	`}`
		401	`}`
		402	`break;`
		403	`}`
		404	`}`
		405	`{`
		406
		407	`(ZI431) = make_return_stmt ( (ZI493), lex_return ) ;`
		408	`}`
		409	`{`
		410
		411	`unreached_fall = 1 ;`
		412	`}`
		413	`ZR418 ();`
		414	`if ((CURRENT_TERMINAL) == 354) {`
		415	`RESTORE_LEXER;`
		416	`goto ZL1;`
		417	`}`
		418	`}`
		419	`break;`
		420	`case 354:`
		421	`return;`
		422	`default:`
		423	`goto ZL1;`
		424	`}`
		425	`goto ZL0;`
		426	`ZL1:;`
		427	`SAVE_LEXER (354);`
		428	`return;`
		429	`ZL0:;`
		430	`*ZO431 = ZI431;`
		431	`}`
		432
		433	`void`
7	7u83	434	`ZR1471(IDENTIFIER ZI1470, EXP ZO431)`
2	7u83	435	`{`
		436	`EXP ZI431;`
		437
		438	`switch (CURRENT_TERMINAL) {`
		439	`default:`
		440	`{`
		441	`IDENTIFIER ZI419;`
		442	`EXP ZI493;`
		443
		444	`{`
		445
		446	`(ZI419) = (*ZI1470) ;`
		447	`crt_id_qualifier = qual_none ;`
		448	`last_namespace = crt_namespace ;`
		449	`}`
		450	`{`
		451
		452	`(ZI493) = make_id_exp ( (ZI419) ) ;`
		453	`}`
		454	`{`
		455
		456	`(ZI431) = make_exp_stmt ( (ZI493) ) ;`
		457	`}`
		458	`}`
		459	`break;`
		460	`case 41:`
		461	`{`
		462	`EXP ZI493;`
		463	`EXP ZI456;`
		464
		465	`{`
		466
		467	`crt_id_qualifier = qual_none ;`
		468	`crt_templ_qualifier = 0 ;`
		469	`qual_namespace = NULL_nspace ;`
		470	`}`
		471	`{`
		472
		473	`if ( unreached_code ) unreached_fall = 0 ;`
		474	`}`
		475	`{`
		476
		477	`(ZI493) = begin_label_stmt ( (*ZI1470), lex_identifier ) ;`
		478	`}`
		479	`ADVANCE_LEXER;`
		480	`ZR661 (&ZI456);`
		481	`if ((CURRENT_TERMINAL) == 354) {`
		482	`RESTORE_LEXER;`
		483	`goto ZL1;`
		484	`}`
		485	`{`
		486
		487	`(ZI431) = end_label_stmt ( (ZI493), (ZI456) ) ;`
		488	`}`
		489	`}`
		490	`break;`
		491	`case 354:`
		492	`return;`
		493	`}`
		494	`goto ZL0;`
		495	`ZL1:;`
		496	`SAVE_LEXER (354);`
		497	`return;`
		498	`ZL0:;`
		499	`*ZO431 = ZI431;`
		500	`}`
		501
		502	`void`
7	7u83	503	`ZR1344(NAMESPACE ZI425, IDENTIFIER ZO419)`
2	7u83	504	`{`
		505	`IDENTIFIER ZI419;`
		506
		507	`switch (CURRENT_TERMINAL) {`
		508	`case 4:`
		509	`{`
		510	`IDENTIFIER ZI478;`
		511
		512	`{`
		513
		514	`ZI478 = crt_token->pp_data.id.use ;`
		515	`}`
		516	`ADVANCE_LEXER;`
		517	`{`
		518
		519	`crt_id_qualifier = qual_nested ;`
		520	`qual_namespace = (*ZI425) ;`
		521	`}`
		522	`{`
		523
		524	`(ZI419) = check_id ( (*ZI425), (ZI478), 0 ) ;`
		525	`last_namespace = (*ZI425) ;`
		526	`}`
		527	`}`
		528	`break;`
		529	`case 2: case 7:`
		530	`{`
		531	`IDENTIFIER ZI1341;`
		532	`IDENTIFIER ZI460;`
		533
		534	`{`
		535	`switch (CURRENT_TERMINAL) {`
		536	`case 7:`
		537	`{`
		538	`{`
		539
		540	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		541	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		542	`ZI1341 = parse_type_template ( id, args, 0 ) ;`
		543	`crt_templ_qualifier = 1 ;`
		544	`RESCAN_LEXER ;`
		545	`}`
		546	`ADVANCE_LEXER;`
		547	`}`
		548	`break;`
		549	`case 2:`
		550	`{`
		551	`{`
		552
		553	`ZI1341 = crt_token->pp_data.id.use ;`
		554	`}`
		555	`ADVANCE_LEXER;`
		556	`}`
		557	`break;`
		558	`default:`
		559	`goto ZL1;`
		560	`}`
		561	`}`
		562	`{`
		563
		564	`crt_id_qualifier = qual_nested ;`
		565	`qual_namespace = (*ZI425) ;`
		566	`}`
		567	`{`
		568
		569	`(ZI460) = check_id ( (*ZI425), (ZI1341), 0 ) ;`
		570	`last_namespace = (*ZI425) ;`
		571	`}`
		572	`{`
		573
		574	`(ZI419) = constr_name ( last_namespace, (ZI460) ) ;`
		575	`}`
		576	`}`
		577	`break;`
		578	`case 1: case 3: case 5: case 6: case 141:`
		579	`case 147:`
		580	`{`
		581	`int ZI480;`
		582	`IDENTIFIER ZI478;`
		583
		584	`ZR475 (*ZI425, &ZI480);`
		585	`ZR476 (*ZI425, &ZI478);`
		586	`if ((CURRENT_TERMINAL) == 354) {`
		587	`RESTORE_LEXER;`
		588	`goto ZL1;`
		589	`}`
		590	`{`
		591
		592	`crt_id_qualifier = qual_nested ;`
		593	`qual_namespace = (*ZI425) ;`
		594	`}`
		595	`{`
		596
		597	`(ZI419) = check_id ( (*ZI425), (ZI478), (ZI480) ) ;`
		598	`last_namespace = (*ZI425) ;`
		599	`}`
		600	`}`
		601	`break;`
		602	`case 354:`
		603	`return;`
		604	`default:`
		605	`goto ZL1;`
		606	`}`
		607	`goto ZL0;`
		608	`ZL1:;`
		609	`SAVE_LEXER (354);`
		610	`return;`
		611	`ZL0:;`
		612	`*ZO419 = ZI419;`
		613	`}`
		614
		615	`void`
7	7u83	616	`ZR552(TYPE ZO414, EXP ZO431, int *ZO551)`
2	7u83	617	`{`
		618	`TYPE ZI414;`
		619	`EXP ZI431;`
		620	`int ZI551;`
		621
		622	`if ((CURRENT_TERMINAL) == 354) {`
		623	`return;`
		624	`}`
		625	`{`
		626	`switch (CURRENT_TERMINAL) {`
		627	`case 53:`
		628	`break;`
		629	`default:`
		630	`goto ZL1;`
		631	`}`
		632	`ADVANCE_LEXER;`
		633	`ZR548 (&ZI414, &ZI551);`
		634	`switch (CURRENT_TERMINAL) {`
		635	`case 49:`
		636	`break;`
		637	`case 354:`
		638	`RESTORE_LEXER;`
		639	`goto ZL1;`
		640	`default:`
		641	`goto ZL1;`
		642	`}`
		643	`ADVANCE_LEXER;`
		644	`switch (CURRENT_TERMINAL) {`
		645	`case 65:`
		646	`break;`
		647	`default:`
		648	`goto ZL1;`
		649	`}`
		650	`ADVANCE_LEXER;`
		651	`ZR491 (&ZI431);`
		652	`switch (CURRENT_TERMINAL) {`
		653	`case 39:`
		654	`break;`
		655	`case 354:`
		656	`RESTORE_LEXER;`
		657	`goto ZL1;`
		658	`default:`
		659	`goto ZL1;`
		660	`}`
		661	`ADVANCE_LEXER;`
		662	`}`
		663	`goto ZL0;`
		664	`ZL1:;`
		665	`SAVE_LEXER (354);`
		666	`return;`
		667	`ZL0:;`
		668	`*ZO414 = ZI414;`
		669	`*ZO431 = ZI431;`
		670	`*ZO551 = ZI551;`
		671	`}`
		672
		673	`void`
7	7u83	674	`ZR698(EXP ZO1185, EXP ZO1186, int *ZO1187)`
2	7u83	675	`{`
		676	`EXP ZI1185;`
		677	`EXP ZI1186;`
		678	`int ZI1187;`
		679
		680	`if ((CURRENT_TERMINAL) == 354) {`
		681	`return;`
		682	`}`
		683	`{`
		684	`EXP ZI558;`
		685	`EXP ZI497;`
		686	`int ZI670;`
		687	`EXP ZI493;`
		688	`EXP ZI431;`
		689
		690	`switch (CURRENT_TERMINAL) {`
		691	`case 26:`
		692	`{`
		693
		694	`ZI558 = crt_token->pp_data.exp ;`
		695	`}`
		696	`break;`
		697	`default:`
		698	`goto ZL1;`
		699	`}`
		700	`ADVANCE_LEXER;`
		701	`{`
		702
		703	`EXP c = crt_hash_cond ;`
		704	`crt_hash_cond = make_if_cond ( (ZI558), c ) ;`
		705	`(ZI497) = c ;`
		706	`}`
		707	`{`
		708
		709	`(ZI670) = unreached_code ;`
		710	`if ( (ZI670) ) {`
		711	`if ( !unreached_last ) {`
		712	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		713	`unreached_last = 1 ;`
		714	`}`
		715	`} else {`
		716	`unreached_last = 0 ;`
		717	`}`
		718	`}`
		719	`ZR678 (&ZI493);`
		720	`if ((CURRENT_TERMINAL) == 354) {`
		721	`RESTORE_LEXER;`
		722	`goto ZL1;`
		723	`}`
		724	`{`
		725	`unreached_prev = (ZI670) ;`
		726	`}`
		727	`{`
		728
		729	`(ZI431) = begin_hash_if_stmt ( (ZI558), (ZI493) ) ;`
		730	`}`
		731	`ZR1188 (ZI431, ZI497, ZI670, &ZI1185, &ZI1186, &ZI1187);`
		732	`if ((CURRENT_TERMINAL) == 354) {`
		733	`RESTORE_LEXER;`
		734	`goto ZL1;`
		735	`}`
		736	`}`
		737	`goto ZL0;`
		738	`ZL1:;`
		739	`SAVE_LEXER (354);`
		740	`return;`
		741	`ZL0:;`
		742	`*ZO1185 = ZI1185;`
		743	`*ZO1186 = ZI1186;`
		744	`*ZO1187 = ZI1187;`
		745	`}`
		746
		747	`void`
7	7u83	748	`ZR785(CV_SPEC *ZO783)`
2	7u83	749	`{`
		750	`CV_SPEC ZI783;`
		751
		752	`if ((CURRENT_TERMINAL) == 354) {`
		753	`return;`
		754	`}`
		755	`{`
		756	`CV_SPEC ZI493;`
		757
		758	`ZR784 (&ZI493);`
		759	`{`
		760	`switch (CURRENT_TERMINAL) {`
		761	`case 98: case 124:`
		762	`{`
		763	`CV_SPEC ZI456;`
		764
		765	`ZR785 (&ZI456);`
		766	`if ((CURRENT_TERMINAL) == 354) {`
		767	`RESTORE_LEXER;`
		768	`goto ZL1;`
		769	`}`
		770	`{`
		771
		772	`CV_SPEC c = ( (ZI493) & (ZI456) ) ;`
		773	`if ( c ) report ( crt_loc, ERR_dcl_type_cv_dup ( c ) ) ;`
		774	`(ZI783) = ( (ZI493) \| (ZI456) ) ;`
		775	`}`
		776	`}`
		777	`break;`
		778	`default:`
		779	`{`
		780	`ZI783 = ZI493;`
		781	`}`
		782	`break;`
		783	`case 354:`
		784	`RESTORE_LEXER;`
		785	`goto ZL1;`
		786	`}`
		787	`}`
		788	`}`
		789	`goto ZL0;`
		790	`ZL1:;`
		791	`SAVE_LEXER (354);`
		792	`return;`
		793	`ZL0:;`
		794	`*ZO783 = ZI783;`
		795	`}`
		796
		797	`void`
7	7u83	798	`ZR1599(void)`
2	7u83	799	`{`
		800	`switch (CURRENT_TERMINAL) {`
		801	`case 77:`
		802	`{`
		803	`ADVANCE_LEXER;`
		804	`{`
		805
		806	`unreached_fall = 0 ;`
		807	`}`
		808	`}`
		809	`break;`
		810	`default:`
		811	`{`
		812	`{`
		813
		814	`unreached_fall = 0 ;`
		815	`}`
		816	`}`
		817	`break;`
		818	`case 354:`
		819	`return;`
		820	`}`
		821	`}`
		822
		823	`void`
7	7u83	824	`ZR1472(NAMESPACE ZI425, EXP ZO431)`
2	7u83	825	`{`
		826	`EXP ZI431;`
		827
		828	`switch (CURRENT_TERMINAL) {`
		829	`case 4:`
		830	`{`
		831	`IDENTIFIER ZI478;`
		832	`IDENTIFIER ZI419;`
		833	`EXP ZI493;`
		834
		835	`{`
		836
		837	`ZI478 = crt_token->pp_data.id.use ;`
		838	`}`
		839	`ADVANCE_LEXER;`
		840	`{`
		841
		842	`crt_id_qualifier = qual_nested ;`
		843	`qual_namespace = (*ZI425) ;`
		844	`}`
		845	`{`
		846
		847	`(ZI419) = check_id ( (*ZI425), (ZI478), 0 ) ;`
		848	`last_namespace = (*ZI425) ;`
		849	`}`
		850	`{`
		851
		852	`(ZI493) = make_id_exp ( (ZI419) ) ;`
		853	`}`
		854	`{`
		855
		856	`(ZI431) = make_exp_stmt ( (ZI493) ) ;`
		857	`}`
		858	`}`
		859	`break;`
		860	`case 1: case 2: case 3: case 5: case 6:`
		861	`case 7: case 141: case 147:`
		862	`{`
		863	`EXP ZI1452;`
		864	`EXP ZI1451;`
		865	`EXP ZI1450;`
		866	`EXP ZI1449;`
		867	`EXP ZI1448;`
		868	`EXP ZI1447;`
		869	`EXP ZI1446;`
		870	`EXP ZI1445;`
		871	`EXP ZI1444;`
		872	`EXP ZI1443;`
		873	`EXP ZI1442;`
		874	`EXP ZI1441;`
		875	`EXP ZI1263;`
		876	`EXP ZI1287;`
		877	`EXP ZI493;`
		878	`int ZI670;`
		879
		880	`ZR1266 (ZI425, &ZI1452);`
		881	`ZR1236 (ZI1452, &ZI1451);`
		882	`ZR1232 (ZI1451, &ZI1450);`
		883	`ZR1228 (ZI1450, &ZI1449);`
		884	`ZR1224 (ZI1449, &ZI1448);`
		885	`ZR1220 (ZI1448, &ZI1447);`
		886	`ZR1216 (ZI1447, &ZI1446);`
		887	`ZR1212 (ZI1446, &ZI1445);`
		888	`ZR1208 (ZI1445, &ZI1444);`
		889	`ZR1204 (ZI1444, &ZI1443);`
		890	`ZR1200 (ZI1443, &ZI1442);`
		891	`ZR1196 (ZI1442, &ZI1441);`
		892	`ZR1192 (ZI1441, &ZI1263);`
		893	`ZR1264 (&ZI1263, &ZI1287);`
		894	`ZR1289 (&ZI1287, &ZI493);`
		895	`if ((CURRENT_TERMINAL) == 354) {`
		896	`RESTORE_LEXER;`
		897	`goto ZL1;`
		898	`}`
		899	`{`
		900
		901	`(ZI670) = unreached_code ;`
		902	`if ( (ZI670) ) {`
		903	`if ( !unreached_last ) {`
		904	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		905	`unreached_last = 1 ;`
		906	`}`
		907	`} else {`
		908	`unreached_last = 0 ;`
		909	`}`
		910	`}`
		911	`{`
		912
		913	`(ZI431) = make_exp_stmt ( (ZI493) ) ;`
		914	`}`
		915	`{`
		916
		917	`unreached_fall = 1 ;`
		918	`}`
		919	`switch (CURRENT_TERMINAL) {`
		920	`case 77:`
		921	`break;`
		922	`default:`
		923	`goto ZL1;`
		924	`}`
		925	`ADVANCE_LEXER;`
		926	`}`
		927	`break;`
		928	`case 354:`
		929	`return;`
		930	`default:`
		931	`goto ZL1;`
		932	`}`
		933	`goto ZL0;`
		934	`ZL1:;`
		935	`SAVE_LEXER (354);`
		936	`return;`
		937	`ZL0:;`
		938	`*ZO431 = ZI431;`
		939	`}`
		940
		941	`void`
7	7u83	942	`ZR1345(NAMESPACE ZI425, IDENTIFIER ZO419)`
2	7u83	943	`{`
		944	`IDENTIFIER ZI419;`
		945
		946	`switch (CURRENT_TERMINAL) {`
		947	`case 4:`
		948	`{`
		949	`IDENTIFIER ZI478;`
		950
		951	`{`
		952
		953	`ZI478 = crt_token->pp_data.id.use ;`
		954	`}`
		955	`ADVANCE_LEXER;`
		956	`{`
		957
		958	`crt_id_qualifier = qual_full ;`
		959	`qual_namespace = (*ZI425) ;`
		960	`}`
		961	`{`
		962
		963	`(ZI419) = check_id ( (*ZI425), (ZI478), 0 ) ;`
		964	`last_namespace = (*ZI425) ;`
		965	`}`
		966	`}`
		967	`break;`
		968	`case 2: case 7:`
		969	`{`
		970	`IDENTIFIER ZI1342;`
		971	`IDENTIFIER ZI460;`
		972
		973	`{`
		974	`switch (CURRENT_TERMINAL) {`
		975	`case 7:`
		976	`{`
		977	`{`
		978
		979	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		980	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		981	`ZI1342 = parse_type_template ( id, args, 0 ) ;`
		982	`crt_templ_qualifier = 1 ;`
		983	`RESCAN_LEXER ;`
		984	`}`
		985	`ADVANCE_LEXER;`
		986	`}`
		987	`break;`
		988	`case 2:`
		989	`{`
		990	`{`
		991
		992	`ZI1342 = crt_token->pp_data.id.use ;`
		993	`}`
		994	`ADVANCE_LEXER;`
		995	`}`
		996	`break;`
		997	`default:`
		998	`goto ZL1;`
		999	`}`
		1000	`}`
		1001	`{`
		1002
		1003	`crt_id_qualifier = qual_full ;`
		1004	`qual_namespace = (*ZI425) ;`
		1005	`}`
		1006	`{`
		1007
		1008	`(ZI460) = check_id ( (*ZI425), (ZI1342), 0 ) ;`
		1009	`last_namespace = (*ZI425) ;`
		1010	`}`
		1011	`{`
		1012
		1013	`(ZI419) = constr_name ( last_namespace, (ZI460) ) ;`
		1014	`}`
		1015	`}`
		1016	`break;`
		1017	`case 1: case 3: case 5: case 6: case 141:`
		1018	`case 147:`
		1019	`{`
		1020	`int ZI480;`
		1021	`IDENTIFIER ZI478;`
		1022
		1023	`ZR475 (*ZI425, &ZI480);`
		1024	`ZR476 (*ZI425, &ZI478);`
		1025	`if ((CURRENT_TERMINAL) == 354) {`
		1026	`RESTORE_LEXER;`
		1027	`goto ZL1;`
		1028	`}`
		1029	`{`
		1030
		1031	`crt_id_qualifier = qual_full ;`
		1032	`qual_namespace = (*ZI425) ;`
		1033	`}`
		1034	`{`
		1035
		1036	`(ZI419) = check_id ( (*ZI425), (ZI478), (ZI480) ) ;`
		1037	`last_namespace = (*ZI425) ;`
		1038	`}`
		1039	`}`
		1040	`break;`
		1041	`case 354:`
		1042	`return;`
		1043	`default:`
		1044	`goto ZL1;`
		1045	`}`
		1046	`goto ZL0;`
		1047	`ZL1:;`
		1048	`SAVE_LEXER (354);`
		1049	`return;`
		1050	`ZL0:;`
		1051	`*ZO419 = ZI419;`
		1052	`}`
		1053
		1054	`void`
7	7u83	1055	`ZR1022(EXP ZI558, EXP *ZO431)`
2	7u83	1056	`{`
		1057	`EXP ZI431;`
		1058
		1059	`if ((CURRENT_TERMINAL) == 354) {`
		1060	`return;`
		1061	`}`
		1062	`{`
		1063	`EXP ZI456;`
		1064	`EXP ZI459;`
		1065	`EXP ZI493;`
		1066
		1067	`ZR1019 (ZI558, &ZI456, &ZI459);`
		1068	`{`
		1069	`if ((CURRENT_TERMINAL) == 354) {`
		1070	`RESTORE_LEXER;`
		1071	`goto ZL1;`
		1072	`}`
		1073	`{`
		1074	`switch (CURRENT_TERMINAL) {`
		1075	`case 64:`
		1076	`break;`
		1077	`default:`
		1078	`goto ZL1;`
		1079	`}`
		1080	`ADVANCE_LEXER;`
		1081	`}`
		1082	`}`
		1083	`{`
		1084
		1085	`COPY_int ( exp_sequence_block ( (ZI456) ), 2 ) ;`
		1086	`}`
		1087	`ZR676 (ZI456, &ZI493);`
		1088	`if ((CURRENT_TERMINAL) == 354) {`
		1089	`RESTORE_LEXER;`
		1090	`goto ZL1;`
		1091	`}`
		1092	`{`
		1093
		1094	`(ZI431) = ctor_postlude ( (ZI493), (ZI459) ) ;`
		1095	`}`
		1096	`{`
		1097	`{`
		1098	`switch (CURRENT_TERMINAL) {`
		1099	`case 38:`
		1100	`break;`
		1101	`default:`
		1102	`goto ZL1;`
		1103	`}`
		1104	`ADVANCE_LEXER;`
		1105	`}`
		1106	`}`
		1107	`}`
		1108	`goto ZL0;`
		1109	`ZL1:;`
		1110	`SAVE_LEXER (354);`
		1111	`return;`
		1112	`ZL0:;`
		1113	`*ZO431 = ZI431;`
		1114	`}`
		1115
		1116	`void`
7	7u83	1117	`ZR1473(NAMESPACE ZI425, EXP ZO431)`
2	7u83	1118	`{`
		1119	`EXP ZI431;`
		1120
		1121	`switch (CURRENT_TERMINAL) {`
		1122	`case 4:`
		1123	`{`
		1124	`IDENTIFIER ZI478;`
		1125	`IDENTIFIER ZI419;`
		1126	`EXP ZI493;`
		1127
		1128	`{`
		1129
		1130	`ZI478 = crt_token->pp_data.id.use ;`
		1131	`}`
		1132	`ADVANCE_LEXER;`
		1133	`{`
		1134
		1135	`crt_id_qualifier = qual_full ;`
		1136	`qual_namespace = (*ZI425) ;`
		1137	`}`
		1138	`{`
		1139
		1140	`(ZI419) = check_id ( (*ZI425), (ZI478), 0 ) ;`
		1141	`last_namespace = (*ZI425) ;`
		1142	`}`
		1143	`{`
		1144
		1145	`(ZI493) = make_id_exp ( (ZI419) ) ;`
		1146	`}`
		1147	`{`
		1148
		1149	`(ZI431) = make_exp_stmt ( (ZI493) ) ;`
		1150	`}`
		1151	`}`
		1152	`break;`
		1153	`case 1: case 2: case 3: case 5: case 6:`
		1154	`case 7: case 141: case 147:`
		1155	`{`
		1156	`EXP ZI1452;`
		1157	`EXP ZI1451;`
		1158	`EXP ZI1450;`
		1159	`EXP ZI1449;`
		1160	`EXP ZI1448;`
		1161	`EXP ZI1447;`
		1162	`EXP ZI1446;`
		1163	`EXP ZI1445;`
		1164	`EXP ZI1444;`
		1165	`EXP ZI1443;`
		1166	`EXP ZI1442;`
		1167	`EXP ZI1441;`
		1168	`EXP ZI1263;`
		1169	`EXP ZI1287;`
		1170	`EXP ZI493;`
		1171	`int ZI670;`
		1172
		1173	`ZR1267 (ZI425, &ZI1452);`
		1174	`ZR1236 (ZI1452, &ZI1451);`
		1175	`ZR1232 (ZI1451, &ZI1450);`
		1176	`ZR1228 (ZI1450, &ZI1449);`
		1177	`ZR1224 (ZI1449, &ZI1448);`
		1178	`ZR1220 (ZI1448, &ZI1447);`
		1179	`ZR1216 (ZI1447, &ZI1446);`
		1180	`ZR1212 (ZI1446, &ZI1445);`
		1181	`ZR1208 (ZI1445, &ZI1444);`
		1182	`ZR1204 (ZI1444, &ZI1443);`
		1183	`ZR1200 (ZI1443, &ZI1442);`
		1184	`ZR1196 (ZI1442, &ZI1441);`
		1185	`ZR1192 (ZI1441, &ZI1263);`
		1186	`ZR1264 (&ZI1263, &ZI1287);`
		1187	`ZR1289 (&ZI1287, &ZI493);`
		1188	`if ((CURRENT_TERMINAL) == 354) {`
		1189	`RESTORE_LEXER;`
		1190	`goto ZL1;`
		1191	`}`
		1192	`{`
		1193
		1194	`(ZI670) = unreached_code ;`
		1195	`if ( (ZI670) ) {`
		1196	`if ( !unreached_last ) {`
		1197	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		1198	`unreached_last = 1 ;`
		1199	`}`
		1200	`} else {`
		1201	`unreached_last = 0 ;`
		1202	`}`
		1203	`}`
		1204	`{`
		1205
		1206	`(ZI431) = make_exp_stmt ( (ZI493) ) ;`
		1207	`}`
		1208	`{`
		1209
		1210	`unreached_fall = 1 ;`
		1211	`}`
		1212	`switch (CURRENT_TERMINAL) {`
		1213	`case 77:`
		1214	`break;`
		1215	`default:`
		1216	`goto ZL1;`
		1217	`}`
		1218	`ADVANCE_LEXER;`
		1219	`}`
		1220	`break;`
		1221	`case 354:`
		1222	`return;`
		1223	`default:`
		1224	`goto ZL1;`
		1225	`}`
		1226	`goto ZL0;`
		1227	`ZL1:;`
		1228	`SAVE_LEXER (354);`
		1229	`return;`
		1230	`ZL0:;`
		1231	`*ZO431 = ZI431;`
		1232	`}`
		1233
		1234	`void`
7	7u83	1235	`ZR1346(IDENTIFIER *ZO419)`
2	7u83	1236	`{`
		1237	`IDENTIFIER ZI419;`
		1238
		1239	`switch (CURRENT_TERMINAL) {`
		1240	`case 4:`
		1241	`{`
		1242	`IDENTIFIER ZI478;`
		1243	`NAMESPACE ZI425;`
		1244
		1245	`{`
		1246
		1247	`ZI478 = crt_token->pp_data.id.use ;`
		1248	`}`
		1249	`ADVANCE_LEXER;`
		1250	`{`
		1251
		1252	`(ZI425) = global_namespace ;`
		1253	`crt_id_qualifier = qual_top ;`
		1254	`qual_namespace = (ZI425) ;`
		1255	`}`
		1256	`{`
		1257
		1258	`(ZI419) = check_id ( (ZI425), (ZI478), 0 ) ;`
		1259	`last_namespace = (ZI425) ;`
		1260	`}`
		1261	`}`
		1262	`break;`
		1263	`case 2: case 7:`
		1264	`{`
		1265	`IDENTIFIER ZI1343;`
		1266	`NAMESPACE ZI425;`
		1267	`IDENTIFIER ZI460;`
		1268
		1269	`{`
		1270	`switch (CURRENT_TERMINAL) {`
		1271	`case 7:`
		1272	`{`
		1273	`{`
		1274
		1275	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		1276	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		1277	`ZI1343 = parse_type_template ( id, args, 0 ) ;`
		1278	`crt_templ_qualifier = 1 ;`
		1279	`RESCAN_LEXER ;`
		1280	`}`
		1281	`ADVANCE_LEXER;`
		1282	`}`
		1283	`break;`
		1284	`case 2:`
		1285	`{`
		1286	`{`
		1287
		1288	`ZI1343 = crt_token->pp_data.id.use ;`
		1289	`}`
		1290	`ADVANCE_LEXER;`
		1291	`}`
		1292	`break;`
		1293	`default:`
		1294	`goto ZL1;`
		1295	`}`
		1296	`}`
		1297	`{`
		1298
		1299	`(ZI425) = global_namespace ;`
		1300	`crt_id_qualifier = qual_top ;`
		1301	`qual_namespace = (ZI425) ;`
		1302	`}`
		1303	`{`
		1304
		1305	`(ZI460) = check_id ( (ZI425), (ZI1343), 0 ) ;`
		1306	`last_namespace = (ZI425) ;`
		1307	`}`
		1308	`{`
		1309
		1310	`(ZI419) = constr_name ( last_namespace, (ZI460) ) ;`
		1311	`}`
		1312	`}`
		1313	`break;`
		1314	`case 1: case 3: case 5: case 6: case 141:`
		1315	`case 147:`
		1316	`{`
		1317	`NAMESPACE ZI425;`
		1318	`int ZI480;`
		1319	`IDENTIFIER ZI478;`
		1320
		1321	`{`
		1322
		1323	`(ZI425) = global_namespace ;`
		1324	`crt_id_qualifier = qual_top ;`
		1325	`qual_namespace = (ZI425) ;`
		1326	`}`
		1327	`ZR475 (ZI425, &ZI480);`
		1328	`ZR476 (ZI425, &ZI478);`
		1329	`if ((CURRENT_TERMINAL) == 354) {`
		1330	`RESTORE_LEXER;`
		1331	`goto ZL1;`
		1332	`}`
		1333	`{`
		1334
		1335	`(ZI419) = check_id ( (ZI425), (ZI478), (ZI480) ) ;`
		1336	`last_namespace = (ZI425) ;`
		1337	`}`
		1338	`}`
		1339	`break;`
		1340	`case 354:`
		1341	`return;`
		1342	`default:`
		1343	`goto ZL1;`
		1344	`}`
		1345	`goto ZL0;`
		1346	`ZL1:;`
		1347	`SAVE_LEXER (354);`
		1348	`return;`
		1349	`ZL0:;`
		1350	`*ZO419 = ZI419;`
		1351	`}`
		1352
		1353	`void`
7	7u83	1354	`ZR1092(BASE_TYPE ZI511, DECL_SPEC ZI1073, TYPE ZI1074, ACCESS_LIST ZI670, IDENTIFIER *ZI459)`
2	7u83	1355	`{`
		1356	`if ((CURRENT_TERMINAL) == 354) {`
		1357	`return;`
		1358	`}`
		1359	`{`
		1360	`{`
		1361
		1362	`/* Resolve function definitions from other declarations */`
		1363	`(ZI0) = is_function_next ;`
		1364	`}`
		1365	`if (!ZI0)`
		1366	`goto ZL2;`
		1367	`{`
		1368
		1369	`free_access ( &(*ZI670) ) ;`
		1370	`}`
		1371	`{`
		1372
		1373	`skip_function ( (*ZI459) ) ;`
		1374	`}`
		1375	`{`
		1376
		1377	`end_declarator ( (*ZI459), 1 ) ;`
		1378	`}`
		1379	`{`
		1380
		1381	`RESCAN_LEXER ;`
		1382	`}`
		1383	`goto ZL0;`
		1384	`}`
		1385	`/UNREACHED/`
		1386	`ZL2:;`
		1387	`switch (CURRENT_TERMINAL) {`
		1388	`case 42:`
		1389	`{`
		1390	`int ZI551;`
		1391
		1392	`ADVANCE_LEXER;`
		1393	`{`
		1394
		1395	`end_declarator ( (*ZI459), 1 ) ;`
		1396	`}`
		1397	`{`
		1398	`(ZI551) = 0 ;`
		1399	`}`
		1400	`{`
		1401
		1402	`crt_templ_qualifier = 0 ;`
		1403	`}`
		1404	`ZR1087 (ZI1073, ZI1074, ZI511, ZI670, ZI551);`
		1405	`if ((CURRENT_TERMINAL) == 354) {`
		1406	`RESTORE_LEXER;`
		1407	`goto ZL1;`
		1408	`}`
		1409	`{`
		1410
		1411	`free_access ( &(*ZI670) ) ;`
		1412	`}`
		1413	`switch (CURRENT_TERMINAL) {`
		1414	`case 77:`
		1415	`break;`
		1416	`default:`
		1417	`goto ZL1;`
		1418	`}`
		1419	`ADVANCE_LEXER;`
		1420	`}`
		1421	`break;`
		1422	`case 77:`
		1423	`{`
		1424	`ADVANCE_LEXER;`
		1425	`{`
		1426
		1427	`free_access ( &(*ZI670) ) ;`
		1428	`}`
		1429	`{`
		1430
		1431	`end_declarator ( (*ZI459), 1 ) ;`
		1432	`}`
		1433	`}`
		1434	`break;`
		1435	`default:`
		1436	`goto ZL1;`
		1437	`}`
		1438	`return;`
		1439	`ZL1:;`
		1440	`SAVE_LEXER (354);`
		1441	`return;`
		1442	`ZL0:;`
		1443	`}`
		1444
		1445	`void`
7	7u83	1446	`ZR1474(EXP *ZO431)`
2	7u83	1447	`{`
		1448	`EXP ZI431;`
		1449
		1450	`switch (CURRENT_TERMINAL) {`
		1451	`case 4:`
		1452	`{`
		1453	`IDENTIFIER ZI478;`
		1454	`NAMESPACE ZI425;`
		1455	`IDENTIFIER ZI419;`
		1456	`EXP ZI493;`
		1457
		1458	`{`
		1459
		1460	`ZI478 = crt_token->pp_data.id.use ;`
		1461	`}`
		1462	`ADVANCE_LEXER;`
		1463	`{`
		1464
		1465	`(ZI425) = global_namespace ;`
		1466	`crt_id_qualifier = qual_top ;`
		1467	`qual_namespace = (ZI425) ;`
		1468	`}`
		1469	`{`
		1470
		1471	`(ZI419) = check_id ( (ZI425), (ZI478), 0 ) ;`
		1472	`last_namespace = (ZI425) ;`
		1473	`}`
		1474	`{`
		1475
		1476	`(ZI493) = make_id_exp ( (ZI419) ) ;`
		1477	`}`
		1478	`{`
		1479
		1480	`(ZI431) = make_exp_stmt ( (ZI493) ) ;`
		1481	`}`
		1482	`}`
		1483	`break;`
		1484	`case 1: case 2: case 3: case 5: case 6:`
		1485	`case 7: case 131: case 140: case 141: case 147:`
		1486	`{`
		1487	`EXP ZI1452;`
		1488	`EXP ZI1451;`
		1489	`EXP ZI1450;`
		1490	`EXP ZI1449;`
		1491	`EXP ZI1448;`
		1492	`EXP ZI1447;`
		1493	`EXP ZI1446;`
		1494	`EXP ZI1445;`
		1495	`EXP ZI1444;`
		1496	`EXP ZI1443;`
		1497	`EXP ZI1442;`
		1498	`EXP ZI1441;`
		1499	`EXP ZI1263;`
		1500	`EXP ZI1287;`
		1501	`EXP ZI493;`
		1502	`int ZI670;`
		1503
		1504	`ZR1284 (&ZI1452);`
		1505	`ZR1236 (ZI1452, &ZI1451);`
		1506	`ZR1232 (ZI1451, &ZI1450);`
		1507	`ZR1228 (ZI1450, &ZI1449);`
		1508	`ZR1224 (ZI1449, &ZI1448);`
		1509	`ZR1220 (ZI1448, &ZI1447);`
		1510	`ZR1216 (ZI1447, &ZI1446);`
		1511	`ZR1212 (ZI1446, &ZI1445);`
		1512	`ZR1208 (ZI1445, &ZI1444);`
		1513	`ZR1204 (ZI1444, &ZI1443);`
		1514	`ZR1200 (ZI1443, &ZI1442);`
		1515	`ZR1196 (ZI1442, &ZI1441);`
		1516	`ZR1192 (ZI1441, &ZI1263);`
		1517	`ZR1264 (&ZI1263, &ZI1287);`
		1518	`ZR1289 (&ZI1287, &ZI493);`
		1519	`if ((CURRENT_TERMINAL) == 354) {`
		1520	`RESTORE_LEXER;`
		1521	`goto ZL1;`
		1522	`}`
		1523	`{`
		1524
		1525	`(ZI670) = unreached_code ;`
		1526	`if ( (ZI670) ) {`
		1527	`if ( !unreached_last ) {`
		1528	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		1529	`unreached_last = 1 ;`
		1530	`}`
		1531	`} else {`
		1532	`unreached_last = 0 ;`
		1533	`}`
		1534	`}`
		1535	`{`
		1536
		1537	`(ZI431) = make_exp_stmt ( (ZI493) ) ;`
		1538	`}`
		1539	`{`
		1540
		1541	`unreached_fall = 1 ;`
		1542	`}`
		1543	`switch (CURRENT_TERMINAL) {`
		1544	`case 77:`
		1545	`break;`
		1546	`default:`
		1547	`goto ZL1;`
		1548	`}`
		1549	`ADVANCE_LEXER;`
		1550	`}`
		1551	`break;`
		1552	`case 354:`
		1553	`return;`
		1554	`default:`
		1555	`goto ZL1;`
		1556	`}`
		1557	`goto ZL0;`
		1558	`ZL1:;`
		1559	`SAVE_LEXER (354);`
		1560	`return;`
		1561	`ZL0:;`
		1562	`*ZO431 = ZI431;`
		1563	`}`
		1564
		1565	`void`
7	7u83	1566	`ZR1220(EXP ZI1218, EXP *ZO1219)`
2	7u83	1567	`{`
		1568	`EXP ZI1219;`
		1569
		1570	`ZL2_1220:;`
		1571	`switch (CURRENT_TERMINAL) {`
		1572	`case 49: case 50: case 53: case 54:`
		1573	`{`
		1574	`int ZI450;`
		1575	`EXP ZI456;`
		1576	`EXP ZI431;`
		1577
		1578	`{`
		1579	`(ZI450) = crt_lex_token ;`
		1580	`}`
		1581	`{`
		1582	`switch (CURRENT_TERMINAL) {`
		1583	`case 49:`
		1584	`{`
		1585	`ADVANCE_LEXER;`
		1586	`}`
		1587	`break;`
		1588	`case 50:`
		1589	`{`
		1590	`ADVANCE_LEXER;`
		1591	`}`
		1592	`break;`
		1593	`case 53:`
		1594	`{`
		1595	`ADVANCE_LEXER;`
		1596	`}`
		1597	`break;`
		1598	`case 54:`
		1599	`{`
		1600	`ADVANCE_LEXER;`
		1601	`}`
		1602	`break;`
		1603	`default:`
		1604	`goto ZL1;`
		1605	`}`
		1606	`}`
		1607	`ZR611 (&ZI456);`
		1608	`if ((CURRENT_TERMINAL) == 354) {`
		1609	`RESTORE_LEXER;`
		1610	`goto ZL1;`
		1611	`}`
		1612	`{`
		1613
		1614	`/* op will be in its primary form */`
		1615	`(ZI431) = make_relation_exp ( (ZI450), (ZI1218), (ZI456) ) ;`
		1616	`}`
		1617	`ZI1218 = ZI431;`
		1618	`goto ZL2_1220;`
		1619	`}`
		1620	`/UNREACHED/`
		1621	`default:`
		1622	`{`
		1623	`ZI1219 = ZI1218;`
		1624	`}`
		1625	`break;`
		1626	`case 354:`
		1627	`return;`
		1628	`}`
		1629	`goto ZL0;`
		1630	`ZL1:;`
		1631	`SAVE_LEXER (354);`
		1632	`return;`
		1633	`ZL0:;`
		1634	`*ZO1219 = ZI1219;`
		1635	`}`
		1636
		1637	`void`
7	7u83	1638	`ZR788(CV_SPEC *ZO783)`
2	7u83	1639	`{`
		1640	`CV_SPEC ZI783;`
		1641
		1642	`switch (CURRENT_TERMINAL) {`
		1643	`case 98: case 124:`
		1644	`{`
		1645	`ZR785 (&ZI783);`
		1646	`if ((CURRENT_TERMINAL) == 354) {`
		1647	`RESTORE_LEXER;`
		1648	`goto ZL1;`
		1649	`}`
		1650	`}`
		1651	`break;`
		1652	`default:`
		1653	`{`
		1654	`{`
		1655	`(ZI783) = cv_none ;`
		1656	`}`
		1657	`}`
		1658	`break;`
		1659	`case 354:`
		1660	`return;`
		1661	`}`
		1662	`goto ZL0;`
		1663	`ZL1:;`
		1664	`SAVE_LEXER (354);`
		1665	`return;`
		1666	`ZL0:;`
		1667	`*ZO783 = ZI783;`
		1668	`}`
		1669
		1670	`void`
7	7u83	1671	`ZR1602(NAMESPACE ZI425, IDENTIFIER ZO419)`
2	7u83	1672	`{`
		1673	`IDENTIFIER ZI419;`
		1674
		1675	`switch (CURRENT_TERMINAL) {`
		1676	`case 4:`
		1677	`{`
		1678	`IDENTIFIER ZI478;`
		1679
		1680	`{`
		1681
		1682	`ZI478 = crt_token->pp_data.id.use ;`
		1683	`}`
		1684	`ADVANCE_LEXER;`
		1685	`{`
		1686
		1687	`crt_id_qualifier = qual_nested ;`
		1688	`qual_namespace = (*ZI425) ;`
		1689	`}`
		1690	`{`
		1691
		1692	`(ZI419) = check_id ( (*ZI425), (ZI478), 0 ) ;`
		1693	`last_namespace = (*ZI425) ;`
		1694	`}`
		1695	`}`
		1696	`break;`
		1697	`case 2: case 7:`
		1698	`{`
		1699	`IDENTIFIER ZI460;`
		1700
		1701	`{`
		1702	`switch (CURRENT_TERMINAL) {`
		1703	`case 7:`
		1704	`{`
		1705	`{`
		1706
		1707	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		1708	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		1709	`ZI460 = parse_type_template ( id, args, 0 ) ;`
		1710	`crt_templ_qualifier = 1 ;`
		1711	`RESCAN_LEXER ;`
		1712	`}`
		1713	`ADVANCE_LEXER;`
		1714	`}`
		1715	`break;`
		1716	`case 2:`
		1717	`{`
		1718	`{`
		1719
		1720	`ZI460 = crt_token->pp_data.id.use ;`
		1721	`}`
		1722	`ADVANCE_LEXER;`
		1723	`}`
		1724	`break;`
		1725	`default:`
		1726	`goto ZL1;`
		1727	`}`
		1728	`}`
		1729	`{`
		1730
		1731	`crt_id_qualifier = qual_nested ;`
		1732	`qual_namespace = (*ZI425) ;`
		1733	`}`
		1734	`{`
		1735
		1736	`(ZI419) = check_id ( (*ZI425), (ZI460), 0 ) ;`
		1737	`last_namespace = (*ZI425) ;`
		1738	`}`
		1739	`}`
		1740	`break;`
		1741	`case 1: case 3: case 5: case 6: case 141:`
		1742	`case 147:`
		1743	`{`
		1744	`int ZI480;`
		1745	`IDENTIFIER ZI478;`
		1746
		1747	`ZR475 (*ZI425, &ZI480);`
		1748	`ZR476 (*ZI425, &ZI478);`
		1749	`if ((CURRENT_TERMINAL) == 354) {`
		1750	`RESTORE_LEXER;`
		1751	`goto ZL1;`
		1752	`}`
		1753	`{`
		1754
		1755	`crt_id_qualifier = qual_nested ;`
		1756	`qual_namespace = (*ZI425) ;`
		1757	`}`
		1758	`{`
		1759
		1760	`(ZI419) = check_id ( (*ZI425), (ZI478), (ZI480) ) ;`
		1761	`last_namespace = (*ZI425) ;`
		1762	`}`
		1763	`}`
		1764	`break;`
		1765	`case 354:`
		1766	`return;`
		1767	`default:`
		1768	`goto ZL1;`
		1769	`}`
		1770	`goto ZL0;`
		1771	`ZL1:;`
		1772	`SAVE_LEXER (354);`
		1773	`return;`
		1774	`ZL0:;`
		1775	`*ZO419 = ZI419;`
		1776	`}`
		1777
		1778	`void`
7	7u83	1779	`ZR712(EXP *ZO431)`
2	7u83	1780	`{`
		1781	`EXP ZI431;`
		1782
		1783	`if ((CURRENT_TERMINAL) == 354) {`
		1784	`return;`
		1785	`}`
		1786	`{`
		1787	`IDENTIFIER ZI459;`
		1788	`EXP ZI493;`
		1789
		1790	`{`
		1791
		1792	`/* Resolve declaration-statements from expression-statements */`
		1793	`int b = predict_decl () ;`
		1794	`if ( b ) in_declaration++ ;`
		1795	`(ZI0) = b ;`
		1796	`}`
		1797	`if (!ZI0)`
		1798	`goto ZL2;`
		1799	`{`
		1800
		1801	`begin_cond () ;`
		1802	`}`
		1803	`ZR1096 (&ZI459);`
		1804	`switch (CURRENT_TERMINAL) {`
		1805	`case 36:`
		1806	`break;`
		1807	`case 354:`
		1808	`RESTORE_LEXER;`
		1809	`goto ZL1;`
		1810	`default:`
		1811	`goto ZL1;`
		1812	`}`
		1813	`ADVANCE_LEXER;`
		1814	`ZR649 (&ZI493);`
		1815	`if ((CURRENT_TERMINAL) == 354) {`
		1816	`RESTORE_LEXER;`
		1817	`goto ZL1;`
		1818	`}`
		1819	`{`
		1820
		1821	`if ( crt_access_list.pending ) {`
		1822	`IGNORE report_access ( (ZI459) ) ;`
		1823	`}`
		1824	`}`
		1825	`{`
		1826
		1827	`int def = init_object ( (ZI459), (ZI493) ) ;`
		1828	`if ( do_dump ) dump_declare ( (ZI459), &decl_loc, def ) ;`
		1829	`}`
		1830	`{`
		1831
		1832	`if ( crt_access_list.pending ) {`
		1833	`IGNORE report_access ( (ZI459) ) ;`
		1834	`}`
		1835	`}`
		1836	`{`
		1837
		1838	`end_declarator ( (ZI459), 1 ) ;`
		1839	`}`
		1840	`{`
		1841
		1842	`(ZI431) = end_cond () ;`
		1843	`in_declaration-- ;`
		1844	`}`
		1845	`goto ZL0;`
		1846	`}`
		1847	`/UNREACHED/`
		1848	`ZL2:;`
		1849	`switch (CURRENT_TERMINAL) {`
		1850	`case 1: case 2: case 3: case 5: case 6:`
		1851	`case 7: case 8: case 9: case 17: case 18:`
		1852	`case 19: case 20: case 21: case 22: case 23:`
		1853	`case 25: case 33: case 43: case 59: case 61:`
		1854	`case 62: case 65: case 69: case 71: case 78:`
		1855	`case 83: case 85: case 97: case 102: case 106:`
		1856	`case 110: case 111: case 114: case 115: case 116:`
		1857	`case 122: case 123: case 127: case 130: case 131:`
		1858	`case 132: case 135: case 140: case 141: case 145:`
		1859	`case 146: case 148: case 149: case 150: case 152:`
		1860	`case 156: case 170: case 184: case 205: case 209:`
		1861	`case 285: case 297: case 298: case 323: case 329:`
		1862	`case 345:`
		1863	`{`
		1864	`ZR491 (&ZI431);`
		1865	`if ((CURRENT_TERMINAL) == 354) {`
		1866	`RESTORE_LEXER;`
		1867	`goto ZL1;`
		1868	`}`
		1869	`}`
		1870	`break;`
		1871	`default:`
		1872	`goto ZL1;`
		1873	`}`
		1874	`goto ZL0;`
		1875	`ZL1:;`
		1876	`SAVE_LEXER (354);`
		1877	`return;`
		1878	`ZL0:;`
		1879	`*ZO431 = ZI431;`
		1880	`}`
		1881
		1882	`void`
7	7u83	1883	`ZR1603(NAMESPACE ZI425, IDENTIFIER ZO419)`
2	7u83	1884	`{`
		1885	`IDENTIFIER ZI419;`
		1886
		1887	`switch (CURRENT_TERMINAL) {`
		1888	`case 4:`
		1889	`{`
		1890	`IDENTIFIER ZI478;`
		1891
		1892	`{`
		1893
		1894	`ZI478 = crt_token->pp_data.id.use ;`
		1895	`}`
		1896	`ADVANCE_LEXER;`
		1897	`{`
		1898
		1899	`crt_id_qualifier = qual_full ;`
		1900	`qual_namespace = (*ZI425) ;`
		1901	`}`
		1902	`{`
		1903
		1904	`(ZI419) = check_id ( (*ZI425), (ZI478), 0 ) ;`
		1905	`last_namespace = (*ZI425) ;`
		1906	`}`
		1907	`}`
		1908	`break;`
		1909	`case 2: case 7:`
		1910	`{`
		1911	`IDENTIFIER ZI460;`
		1912
		1913	`{`
		1914	`switch (CURRENT_TERMINAL) {`
		1915	`case 7:`
		1916	`{`
		1917	`{`
		1918
		1919	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		1920	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		1921	`ZI460 = parse_type_template ( id, args, 0 ) ;`
		1922	`crt_templ_qualifier = 1 ;`
		1923	`RESCAN_LEXER ;`
		1924	`}`
		1925	`ADVANCE_LEXER;`
		1926	`}`
		1927	`break;`
		1928	`case 2:`
		1929	`{`
		1930	`{`
		1931
		1932	`ZI460 = crt_token->pp_data.id.use ;`
		1933	`}`
		1934	`ADVANCE_LEXER;`
		1935	`}`
		1936	`break;`
		1937	`default:`
		1938	`goto ZL1;`
		1939	`}`
		1940	`}`
		1941	`{`
		1942
		1943	`crt_id_qualifier = qual_full ;`
		1944	`qual_namespace = (*ZI425) ;`
		1945	`}`
		1946	`{`
		1947
		1948	`(ZI419) = check_id ( (*ZI425), (ZI460), 0 ) ;`
		1949	`last_namespace = (*ZI425) ;`
		1950	`}`
		1951	`}`
		1952	`break;`
		1953	`case 1: case 3: case 5: case 6: case 141:`
		1954	`case 147:`
		1955	`{`
		1956	`int ZI480;`
		1957	`IDENTIFIER ZI478;`
		1958
		1959	`ZR475 (*ZI425, &ZI480);`
		1960	`ZR476 (*ZI425, &ZI478);`
		1961	`if ((CURRENT_TERMINAL) == 354) {`
		1962	`RESTORE_LEXER;`
		1963	`goto ZL1;`
		1964	`}`
		1965	`{`
		1966
		1967	`crt_id_qualifier = qual_full ;`
		1968	`qual_namespace = (*ZI425) ;`
		1969	`}`
		1970	`{`
		1971
		1972	`(ZI419) = check_id ( (*ZI425), (ZI478), (ZI480) ) ;`
		1973	`last_namespace = (*ZI425) ;`
		1974	`}`
		1975	`}`
		1976	`break;`
		1977	`case 354:`
		1978	`return;`
		1979	`default:`
		1980	`goto ZL1;`
		1981	`}`
		1982	`goto ZL0;`
		1983	`ZL1:;`
		1984	`SAVE_LEXER (354);`
		1985	`return;`
		1986	`ZL0:;`
		1987	`*ZO419 = ZI419;`
		1988	`}`
		1989
		1990	`void`
7	7u83	1991	`ZR1604(IDENTIFIER *ZO419)`
2	7u83	1992	`{`
		1993	`IDENTIFIER ZI419;`
		1994
		1995	`switch (CURRENT_TERMINAL) {`
		1996	`case 4:`
		1997	`{`
		1998	`IDENTIFIER ZI478;`
		1999	`NAMESPACE ZI425;`
		2000
		2001	`{`
		2002
		2003	`ZI478 = crt_token->pp_data.id.use ;`
		2004	`}`
		2005	`ADVANCE_LEXER;`
		2006	`{`
		2007
		2008	`(ZI425) = global_namespace ;`
		2009	`crt_id_qualifier = qual_top ;`
		2010	`qual_namespace = (ZI425) ;`
		2011	`}`
		2012	`{`
		2013
		2014	`(ZI419) = check_id ( (ZI425), (ZI478), 0 ) ;`
		2015	`last_namespace = (ZI425) ;`
		2016	`}`
		2017	`}`
		2018	`break;`
		2019	`case 2: case 7:`
		2020	`{`
		2021	`IDENTIFIER ZI460;`
		2022	`NAMESPACE ZI425;`
		2023
		2024	`{`
		2025	`switch (CURRENT_TERMINAL) {`
		2026	`case 7:`
		2027	`{`
		2028	`{`
		2029
		2030	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		2031	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		2032	`ZI460 = parse_type_template ( id, args, 0 ) ;`
		2033	`crt_templ_qualifier = 1 ;`
		2034	`RESCAN_LEXER ;`
		2035	`}`
		2036	`ADVANCE_LEXER;`
		2037	`}`
		2038	`break;`
		2039	`case 2:`
		2040	`{`
		2041	`{`
		2042
		2043	`ZI460 = crt_token->pp_data.id.use ;`
		2044	`}`
		2045	`ADVANCE_LEXER;`
		2046	`}`
		2047	`break;`
		2048	`default:`
		2049	`goto ZL1;`
		2050	`}`
		2051	`}`
		2052	`{`
		2053
		2054	`(ZI425) = global_namespace ;`
		2055	`crt_id_qualifier = qual_top ;`
		2056	`qual_namespace = (ZI425) ;`
		2057	`}`
		2058	`{`
		2059
		2060	`(ZI419) = check_id ( (ZI425), (ZI460), 0 ) ;`
		2061	`last_namespace = (ZI425) ;`
		2062	`}`
		2063	`}`
		2064	`break;`
		2065	`case 1: case 3: case 5: case 6: case 141:`
		2066	`case 147:`
		2067	`{`
		2068	`NAMESPACE ZI425;`
		2069	`int ZI480;`
		2070	`IDENTIFIER ZI478;`
		2071
		2072	`{`
		2073
		2074	`(ZI425) = global_namespace ;`
		2075	`crt_id_qualifier = qual_top ;`
		2076	`qual_namespace = (ZI425) ;`
		2077	`}`
		2078	`ZR475 (ZI425, &ZI480);`
		2079	`ZR476 (ZI425, &ZI478);`
		2080	`if ((CURRENT_TERMINAL) == 354) {`
		2081	`RESTORE_LEXER;`
		2082	`goto ZL1;`
		2083	`}`
		2084	`{`
		2085
		2086	`(ZI419) = check_id ( (ZI425), (ZI478), (ZI480) ) ;`
		2087	`last_namespace = (ZI425) ;`
		2088	`}`
		2089	`}`
		2090	`break;`
		2091	`case 354:`
		2092	`return;`
		2093	`default:`
		2094	`goto ZL1;`
		2095	`}`
		2096	`goto ZL0;`
		2097	`ZL1:;`
		2098	`SAVE_LEXER (354);`
		2099	`return;`
		2100	`ZL0:;`
		2101	`*ZO419 = ZI419;`
		2102	`}`
		2103
		2104	`void`
7	7u83	2105	`ZR847(int *ZO414)`
2	7u83	2106	`{`
		2107	`int ZI414;`
		2108
		2109	`switch (CURRENT_TERMINAL) {`
		2110	`case 41:`
		2111	`{`
		2112	`ADVANCE_LEXER;`
		2113	`ZR1326 (&ZI414);`
		2114	`if ((CURRENT_TERMINAL) == 354) {`
		2115	`RESTORE_LEXER;`
		2116	`goto ZL1;`
		2117	`}`
		2118	`}`
		2119	`break;`
		2120	`default:`
		2121	`{`
		2122	`{`
		2123	`(ZI414) = 1 ;`
		2124	`}`
		2125	`}`
		2126	`break;`
		2127	`case 354:`
		2128	`return;`
		2129	`}`
		2130	`goto ZL0;`
		2131	`ZL1:;`
		2132	`SAVE_LEXER (354);`
		2133	`return;`
		2134	`ZL0:;`
		2135	`*ZO414 = ZI414;`
		2136	`}`
		2137
		2138	`void`
7	7u83	2139	`ZR990(TYPE *ZO1148)`
2	7u83	2140	`{`
		2141	`TYPE ZI1148;`
		2142
		2143	`if ((CURRENT_TERMINAL) == 354) {`
		2144	`return;`
		2145	`}`
		2146	`{`
		2147	`EXP ZI493;`
		2148	`EXP ZI431;`
		2149	`TYPE ZI414;`
		2150
		2151	`{`
		2152	`{`
		2153	`switch (CURRENT_TERMINAL) {`
		2154	`case 66:`
		2155	`break;`
		2156	`default:`
		2157	`goto ZL1;`
		2158	`}`
		2159	`ADVANCE_LEXER;`
		2160	`}`
		2161	`}`
		2162	`ZR491 (&ZI493);`
		2163	`if ((CURRENT_TERMINAL) == 354) {`
		2164	`RESTORE_LEXER;`
		2165	`goto ZL1;`
		2166	`}`
		2167	`{`
		2168
		2169	`(ZI431) = convert_reference ( (ZI493), REF_NORMAL ) ;`
		2170	`(ZI431) = convert_lvalue ( (ZI431) ) ;`
		2171	`}`
		2172	`{`
		2173
		2174	`/* First array bound in a new-declarator */`
		2175	`NAT n = make_new_array_dim ( (ZI431) ) ;`
		2176	`MAKE_type_array ( cv_none, NULL_type, n, (ZI414) ) ;`
		2177	`}`
		2178	`{`
		2179	`{`
		2180	`switch (CURRENT_TERMINAL) {`
		2181	`case 40:`
		2182	`break;`
		2183	`default:`
		2184	`goto ZL1;`
		2185	`}`
		2186	`ADVANCE_LEXER;`
		2187	`}`
		2188	`}`
		2189	`ZR1149 (ZI414, &ZI1148);`
		2190	`if ((CURRENT_TERMINAL) == 354) {`
		2191	`RESTORE_LEXER;`
		2192	`goto ZL1;`
		2193	`}`
		2194	`}`
		2195	`goto ZL0;`
		2196	`ZL1:;`
		2197	`SAVE_LEXER (354);`
		2198	`return;`
		2199	`ZL0:;`
		2200	`*ZO1148 = ZI1148;`
		2201	`}`
		2202
		2203	`void`
7	7u83	2204	`ZR1224(EXP ZI1222, EXP *ZO1223)`
2	7u83	2205	`{`
		2206	`EXP ZI1223;`
		2207
		2208	`ZL2_1224:;`
		2209	`switch (CURRENT_TERMINAL) {`
		2210	`case 57:`
		2211	`{`
		2212	`EXP ZI456;`
		2213	`EXP ZI431;`
		2214
		2215	`ADVANCE_LEXER;`
		2216	`ZR608 (&ZI456);`
		2217	`if ((CURRENT_TERMINAL) == 354) {`
		2218	`RESTORE_LEXER;`
		2219	`goto ZL1;`
		2220	`}`
		2221	`{`
		2222
		2223	`(ZI431) = make_shift_exp ( lex_lshift, (ZI1222), (ZI456) ) ;`
		2224	`}`
		2225	`ZI1222 = ZI431;`
		2226	`goto ZL2_1224;`
		2227	`}`
		2228	`/UNREACHED/`
		2229	`case 75:`
		2230	`{`
		2231	`EXP ZI456;`
		2232	`EXP ZI431;`
		2233
		2234	`ADVANCE_LEXER;`
		2235	`ZR608 (&ZI456);`
		2236	`if ((CURRENT_TERMINAL) == 354) {`
		2237	`RESTORE_LEXER;`
		2238	`goto ZL1;`
		2239	`}`
		2240	`{`
		2241
		2242	`(ZI431) = make_shift_exp ( lex_rshift, (ZI1222), (ZI456) ) ;`
		2243	`}`
		2244	`ZI1222 = ZI431;`
		2245	`goto ZL2_1224;`
		2246	`}`
		2247	`/UNREACHED/`
		2248	`default:`
		2249	`{`
		2250	`ZI1223 = ZI1222;`
		2251	`}`
		2252	`break;`
		2253	`case 354:`
		2254	`return;`
		2255	`}`
		2256	`goto ZL0;`
		2257	`ZL1:;`
		2258	`SAVE_LEXER (354);`
		2259	`return;`
		2260	`ZL0:;`
		2261	`*ZO1223 = ZI1223;`
		2262	`}`
		2263
		2264	`void`
7	7u83	2265	`ZR427(NAMESPACE *ZO425)`
2	7u83	2266	`{`
		2267	`NAMESPACE ZI425;`
		2268
		2269	`switch (CURRENT_TERMINAL) {`
		2270	`case 83:`
		2271	`{`
		2272	`ADVANCE_LEXER;`
		2273	`{`
		2274
		2275	`(ZI425) = global_namespace ;`
		2276	`crt_id_qualifier = qual_top ;`
		2277	`qual_namespace = (ZI425) ;`
		2278	`}`
		2279	`}`
		2280	`break;`
		2281	`case 8: case 9:`
		2282	`{`
		2283	`ZR426 (&ZI425);`
		2284	`if ((CURRENT_TERMINAL) == 354) {`
		2285	`RESTORE_LEXER;`
		2286	`goto ZL1;`
		2287	`}`
		2288	`}`
		2289	`break;`
		2290	`case 354:`
		2291	`return;`
		2292	`default:`
		2293	`goto ZL1;`
		2294	`}`
		2295	`goto ZL0;`
		2296	`ZL1:;`
		2297	`SAVE_LEXER (354);`
		2298	`return;`
		2299	`ZL0:;`
		2300	`*ZO425 = ZI425;`
		2301	`}`
		2302
		2303	`void`
7	7u83	2304	`ZR662(void)`
2	7u83	2305	`{`
		2306	`switch (CURRENT_TERMINAL) {`
		2307	`case 222:`
		2308	`{`
		2309	`ADVANCE_LEXER;`
		2310	`ZR1599 ();`
		2311	`if ((CURRENT_TERMINAL) == 354) {`
		2312	`RESTORE_LEXER;`
		2313	`goto ZL1;`
		2314	`}`
		2315	`}`
		2316	`break;`
		2317	`case 354:`
		2318	`return;`
		2319	`default:`
		2320	`break;`
		2321	`}`
		2322	`return;`
		2323	`ZL1:;`
		2324	`SAVE_LEXER (354);`
		2325	`return;`
		2326	`}`
		2327
		2328	`void`
7	7u83	2329	`ZR784(CV_SPEC *ZO783)`
2	7u83	2330	`{`
		2331	`CV_SPEC ZI783;`
		2332
		2333	`switch (CURRENT_TERMINAL) {`
		2334	`case 98:`
		2335	`{`
		2336	`ADVANCE_LEXER;`
		2337	`{`
		2338	`(ZI783) = cv_const ;`
		2339	`}`
		2340	`}`
		2341	`break;`
		2342	`case 124:`
		2343	`{`
		2344	`ADVANCE_LEXER;`
		2345	`{`
		2346	`(ZI783) = cv_volatile ;`
		2347	`}`
		2348	`}`
		2349	`break;`
		2350	`case 354:`
		2351	`return;`
		2352	`default:`
		2353	`goto ZL1;`
		2354	`}`
		2355	`goto ZL0;`
		2356	`ZL1:;`
		2357	`SAVE_LEXER (354);`
		2358	`return;`
		2359	`ZL0:;`
		2360	`*ZO783 = ZI783;`
		2361	`}`
		2362
		2363	`void`
7	7u83	2364	`ZR835(void)`
2	7u83	2365	`{`
		2366	`if ((CURRENT_TERMINAL) == 354) {`
		2367	`return;`
		2368	`}`
		2369	`{`
		2370	`EXP ZI497;`
		2371
		2372	`ZR834 (&ZI497);`
		2373	`{`
		2374	`switch (CURRENT_TERMINAL) {`
		2375	`case 28:`
		2376	`{`
		2377	`ADVANCE_LEXER;`
		2378	`{`
		2379
		2380	`crt_hash_cond = make_else_cond ( crt_hash_cond ) ;`
		2381	`}`
		2382	`{`
		2383
		2384	`target_decl ( lex_else, NULL_exp ) ;`
		2385	`}`
		2386	`ZR833 ();`
		2387	`if ((CURRENT_TERMINAL) == 354) {`
		2388	`RESTORE_LEXER;`
		2389	`goto ZL1;`
		2390	`}`
		2391	`}`
		2392	`break;`
		2393	`case 354:`
		2394	`RESTORE_LEXER;`
		2395	`goto ZL1;`
		2396	`default:`
		2397	`break;`
		2398	`}`
		2399	`}`
		2400	`{`
		2401
		2402	`crt_hash_cond = (ZI497) ;`
		2403	`}`
		2404	`switch (CURRENT_TERMINAL) {`
		2405	`case 29:`
		2406	`break;`
		2407	`default:`
		2408	`goto ZL1;`
		2409	`}`
		2410	`ADVANCE_LEXER;`
		2411	`{`
		2412
		2413	`target_decl ( lex_endif, NULL_exp ) ;`
		2414	`}`
		2415	`}`
		2416	`return;`
		2417	`ZL1:;`
		2418	`SAVE_LEXER (354);`
		2419	`return;`
		2420	`}`
		2421
		2422	`void`
7	7u83	2423	`ZR596(void)`
2	7u83	2424	`{`
		2425	`switch (CURRENT_TERMINAL) {`
		2426	`case 85:`
		2427	`{`
		2428	`ADVANCE_LEXER;`
		2429	`}`
		2430	`break;`
		2431	`case 59:`
		2432	`{`
		2433	`ADVANCE_LEXER;`
		2434	`}`
		2435	`break;`
		2436	`case 69:`
		2437	`{`
		2438	`ADVANCE_LEXER;`
		2439	`}`
		2440	`break;`
		2441	`case 43:`
		2442	`{`
		2443	`{`
		2444	`{`
		2445	`switch (CURRENT_TERMINAL) {`
		2446	`case 43:`
		2447	`break;`
		2448	`default:`
		2449	`goto ZL1;`
		2450	`}`
		2451	`ADVANCE_LEXER;`
		2452	`}`
		2453	`}`
		2454	`}`
		2455	`break;`
		2456	`case 354:`
		2457	`return;`
		2458	`default:`
		2459	`goto ZL1;`
		2460	`}`
		2461	`return;`
		2462	`ZL1:;`
		2463	`SAVE_LEXER (354);`
		2464	`return;`
		2465	`}`
		2466
		2467	`void`
7	7u83	2468	`ZR1084(DECL_SPEC ZI689, TYPE ZI497, BASE_TYPE ZI480, ACCESS_LIST ZI670, int ZI720, IDENTIFIER *ZO459)`
2	7u83	2469	`{`
		2470	`IDENTIFIER ZI459;`
		2471
		2472	`switch (CURRENT_TERMINAL) {`
		2473	`case 83:`
		2474	`{`
		2475	`IDENTIFIER ZI1353;`
		2476	`TYPE ZI1354;`
		2477	`int ZI1355;`
		2478	`TYPE ZI1347;`
		2479	`IDENTIFIER ZI419;`
		2480	`int ZI558;`
		2481	`TYPE ZI414;`
		2482	`int ZI1085;`
		2483	`EXP ZI431;`
		2484
		2485	`ADVANCE_LEXER;`
		2486	`ZR1346 (&ZI1353);`
		2487	`if ((CURRENT_TERMINAL) == 354) {`
		2488	`RESTORE_LEXER;`
		2489	`goto ZL1;`
		2490	`}`
		2491	`{`
		2492
		2493	`(ZI1354) = NULL_type ;`
		2494	`}`
		2495	`{`
		2496	`(ZI1355) = 0 ;`
		2497	`}`
		2498	`{`
		2499
		2500	`begin_declarator ( (ZI1353), crt_id_qualifier, qual_namespace, 1 ) ;`
		2501	`}`
		2502	`ZR1177 (ZI1354, ZI1353, ZI1355, &ZI1347, &ZI419, &ZI558);`
		2503	`if ((CURRENT_TERMINAL) == 354) {`
		2504	`RESTORE_LEXER;`
		2505	`goto ZL1;`
		2506	`}`
		2507	`{`
		2508
		2509	`if ( !IS_NULL_type ( (ZI497) ) ) template_decl ( (ZI497) ) ;`
		2510	`}`
		2511	`{`
		2512
		2513	`(ZI414) = ( IS_NULL_type ( (ZI1347) ) ? (ZI497) : inject_pre_type ( (ZI1347), (ZI497), 1 ) ) ;`
		2514	`}`
		2515	`{`
		2516
		2517	`if ( (ZI558) ) report ( crt_loc, ERR_dcl_init_bad () ) ;`
		2518	`}`
		2519	`{`
		2520
		2521	`DECL_SPEC ds = (ZI689) ;`
		2522	`if ( type_tag ( (ZI414) ) == type_func_tag ) {`
		2523	`/* Look ahead for function definitions */`
		2524	`int def = predict_func_defn () ;`
		2525	`if ( def & !have_func_declarator ) adjust_param ( (ZI414) ) ;`
		2526	`if ( ds & dspec_friend ) {`
		2527	`(ZI459) = make_friend_decl ( ds, (ZI414), (ZI419), def, 1 ) ;`
		2528	`(ZI1085) = 1 ;`
		2529	`} else {`
		2530	`(ZI459) = make_func_mem_decl ( ds, (ZI414), (ZI419), def ) ;`
		2531	`(ZI1085) = 0 ;`
		2532	`}`
		2533	`is_function_next = def ;`
		2534	`} else {`
		2535	`int f = ( (ZI720) && ( crt_lex_token == lex_semicolon ) ) ;`
		2536	`(ZI459) = make_member_decl ( ds, (ZI414), (ZI419), f ) ;`
		2537	`(ZI1085) = 0 ;`
		2538	`is_function_next = 0 ;`
		2539	`}`
		2540	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		2541	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		2542	`bs \|= (ZI480) ;`
		2543	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		2544	`}`
		2545	`have_type_declaration = TYPE_DECL_NONE ;`
		2546	`have_func_declarator = 0 ;`
		2547	`}`
		2548	`{`
		2549
		2550	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		2551	`}`
		2552	`{`
		2553
		2554	`if ( crt_access_list.pending ) {`
		2555	`IGNORE report_access ( (ZI459) ) ;`
		2556	`}`
		2557	`}`
		2558	`ZR1083 (&ZI431);`
		2559	`if ((CURRENT_TERMINAL) == 354) {`
		2560	`RESTORE_LEXER;`
		2561	`goto ZL1;`
		2562	`}`
		2563	`{`
		2564
		2565	`int def = ( (ZI1085) ? init_object ( (ZI459), (ZI431) ) : init_member ( (ZI459), (ZI431) ) ) ;`
		2566	`if ( do_dump ) dump_declare ( (ZI459), &decl_loc, def ) ;`
		2567	`}`
		2568	`{`
		2569
		2570	`if ( crt_access_list.pending ) {`
		2571	`IGNORE report_access ( (ZI459) ) ;`
		2572	`}`
		2573	`}`
		2574	`}`
		2575	`break;`
		2576	`case 5:`
		2577	`{`
		2578	`IDENTIFIER ZI478;`
		2579	`IDENTIFIER ZI1353;`
		2580	`TYPE ZI1354;`
		2581	`int ZI1355;`
		2582	`TYPE ZI1347;`
		2583	`IDENTIFIER ZI419;`
		2584	`int ZI558;`
		2585	`TYPE ZI414;`
		2586	`int ZI1085;`
		2587	`EXP ZI431;`
		2588
		2589	`{`
		2590
		2591	`ZI478 = crt_token->pp_data.id.use ;`
		2592	`}`
		2593	`ADVANCE_LEXER;`
		2594	`{`
		2595
		2596	`(ZI1353) = check_id ( NULL_nspace, (ZI478), 0 ) ;`
		2597	`crt_id_qualifier = qual_none ;`
		2598	`last_namespace = crt_namespace ;`
		2599	`}`
		2600	`{`
		2601
		2602	`(ZI1354) = NULL_type ;`
		2603	`}`
		2604	`{`
		2605	`(ZI1355) = 0 ;`
		2606	`}`
		2607	`{`
		2608
		2609	`begin_declarator ( (ZI1353), crt_id_qualifier, qual_namespace, 1 ) ;`
		2610	`}`
		2611	`ZR1177 (ZI1354, ZI1353, ZI1355, &ZI1347, &ZI419, &ZI558);`
		2612	`if ((CURRENT_TERMINAL) == 354) {`
		2613	`RESTORE_LEXER;`
		2614	`goto ZL1;`
		2615	`}`
		2616	`{`
		2617
		2618	`if ( !IS_NULL_type ( (ZI497) ) ) template_decl ( (ZI497) ) ;`
		2619	`}`
		2620	`{`
		2621
		2622	`(ZI414) = ( IS_NULL_type ( (ZI1347) ) ? (ZI497) : inject_pre_type ( (ZI1347), (ZI497), 1 ) ) ;`
		2623	`}`
		2624	`{`
		2625
		2626	`if ( (ZI558) ) report ( crt_loc, ERR_dcl_init_bad () ) ;`
		2627	`}`
		2628	`{`
		2629
		2630	`DECL_SPEC ds = (ZI689) ;`
		2631	`if ( type_tag ( (ZI414) ) == type_func_tag ) {`
		2632	`/* Look ahead for function definitions */`
		2633	`int def = predict_func_defn () ;`
		2634	`if ( def & !have_func_declarator ) adjust_param ( (ZI414) ) ;`
		2635	`if ( ds & dspec_friend ) {`
		2636	`(ZI459) = make_friend_decl ( ds, (ZI414), (ZI419), def, 1 ) ;`
		2637	`(ZI1085) = 1 ;`
		2638	`} else {`
		2639	`(ZI459) = make_func_mem_decl ( ds, (ZI414), (ZI419), def ) ;`
		2640	`(ZI1085) = 0 ;`
		2641	`}`
		2642	`is_function_next = def ;`
		2643	`} else {`
		2644	`int f = ( (ZI720) && ( crt_lex_token == lex_semicolon ) ) ;`
		2645	`(ZI459) = make_member_decl ( ds, (ZI414), (ZI419), f ) ;`
		2646	`(ZI1085) = 0 ;`
		2647	`is_function_next = 0 ;`
		2648	`}`
		2649	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		2650	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		2651	`bs \|= (ZI480) ;`
		2652	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		2653	`}`
		2654	`have_type_declaration = TYPE_DECL_NONE ;`
		2655	`have_func_declarator = 0 ;`
		2656	`}`
		2657	`{`
		2658
		2659	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		2660	`}`
		2661	`{`
		2662
		2663	`if ( crt_access_list.pending ) {`
		2664	`IGNORE report_access ( (ZI459) ) ;`
		2665	`}`
		2666	`}`
		2667	`ZR1083 (&ZI431);`
		2668	`if ((CURRENT_TERMINAL) == 354) {`
		2669	`RESTORE_LEXER;`
		2670	`goto ZL1;`
		2671	`}`
		2672	`{`
		2673
		2674	`int def = ( (ZI1085) ? init_object ( (ZI459), (ZI431) ) : init_member ( (ZI459), (ZI431) ) ) ;`
		2675	`if ( do_dump ) dump_declare ( (ZI459), &decl_loc, def ) ;`
		2676	`}`
		2677	`{`
		2678
		2679	`if ( crt_access_list.pending ) {`
		2680	`IGNORE report_access ( (ZI459) ) ;`
		2681	`}`
		2682	`}`
		2683	`}`
		2684	`break;`
		2685	`case 9:`
		2686	`{`
		2687	`NAMESPACE ZI425;`
		2688	`IDENTIFIER ZI1353;`
		2689	`TYPE ZI1354;`
		2690	`int ZI1355;`
		2691	`TYPE ZI1347;`
		2692	`IDENTIFIER ZI419;`
		2693	`int ZI558;`
		2694	`TYPE ZI414;`
		2695	`int ZI1085;`
		2696	`EXP ZI431;`
		2697
		2698	`{`
		2699
		2700	`ZI425 = crt_token->pp_data.ns ;`
		2701	`}`
		2702	`ADVANCE_LEXER;`
		2703	`ZR1345 (&ZI425, &ZI1353);`
		2704	`if ((CURRENT_TERMINAL) == 354) {`
		2705	`RESTORE_LEXER;`
		2706	`goto ZL1;`
		2707	`}`
		2708	`{`
		2709
		2710	`(ZI1354) = NULL_type ;`
		2711	`}`
		2712	`{`
		2713	`(ZI1355) = 0 ;`
		2714	`}`
		2715	`{`
		2716
		2717	`begin_declarator ( (ZI1353), crt_id_qualifier, qual_namespace, 1 ) ;`
		2718	`}`
		2719	`ZR1177 (ZI1354, ZI1353, ZI1355, &ZI1347, &ZI419, &ZI558);`
		2720	`if ((CURRENT_TERMINAL) == 354) {`
		2721	`RESTORE_LEXER;`
		2722	`goto ZL1;`
		2723	`}`
		2724	`{`
		2725
		2726	`if ( !IS_NULL_type ( (ZI497) ) ) template_decl ( (ZI497) ) ;`
		2727	`}`
		2728	`{`
		2729
		2730	`(ZI414) = ( IS_NULL_type ( (ZI1347) ) ? (ZI497) : inject_pre_type ( (ZI1347), (ZI497), 1 ) ) ;`
		2731	`}`
		2732	`{`
		2733
		2734	`if ( (ZI558) ) report ( crt_loc, ERR_dcl_init_bad () ) ;`
		2735	`}`
		2736	`{`
		2737
		2738	`DECL_SPEC ds = (ZI689) ;`
		2739	`if ( type_tag ( (ZI414) ) == type_func_tag ) {`
		2740	`/* Look ahead for function definitions */`
		2741	`int def = predict_func_defn () ;`
		2742	`if ( def & !have_func_declarator ) adjust_param ( (ZI414) ) ;`
		2743	`if ( ds & dspec_friend ) {`
		2744	`(ZI459) = make_friend_decl ( ds, (ZI414), (ZI419), def, 1 ) ;`
		2745	`(ZI1085) = 1 ;`
		2746	`} else {`
		2747	`(ZI459) = make_func_mem_decl ( ds, (ZI414), (ZI419), def ) ;`
		2748	`(ZI1085) = 0 ;`
		2749	`}`
		2750	`is_function_next = def ;`
		2751	`} else {`
		2752	`int f = ( (ZI720) && ( crt_lex_token == lex_semicolon ) ) ;`
		2753	`(ZI459) = make_member_decl ( ds, (ZI414), (ZI419), f ) ;`
		2754	`(ZI1085) = 0 ;`
		2755	`is_function_next = 0 ;`
		2756	`}`
		2757	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		2758	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		2759	`bs \|= (ZI480) ;`
		2760	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		2761	`}`
		2762	`have_type_declaration = TYPE_DECL_NONE ;`
		2763	`have_func_declarator = 0 ;`
		2764	`}`
		2765	`{`
		2766
		2767	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		2768	`}`
		2769	`{`
		2770
		2771	`if ( crt_access_list.pending ) {`
		2772	`IGNORE report_access ( (ZI459) ) ;`
		2773	`}`
		2774	`}`
		2775	`ZR1083 (&ZI431);`
		2776	`if ((CURRENT_TERMINAL) == 354) {`
		2777	`RESTORE_LEXER;`
		2778	`goto ZL1;`
		2779	`}`
		2780	`{`
		2781
		2782	`int def = ( (ZI1085) ? init_object ( (ZI459), (ZI431) ) : init_member ( (ZI459), (ZI431) ) ) ;`
		2783	`if ( do_dump ) dump_declare ( (ZI459), &decl_loc, def ) ;`
		2784	`}`
		2785	`{`
		2786
		2787	`if ( crt_access_list.pending ) {`
		2788	`IGNORE report_access ( (ZI459) ) ;`
		2789	`}`
		2790	`}`
		2791	`}`
		2792	`break;`
		2793	`case 1:`
		2794	`{`
		2795	`IDENTIFIER ZI1360;`
		2796	`IDENTIFIER ZI1361;`
		2797
		2798	`{`
		2799
		2800	`ZI1360 = crt_token->pp_data.id.use ;`
		2801	`}`
		2802	`ADVANCE_LEXER;`
		2803	`{`
		2804
		2805	`(ZI1361) = (ZI1360) ;`
		2806	`crt_id_qualifier = qual_none ;`
		2807	`last_namespace = crt_namespace ;`
		2808	`}`
		2809	`ZR1365 (&ZI689, &ZI497, &ZI480, &ZI670, &ZI720, &ZI1361, &ZI459);`
		2810	`if ((CURRENT_TERMINAL) == 354) {`
		2811	`RESTORE_LEXER;`
		2812	`goto ZL1;`
		2813	`}`
		2814	`}`
		2815	`break;`
		2816	`case 3:`
		2817	`{`
		2818	`IDENTIFIER ZI1363;`
		2819	`IDENTIFIER ZI1364;`
		2820
		2821	`{`
		2822
		2823	`ZI1363 = crt_token->pp_data.id.use ;`
		2824	`}`
		2825	`ADVANCE_LEXER;`
		2826	`{`
		2827
		2828	`(ZI1364) = (ZI1363) ;`
		2829	`crt_id_qualifier = qual_none ;`
		2830	`last_namespace = crt_namespace ;`
		2831	`}`
		2832	`ZR1365 (&ZI689, &ZI497, &ZI480, &ZI670, &ZI720, &ZI1364, &ZI459);`
		2833	`if ((CURRENT_TERMINAL) == 354) {`
		2834	`RESTORE_LEXER;`
		2835	`goto ZL1;`
		2836	`}`
		2837	`}`
		2838	`break;`
		2839	`case 8:`
		2840	`{`
		2841	`NAMESPACE ZI425;`
		2842	`IDENTIFIER ZI1353;`
		2843	`TYPE ZI1354;`
		2844	`int ZI1355;`
		2845	`TYPE ZI1347;`
		2846	`IDENTIFIER ZI419;`
		2847	`int ZI558;`
		2848	`TYPE ZI414;`
		2849	`int ZI1085;`
		2850	`EXP ZI431;`
		2851
		2852	`{`
		2853
		2854	`ZI425 = crt_token->pp_data.ns ;`
		2855	`}`
		2856	`ADVANCE_LEXER;`
		2857	`ZR1344 (&ZI425, &ZI1353);`
		2858	`if ((CURRENT_TERMINAL) == 354) {`
		2859	`RESTORE_LEXER;`
		2860	`goto ZL1;`
		2861	`}`
		2862	`{`
		2863
		2864	`(ZI1354) = NULL_type ;`
		2865	`}`
		2866	`{`
		2867	`(ZI1355) = 0 ;`
		2868	`}`
		2869	`{`
		2870
		2871	`begin_declarator ( (ZI1353), crt_id_qualifier, qual_namespace, 1 ) ;`
		2872	`}`
		2873	`ZR1177 (ZI1354, ZI1353, ZI1355, &ZI1347, &ZI419, &ZI558);`
		2874	`if ((CURRENT_TERMINAL) == 354) {`
		2875	`RESTORE_LEXER;`
		2876	`goto ZL1;`
		2877	`}`
		2878	`{`
		2879
		2880	`if ( !IS_NULL_type ( (ZI497) ) ) template_decl ( (ZI497) ) ;`
		2881	`}`
		2882	`{`
		2883
		2884	`(ZI414) = ( IS_NULL_type ( (ZI1347) ) ? (ZI497) : inject_pre_type ( (ZI1347), (ZI497), 1 ) ) ;`
		2885	`}`
		2886	`{`
		2887
		2888	`if ( (ZI558) ) report ( crt_loc, ERR_dcl_init_bad () ) ;`
		2889	`}`
		2890	`{`
		2891
		2892	`DECL_SPEC ds = (ZI689) ;`
		2893	`if ( type_tag ( (ZI414) ) == type_func_tag ) {`
		2894	`/* Look ahead for function definitions */`
		2895	`int def = predict_func_defn () ;`
		2896	`if ( def & !have_func_declarator ) adjust_param ( (ZI414) ) ;`
		2897	`if ( ds & dspec_friend ) {`
		2898	`(ZI459) = make_friend_decl ( ds, (ZI414), (ZI419), def, 1 ) ;`
		2899	`(ZI1085) = 1 ;`
		2900	`} else {`
		2901	`(ZI459) = make_func_mem_decl ( ds, (ZI414), (ZI419), def ) ;`
		2902	`(ZI1085) = 0 ;`
		2903	`}`
		2904	`is_function_next = def ;`
		2905	`} else {`
		2906	`int f = ( (ZI720) && ( crt_lex_token == lex_semicolon ) ) ;`
		2907	`(ZI459) = make_member_decl ( ds, (ZI414), (ZI419), f ) ;`
		2908	`(ZI1085) = 0 ;`
		2909	`is_function_next = 0 ;`
		2910	`}`
		2911	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		2912	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		2913	`bs \|= (ZI480) ;`
		2914	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		2915	`}`
		2916	`have_type_declaration = TYPE_DECL_NONE ;`
		2917	`have_func_declarator = 0 ;`
		2918	`}`
		2919	`{`
		2920
		2921	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		2922	`}`
		2923	`{`
		2924
		2925	`if ( crt_access_list.pending ) {`
		2926	`IGNORE report_access ( (ZI459) ) ;`
		2927	`}`
		2928	`}`
		2929	`ZR1083 (&ZI431);`
		2930	`if ((CURRENT_TERMINAL) == 354) {`
		2931	`RESTORE_LEXER;`
		2932	`goto ZL1;`
		2933	`}`
		2934	`{`
		2935
		2936	`int def = ( (ZI1085) ? init_object ( (ZI459), (ZI431) ) : init_member ( (ZI459), (ZI431) ) ) ;`
		2937	`if ( do_dump ) dump_declare ( (ZI459), &decl_loc, def ) ;`
		2938	`}`
		2939	`{`
		2940
		2941	`if ( crt_access_list.pending ) {`
		2942	`IGNORE report_access ( (ZI459) ) ;`
		2943	`}`
		2944	`}`
		2945	`}`
		2946	`break;`
		2947	`case 65:`
		2948	`{`
		2949	`TYPE ZI1350;`
		2950	`IDENTIFIER ZI1351;`
		2951	`int ZI1352;`
		2952	`TYPE ZI1347;`
		2953	`IDENTIFIER ZI419;`
		2954	`int ZI558;`
		2955	`TYPE ZI414;`
		2956	`int ZI1085;`
		2957	`EXP ZI431;`
		2958
		2959	`ADVANCE_LEXER;`
		2960	`ZR940 (&ZI1350, &ZI1351, &ZI1352);`
		2961	`if ((CURRENT_TERMINAL) == 354) {`
		2962	`RESTORE_LEXER;`
		2963	`goto ZL1;`
		2964	`}`
		2965	`{`
		2966
		2967	`if ( (ZI1352) ) report ( crt_loc, ERR_dcl_init_bad () ) ;`
		2968	`}`
		2969	`{`
		2970
		2971	`if ( IS_NULL_type ( (ZI1350) ) ) {`
		2972	`report ( crt_loc, ERR_dcl_meaning_paren () ) ;`
		2973	`}`
		2974	`}`
		2975	`switch (CURRENT_TERMINAL) {`
		2976	`case 39:`
		2977	`break;`
		2978	`default:`
		2979	`goto ZL1;`
		2980	`}`
		2981	`ADVANCE_LEXER;`
		2982	`ZR1177 (ZI1350, ZI1351, ZI1352, &ZI1347, &ZI419, &ZI558);`
		2983	`if ((CURRENT_TERMINAL) == 354) {`
		2984	`RESTORE_LEXER;`
		2985	`goto ZL1;`
		2986	`}`
		2987	`{`
		2988
		2989	`if ( !IS_NULL_type ( (ZI497) ) ) template_decl ( (ZI497) ) ;`
		2990	`}`
		2991	`{`
		2992
		2993	`(ZI414) = ( IS_NULL_type ( (ZI1347) ) ? (ZI497) : inject_pre_type ( (ZI1347), (ZI497), 1 ) ) ;`
		2994	`}`
		2995	`{`
		2996
		2997	`if ( (ZI558) ) report ( crt_loc, ERR_dcl_init_bad () ) ;`
		2998	`}`
		2999	`{`
		3000
		3001	`DECL_SPEC ds = (ZI689) ;`
		3002	`if ( type_tag ( (ZI414) ) == type_func_tag ) {`
		3003	`/* Look ahead for function definitions */`
		3004	`int def = predict_func_defn () ;`
		3005	`if ( def & !have_func_declarator ) adjust_param ( (ZI414) ) ;`
		3006	`if ( ds & dspec_friend ) {`
		3007	`(ZI459) = make_friend_decl ( ds, (ZI414), (ZI419), def, 1 ) ;`
		3008	`(ZI1085) = 1 ;`
		3009	`} else {`
		3010	`(ZI459) = make_func_mem_decl ( ds, (ZI414), (ZI419), def ) ;`
		3011	`(ZI1085) = 0 ;`
		3012	`}`
		3013	`is_function_next = def ;`
		3014	`} else {`
		3015	`int f = ( (ZI720) && ( crt_lex_token == lex_semicolon ) ) ;`
		3016	`(ZI459) = make_member_decl ( ds, (ZI414), (ZI419), f ) ;`
		3017	`(ZI1085) = 0 ;`
		3018	`is_function_next = 0 ;`
		3019	`}`
		3020	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		3021	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		3022	`bs \|= (ZI480) ;`
		3023	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		3024	`}`
		3025	`have_type_declaration = TYPE_DECL_NONE ;`
		3026	`have_func_declarator = 0 ;`
		3027	`}`
		3028	`{`
		3029
		3030	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		3031	`}`
		3032	`{`
		3033
		3034	`if ( crt_access_list.pending ) {`
		3035	`IGNORE report_access ( (ZI459) ) ;`
		3036	`}`
		3037	`}`
		3038	`ZR1083 (&ZI431);`
		3039	`if ((CURRENT_TERMINAL) == 354) {`
		3040	`RESTORE_LEXER;`
		3041	`goto ZL1;`
		3042	`}`
		3043	`{`
		3044
		3045	`int def = ( (ZI1085) ? init_object ( (ZI459), (ZI431) ) : init_member ( (ZI459), (ZI431) ) ) ;`
		3046	`if ( do_dump ) dump_declare ( (ZI459), &decl_loc, def ) ;`
		3047	`}`
		3048	`{`
		3049
		3050	`if ( crt_access_list.pending ) {`
		3051	`IGNORE report_access ( (ZI459) ) ;`
		3052	`}`
		3053	`}`
		3054	`}`
		3055	`break;`
		3056	`case 4:`
		3057	`{`
		3058	`IDENTIFIER ZI1357;`
		3059	`IDENTIFIER ZI1358;`
		3060
		3061	`{`
		3062
		3063	`ZI1357 = crt_token->pp_data.id.use ;`
		3064	`}`
		3065	`ADVANCE_LEXER;`
		3066	`{`
		3067
		3068	`(ZI1358) = (ZI1357) ;`
		3069	`crt_id_qualifier = qual_none ;`
		3070	`last_namespace = crt_namespace ;`
		3071	`}`
		3072	`ZR1365 (&ZI689, &ZI497, &ZI480, &ZI670, &ZI720, &ZI1358, &ZI459);`
		3073	`if ((CURRENT_TERMINAL) == 354) {`
		3074	`RESTORE_LEXER;`
		3075	`goto ZL1;`
		3076	`}`
		3077	`}`
		3078	`break;`
		3079	`case 6:`
		3080	`{`
		3081	`IDENTIFIER ZI478;`
		3082	`IDENTIFIER ZI1353;`
		3083	`TYPE ZI1354;`
		3084	`int ZI1355;`
		3085	`TYPE ZI1347;`
		3086	`IDENTIFIER ZI419;`
		3087	`int ZI558;`
		3088	`TYPE ZI414;`
		3089	`int ZI1085;`
		3090	`EXP ZI431;`
		3091
		3092	`{`
		3093
		3094	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		3095	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		3096	`ZI478 = parse_id_template ( id, args, 0 ) ;`
		3097	`crt_templ_qualifier = 1 ;`
		3098	`RESCAN_LEXER ;`
		3099	`}`
		3100	`ADVANCE_LEXER;`
		3101	`{`
		3102
		3103	`(ZI1353) = check_id ( NULL_nspace, (ZI478), 0 ) ;`
		3104	`crt_id_qualifier = qual_none ;`
		3105	`last_namespace = crt_namespace ;`
		3106	`}`
		3107	`{`
		3108
		3109	`(ZI1354) = NULL_type ;`
		3110	`}`
		3111	`{`
		3112	`(ZI1355) = 0 ;`
		3113	`}`
		3114	`{`
		3115
		3116	`begin_declarator ( (ZI1353), crt_id_qualifier, qual_namespace, 1 ) ;`
		3117	`}`
		3118	`ZR1177 (ZI1354, ZI1353, ZI1355, &ZI1347, &ZI419, &ZI558);`
		3119	`if ((CURRENT_TERMINAL) == 354) {`
		3120	`RESTORE_LEXER;`
		3121	`goto ZL1;`
		3122	`}`
		3123	`{`
		3124
		3125	`if ( !IS_NULL_type ( (ZI497) ) ) template_decl ( (ZI497) ) ;`
		3126	`}`
		3127	`{`
		3128
		3129	`(ZI414) = ( IS_NULL_type ( (ZI1347) ) ? (ZI497) : inject_pre_type ( (ZI1347), (ZI497), 1 ) ) ;`
		3130	`}`
		3131	`{`
		3132
		3133	`if ( (ZI558) ) report ( crt_loc, ERR_dcl_init_bad () ) ;`
		3134	`}`
		3135	`{`
		3136
		3137	`DECL_SPEC ds = (ZI689) ;`
		3138	`if ( type_tag ( (ZI414) ) == type_func_tag ) {`
		3139	`/* Look ahead for function definitions */`
		3140	`int def = predict_func_defn () ;`
		3141	`if ( def & !have_func_declarator ) adjust_param ( (ZI414) ) ;`
		3142	`if ( ds & dspec_friend ) {`
		3143	`(ZI459) = make_friend_decl ( ds, (ZI414), (ZI419), def, 1 ) ;`
		3144	`(ZI1085) = 1 ;`
		3145	`} else {`
		3146	`(ZI459) = make_func_mem_decl ( ds, (ZI414), (ZI419), def ) ;`
		3147	`(ZI1085) = 0 ;`
		3148	`}`
		3149	`is_function_next = def ;`
		3150	`} else {`
		3151	`int f = ( (ZI720) && ( crt_lex_token == lex_semicolon ) ) ;`
		3152	`(ZI459) = make_member_decl ( ds, (ZI414), (ZI419), f ) ;`
		3153	`(ZI1085) = 0 ;`
		3154	`is_function_next = 0 ;`
		3155	`}`
		3156	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		3157	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		3158	`bs \|= (ZI480) ;`
		3159	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		3160	`}`
		3161	`have_type_declaration = TYPE_DECL_NONE ;`
		3162	`have_func_declarator = 0 ;`
		3163	`}`
		3164	`{`
		3165
		3166	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		3167	`}`
		3168	`{`
		3169
		3170	`if ( crt_access_list.pending ) {`
		3171	`IGNORE report_access ( (ZI459) ) ;`
		3172	`}`
		3173	`}`
		3174	`ZR1083 (&ZI431);`
		3175	`if ((CURRENT_TERMINAL) == 354) {`
		3176	`RESTORE_LEXER;`
		3177	`goto ZL1;`
		3178	`}`
		3179	`{`
		3180
		3181	`int def = ( (ZI1085) ? init_object ( (ZI459), (ZI431) ) : init_member ( (ZI459), (ZI431) ) ) ;`
		3182	`if ( do_dump ) dump_declare ( (ZI459), &decl_loc, def ) ;`
		3183	`}`
		3184	`{`
		3185
		3186	`if ( crt_access_list.pending ) {`
		3187	`IGNORE report_access ( (ZI459) ) ;`
		3188	`}`
		3189	`}`
		3190	`}`
		3191	`break;`
		3192	`case 7:`
		3193	`{`
		3194	`IDENTIFIER ZI1356;`
		3195	`IDENTIFIER ZI460;`
		3196	`IDENTIFIER ZI1353;`
		3197	`TYPE ZI1354;`
		3198	`int ZI1355;`
		3199	`TYPE ZI1347;`
		3200	`IDENTIFIER ZI419;`
		3201	`int ZI558;`
		3202	`TYPE ZI414;`
		3203	`int ZI1085;`
		3204	`EXP ZI431;`
		3205
		3206	`{`
		3207
		3208	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		3209	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		3210	`ZI1356 = parse_type_template ( id, args, 0 ) ;`
		3211	`crt_templ_qualifier = 1 ;`
		3212	`RESCAN_LEXER ;`
		3213	`}`
		3214	`ADVANCE_LEXER;`
		3215	`{`
		3216
		3217	`(ZI460) = (ZI1356) ;`
		3218	`crt_id_qualifier = qual_none ;`
		3219	`last_namespace = crt_namespace ;`
		3220	`}`
		3221	`{`
		3222
		3223	`(ZI1353) = constr_name ( last_namespace, (ZI460) ) ;`
		3224	`}`
		3225	`{`
		3226
		3227	`(ZI1354) = NULL_type ;`
		3228	`}`
		3229	`{`
		3230	`(ZI1355) = 0 ;`
		3231	`}`
		3232	`{`
		3233
		3234	`begin_declarator ( (ZI1353), crt_id_qualifier, qual_namespace, 1 ) ;`
		3235	`}`
		3236	`ZR1177 (ZI1354, ZI1353, ZI1355, &ZI1347, &ZI419, &ZI558);`
		3237	`if ((CURRENT_TERMINAL) == 354) {`
		3238	`RESTORE_LEXER;`
		3239	`goto ZL1;`
		3240	`}`
		3241	`{`
		3242
		3243	`if ( !IS_NULL_type ( (ZI497) ) ) template_decl ( (ZI497) ) ;`
		3244	`}`
		3245	`{`
		3246
		3247	`(ZI414) = ( IS_NULL_type ( (ZI1347) ) ? (ZI497) : inject_pre_type ( (ZI1347), (ZI497), 1 ) ) ;`
		3248	`}`
		3249	`{`
		3250
		3251	`if ( (ZI558) ) report ( crt_loc, ERR_dcl_init_bad () ) ;`
		3252	`}`
		3253	`{`
		3254
		3255	`DECL_SPEC ds = (ZI689) ;`
		3256	`if ( type_tag ( (ZI414) ) == type_func_tag ) {`
		3257	`/* Look ahead for function definitions */`
		3258	`int def = predict_func_defn () ;`
		3259	`if ( def & !have_func_declarator ) adjust_param ( (ZI414) ) ;`
		3260	`if ( ds & dspec_friend ) {`
		3261	`(ZI459) = make_friend_decl ( ds, (ZI414), (ZI419), def, 1 ) ;`
		3262	`(ZI1085) = 1 ;`
		3263	`} else {`
		3264	`(ZI459) = make_func_mem_decl ( ds, (ZI414), (ZI419), def ) ;`
		3265	`(ZI1085) = 0 ;`
		3266	`}`
		3267	`is_function_next = def ;`
		3268	`} else {`
		3269	`int f = ( (ZI720) && ( crt_lex_token == lex_semicolon ) ) ;`
		3270	`(ZI459) = make_member_decl ( ds, (ZI414), (ZI419), f ) ;`
		3271	`(ZI1085) = 0 ;`
		3272	`is_function_next = 0 ;`
		3273	`}`
		3274	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		3275	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		3276	`bs \|= (ZI480) ;`
		3277	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		3278	`}`
		3279	`have_type_declaration = TYPE_DECL_NONE ;`
		3280	`have_func_declarator = 0 ;`
		3281	`}`
		3282	`{`
		3283
		3284	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		3285	`}`
		3286	`{`
		3287
		3288	`if ( crt_access_list.pending ) {`
		3289	`IGNORE report_access ( (ZI459) ) ;`
		3290	`}`
		3291	`}`
		3292	`ZR1083 (&ZI431);`
		3293	`if ((CURRENT_TERMINAL) == 354) {`
		3294	`RESTORE_LEXER;`
		3295	`goto ZL1;`
		3296	`}`
		3297	`{`
		3298
		3299	`int def = ( (ZI1085) ? init_object ( (ZI459), (ZI431) ) : init_member ( (ZI459), (ZI431) ) ) ;`
		3300	`if ( do_dump ) dump_declare ( (ZI459), &decl_loc, def ) ;`
		3301	`}`
		3302	`{`
		3303
		3304	`if ( crt_access_list.pending ) {`
		3305	`IGNORE report_access ( (ZI459) ) ;`
		3306	`}`
		3307	`}`
		3308	`}`
		3309	`break;`
		3310	`case 2:`
		3311	`{`
		3312	`IDENTIFIER ZI1366;`
		3313	`IDENTIFIER ZI1367;`
		3314
		3315	`{`
		3316
		3317	`ZI1366 = crt_token->pp_data.id.use ;`
		3318	`}`
		3319	`ADVANCE_LEXER;`
		3320	`{`
		3321
		3322	`(ZI1367) = (ZI1366) ;`
		3323	`crt_id_qualifier = qual_none ;`
		3324	`last_namespace = crt_namespace ;`
		3325	`}`
		3326	`ZR1368 (&ZI689, &ZI497, &ZI480, &ZI670, &ZI720, &ZI1367, &ZI459);`
		3327	`if ((CURRENT_TERMINAL) == 354) {`
		3328	`RESTORE_LEXER;`
		3329	`goto ZL1;`
		3330	`}`
		3331	`}`
		3332	`break;`
		3333	`case 141:`
		3334	`{`
		3335	`IDENTIFIER ZI478;`
		3336	`IDENTIFIER ZI1353;`
		3337	`TYPE ZI1354;`
		3338	`int ZI1355;`
		3339	`TYPE ZI1347;`
		3340	`IDENTIFIER ZI419;`
		3341	`int ZI558;`
		3342	`TYPE ZI414;`
		3343	`int ZI1085;`
		3344	`EXP ZI431;`
		3345
		3346	`parse_operator (&ZI478);`
		3347	`if ((CURRENT_TERMINAL) == 354) {`
		3348	`RESTORE_LEXER;`
		3349	`goto ZL1;`
		3350	`}`
		3351	`{`
		3352
		3353	`(ZI1353) = check_id ( NULL_nspace, (ZI478), 0 ) ;`
		3354	`crt_id_qualifier = qual_none ;`
		3355	`last_namespace = crt_namespace ;`
		3356	`}`
		3357	`{`
		3358
		3359	`(ZI1354) = NULL_type ;`
		3360	`}`
		3361	`{`
		3362	`(ZI1355) = 0 ;`
		3363	`}`
		3364	`{`
		3365
		3366	`begin_declarator ( (ZI1353), crt_id_qualifier, qual_namespace, 1 ) ;`
		3367	`}`
		3368	`ZR1177 (ZI1354, ZI1353, ZI1355, &ZI1347, &ZI419, &ZI558);`
		3369	`if ((CURRENT_TERMINAL) == 354) {`
		3370	`RESTORE_LEXER;`
		3371	`goto ZL1;`
		3372	`}`
		3373	`{`
		3374
		3375	`if ( !IS_NULL_type ( (ZI497) ) ) template_decl ( (ZI497) ) ;`
		3376	`}`
		3377	`{`
		3378
		3379	`(ZI414) = ( IS_NULL_type ( (ZI1347) ) ? (ZI497) : inject_pre_type ( (ZI1347), (ZI497), 1 ) ) ;`
		3380	`}`
		3381	`{`
		3382
		3383	`if ( (ZI558) ) report ( crt_loc, ERR_dcl_init_bad () ) ;`
		3384	`}`
		3385	`{`
		3386
		3387	`DECL_SPEC ds = (ZI689) ;`
		3388	`if ( type_tag ( (ZI414) ) == type_func_tag ) {`
		3389	`/* Look ahead for function definitions */`
		3390	`int def = predict_func_defn () ;`
		3391	`if ( def & !have_func_declarator ) adjust_param ( (ZI414) ) ;`
		3392	`if ( ds & dspec_friend ) {`
		3393	`(ZI459) = make_friend_decl ( ds, (ZI414), (ZI419), def, 1 ) ;`
		3394	`(ZI1085) = 1 ;`
		3395	`} else {`
		3396	`(ZI459) = make_func_mem_decl ( ds, (ZI414), (ZI419), def ) ;`
		3397	`(ZI1085) = 0 ;`
		3398	`}`
		3399	`is_function_next = def ;`
		3400	`} else {`
		3401	`int f = ( (ZI720) && ( crt_lex_token == lex_semicolon ) ) ;`
		3402	`(ZI459) = make_member_decl ( ds, (ZI414), (ZI419), f ) ;`
		3403	`(ZI1085) = 0 ;`
		3404	`is_function_next = 0 ;`
		3405	`}`
		3406	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		3407	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		3408	`bs \|= (ZI480) ;`
		3409	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		3410	`}`
		3411	`have_type_declaration = TYPE_DECL_NONE ;`
		3412	`have_func_declarator = 0 ;`
		3413	`}`
		3414	`{`
		3415
		3416	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		3417	`}`
		3418	`{`
		3419
		3420	`if ( crt_access_list.pending ) {`
		3421	`IGNORE report_access ( (ZI459) ) ;`
		3422	`}`
		3423	`}`
		3424	`ZR1083 (&ZI431);`
		3425	`if ((CURRENT_TERMINAL) == 354) {`
		3426	`RESTORE_LEXER;`
		3427	`goto ZL1;`
		3428	`}`
		3429	`{`
		3430
		3431	`int def = ( (ZI1085) ? init_object ( (ZI459), (ZI431) ) : init_member ( (ZI459), (ZI431) ) ) ;`
		3432	`if ( do_dump ) dump_declare ( (ZI459), &decl_loc, def ) ;`
		3433	`}`
		3434	`{`
		3435
		3436	`if ( crt_access_list.pending ) {`
		3437	`IGNORE report_access ( (ZI459) ) ;`
		3438	`}`
		3439	`}`
		3440	`}`
		3441	`break;`
		3442	`case 10: case 11: case 33: case 78:`
		3443	`{`
		3444	`TYPE ZI1348;`
		3445	`TYPE ZI1349;`
		3446	`IDENTIFIER ZI419;`
		3447	`int ZI558;`
		3448	`TYPE ZI1347;`
		3449	`TYPE ZI414;`
		3450	`int ZI1085;`
		3451	`EXP ZI431;`
		3452
		3453	`ZR926 (&ZI1348);`
		3454	`ZR940 (&ZI1349, &ZI419, &ZI558);`
		3455	`if ((CURRENT_TERMINAL) == 354) {`
		3456	`RESTORE_LEXER;`
		3457	`goto ZL1;`
		3458	`}`
		3459	`{`
		3460
		3461	`(ZI1347) = ( IS_NULL_type ( (ZI1349) ) ? (ZI1348) : inject_pre_type ( (ZI1349), (ZI1348), 0 ) ) ;`
		3462	`}`
		3463	`{`
		3464
		3465	`if ( !IS_NULL_type ( (ZI497) ) ) template_decl ( (ZI497) ) ;`
		3466	`}`
		3467	`{`
		3468
		3469	`(ZI414) = ( IS_NULL_type ( (ZI1347) ) ? (ZI497) : inject_pre_type ( (ZI1347), (ZI497), 1 ) ) ;`
		3470	`}`
		3471	`{`
		3472
		3473	`if ( (ZI558) ) report ( crt_loc, ERR_dcl_init_bad () ) ;`
		3474	`}`
		3475	`{`
		3476
		3477	`DECL_SPEC ds = (ZI689) ;`
		3478	`if ( type_tag ( (ZI414) ) == type_func_tag ) {`
		3479	`/* Look ahead for function definitions */`
		3480	`int def = predict_func_defn () ;`
		3481	`if ( def & !have_func_declarator ) adjust_param ( (ZI414) ) ;`
		3482	`if ( ds & dspec_friend ) {`
		3483	`(ZI459) = make_friend_decl ( ds, (ZI414), (ZI419), def, 1 ) ;`
		3484	`(ZI1085) = 1 ;`
		3485	`} else {`
		3486	`(ZI459) = make_func_mem_decl ( ds, (ZI414), (ZI419), def ) ;`
		3487	`(ZI1085) = 0 ;`
		3488	`}`
		3489	`is_function_next = def ;`
		3490	`} else {`
		3491	`int f = ( (ZI720) && ( crt_lex_token == lex_semicolon ) ) ;`
		3492	`(ZI459) = make_member_decl ( ds, (ZI414), (ZI419), f ) ;`
		3493	`(ZI1085) = 0 ;`
		3494	`is_function_next = 0 ;`
		3495	`}`
		3496	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		3497	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		3498	`bs \|= (ZI480) ;`
		3499	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		3500	`}`
		3501	`have_type_declaration = TYPE_DECL_NONE ;`
		3502	`have_func_declarator = 0 ;`
		3503	`}`
		3504	`{`
		3505
		3506	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		3507	`}`
		3508	`{`
		3509
		3510	`if ( crt_access_list.pending ) {`
		3511	`IGNORE report_access ( (ZI459) ) ;`
		3512	`}`
		3513	`}`
		3514	`ZR1083 (&ZI431);`
		3515	`if ((CURRENT_TERMINAL) == 354) {`
		3516	`RESTORE_LEXER;`
		3517	`goto ZL1;`
		3518	`}`
		3519	`{`
		3520
		3521	`int def = ( (ZI1085) ? init_object ( (ZI459), (ZI431) ) : init_member ( (ZI459), (ZI431) ) ) ;`
		3522	`if ( do_dump ) dump_declare ( (ZI459), &decl_loc, def ) ;`
		3523	`}`
		3524	`{`
		3525
		3526	`if ( crt_access_list.pending ) {`
		3527	`IGNORE report_access ( (ZI459) ) ;`
		3528	`}`
		3529	`}`
		3530	`}`
		3531	`break;`
		3532	`case 41:`
		3533	`{`
		3534	`IDENTIFIER ZI419;`
		3535	`QUALIFIER ZI455;`
		3536	`int ZI456;`
		3537	`EXP ZI558;`
		3538	`TYPE ZI414;`
		3539
		3540	`{`
		3541
		3542	`HASHID nm = lookup_anon () ;`
		3543	`(ZI419) = DEREF_id ( hashid_id ( nm ) ) ;`
		3544	`crt_id_qualifier = qual_none ;`
		3545	`qual_namespace = NULL_nspace ;`
		3546	`}`
		3547	`{`
		3548
		3549	`if ( !IS_NULL_type ( (ZI497) ) ) template_decl ( (ZI497) ) ;`
		3550	`}`
		3551	`{`
		3552
		3553	`begin_declarator ( (ZI419), crt_id_qualifier, qual_namespace, 1 ) ;`
		3554	`}`
		3555	`{`
		3556
		3557	`(ZI455) = crt_id_qualifier ;`
		3558	`(ZI456) = crt_templ_qualifier ;`
		3559	`}`
		3560	`ADVANCE_LEXER;`
		3561	`ZR651 (&ZI558);`
		3562	`if ((CURRENT_TERMINAL) == 354) {`
		3563	`RESTORE_LEXER;`
		3564	`goto ZL1;`
		3565	`}`
		3566	`{`
		3567
		3568	`crt_id_qualifier = (ZI455) ;`
		3569	`crt_templ_qualifier = (ZI456) ;`
		3570	`}`
		3571	`{`
		3572
		3573	`/* Check for anonymous bitfields */`
		3574	`HASHID nm = DEREF_hashid ( id_name ( (ZI419) ) ) ;`
		3575	`int z = IS_hashid_anon ( nm ) ;`
		3576	`(ZI414) = make_bitfield_type ( (ZI497), (ZI480), (ZI558), z ) ;`
		3577	`}`
		3578	`{`
		3579
		3580	`IDENTIFIER id = make_member_decl ( (ZI689), (ZI414), (ZI419), 0 ) ;`
		3581	`int def = init_member ( id, NULL_exp ) ;`
		3582	`if ( do_dump ) dump_declare ( id, &decl_loc, def ) ;`
		3583	`have_type_declaration = TYPE_DECL_NONE ;`
		3584	`have_func_declarator = 0 ;`
		3585	`is_function_next = 0 ;`
		3586	`(ZI459) = id ;`
		3587	`}`
		3588	`{`
		3589
		3590	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		3591	`}`
		3592	`{`
		3593
		3594	`if ( crt_access_list.pending ) {`
		3595	`IGNORE report_access ( (ZI459) ) ;`
		3596	`}`
		3597	`}`
		3598	`}`
		3599	`break;`
		3600	`case 354:`
		3601	`return;`
		3602	`default:`
		3603	`goto ZL1;`
		3604	`}`
		3605	`goto ZL0;`
		3606	`ZL1:;`
		3607	`SAVE_LEXER (354);`
		3608	`return;`
		3609	`ZL0:;`
		3610	`*ZO459 = ZI459;`
		3611	`}`
		3612
		3613	`void`
7	7u83	3614	`ZR428(NAMESPACE *ZO425)`
2	7u83	3615	`{`
		3616	`NAMESPACE ZI425;`
		3617
		3618	`switch (CURRENT_TERMINAL) {`
		3619	`case 8: case 9: case 83:`
		3620	`{`
		3621	`ZR427 (&ZI425);`
		3622	`if ((CURRENT_TERMINAL) == 354) {`
		3623	`RESTORE_LEXER;`
		3624	`goto ZL1;`
		3625	`}`
		3626	`}`
		3627	`break;`
		3628	`default:`
		3629	`{`
		3630	`{`
		3631
		3632	`(ZI425) = NULL_nspace ;`
		3633	`crt_id_qualifier = qual_none ;`
		3634	`qual_namespace = NULL_nspace ;`
		3635	`}`
		3636	`}`
		3637	`break;`
		3638	`case 354:`
		3639	`return;`
		3640	`}`
		3641	`goto ZL0;`
		3642	`ZL1:;`
		3643	`SAVE_LEXER (354);`
		3644	`return;`
		3645	`ZL0:;`
		3646	`*ZO425 = ZI425;`
		3647	`}`
		3648
		3649	`void`
7	7u83	3650	`ZR1228(EXP ZI1226, EXP *ZO1227)`
2	7u83	3651	`{`
		3652	`EXP ZI1227;`
		3653
		3654	`ZL2_1228:;`
		3655	`switch (CURRENT_TERMINAL) {`
		3656	`case 59:`
		3657	`{`
		3658	`EXP ZI456;`
		3659	`EXP ZI431;`
		3660
		3661	`ADVANCE_LEXER;`
		3662	`ZR605 (&ZI456);`
		3663	`if ((CURRENT_TERMINAL) == 354) {`
		3664	`RESTORE_LEXER;`
		3665	`goto ZL1;`
		3666	`}`
		3667	`{`
		3668
		3669	`(ZI431) = make_minus_exp ( (ZI1226), (ZI456) ) ;`
		3670	`}`
		3671	`ZI1226 = ZI431;`
		3672	`goto ZL2_1228;`
		3673	`}`
		3674	`/UNREACHED/`
		3675	`case 69:`
		3676	`{`
		3677	`EXP ZI456;`
		3678	`EXP ZI431;`
		3679
		3680	`ADVANCE_LEXER;`
		3681	`ZR605 (&ZI456);`
		3682	`if ((CURRENT_TERMINAL) == 354) {`
		3683	`RESTORE_LEXER;`
		3684	`goto ZL1;`
		3685	`}`
		3686	`{`
		3687
		3688	`(ZI431) = make_plus_exp ( (ZI1226), (ZI456) ) ;`
		3689	`}`
		3690	`ZI1226 = ZI431;`
		3691	`goto ZL2_1228;`
		3692	`}`
		3693	`/UNREACHED/`
		3694	`default:`
		3695	`{`
		3696	`ZI1227 = ZI1226;`
		3697	`}`
		3698	`break;`
		3699	`case 354:`
		3700	`return;`
		3701	`}`
		3702	`goto ZL0;`
		3703	`ZL1:;`
		3704	`SAVE_LEXER (354);`
		3705	`return;`
		3706	`ZL0:;`
		3707	`*ZO1227 = ZI1227;`
		3708	`}`
		3709
		3710	`void`
7	7u83	3711	`ZR998(IDENTIFIER ZI459, EXP *ZO431)`
2	7u83	3712	`{`
		3713	`EXP ZI431;`
		3714
		3715	`switch (CURRENT_TERMINAL) {`
		3716	`case 1: case 2: case 3: case 5: case 6:`
		3717	`case 7: case 8: case 9: case 17: case 18:`
		3718	`case 19: case 20: case 21: case 22: case 23:`
		3719	`case 25: case 33: case 43: case 59: case 61:`
		3720	`case 62: case 65: case 69: case 71: case 78:`
		3721	`case 83: case 85: case 97: case 102: case 106:`
		3722	`case 110: case 111: case 114: case 115: case 116:`
		3723	`case 122: case 123: case 127: case 130: case 131:`
		3724	`case 132: case 135: case 140: case 141: case 145:`
		3725	`case 146: case 148: case 149: case 150: case 152:`
		3726	`case 156: case 170: case 184: case 205: case 209:`
		3727	`case 285: case 298: case 329:`
		3728	`{`
		3729	`ZR649 (&ZI431);`
		3730	`if ((CURRENT_TERMINAL) == 354) {`
		3731	`RESTORE_LEXER;`
		3732	`goto ZL1;`
		3733	`}`
		3734	`{`
		3735
		3736	`if ( crt_access_list.pending ) {`
		3737	`IGNORE report_access ( (ZI459) ) ;`
		3738	`}`
		3739	`}`
		3740	`}`
		3741	`break;`
		3742	`case 64:`
		3743	`{`
		3744	`SID_LIST_EXP ZI497;`
		3745
		3746	`{`
		3747	`{`
		3748	`switch (CURRENT_TERMINAL) {`
		3749	`case 64:`
		3750	`break;`
		3751	`default:`
		3752	`goto ZL1;`
		3753	`}`
		3754	`ADVANCE_LEXER;`
		3755	`}`
		3756	`}`
		3757	`ZR1001 (&ZI459, &ZI497);`
		3758	`{`
		3759	`if ((CURRENT_TERMINAL) == 354) {`
		3760	`RESTORE_LEXER;`
		3761	`goto ZL1;`
		3762	`}`
		3763	`{`
		3764	`switch (CURRENT_TERMINAL) {`
		3765	`case 38:`
		3766	`break;`
		3767	`default:`
		3768	`goto ZL1;`
		3769	`}`
		3770	`ADVANCE_LEXER;`
		3771	`}`
		3772	`}`
		3773	`{`
		3774
		3775	`/* The expression type is a dummy */`
		3776	`MAKE_exp_aggregate ( type_void, (ZI497), NULL_list ( OFFSET ), (ZI431) ) ;`
		3777	`}`
		3778	`}`
		3779	`break;`
		3780	`case 354:`
		3781	`return;`
		3782	`default:`
		3783	`goto ZL1;`
		3784	`}`
		3785	`goto ZL0;`
		3786	`ZL1:;`
		3787	`SAVE_LEXER (354);`
		3788	`return;`
		3789	`ZL0:;`
		3790	`*ZO431 = ZI431;`
		3791	`}`
		3792
		3793	`void`
7	7u83	3794	`ZR1089(TYPE ZI414, DECL_SPEC ZI689)`
2	7u83	3795	`{`
		3796	`if ((CURRENT_TERMINAL) == 354) {`
		3797	`return;`
		3798	`}`
		3799	`{`
		3800	`int ZI714;`
		3801	`TOKEN ZI497;`
		3802	`TYPE ZI875;`
		3803
		3804	`ZR1110 (&ZI714);`
		3805	`switch (CURRENT_TERMINAL) {`
		3806	`case 147:`
		3807	`break;`
		3808	`case 354:`
		3809	`RESTORE_LEXER;`
		3810	`goto ZL1;`
		3811	`default:`
		3812	`goto ZL1;`
		3813	`}`
		3814	`ADVANCE_LEXER;`
		3815	`{`
		3816
		3817	`(ZI497) = template_params ( (ZI714) ) ;`
		3818	`RESCAN_LEXER ;`
		3819	`}`
		3820	`{`
		3821
		3822	`(ZI875) = make_template_type ( (ZI497), (ZI414) ) ;`
		3823	`}`
		3824	`ZR838 (ZI875, ZI689);`
		3825	`if ((CURRENT_TERMINAL) == 354) {`
		3826	`RESTORE_LEXER;`
		3827	`goto ZL1;`
		3828	`}`
		3829	`{`
		3830
		3831	`end_template ( (ZI497) ) ;`
		3832	`}`
		3833	`{`
		3834
		3835	`RESCAN_LEXER ;`
		3836	`}`
		3837	`}`
		3838	`return;`
		3839	`ZL1:;`
		3840	`SAVE_LEXER (354);`
		3841	`return;`
		3842	`}`
		3843
		3844	`void`
7	7u83	3845	`ZR608(EXP *ZO1227)`
2	7u83	3846	`{`
		3847	`EXP ZI1227;`
		3848
		3849	`if ((CURRENT_TERMINAL) == 354) {`
		3850	`return;`
		3851	`}`
		3852	`{`
		3853	`EXP ZI431;`
		3854
		3855	`ZR605 (&ZI431);`
		3856	`ZR1228 (ZI431, &ZI1227);`
		3857	`if ((CURRENT_TERMINAL) == 354) {`
		3858	`RESTORE_LEXER;`
		3859	`goto ZL1;`
		3860	`}`
		3861	`}`
		3862	`goto ZL0;`
		3863	`ZL1:;`
		3864	`SAVE_LEXER (354);`
		3865	`return;`
		3866	`ZL0:;`
		3867	`*ZO1227 = ZI1227;`
		3868	`}`
		3869
		3870	`void`
7	7u83	3871	`ZR949(TYPE ZO1174, IDENTIFIER ZO1175, int *ZO1176)`
2	7u83	3872	`{`
		3873	`TYPE ZI1174;`
		3874	`IDENTIFIER ZI1175;`
		3875	`int ZI1176;`
		3876
		3877	`switch (CURRENT_TERMINAL) {`
		3878	`case 65:`
		3879	`{`
		3880	`TYPE ZI414;`
		3881	`IDENTIFIER ZI419;`
		3882	`int ZI558;`
		3883
		3884	`ADVANCE_LEXER;`
		3885	`ZR940 (&ZI414, &ZI419, &ZI558);`
		3886	`if ((CURRENT_TERMINAL) == 354) {`
		3887	`RESTORE_LEXER;`
		3888	`goto ZL1;`
		3889	`}`
		3890	`{`
		3891
		3892	`if ( (ZI558) ) report ( crt_loc, ERR_dcl_init_bad () ) ;`
		3893	`}`
		3894	`{`
		3895
		3896	`if ( IS_NULL_type ( (ZI414) ) ) {`
		3897	`report ( crt_loc, ERR_dcl_meaning_paren () ) ;`
		3898	`}`
		3899	`}`
		3900	`switch (CURRENT_TERMINAL) {`
		3901	`case 39:`
		3902	`break;`
		3903	`default:`
		3904	`goto ZL1;`
		3905	`}`
		3906	`ADVANCE_LEXER;`
		3907	`ZR1177 (ZI414, ZI419, ZI558, &ZI1174, &ZI1175, &ZI1176);`
		3908	`if ((CURRENT_TERMINAL) == 354) {`
		3909	`RESTORE_LEXER;`
		3910	`goto ZL1;`
		3911	`}`
		3912	`}`
		3913	`break;`
		3914	`case 1: case 2: case 3: case 4: case 5:`
		3915	`case 6: case 7: case 8: case 9: case 83:`
		3916	`case 141:`
		3917	`{`
		3918	`IDENTIFIER ZI419;`
		3919	`TYPE ZI414;`
		3920	`int ZI558;`
		3921
		3922	`ZR942 (&ZI419);`
		3923	`if ((CURRENT_TERMINAL) == 354) {`
		3924	`RESTORE_LEXER;`
		3925	`goto ZL1;`
		3926	`}`
		3927	`{`
		3928
		3929	`(ZI414) = NULL_type ;`
		3930	`}`
		3931	`{`
		3932	`(ZI558) = 0 ;`
		3933	`}`
		3934	`{`
		3935
		3936	`begin_declarator ( (ZI419), crt_id_qualifier, qual_namespace, 1 ) ;`
		3937	`}`
		3938	`ZR1177 (ZI414, ZI419, ZI558, &ZI1174, &ZI1175, &ZI1176);`
		3939	`if ((CURRENT_TERMINAL) == 354) {`
		3940	`RESTORE_LEXER;`
		3941	`goto ZL1;`
		3942	`}`
		3943	`}`
		3944	`break;`
		3945	`case 354:`
		3946	`return;`
		3947	`default:`
		3948	`goto ZL1;`
		3949	`}`
		3950	`goto ZL0;`
		3951	`ZL1:;`
		3952	`SAVE_LEXER (354);`
		3953	`return;`
		3954	`ZL0:;`
		3955	`*ZO1174 = ZI1174;`
		3956	`*ZO1175 = ZI1175;`
		3957	`*ZO1176 = ZI1176;`
		3958	`}`
		3959
		3960	`void`
7	7u83	3961	`ZR713(EXP *ZO431)`
2	7u83	3962	`{`
		3963	`EXP ZI431;`
		3964
		3965	`switch (CURRENT_TERMINAL) {`
		3966	`case 109:`
		3967	`{`
		3968	`unsigned ZI714;`
		3969	`int ZI670;`
		3970	`EXP ZI558;`
		3971	`EXP ZI493;`
		3972	`EXP ZI715;`
		3973	`EXP ZI716;`
		3974	`EXP ZI456;`
		3975	`EXP ZI459;`
		3976	`EXP ZI720;`
		3977
		3978	`ADVANCE_LEXER;`
		3979	`{`
		3980	`(ZI714) = crt_condition ;`
		3981	`}`
		3982	`{`
		3983
		3984	`(ZI670) = unreached_code ;`
		3985	`if ( (ZI670) ) {`
		3986	`if ( !unreached_last ) {`
		3987	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		3988	`unreached_last = 1 ;`
		3989	`}`
		3990	`} else {`
		3991	`unreached_last = 0 ;`
		3992	`}`
		3993	`}`
		3994	`ZR417 ();`
		3995	`ZR712 (&ZI558);`
		3996	`if ((CURRENT_TERMINAL) == 354) {`
		3997	`RESTORE_LEXER;`
		3998	`goto ZL1;`
		3999	`}`
		4000	`{`
		4001
		4002	`(ZI493) = begin_if_stmt ( (ZI558) ) ;`
		4003	`}`
		4004	`switch (CURRENT_TERMINAL) {`
		4005	`case 39:`
		4006	`break;`
		4007	`default:`
		4008	`goto ZL1;`
		4009	`}`
		4010	`ADVANCE_LEXER;`
		4011	`{`
		4012
		4013	`(ZI715) = begin_compound_stmt ( 1 ) ;`
		4014	`}`
		4015	`{`
		4016
		4017	`(ZI716) = inject_cond ( (ZI715), (ZI558) ) ;`
		4018	`}`
		4019	`ZR681 (ZI716, &ZI456);`
		4020	`if ((CURRENT_TERMINAL) == 354) {`
		4021	`RESTORE_LEXER;`
		4022	`goto ZL1;`
		4023	`}`
		4024	`{`
		4025	`unreached_prev = (ZI670) ;`
		4026	`}`
		4027	`{`
		4028
		4029	`(ZI459) = cont_if_stmt ( (ZI493), (ZI456) ) ;`
		4030	`}`
		4031	`{`
		4032	`{`
		4033	`EXP ZI718;`
		4034	`EXP ZI719;`
		4035
		4036	`switch (CURRENT_TERMINAL) {`
		4037	`case 103:`
		4038	`break;`
		4039	`default:`
		4040	`goto ZL3;`
		4041	`}`
		4042	`ADVANCE_LEXER;`
		4043	`{`
		4044
		4045	`check_empty_stmt ( lex_else ) ;`
		4046	`}`
		4047	`{`
		4048
		4049	`(ZI718) = begin_compound_stmt ( 1 ) ;`
		4050	`}`
		4051	`{`
		4052
		4053	`(ZI719) = inject_cond ( (ZI718), (ZI558) ) ;`
		4054	`}`
		4055	`ZR681 (ZI719, &ZI720);`
		4056	`if ((CURRENT_TERMINAL) == 354) {`
		4057	`RESTORE_LEXER;`
		4058	`goto ZL3;`
		4059	`}`
		4060	`}`
		4061	`goto ZL2;`
		4062	`ZL3:;`
		4063	`{`
		4064	`{`
		4065
		4066	`report ( crt_loc, ERR_stmt_if_no_else () ) ;`
		4067	`(ZI720) = NULL_exp ;`
		4068	`}`
		4069	`}`
		4070	`ZL2:;`
		4071	`}`
		4072	`{`
		4073	`unreached_prev = (ZI670) ;`
		4074	`}`
		4075	`{`
		4076
		4077	`(ZI431) = end_if_stmt ( (ZI459), (ZI720) ) ;`
		4078	`}`
		4079	`{`
		4080	`crt_condition = (ZI714) ;`
		4081	`}`
		4082	`{`
		4083
		4084	`unreached_fall = 1 ;`
		4085	`}`
		4086	`}`
		4087	`break;`
		4088	`case 119:`
		4089	`{`
		4090	`int ZI670;`
		4091	`EXP ZI558;`
		4092	`EXP ZI493;`
		4093	`int ZI722;`
		4094	`EXP ZI715;`
		4095	`EXP ZI716;`
		4096	`EXP ZI456;`
		4097
		4098	`ADVANCE_LEXER;`
		4099	`{`
		4100
		4101	`(ZI670) = unreached_code ;`
		4102	`if ( (ZI670) ) {`
		4103	`if ( !unreached_last ) {`
		4104	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		4105	`unreached_last = 1 ;`
		4106	`}`
		4107	`} else {`
		4108	`unreached_last = 0 ;`
		4109	`}`
		4110	`}`
		4111	`switch (CURRENT_TERMINAL) {`
		4112	`case 65:`
		4113	`break;`
		4114	`default:`
		4115	`goto ZL1;`
		4116	`}`
		4117	`ADVANCE_LEXER;`
		4118	`ZR712 (&ZI558);`
		4119	`if ((CURRENT_TERMINAL) == 354) {`
		4120	`RESTORE_LEXER;`
		4121	`goto ZL1;`
		4122	`}`
		4123	`{`
		4124
		4125	`(ZI493) = begin_switch_stmt ( (ZI558) ) ;`
		4126	`}`
		4127	`switch (CURRENT_TERMINAL) {`
		4128	`case 39:`
		4129	`break;`
		4130	`default:`
		4131	`goto ZL1;`
		4132	`}`
		4133	`ADVANCE_LEXER;`
		4134	`{`
		4135	`switch (CURRENT_TERMINAL) {`
		4136	`case 216:`
		4137	`{`
		4138	`ADVANCE_LEXER;`
		4139	`{`
		4140	`(ZI722) = 1 ;`
		4141	`}`
		4142	`}`
		4143	`break;`
		4144	`default:`
		4145	`{`
		4146	`{`
		4147	`(ZI722) = 0 ;`
		4148	`}`
		4149	`}`
		4150	`break;`
		4151	`}`
		4152	`}`
		4153	`{`
		4154
		4155	`(ZI715) = begin_compound_stmt ( 1 ) ;`
		4156	`}`
		4157	`{`
		4158
		4159	`(ZI716) = inject_cond ( (ZI715), (ZI558) ) ;`
		4160	`}`
		4161	`ZR681 (ZI716, &ZI456);`
		4162	`if ((CURRENT_TERMINAL) == 354) {`
		4163	`RESTORE_LEXER;`
		4164	`goto ZL1;`
		4165	`}`
		4166	`{`
		4167	`unreached_prev = (ZI670) ;`
		4168	`}`
		4169	`{`
		4170
		4171	`(ZI431) = end_switch_stmt ( (ZI493), (ZI456), (ZI722) ) ;`
		4172	`}`
		4173	`{`
		4174
		4175	`unreached_fall = 1 ;`
		4176	`}`
		4177	`}`
		4178	`break;`
		4179	`case 26:`
		4180	`{`
		4181	`ZR699 (&ZI431);`
		4182	`if ((CURRENT_TERMINAL) == 354) {`
		4183	`RESTORE_LEXER;`
		4184	`goto ZL1;`
		4185	`}`
		4186	`{`
		4187
		4188	`unreached_fall = 1 ;`
		4189	`}`
		4190	`}`
		4191	`break;`
		4192	`case 354:`
		4193	`return;`
		4194	`default:`
		4195	`goto ZL1;`
		4196	`}`
		4197	`goto ZL0;`
		4198	`ZL1:;`
		4199	`SAVE_LEXER (354);`
		4200	`return;`
		4201	`ZL0:;`
		4202	`*ZO431 = ZI431;`
		4203	`}`
		4204
		4205	`void`
7	7u83	4206	`ZR491(EXP *ZO431)`
2	7u83	4207	`{`
		4208	`EXP ZI431;`
		4209
		4210	`switch (CURRENT_TERMINAL) {`
		4211	`case 1: case 2: case 3: case 5: case 6:`
		4212	`case 7: case 8: case 9: case 17: case 18:`
		4213	`case 19: case 20: case 21: case 22: case 23:`
		4214	`case 25: case 33: case 43: case 59: case 61:`
		4215	`case 62: case 65: case 69: case 71: case 78:`
		4216	`case 83: case 85: case 97: case 102: case 106:`
		4217	`case 110: case 111: case 114: case 115: case 116:`
		4218	`case 122: case 123: case 127: case 130: case 131:`
		4219	`case 132: case 135: case 140: case 141: case 145:`
		4220	`case 146: case 148: case 149: case 150: case 152:`
		4221	`case 156: case 170: case 184: case 205: case 209:`
		4222	`case 285: case 298: case 329:`
		4223	`{`
		4224	`EXP ZI1287;`
		4225
		4226	`ZR496 (&ZI1287);`
		4227	`ZR1289 (&ZI1287, &ZI431);`
		4228	`if ((CURRENT_TERMINAL) == 354) {`
		4229	`RESTORE_LEXER;`
		4230	`goto ZL1;`
		4231	`}`
		4232	`}`
		4233	`break;`
		4234	`case 297: case 323:`
		4235	`{`
		4236	`EXP ZI493;`
		4237	`SID_LIST_EXP ZI480;`
		4238	`SID_LIST_EXP ZI497;`
		4239
		4240	`ZR643 (&ZI493);`
		4241	`ZR648 (&ZI480);`
		4242	`if ((CURRENT_TERMINAL) == 354) {`
		4243	`RESTORE_LEXER;`
		4244	`goto ZL1;`
		4245	`}`
		4246	`{`
		4247
		4248	`CONS_exp ( (ZI493), (ZI480), (ZI497) ) ;`
		4249	`}`
		4250	`{`
		4251
		4252	`(ZI431) = make_comma_exp ( (ZI497) ) ;`
		4253	`}`
		4254	`}`
		4255	`break;`
		4256	`case 345:`
		4257	`{`
		4258	`EXP ZI493;`
		4259	`SID_LIST_EXP ZI480;`
		4260	`SID_LIST_EXP ZI497;`
		4261
		4262	`ZR644 (&ZI493);`
		4263	`ZR648 (&ZI480);`
		4264	`if ((CURRENT_TERMINAL) == 354) {`
		4265	`RESTORE_LEXER;`
		4266	`goto ZL1;`
		4267	`}`
		4268	`{`
		4269
		4270	`CONS_exp ( (ZI493), (ZI480), (ZI497) ) ;`
		4271	`}`
		4272	`{`
		4273
		4274	`(ZI431) = make_comma_exp ( (ZI497) ) ;`
		4275	`}`
		4276	`}`
		4277	`break;`
		4278	`case 354:`
		4279	`return;`
		4280	`default:`
		4281	`goto ZL1;`
		4282	`}`
		4283	`goto ZL0;`
		4284	`ZL1:;`
		4285	`SAVE_LEXER (354);`
		4286	`return;`
		4287	`ZL0:;`
		4288	`*ZO431 = ZI431;`
		4289	`}`
		4290
		4291	`void`
7	7u83	4292	`ZR571(SID_LIST_EXP ZO497, TYPE ZO414, int *ZO551)`
2	7u83	4293	`{`
		4294	`SID_LIST_EXP ZI497;`
		4295	`TYPE ZI414;`
		4296	`int ZI551;`
		4297
		4298	`switch (CURRENT_TERMINAL) {`
		4299	`case 65:`
		4300	`{`
		4301	`ADVANCE_LEXER;`
		4302	`{`
		4303	`{`
		4304	`{`
		4305
		4306	`/* Resolve type-ids from expressions */`
		4307	`(ZI0) = predict_typeid ( 0 ) ;`
		4308	`}`
		4309	`if (!ZI0)`
		4310	`goto ZL3;`
		4311	`ZR548 (&ZI414, &ZI551);`
		4312	`switch (CURRENT_TERMINAL) {`
		4313	`case 39:`
		4314	`break;`
		4315	`case 354:`
		4316	`RESTORE_LEXER;`
		4317	`goto ZL1;`
		4318	`default:`
		4319	`goto ZL1;`
		4320	`}`
		4321	`ADVANCE_LEXER;`
		4322	`{`
		4323
		4324	`(ZI497) = NULL_list ( EXP ) ;`
		4325	`}`
		4326	`goto ZL2;`
		4327	`}`
		4328	`/UNREACHED/`
		4329	`ZL3:;`
		4330	`switch (CURRENT_TERMINAL) {`
		4331	`case 1: case 2: case 3: case 5: case 6:`
		4332	`case 7: case 8: case 9: case 17: case 18:`
		4333	`case 19: case 20: case 21: case 22: case 23:`
		4334	`case 25: case 33: case 43: case 59: case 61:`
		4335	`case 62: case 65: case 69: case 71: case 78:`
		4336	`case 83: case 85: case 97: case 102: case 106:`
		4337	`case 110: case 111: case 114: case 115: case 116:`
		4338	`case 122: case 123: case 127: case 130: case 131:`
		4339	`case 132: case 135: case 140: case 141: case 145:`
		4340	`case 146: case 148: case 149: case 150: case 152:`
		4341	`case 156: case 170: case 184: case 205: case 209:`
		4342	`case 285: case 298: case 329:`
		4343	`{`
		4344	`int ZI457;`
		4345	`TYPE ZI574;`
		4346	`int ZI575;`
		4347
		4348	`ZR498 (&ZI497);`
		4349	`switch (CURRENT_TERMINAL) {`
		4350	`case 39:`
		4351	`break;`
		4352	`case 354:`
		4353	`RESTORE_LEXER;`
		4354	`goto ZL1;`
		4355	`default:`
		4356	`goto ZL1;`
		4357	`}`
		4358	`ADVANCE_LEXER;`
		4359	`{`
		4360
		4361	`(ZI457) = have_type_declaration ;`
		4362	`have_type_declaration = TYPE_DECL_NONE ;`
		4363	`}`
		4364	`{`
		4365	`switch (CURRENT_TERMINAL) {`
		4366	`case 65:`
		4367	`{`
		4368	`ADVANCE_LEXER;`
		4369	`ZR548 (&ZI574, &ZI575);`
		4370	`switch (CURRENT_TERMINAL) {`
		4371	`case 39:`
		4372	`break;`
		4373	`case 354:`
		4374	`RESTORE_LEXER;`
		4375	`goto ZL1;`
		4376	`default:`
		4377	`goto ZL1;`
		4378	`}`
		4379	`ADVANCE_LEXER;`
		4380	`}`
		4381	`break;`
		4382	`case 2: case 7: case 8: case 9: case 25:`
		4383	`case 83: case 97: case 98: case 102: case 104:`
		4384	`case 106: case 110: case 111: case 114: case 115:`
		4385	`case 118: case 121: case 122: case 123: case 124:`
		4386	`case 127: case 129: case 153: case 156: case 184:`
		4387	`case 285: case 298:`
		4388	`{`
		4389	`ZR568 (&ZI574, &ZI575);`
		4390	`if ((CURRENT_TERMINAL) == 354) {`
		4391	`RESTORE_LEXER;`
		4392	`goto ZL1;`
		4393	`}`
		4394	`}`
		4395	`break;`
		4396	`default:`
		4397	`goto ZL1;`
		4398	`}`
		4399	`}`
		4400	`{`
		4401
		4402	`have_type_declaration = (ZI457) ;`
		4403	`}`
		4404	`ZI414 = ZI574;`
		4405	`ZI551 = ZI575;`
		4406	`}`
		4407	`break;`
		4408	`default:`
		4409	`goto ZL1;`
		4410	`}`
		4411	`ZL2:;`
		4412	`}`
		4413	`}`
		4414	`break;`
		4415	`case 2: case 7: case 8: case 9: case 25:`
		4416	`case 83: case 97: case 98: case 102: case 104:`
		4417	`case 106: case 110: case 111: case 114: case 115:`
		4418	`case 118: case 121: case 122: case 123: case 124:`
		4419	`case 127: case 129: case 153: case 156: case 184:`
		4420	`case 285: case 298:`
		4421	`{`
		4422	`ZR568 (&ZI414, &ZI551);`
		4423	`if ((CURRENT_TERMINAL) == 354) {`
		4424	`RESTORE_LEXER;`
		4425	`goto ZL1;`
		4426	`}`
		4427	`{`
		4428
		4429	`(ZI497) = NULL_list ( EXP ) ;`
		4430	`}`
		4431	`}`
		4432	`break;`
		4433	`case 354:`
		4434	`return;`
		4435	`default:`
		4436	`goto ZL1;`
		4437	`}`
		4438	`goto ZL0;`
		4439	`ZL1:;`
		4440	`SAVE_LEXER (354);`
		4441	`return;`
		4442	`ZL0:;`
		4443	`*ZO497 = ZI497;`
		4444	`*ZO414 = ZI414;`
		4445	`*ZO551 = ZI551;`
		4446	`}`
		4447
		4448	`void`
7	7u83	4449	`ZR676(EXP ZI558, EXP *ZO431)`
2	7u83	4450	`{`
		4451	`EXP ZI431;`
		4452
		4453	`if ((CURRENT_TERMINAL) == 354) {`
		4454	`return;`
		4455	`}`
		4456	`ZL2_676:;`
		4457	`{`
		4458	`DECL_SPEC ZI689;`
		4459	`TYPE ZI414;`
		4460	`EXP ZI1478;`
		4461	`EXP ZI493;`
		4462	`EXP ZI456;`
		4463
		4464	`{`
		4465
		4466	`/* Resolve declaration-statements from expression-statements */`
		4467	`int b = predict_decl () ;`
		4468	`if ( b ) in_declaration++ ;`
		4469	`(ZI0) = b ;`
		4470	`}`
		4471	`if (!ZI0)`
		4472	`goto ZL3;`
		4473	`{`
		4474	`(ZI689) = dspec_none ;`
		4475	`}`
		4476	`{`
		4477
		4478	`(ZI414) = NULL_type ;`
		4479	`}`
		4480	`ZR687 (ZI414, ZI689, &ZI1478);`
		4481	`if ((CURRENT_TERMINAL) == 354) {`
		4482	`RESTORE_LEXER;`
		4483	`goto ZL1;`
		4484	`}`
		4485	`{`
		4486
		4487	`(ZI493) = (ZI1478) ;`
		4488	`in_declaration-- ;`
		4489	`}`
		4490	`{`
		4491
		4492	`unreached_fall = 1 ;`
		4493	`}`
		4494	`{`
		4495
		4496	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		4497	`}`
		4498	`ZI558 = ZI456;`
		4499	`goto ZL2_676;`
		4500	`}`
		4501	`/UNREACHED/`
		4502	`ZL3:;`
		4503	`switch (CURRENT_TERMINAL) {`
		4504	`case 170:`
		4505	`{`
		4506	`int ZI450;`
		4507	`EXP ZI1452;`
		4508	`EXP ZI1451;`
		4509	`EXP ZI1450;`
		4510	`EXP ZI1449;`
		4511	`EXP ZI1448;`
		4512	`EXP ZI1447;`
		4513	`EXP ZI1446;`
		4514	`EXP ZI1445;`
		4515	`EXP ZI1444;`
		4516	`EXP ZI1443;`
		4517	`EXP ZI1442;`
		4518	`EXP ZI1441;`
		4519	`EXP ZI1263;`
		4520	`EXP ZI1287;`
		4521	`EXP ZI1488;`
		4522	`int ZI670;`
		4523	`EXP ZI493;`
		4524	`EXP ZI456;`
		4525
		4526	`ADVANCE_LEXER;`
		4527	`{`
		4528	`(ZI450) = lex_alignof ;`
		4529	`}`
		4530	`ZR593 (ZI450, &ZI1452);`
		4531	`ZR1236 (ZI1452, &ZI1451);`
		4532	`ZR1232 (ZI1451, &ZI1450);`
		4533	`ZR1228 (ZI1450, &ZI1449);`
		4534	`ZR1224 (ZI1449, &ZI1448);`
		4535	`ZR1220 (ZI1448, &ZI1447);`
		4536	`ZR1216 (ZI1447, &ZI1446);`
		4537	`ZR1212 (ZI1446, &ZI1445);`
		4538	`ZR1208 (ZI1445, &ZI1444);`
		4539	`ZR1204 (ZI1444, &ZI1443);`
		4540	`ZR1200 (ZI1443, &ZI1442);`
		4541	`ZR1196 (ZI1442, &ZI1441);`
		4542	`ZR1192 (ZI1441, &ZI1263);`
		4543	`ZR1264 (&ZI1263, &ZI1287);`
		4544	`ZR1289 (&ZI1287, &ZI1488);`
		4545	`if ((CURRENT_TERMINAL) == 354) {`
		4546	`RESTORE_LEXER;`
		4547	`goto ZL1;`
		4548	`}`
		4549	`{`
		4550
		4551	`(ZI670) = unreached_code ;`
		4552	`if ( (ZI670) ) {`
		4553	`if ( !unreached_last ) {`
		4554	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		4555	`unreached_last = 1 ;`
		4556	`}`
		4557	`} else {`
		4558	`unreached_last = 0 ;`
		4559	`}`
		4560	`}`
		4561	`{`
		4562
		4563	`(ZI493) = make_exp_stmt ( (ZI1488) ) ;`
		4564	`}`
		4565	`{`
		4566
		4567	`unreached_fall = 1 ;`
		4568	`}`
		4569	`switch (CURRENT_TERMINAL) {`
		4570	`case 77:`
		4571	`break;`
		4572	`default:`
		4573	`goto ZL1;`
		4574	`}`
		4575	`ADVANCE_LEXER;`
		4576	`{`
		4577
		4578	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		4579	`}`
		4580	`ZI558 = ZI456;`
		4581	`goto ZL2_676;`
		4582	`}`
		4583	`/UNREACHED/`
		4584	`case 83:`
		4585	`{`
		4586	`EXP ZI493;`
		4587	`EXP ZI456;`
		4588
		4589	`ADVANCE_LEXER;`
		4590	`ZR1474 (&ZI493);`
		4591	`if ((CURRENT_TERMINAL) == 354) {`
		4592	`RESTORE_LEXER;`
		4593	`goto ZL1;`
		4594	`}`
		4595	`{`
		4596
		4597	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		4598	`}`
		4599	`ZI558 = ZI456;`
		4600	`goto ZL2_676;`
		4601	`}`
		4602	`/UNREACHED/`
		4603	`case 23:`
		4604	`{`
		4605	`EXP ZI1279;`
		4606	`EXP ZI1452;`
		4607	`EXP ZI1451;`
		4608	`EXP ZI1450;`
		4609	`EXP ZI1449;`
		4610	`EXP ZI1448;`
		4611	`EXP ZI1447;`
		4612	`EXP ZI1446;`
		4613	`EXP ZI1445;`
		4614	`EXP ZI1444;`
		4615	`EXP ZI1443;`
		4616	`EXP ZI1442;`
		4617	`EXP ZI1441;`
		4618	`EXP ZI1263;`
		4619	`EXP ZI1287;`
		4620	`EXP ZI1498;`
		4621	`int ZI670;`
		4622	`EXP ZI493;`
		4623	`EXP ZI456;`
		4624
		4625	`{`
		4626
		4627	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		4628	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		4629	`ZI1279 = parse_exp_token ( id, args ) ;`
		4630	`RESCAN_LEXER ;`
		4631	`}`
		4632	`ADVANCE_LEXER;`
		4633	`ZR1240 (ZI1279, &ZI1452);`
		4634	`ZR1236 (ZI1452, &ZI1451);`
		4635	`ZR1232 (ZI1451, &ZI1450);`
		4636	`ZR1228 (ZI1450, &ZI1449);`
		4637	`ZR1224 (ZI1449, &ZI1448);`
		4638	`ZR1220 (ZI1448, &ZI1447);`
		4639	`ZR1216 (ZI1447, &ZI1446);`
		4640	`ZR1212 (ZI1446, &ZI1445);`
		4641	`ZR1208 (ZI1445, &ZI1444);`
		4642	`ZR1204 (ZI1444, &ZI1443);`
		4643	`ZR1200 (ZI1443, &ZI1442);`
		4644	`ZR1196 (ZI1442, &ZI1441);`
		4645	`ZR1192 (ZI1441, &ZI1263);`
		4646	`ZR1264 (&ZI1263, &ZI1287);`
		4647	`ZR1289 (&ZI1287, &ZI1498);`
		4648	`if ((CURRENT_TERMINAL) == 354) {`
		4649	`RESTORE_LEXER;`
		4650	`goto ZL1;`
		4651	`}`
		4652	`{`
		4653
		4654	`(ZI670) = unreached_code ;`
		4655	`if ( (ZI670) ) {`
		4656	`if ( !unreached_last ) {`
		4657	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		4658	`unreached_last = 1 ;`
		4659	`}`
		4660	`} else {`
		4661	`unreached_last = 0 ;`
		4662	`}`
		4663	`}`
		4664	`{`
		4665
		4666	`(ZI493) = make_exp_stmt ( (ZI1498) ) ;`
		4667	`}`
		4668	`{`
		4669
		4670	`unreached_fall = 1 ;`
		4671	`}`
		4672	`switch (CURRENT_TERMINAL) {`
		4673	`case 77:`
		4674	`break;`
		4675	`default:`
		4676	`goto ZL1;`
		4677	`}`
		4678	`ADVANCE_LEXER;`
		4679	`{`
		4680
		4681	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		4682	`}`
		4683	`ZI558 = ZI456;`
		4684	`goto ZL2_676;`
		4685	`}`
		4686	`/UNREACHED/`
		4687	`case 24:`
		4688	`{`
		4689	`EXP ZI1476;`
		4690	`EXP ZI493;`
		4691	`EXP ZI456;`
		4692
		4693	`{`
		4694
		4695	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		4696	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		4697	`ZI1476 = parse_exp_token ( id, args ) ;`
		4698	`RESCAN_LEXER ;`
		4699	`}`
		4700	`ADVANCE_LEXER;`
		4701	`{`
		4702
		4703	`(ZI493) = make_exp_stmt ( (ZI1476) ) ;`
		4704	`}`
		4705	`{`
		4706
		4707	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		4708	`}`
		4709	`ZI558 = ZI456;`
		4710	`goto ZL2_676;`
		4711	`}`
		4712	`/UNREACHED/`
		4713	`case 25:`
		4714	`{`
		4715	`TYPE ZI1265;`
		4716	`BASE_TYPE ZI511;`
		4717	`CV_SPEC ZI783;`
		4718	`TYPE ZI414;`
		4719	`SID_LIST_EXP ZI497;`
		4720	`EXP ZI1282;`
		4721	`EXP ZI1452;`
		4722	`EXP ZI1451;`
		4723	`EXP ZI1450;`
		4724	`EXP ZI1449;`
		4725	`EXP ZI1448;`
		4726	`EXP ZI1447;`
		4727	`EXP ZI1446;`
		4728	`EXP ZI1445;`
		4729	`EXP ZI1444;`
		4730	`EXP ZI1443;`
		4731	`EXP ZI1442;`
		4732	`EXP ZI1441;`
		4733	`EXP ZI1263;`
		4734	`EXP ZI1287;`
		4735	`EXP ZI1500;`
		4736	`int ZI670;`
		4737	`EXP ZI493;`
		4738	`EXP ZI456;`
		4739
		4740	`{`
		4741
		4742	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		4743	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		4744	`ZI1265 = parse_type_token ( id, args ) ;`
		4745	`have_type_declaration = TYPE_DECL_NONE ;`
		4746	`have_type_specifier = 1 ;`
		4747	`RESCAN_LEXER ;`
		4748	`}`
		4749	`ADVANCE_LEXER;`
		4750	`{`
		4751	`(ZI511) = btype_none ;`
		4752	`}`
		4753	`{`
		4754	`(ZI783) = cv_none ;`
		4755	`}`
		4756	`{`
		4757
		4758	`(ZI414) = complete_pre_type ( (ZI511), (ZI1265), (ZI783), 1 ) ;`
		4759	`have_type_specifier = 0 ;`
		4760	`}`
		4761	`switch (CURRENT_TERMINAL) {`
		4762	`case 65:`
		4763	`break;`
		4764	`default:`
		4765	`goto ZL1;`
		4766	`}`
		4767	`ADVANCE_LEXER;`
		4768	`ZR500 (&ZI497);`
		4769	`switch (CURRENT_TERMINAL) {`
		4770	`case 39:`
		4771	`break;`
		4772	`case 354:`
		4773	`RESTORE_LEXER;`
		4774	`goto ZL1;`
		4775	`default:`
		4776	`goto ZL1;`
		4777	`}`
		4778	`ADVANCE_LEXER;`
		4779	`{`
		4780
		4781	`(ZI1282) = make_func_cast_exp ( (ZI414), (ZI497) ) ;`
		4782	`}`
		4783	`ZR1240 (ZI1282, &ZI1452);`
		4784	`ZR1236 (ZI1452, &ZI1451);`
		4785	`ZR1232 (ZI1451, &ZI1450);`
		4786	`ZR1228 (ZI1450, &ZI1449);`
		4787	`ZR1224 (ZI1449, &ZI1448);`
		4788	`ZR1220 (ZI1448, &ZI1447);`
		4789	`ZR1216 (ZI1447, &ZI1446);`
		4790	`ZR1212 (ZI1446, &ZI1445);`
		4791	`ZR1208 (ZI1445, &ZI1444);`
		4792	`ZR1204 (ZI1444, &ZI1443);`
		4793	`ZR1200 (ZI1443, &ZI1442);`
		4794	`ZR1196 (ZI1442, &ZI1441);`
		4795	`ZR1192 (ZI1441, &ZI1263);`
		4796	`ZR1264 (&ZI1263, &ZI1287);`
		4797	`ZR1289 (&ZI1287, &ZI1500);`
		4798	`if ((CURRENT_TERMINAL) == 354) {`
		4799	`RESTORE_LEXER;`
		4800	`goto ZL1;`
		4801	`}`
		4802	`{`
		4803
		4804	`(ZI670) = unreached_code ;`
		4805	`if ( (ZI670) ) {`
		4806	`if ( !unreached_last ) {`
		4807	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		4808	`unreached_last = 1 ;`
		4809	`}`
		4810	`} else {`
		4811	`unreached_last = 0 ;`
		4812	`}`
		4813	`}`
		4814	`{`
		4815
		4816	`(ZI493) = make_exp_stmt ( (ZI1500) ) ;`
		4817	`}`
		4818	`{`
		4819
		4820	`unreached_fall = 1 ;`
		4821	`}`
		4822	`switch (CURRENT_TERMINAL) {`
		4823	`case 77:`
		4824	`break;`
		4825	`default:`
		4826	`goto ZL1;`
		4827	`}`
		4828	`ADVANCE_LEXER;`
		4829	`{`
		4830
		4831	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		4832	`}`
		4833	`ZI558 = ZI456;`
		4834	`goto ZL2_676;`
		4835	`}`
		4836	`/UNREACHED/`
		4837	`case 130:`
		4838	`{`
		4839	`TYPE ZI414;`
		4840	`EXP ZI1460;`
		4841	`int ZI551;`
		4842	`EXP ZI1271;`
		4843	`EXP ZI1452;`
		4844	`EXP ZI1451;`
		4845	`EXP ZI1450;`
		4846	`EXP ZI1449;`
		4847	`EXP ZI1448;`
		4848	`EXP ZI1447;`
		4849	`EXP ZI1446;`
		4850	`EXP ZI1445;`
		4851	`EXP ZI1444;`
		4852	`EXP ZI1443;`
		4853	`EXP ZI1442;`
		4854	`EXP ZI1441;`
		4855	`EXP ZI1263;`
		4856	`EXP ZI1287;`
		4857	`EXP ZI1491;`
		4858	`int ZI670;`
		4859	`EXP ZI493;`
		4860	`EXP ZI456;`
		4861
		4862	`ADVANCE_LEXER;`
		4863	`ZR552 (&ZI414, &ZI1460, &ZI551);`
		4864	`if ((CURRENT_TERMINAL) == 354) {`
		4865	`RESTORE_LEXER;`
		4866	`goto ZL1;`
		4867	`}`
		4868	`{`
		4869
		4870	`/* n is the number of type definitions in t */`
		4871	`(ZI1271) = make_const_cast_exp ( (ZI414), (ZI1460), (ZI551) ) ;`
		4872	`}`
		4873	`ZR1240 (ZI1271, &ZI1452);`
		4874	`ZR1236 (ZI1452, &ZI1451);`
		4875	`ZR1232 (ZI1451, &ZI1450);`
		4876	`ZR1228 (ZI1450, &ZI1449);`
		4877	`ZR1224 (ZI1449, &ZI1448);`
		4878	`ZR1220 (ZI1448, &ZI1447);`
		4879	`ZR1216 (ZI1447, &ZI1446);`
		4880	`ZR1212 (ZI1446, &ZI1445);`
		4881	`ZR1208 (ZI1445, &ZI1444);`
		4882	`ZR1204 (ZI1444, &ZI1443);`
		4883	`ZR1200 (ZI1443, &ZI1442);`
		4884	`ZR1196 (ZI1442, &ZI1441);`
		4885	`ZR1192 (ZI1441, &ZI1263);`
		4886	`ZR1264 (&ZI1263, &ZI1287);`
		4887	`ZR1289 (&ZI1287, &ZI1491);`
		4888	`if ((CURRENT_TERMINAL) == 354) {`
		4889	`RESTORE_LEXER;`
		4890	`goto ZL1;`
		4891	`}`
		4892	`{`
		4893
		4894	`(ZI670) = unreached_code ;`
		4895	`if ( (ZI670) ) {`
		4896	`if ( !unreached_last ) {`
		4897	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		4898	`unreached_last = 1 ;`
		4899	`}`
		4900	`} else {`
		4901	`unreached_last = 0 ;`
		4902	`}`
		4903	`}`
		4904	`{`
		4905
		4906	`(ZI493) = make_exp_stmt ( (ZI1491) ) ;`
		4907	`}`
		4908	`{`
		4909
		4910	`unreached_fall = 1 ;`
		4911	`}`
		4912	`switch (CURRENT_TERMINAL) {`
		4913	`case 77:`
		4914	`break;`
		4915	`default:`
		4916	`goto ZL1;`
		4917	`}`
		4918	`ADVANCE_LEXER;`
		4919	`{`
		4920
		4921	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		4922	`}`
		4923	`ZI558 = ZI456;`
		4924	`goto ZL2_676;`
		4925	`}`
		4926	`/UNREACHED/`
		4927	`case 5:`
		4928	`{`
		4929	`IDENTIFIER ZI478;`
		4930	`IDENTIFIER ZI419;`
		4931	`EXP ZI1283;`
		4932	`EXP ZI1452;`
		4933	`EXP ZI1451;`
		4934	`EXP ZI1450;`
		4935	`EXP ZI1449;`
		4936	`EXP ZI1448;`
		4937	`EXP ZI1447;`
		4938	`EXP ZI1446;`
		4939	`EXP ZI1445;`
		4940	`EXP ZI1444;`
		4941	`EXP ZI1443;`
		4942	`EXP ZI1442;`
		4943	`EXP ZI1441;`
		4944	`EXP ZI1263;`
		4945	`EXP ZI1287;`
		4946	`EXP ZI1504;`
		4947	`int ZI670;`
		4948	`EXP ZI493;`
		4949	`EXP ZI456;`
		4950
		4951	`{`
		4952
		4953	`ZI478 = crt_token->pp_data.id.use ;`
		4954	`}`
		4955	`ADVANCE_LEXER;`
		4956	`{`
		4957
		4958	`(ZI419) = check_id ( NULL_nspace, (ZI478), 0 ) ;`
		4959	`crt_id_qualifier = qual_none ;`
		4960	`last_namespace = crt_namespace ;`
		4961	`}`
		4962	`{`
		4963
		4964	`(ZI1283) = make_id_exp ( (ZI419) ) ;`
		4965	`}`
		4966	`ZR1240 (ZI1283, &ZI1452);`
		4967	`ZR1236 (ZI1452, &ZI1451);`
		4968	`ZR1232 (ZI1451, &ZI1450);`
		4969	`ZR1228 (ZI1450, &ZI1449);`
		4970	`ZR1224 (ZI1449, &ZI1448);`
		4971	`ZR1220 (ZI1448, &ZI1447);`
		4972	`ZR1216 (ZI1447, &ZI1446);`
		4973	`ZR1212 (ZI1446, &ZI1445);`
		4974	`ZR1208 (ZI1445, &ZI1444);`
		4975	`ZR1204 (ZI1444, &ZI1443);`
		4976	`ZR1200 (ZI1443, &ZI1442);`
		4977	`ZR1196 (ZI1442, &ZI1441);`
		4978	`ZR1192 (ZI1441, &ZI1263);`
		4979	`ZR1264 (&ZI1263, &ZI1287);`
		4980	`ZR1289 (&ZI1287, &ZI1504);`
		4981	`if ((CURRENT_TERMINAL) == 354) {`
		4982	`RESTORE_LEXER;`
		4983	`goto ZL1;`
		4984	`}`
		4985	`{`
		4986
		4987	`(ZI670) = unreached_code ;`
		4988	`if ( (ZI670) ) {`
		4989	`if ( !unreached_last ) {`
		4990	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		4991	`unreached_last = 1 ;`
		4992	`}`
		4993	`} else {`
		4994	`unreached_last = 0 ;`
		4995	`}`
		4996	`}`
		4997	`{`
		4998
		4999	`(ZI493) = make_exp_stmt ( (ZI1504) ) ;`
		5000	`}`
		5001	`{`
		5002
		5003	`unreached_fall = 1 ;`
		5004	`}`
		5005	`switch (CURRENT_TERMINAL) {`
		5006	`case 77:`
		5007	`break;`
		5008	`default:`
		5009	`goto ZL1;`
		5010	`}`
		5011	`ADVANCE_LEXER;`
		5012	`{`
		5013
		5014	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5015	`}`
		5016	`ZI558 = ZI456;`
		5017	`goto ZL2_676;`
		5018	`}`
		5019	`/UNREACHED/`
		5020	`case 205:`
		5021	`{`
		5022	`EXP ZI1453;`
		5023	`EXP ZI1452;`
		5024	`EXP ZI1451;`
		5025	`EXP ZI1450;`
		5026	`EXP ZI1449;`
		5027	`EXP ZI1448;`
		5028	`EXP ZI1447;`
		5029	`EXP ZI1446;`
		5030	`EXP ZI1445;`
		5031	`EXP ZI1444;`
		5032	`EXP ZI1443;`
		5033	`EXP ZI1442;`
		5034	`EXP ZI1441;`
		5035	`EXP ZI1263;`
		5036	`EXP ZI1287;`
		5037	`EXP ZI1480;`
		5038	`int ZI670;`
		5039	`EXP ZI493;`
		5040	`EXP ZI456;`
		5041
		5042	`ADVANCE_LEXER;`
		5043	`ZR581 (&ZI1453);`
		5044	`if ((CURRENT_TERMINAL) == 354) {`
		5045	`RESTORE_LEXER;`
		5046	`goto ZL1;`
		5047	`}`
		5048	`{`
		5049
		5050	`(ZI1452) = make_cast_exp ( type_void, (ZI1453), 0 ) ;`
		5051	`}`
		5052	`ZR1236 (ZI1452, &ZI1451);`
		5053	`ZR1232 (ZI1451, &ZI1450);`
		5054	`ZR1228 (ZI1450, &ZI1449);`
		5055	`ZR1224 (ZI1449, &ZI1448);`
		5056	`ZR1220 (ZI1448, &ZI1447);`
		5057	`ZR1216 (ZI1447, &ZI1446);`
		5058	`ZR1212 (ZI1446, &ZI1445);`
		5059	`ZR1208 (ZI1445, &ZI1444);`
		5060	`ZR1204 (ZI1444, &ZI1443);`
		5061	`ZR1200 (ZI1443, &ZI1442);`
		5062	`ZR1196 (ZI1442, &ZI1441);`
		5063	`ZR1192 (ZI1441, &ZI1263);`
		5064	`ZR1264 (&ZI1263, &ZI1287);`
		5065	`ZR1289 (&ZI1287, &ZI1480);`
		5066	`if ((CURRENT_TERMINAL) == 354) {`
		5067	`RESTORE_LEXER;`
		5068	`goto ZL1;`
		5069	`}`
		5070	`{`
		5071
		5072	`(ZI670) = unreached_code ;`
		5073	`if ( (ZI670) ) {`
		5074	`if ( !unreached_last ) {`
		5075	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		5076	`unreached_last = 1 ;`
		5077	`}`
		5078	`} else {`
		5079	`unreached_last = 0 ;`
		5080	`}`
		5081	`}`
		5082	`{`
		5083
		5084	`(ZI493) = make_exp_stmt ( (ZI1480) ) ;`
		5085	`}`
		5086	`{`
		5087
		5088	`unreached_fall = 1 ;`
		5089	`}`
		5090	`switch (CURRENT_TERMINAL) {`
		5091	`case 77:`
		5092	`break;`
		5093	`default:`
		5094	`goto ZL1;`
		5095	`}`
		5096	`ADVANCE_LEXER;`
		5097	`{`
		5098
		5099	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5100	`}`
		5101	`ZI558 = ZI456;`
		5102	`goto ZL2_676;`
		5103	`}`
		5104	`/UNREACHED/`
		5105	`case 132:`
		5106	`{`
		5107	`TYPE ZI414;`
		5108	`EXP ZI1463;`
		5109	`int ZI551;`
		5110	`EXP ZI1274;`
		5111	`EXP ZI1452;`
		5112	`EXP ZI1451;`
		5113	`EXP ZI1450;`
		5114	`EXP ZI1449;`
		5115	`EXP ZI1448;`
		5116	`EXP ZI1447;`
		5117	`EXP ZI1446;`
		5118	`EXP ZI1445;`
		5119	`EXP ZI1444;`
		5120	`EXP ZI1443;`
		5121	`EXP ZI1442;`
		5122	`EXP ZI1441;`
		5123	`EXP ZI1263;`
		5124	`EXP ZI1287;`
		5125	`EXP ZI1494;`
		5126	`int ZI670;`
		5127	`EXP ZI493;`
		5128	`EXP ZI456;`
		5129
		5130	`ADVANCE_LEXER;`
		5131	`ZR552 (&ZI414, &ZI1463, &ZI551);`
		5132	`if ((CURRENT_TERMINAL) == 354) {`
		5133	`RESTORE_LEXER;`
		5134	`goto ZL1;`
		5135	`}`
		5136	`{`
		5137
		5138	`/* n is the number of type definitions in t */`
		5139	`(ZI1274) = make_dynamic_cast_exp ( (ZI414), (ZI1463), (ZI551) ) ;`
		5140	`}`
		5141	`ZR1240 (ZI1274, &ZI1452);`
		5142	`ZR1236 (ZI1452, &ZI1451);`
		5143	`ZR1232 (ZI1451, &ZI1450);`
		5144	`ZR1228 (ZI1450, &ZI1449);`
		5145	`ZR1224 (ZI1449, &ZI1448);`
		5146	`ZR1220 (ZI1448, &ZI1447);`
		5147	`ZR1216 (ZI1447, &ZI1446);`
		5148	`ZR1212 (ZI1446, &ZI1445);`
		5149	`ZR1208 (ZI1445, &ZI1444);`
		5150	`ZR1204 (ZI1444, &ZI1443);`
		5151	`ZR1200 (ZI1443, &ZI1442);`
		5152	`ZR1196 (ZI1442, &ZI1441);`
		5153	`ZR1192 (ZI1441, &ZI1263);`
		5154	`ZR1264 (&ZI1263, &ZI1287);`
		5155	`ZR1289 (&ZI1287, &ZI1494);`
		5156	`if ((CURRENT_TERMINAL) == 354) {`
		5157	`RESTORE_LEXER;`
		5158	`goto ZL1;`
		5159	`}`
		5160	`{`
		5161
		5162	`(ZI670) = unreached_code ;`
		5163	`if ( (ZI670) ) {`
		5164	`if ( !unreached_last ) {`
		5165	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		5166	`unreached_last = 1 ;`
		5167	`}`
		5168	`} else {`
		5169	`unreached_last = 0 ;`
		5170	`}`
		5171	`}`
		5172	`{`
		5173
		5174	`(ZI493) = make_exp_stmt ( (ZI1494) ) ;`
		5175	`}`
		5176	`{`
		5177
		5178	`unreached_fall = 1 ;`
		5179	`}`
		5180	`switch (CURRENT_TERMINAL) {`
		5181	`case 77:`
		5182	`break;`
		5183	`default:`
		5184	`goto ZL1;`
		5185	`}`
		5186	`ADVANCE_LEXER;`
		5187	`{`
		5188
		5189	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5190	`}`
		5191	`ZI558 = ZI456;`
		5192	`goto ZL2_676;`
		5193	`}`
		5194	`/UNREACHED/`
		5195	`case 209:`
		5196	`{`
		5197	`EXP ZI1277;`
		5198	`EXP ZI1452;`
		5199	`EXP ZI1451;`
		5200	`EXP ZI1450;`
		5201	`EXP ZI1449;`
		5202	`EXP ZI1448;`
		5203	`EXP ZI1447;`
		5204	`EXP ZI1446;`
		5205	`EXP ZI1445;`
		5206	`EXP ZI1444;`
		5207	`EXP ZI1443;`
		5208	`EXP ZI1442;`
		5209	`EXP ZI1441;`
		5210	`EXP ZI1263;`
		5211	`EXP ZI1287;`
		5212	`EXP ZI1497;`
		5213	`int ZI670;`
		5214	`EXP ZI493;`
		5215	`EXP ZI456;`
		5216
		5217	`ADVANCE_LEXER;`
		5218	`{`
		5219
		5220	`(ZI1277) = make_ellipsis_exp () ;`
		5221	`}`
		5222	`ZR1240 (ZI1277, &ZI1452);`
		5223	`ZR1236 (ZI1452, &ZI1451);`
		5224	`ZR1232 (ZI1451, &ZI1450);`
		5225	`ZR1228 (ZI1450, &ZI1449);`
		5226	`ZR1224 (ZI1449, &ZI1448);`
		5227	`ZR1220 (ZI1448, &ZI1447);`
		5228	`ZR1216 (ZI1447, &ZI1446);`
		5229	`ZR1212 (ZI1446, &ZI1445);`
		5230	`ZR1208 (ZI1445, &ZI1444);`
		5231	`ZR1204 (ZI1444, &ZI1443);`
		5232	`ZR1200 (ZI1443, &ZI1442);`
		5233	`ZR1196 (ZI1442, &ZI1441);`
		5234	`ZR1192 (ZI1441, &ZI1263);`
		5235	`ZR1264 (&ZI1263, &ZI1287);`
		5236	`ZR1289 (&ZI1287, &ZI1497);`
		5237	`if ((CURRENT_TERMINAL) == 354) {`
		5238	`RESTORE_LEXER;`
		5239	`goto ZL1;`
		5240	`}`
		5241	`{`
		5242
		5243	`(ZI670) = unreached_code ;`
		5244	`if ( (ZI670) ) {`
		5245	`if ( !unreached_last ) {`
		5246	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		5247	`unreached_last = 1 ;`
		5248	`}`
		5249	`} else {`
		5250	`unreached_last = 0 ;`
		5251	`}`
		5252	`}`
		5253	`{`
		5254
		5255	`(ZI493) = make_exp_stmt ( (ZI1497) ) ;`
		5256	`}`
		5257	`{`
		5258
		5259	`unreached_fall = 1 ;`
		5260	`}`
		5261	`switch (CURRENT_TERMINAL) {`
		5262	`case 77:`
		5263	`break;`
		5264	`default:`
		5265	`goto ZL1;`
		5266	`}`
		5267	`ADVANCE_LEXER;`
		5268	`{`
		5269
		5270	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5271	`}`
		5272	`ZI558 = ZI456;`
		5273	`goto ZL2_676;`
		5274	`}`
		5275	`/UNREACHED/`
		5276	`case 9:`
		5277	`{`
		5278	`NAMESPACE ZI425;`
		5279	`EXP ZI493;`
		5280	`EXP ZI456;`
		5281
		5282	`{`
		5283
		5284	`ZI425 = crt_token->pp_data.ns ;`
		5285	`}`
		5286	`ADVANCE_LEXER;`
		5287	`ZR1473 (&ZI425, &ZI493);`
		5288	`if ((CURRENT_TERMINAL) == 354) {`
		5289	`RESTORE_LEXER;`
		5290	`goto ZL1;`
		5291	`}`
		5292	`{`
		5293
		5294	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5295	`}`
		5296	`ZI558 = ZI456;`
		5297	`goto ZL2_676;`
		5298	`}`
		5299	`/UNREACHED/`
		5300	`case 1:`
		5301	`{`
		5302	`IDENTIFIER ZI1464;`
		5303	`EXP ZI493;`
		5304	`EXP ZI456;`
		5305
		5306	`{`
		5307
		5308	`ZI1464 = crt_token->pp_data.id.use ;`
		5309	`}`
		5310	`ADVANCE_LEXER;`
		5311	`ZR1469 (&ZI1464, &ZI493);`
		5312	`if ((CURRENT_TERMINAL) == 354) {`
		5313	`RESTORE_LEXER;`
		5314	`goto ZL1;`
		5315	`}`
		5316	`{`
		5317
		5318	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5319	`}`
		5320	`ZI558 = ZI456;`
		5321	`goto ZL2_676;`
		5322	`}`
		5323	`/UNREACHED/`
		5324	`case 345:`
		5325	`{`
		5326	`EXP ZI493;`
		5327	`EXP ZI456;`
		5328
		5329	`ADVANCE_LEXER;`
		5330	`ZR1439 (&ZI493);`
		5331	`if ((CURRENT_TERMINAL) == 354) {`
		5332	`RESTORE_LEXER;`
		5333	`goto ZL1;`
		5334	`}`
		5335	`{`
		5336
		5337	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5338	`}`
		5339	`ZI558 = ZI456;`
		5340	`goto ZL2_676;`
		5341	`}`
		5342	`/UNREACHED/`
		5343	`case 61:`
		5344	`{`
		5345	`EXP ZI1455;`
		5346	`EXP ZI1452;`
		5347	`EXP ZI1451;`
		5348	`EXP ZI1450;`
		5349	`EXP ZI1449;`
		5350	`EXP ZI1448;`
		5351	`EXP ZI1447;`
		5352	`EXP ZI1446;`
		5353	`EXP ZI1445;`
		5354	`EXP ZI1444;`
		5355	`EXP ZI1443;`
		5356	`EXP ZI1442;`
		5357	`EXP ZI1441;`
		5358	`EXP ZI1263;`
		5359	`EXP ZI1287;`
		5360	`EXP ZI1482;`
		5361	`int ZI670;`
		5362	`EXP ZI493;`
		5363	`EXP ZI456;`
		5364
		5365	`ADVANCE_LEXER;`
		5366	`ZR581 (&ZI1455);`
		5367	`if ((CURRENT_TERMINAL) == 354) {`
		5368	`RESTORE_LEXER;`
		5369	`goto ZL1;`
		5370	`}`
		5371	`{`
		5372
		5373	`(ZI1452) = make_prefix_exp ( lex_minus_Hminus, (ZI1455) ) ;`
		5374	`}`
		5375	`ZR1236 (ZI1452, &ZI1451);`
		5376	`ZR1232 (ZI1451, &ZI1450);`
		5377	`ZR1228 (ZI1450, &ZI1449);`
		5378	`ZR1224 (ZI1449, &ZI1448);`
		5379	`ZR1220 (ZI1448, &ZI1447);`
		5380	`ZR1216 (ZI1447, &ZI1446);`
		5381	`ZR1212 (ZI1446, &ZI1445);`
		5382	`ZR1208 (ZI1445, &ZI1444);`
		5383	`ZR1204 (ZI1444, &ZI1443);`
		5384	`ZR1200 (ZI1443, &ZI1442);`
		5385	`ZR1196 (ZI1442, &ZI1441);`
		5386	`ZR1192 (ZI1441, &ZI1263);`
		5387	`ZR1264 (&ZI1263, &ZI1287);`
		5388	`ZR1289 (&ZI1287, &ZI1482);`
		5389	`if ((CURRENT_TERMINAL) == 354) {`
		5390	`RESTORE_LEXER;`
		5391	`goto ZL1;`
		5392	`}`
		5393	`{`
		5394
		5395	`(ZI670) = unreached_code ;`
		5396	`if ( (ZI670) ) {`
		5397	`if ( !unreached_last ) {`
		5398	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		5399	`unreached_last = 1 ;`
		5400	`}`
		5401	`} else {`
		5402	`unreached_last = 0 ;`
		5403	`}`
		5404	`}`
		5405	`{`
		5406
		5407	`(ZI493) = make_exp_stmt ( (ZI1482) ) ;`
		5408	`}`
		5409	`{`
		5410
		5411	`unreached_fall = 1 ;`
		5412	`}`
		5413	`switch (CURRENT_TERMINAL) {`
		5414	`case 77:`
		5415	`break;`
		5416	`default:`
		5417	`goto ZL1;`
		5418	`}`
		5419	`ADVANCE_LEXER;`
		5420	`{`
		5421
		5422	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5423	`}`
		5424	`ZI558 = ZI456;`
		5425	`goto ZL2_676;`
		5426	`}`
		5427	`/UNREACHED/`
		5428	`case 3:`
		5429	`{`
		5430	`IDENTIFIER ZI1468;`
		5431	`EXP ZI493;`
		5432	`EXP ZI456;`
		5433
		5434	`{`
		5435
		5436	`ZI1468 = crt_token->pp_data.id.use ;`
		5437	`}`
		5438	`ADVANCE_LEXER;`
		5439	`ZR1469 (&ZI1468, &ZI493);`
		5440	`if ((CURRENT_TERMINAL) == 354) {`
		5441	`RESTORE_LEXER;`
		5442	`goto ZL1;`
		5443	`}`
		5444	`{`
		5445
		5446	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5447	`}`
		5448	`ZI558 = ZI456;`
		5449	`goto ZL2_676;`
		5450	`}`
		5451	`/UNREACHED/`
		5452	`case 8:`
		5453	`{`
		5454	`NAMESPACE ZI425;`
		5455	`EXP ZI493;`
		5456	`EXP ZI456;`
		5457
		5458	`{`
		5459
		5460	`ZI425 = crt_token->pp_data.ns ;`
		5461	`}`
		5462	`ADVANCE_LEXER;`
		5463	`ZR1472 (&ZI425, &ZI493);`
		5464	`if ((CURRENT_TERMINAL) == 354) {`
		5465	`RESTORE_LEXER;`
		5466	`goto ZL1;`
		5467	`}`
		5468	`{`
		5469
		5470	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5471	`}`
		5472	`ZI558 = ZI456;`
		5473	`goto ZL2_676;`
		5474	`}`
		5475	`/UNREACHED/`
		5476	`case 65:`
		5477	`{`
		5478	`EXP ZI1452;`
		5479	`EXP ZI1451;`
		5480	`EXP ZI1450;`
		5481	`EXP ZI1449;`
		5482	`EXP ZI1448;`
		5483	`EXP ZI1447;`
		5484	`EXP ZI1446;`
		5485	`EXP ZI1445;`
		5486	`EXP ZI1444;`
		5487	`EXP ZI1443;`
		5488	`EXP ZI1442;`
		5489	`EXP ZI1441;`
		5490	`EXP ZI1263;`
		5491	`EXP ZI1287;`
		5492	`EXP ZI1479;`
		5493	`int ZI670;`
		5494	`EXP ZI493;`
		5495	`EXP ZI456;`
		5496
		5497	`ADVANCE_LEXER;`
		5498	`ZR1286 (&ZI1452);`
		5499	`ZR1236 (ZI1452, &ZI1451);`
		5500	`ZR1232 (ZI1451, &ZI1450);`
		5501	`ZR1228 (ZI1450, &ZI1449);`
		5502	`ZR1224 (ZI1449, &ZI1448);`
		5503	`ZR1220 (ZI1448, &ZI1447);`
		5504	`ZR1216 (ZI1447, &ZI1446);`
		5505	`ZR1212 (ZI1446, &ZI1445);`
		5506	`ZR1208 (ZI1445, &ZI1444);`
		5507	`ZR1204 (ZI1444, &ZI1443);`
		5508	`ZR1200 (ZI1443, &ZI1442);`
		5509	`ZR1196 (ZI1442, &ZI1441);`
		5510	`ZR1192 (ZI1441, &ZI1263);`
		5511	`ZR1264 (&ZI1263, &ZI1287);`
		5512	`ZR1289 (&ZI1287, &ZI1479);`
		5513	`if ((CURRENT_TERMINAL) == 354) {`
		5514	`RESTORE_LEXER;`
		5515	`goto ZL1;`
		5516	`}`
		5517	`{`
		5518
		5519	`(ZI670) = unreached_code ;`
		5520	`if ( (ZI670) ) {`
		5521	`if ( !unreached_last ) {`
		5522	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		5523	`unreached_last = 1 ;`
		5524	`}`
		5525	`} else {`
		5526	`unreached_last = 0 ;`
		5527	`}`
		5528	`}`
		5529	`{`
		5530
		5531	`(ZI493) = make_exp_stmt ( (ZI1479) ) ;`
		5532	`}`
		5533	`{`
		5534
		5535	`unreached_fall = 1 ;`
		5536	`}`
		5537	`switch (CURRENT_TERMINAL) {`
		5538	`case 77:`
		5539	`break;`
		5540	`default:`
		5541	`goto ZL1;`
		5542	`}`
		5543	`ADVANCE_LEXER;`
		5544	`{`
		5545
		5546	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5547	`}`
		5548	`ZI558 = ZI456;`
		5549	`goto ZL2_676;`
		5550	`}`
		5551	`/UNREACHED/`
		5552	`case 71:`
		5553	`{`
		5554	`EXP ZI1454;`
		5555	`EXP ZI1452;`
		5556	`EXP ZI1451;`
		5557	`EXP ZI1450;`
		5558	`EXP ZI1449;`
		5559	`EXP ZI1448;`
		5560	`EXP ZI1447;`
		5561	`EXP ZI1446;`
		5562	`EXP ZI1445;`
		5563	`EXP ZI1444;`
		5564	`EXP ZI1443;`
		5565	`EXP ZI1442;`
		5566	`EXP ZI1441;`
		5567	`EXP ZI1263;`
		5568	`EXP ZI1287;`
		5569	`EXP ZI1481;`
		5570	`int ZI670;`
		5571	`EXP ZI493;`
		5572	`EXP ZI456;`
		5573
		5574	`ADVANCE_LEXER;`
		5575	`ZR581 (&ZI1454);`
		5576	`if ((CURRENT_TERMINAL) == 354) {`
		5577	`RESTORE_LEXER;`
		5578	`goto ZL1;`
		5579	`}`
		5580	`{`
		5581
		5582	`(ZI1452) = make_prefix_exp ( lex_plus_Hplus, (ZI1454) ) ;`
		5583	`}`
		5584	`ZR1236 (ZI1452, &ZI1451);`
		5585	`ZR1232 (ZI1451, &ZI1450);`
		5586	`ZR1228 (ZI1450, &ZI1449);`
		5587	`ZR1224 (ZI1449, &ZI1448);`
		5588	`ZR1220 (ZI1448, &ZI1447);`
		5589	`ZR1216 (ZI1447, &ZI1446);`
		5590	`ZR1212 (ZI1446, &ZI1445);`
		5591	`ZR1208 (ZI1445, &ZI1444);`
		5592	`ZR1204 (ZI1444, &ZI1443);`
		5593	`ZR1200 (ZI1443, &ZI1442);`
		5594	`ZR1196 (ZI1442, &ZI1441);`
		5595	`ZR1192 (ZI1441, &ZI1263);`
		5596	`ZR1264 (&ZI1263, &ZI1287);`
		5597	`ZR1289 (&ZI1287, &ZI1481);`
		5598	`if ((CURRENT_TERMINAL) == 354) {`
		5599	`RESTORE_LEXER;`
		5600	`goto ZL1;`
		5601	`}`
		5602	`{`
		5603
		5604	`(ZI670) = unreached_code ;`
		5605	`if ( (ZI670) ) {`
		5606	`if ( !unreached_last ) {`
		5607	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		5608	`unreached_last = 1 ;`
		5609	`}`
		5610	`} else {`
		5611	`unreached_last = 0 ;`
		5612	`}`
		5613	`}`
		5614	`{`
		5615
		5616	`(ZI493) = make_exp_stmt ( (ZI1481) ) ;`
		5617	`}`
		5618	`{`
		5619
		5620	`unreached_fall = 1 ;`
		5621	`}`
		5622	`switch (CURRENT_TERMINAL) {`
		5623	`case 77:`
		5624	`break;`
		5625	`default:`
		5626	`goto ZL1;`
		5627	`}`
		5628	`ADVANCE_LEXER;`
		5629	`{`
		5630
		5631	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5632	`}`
		5633	`ZI558 = ZI456;`
		5634	`goto ZL2_676;`
		5635	`}`
		5636	`/UNREACHED/`
		5637	`case 145:`
		5638	`{`
		5639	`TYPE ZI414;`
		5640	`EXP ZI1461;`
		5641	`int ZI551;`
		5642	`EXP ZI1272;`
		5643	`EXP ZI1452;`
		5644	`EXP ZI1451;`
		5645	`EXP ZI1450;`
		5646	`EXP ZI1449;`
		5647	`EXP ZI1448;`
		5648	`EXP ZI1447;`
		5649	`EXP ZI1446;`
		5650	`EXP ZI1445;`
		5651	`EXP ZI1444;`
		5652	`EXP ZI1443;`
		5653	`EXP ZI1442;`
		5654	`EXP ZI1441;`
		5655	`EXP ZI1263;`
		5656	`EXP ZI1287;`
		5657	`EXP ZI1492;`
		5658	`int ZI670;`
		5659	`EXP ZI493;`
		5660	`EXP ZI456;`
		5661
		5662	`ADVANCE_LEXER;`
		5663	`ZR552 (&ZI414, &ZI1461, &ZI551);`
		5664	`if ((CURRENT_TERMINAL) == 354) {`
		5665	`RESTORE_LEXER;`
		5666	`goto ZL1;`
		5667	`}`
		5668	`{`
		5669
		5670	`/* n is the number of type definitions in t */`
		5671	`(ZI1272) = make_reinterp_cast_exp ( (ZI414), (ZI1461), (ZI551) ) ;`
		5672	`}`
		5673	`ZR1240 (ZI1272, &ZI1452);`
		5674	`ZR1236 (ZI1452, &ZI1451);`
		5675	`ZR1232 (ZI1451, &ZI1450);`
		5676	`ZR1228 (ZI1450, &ZI1449);`
		5677	`ZR1224 (ZI1449, &ZI1448);`
		5678	`ZR1220 (ZI1448, &ZI1447);`
		5679	`ZR1216 (ZI1447, &ZI1446);`
		5680	`ZR1212 (ZI1446, &ZI1445);`
		5681	`ZR1208 (ZI1445, &ZI1444);`
		5682	`ZR1204 (ZI1444, &ZI1443);`
		5683	`ZR1200 (ZI1443, &ZI1442);`
		5684	`ZR1196 (ZI1442, &ZI1441);`
		5685	`ZR1192 (ZI1441, &ZI1263);`
		5686	`ZR1264 (&ZI1263, &ZI1287);`
		5687	`ZR1289 (&ZI1287, &ZI1492);`
		5688	`if ((CURRENT_TERMINAL) == 354) {`
		5689	`RESTORE_LEXER;`
		5690	`goto ZL1;`
		5691	`}`
		5692	`{`
		5693
		5694	`(ZI670) = unreached_code ;`
		5695	`if ( (ZI670) ) {`
		5696	`if ( !unreached_last ) {`
		5697	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		5698	`unreached_last = 1 ;`
		5699	`}`
		5700	`} else {`
		5701	`unreached_last = 0 ;`
		5702	`}`
		5703	`}`
		5704	`{`
		5705
		5706	`(ZI493) = make_exp_stmt ( (ZI1492) ) ;`
		5707	`}`
		5708	`{`
		5709
		5710	`unreached_fall = 1 ;`
		5711	`}`
		5712	`switch (CURRENT_TERMINAL) {`
		5713	`case 77:`
		5714	`break;`
		5715	`default:`
		5716	`goto ZL1;`
		5717	`}`
		5718	`ADVANCE_LEXER;`
		5719	`{`
		5720
		5721	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5722	`}`
		5723	`ZI558 = ZI456;`
		5724	`goto ZL2_676;`
		5725	`}`
		5726	`/UNREACHED/`
		5727	`case 77:`
		5728	`{`
		5729	`EXP ZI493;`
		5730	`EXP ZI456;`
		5731
		5732	`ADVANCE_LEXER;`
		5733	`{`
		5734
		5735	`(ZI493) = NULL_exp ;`
		5736	`}`
		5737	`{`
		5738
		5739	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5740	`}`
		5741	`ZI558 = ZI456;`
		5742	`goto ZL2_676;`
		5743	`}`
		5744	`/UNREACHED/`
		5745	`case 116:`
		5746	`{`
		5747	`int ZI450;`
		5748	`EXP ZI1452;`
		5749	`EXP ZI1451;`
		5750	`EXP ZI1450;`
		5751	`EXP ZI1449;`
		5752	`EXP ZI1448;`
		5753	`EXP ZI1447;`
		5754	`EXP ZI1446;`
		5755	`EXP ZI1445;`
		5756	`EXP ZI1444;`
		5757	`EXP ZI1443;`
		5758	`EXP ZI1442;`
		5759	`EXP ZI1441;`
		5760	`EXP ZI1263;`
		5761	`EXP ZI1287;`
		5762	`EXP ZI1487;`
		5763	`int ZI670;`
		5764	`EXP ZI493;`
		5765	`EXP ZI456;`
		5766
		5767	`ADVANCE_LEXER;`
		5768	`{`
		5769	`(ZI450) = lex_sizeof ;`
		5770	`}`
		5771	`ZR593 (ZI450, &ZI1452);`
		5772	`ZR1236 (ZI1452, &ZI1451);`
		5773	`ZR1232 (ZI1451, &ZI1450);`
		5774	`ZR1228 (ZI1450, &ZI1449);`
		5775	`ZR1224 (ZI1449, &ZI1448);`
		5776	`ZR1220 (ZI1448, &ZI1447);`
		5777	`ZR1216 (ZI1447, &ZI1446);`
		5778	`ZR1212 (ZI1446, &ZI1445);`
		5779	`ZR1208 (ZI1445, &ZI1444);`
		5780	`ZR1204 (ZI1444, &ZI1443);`
		5781	`ZR1200 (ZI1443, &ZI1442);`
		5782	`ZR1196 (ZI1442, &ZI1441);`
		5783	`ZR1192 (ZI1441, &ZI1263);`
		5784	`ZR1264 (&ZI1263, &ZI1287);`
		5785	`ZR1289 (&ZI1287, &ZI1487);`
		5786	`if ((CURRENT_TERMINAL) == 354) {`
		5787	`RESTORE_LEXER;`
		5788	`goto ZL1;`
		5789	`}`
		5790	`{`
		5791
		5792	`(ZI670) = unreached_code ;`
		5793	`if ( (ZI670) ) {`
		5794	`if ( !unreached_last ) {`
		5795	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		5796	`unreached_last = 1 ;`
		5797	`}`
		5798	`} else {`
		5799	`unreached_last = 0 ;`
		5800	`}`
		5801	`}`
		5802	`{`
		5803
		5804	`(ZI493) = make_exp_stmt ( (ZI1487) ) ;`
		5805	`}`
		5806	`{`
		5807
		5808	`unreached_fall = 1 ;`
		5809	`}`
		5810	`switch (CURRENT_TERMINAL) {`
		5811	`case 77:`
		5812	`break;`
		5813	`default:`
		5814	`goto ZL1;`
		5815	`}`
		5816	`ADVANCE_LEXER;`
		5817	`{`
		5818
		5819	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5820	`}`
		5821	`ZI558 = ZI456;`
		5822	`goto ZL2_676;`
		5823	`}`
		5824	`/UNREACHED/`
		5825	`case 78:`
		5826	`{`
		5827	`EXP ZI1456;`
		5828	`EXP ZI1452;`
		5829	`EXP ZI1451;`
		5830	`EXP ZI1450;`
		5831	`EXP ZI1449;`
		5832	`EXP ZI1448;`
		5833	`EXP ZI1447;`
		5834	`EXP ZI1446;`
		5835	`EXP ZI1445;`
		5836	`EXP ZI1444;`
		5837	`EXP ZI1443;`
		5838	`EXP ZI1442;`
		5839	`EXP ZI1441;`
		5840	`EXP ZI1263;`
		5841	`EXP ZI1287;`
		5842	`EXP ZI1483;`
		5843	`int ZI670;`
		5844	`EXP ZI493;`
		5845	`EXP ZI456;`
		5846
		5847	`ADVANCE_LEXER;`
		5848	`ZR581 (&ZI1456);`
		5849	`if ((CURRENT_TERMINAL) == 354) {`
		5850	`RESTORE_LEXER;`
		5851	`goto ZL1;`
		5852	`}`
		5853	`{`
		5854
		5855	`(ZI1452) = make_indir_exp ( (ZI1456) ) ;`
		5856	`}`
		5857	`ZR1236 (ZI1452, &ZI1451);`
		5858	`ZR1232 (ZI1451, &ZI1450);`
		5859	`ZR1228 (ZI1450, &ZI1449);`
		5860	`ZR1224 (ZI1449, &ZI1448);`
		5861	`ZR1220 (ZI1448, &ZI1447);`
		5862	`ZR1216 (ZI1447, &ZI1446);`
		5863	`ZR1212 (ZI1446, &ZI1445);`
		5864	`ZR1208 (ZI1445, &ZI1444);`
		5865	`ZR1204 (ZI1444, &ZI1443);`
		5866	`ZR1200 (ZI1443, &ZI1442);`
		5867	`ZR1196 (ZI1442, &ZI1441);`
		5868	`ZR1192 (ZI1441, &ZI1263);`
		5869	`ZR1264 (&ZI1263, &ZI1287);`
		5870	`ZR1289 (&ZI1287, &ZI1483);`
		5871	`if ((CURRENT_TERMINAL) == 354) {`
		5872	`RESTORE_LEXER;`
		5873	`goto ZL1;`
		5874	`}`
		5875	`{`
		5876
		5877	`(ZI670) = unreached_code ;`
		5878	`if ( (ZI670) ) {`
		5879	`if ( !unreached_last ) {`
		5880	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		5881	`unreached_last = 1 ;`
		5882	`}`
		5883	`} else {`
		5884	`unreached_last = 0 ;`
		5885	`}`
		5886	`}`
		5887	`{`
		5888
		5889	`(ZI493) = make_exp_stmt ( (ZI1483) ) ;`
		5890	`}`
		5891	`{`
		5892
		5893	`unreached_fall = 1 ;`
		5894	`}`
		5895	`switch (CURRENT_TERMINAL) {`
		5896	`case 77:`
		5897	`break;`
		5898	`default:`
		5899	`goto ZL1;`
		5900	`}`
		5901	`ADVANCE_LEXER;`
		5902	`{`
		5903
		5904	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5905	`}`
		5906	`ZI558 = ZI456;`
		5907	`goto ZL2_676;`
		5908	`}`
		5909	`/UNREACHED/`
		5910	`case 4:`
		5911	`{`
		5912	`IDENTIFIER ZI1470;`
		5913	`EXP ZI493;`
		5914	`EXP ZI456;`
		5915
		5916	`{`
		5917
		5918	`ZI1470 = crt_token->pp_data.id.use ;`
		5919	`}`
		5920	`ADVANCE_LEXER;`
		5921	`ZR1471 (&ZI1470, &ZI493);`
		5922	`if ((CURRENT_TERMINAL) == 354) {`
		5923	`RESTORE_LEXER;`
		5924	`goto ZL1;`
		5925	`}`
		5926	`{`
		5927
		5928	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		5929	`}`
		5930	`ZI558 = ZI456;`
		5931	`goto ZL2_676;`
		5932	`}`
		5933	`/UNREACHED/`
		5934	`case 146:`
		5935	`{`
		5936	`TYPE ZI414;`
		5937	`EXP ZI1462;`
		5938	`int ZI551;`
		5939	`EXP ZI1273;`
		5940	`EXP ZI1452;`
		5941	`EXP ZI1451;`
		5942	`EXP ZI1450;`
		5943	`EXP ZI1449;`
		5944	`EXP ZI1448;`
		5945	`EXP ZI1447;`
		5946	`EXP ZI1446;`
		5947	`EXP ZI1445;`
		5948	`EXP ZI1444;`
		5949	`EXP ZI1443;`
		5950	`EXP ZI1442;`
		5951	`EXP ZI1441;`
		5952	`EXP ZI1263;`
		5953	`EXP ZI1287;`
		5954	`EXP ZI1493;`
		5955	`int ZI670;`
		5956	`EXP ZI493;`
		5957	`EXP ZI456;`
		5958
		5959	`ADVANCE_LEXER;`
		5960	`ZR552 (&ZI414, &ZI1462, &ZI551);`
		5961	`if ((CURRENT_TERMINAL) == 354) {`
		5962	`RESTORE_LEXER;`
		5963	`goto ZL1;`
		5964	`}`
		5965	`{`
		5966
		5967	`(ZI1273) = make_static_cast_exp ( (ZI414), (ZI1462), (ZI551) ) ;`
		5968	`}`
		5969	`ZR1240 (ZI1273, &ZI1452);`
		5970	`ZR1236 (ZI1452, &ZI1451);`
		5971	`ZR1232 (ZI1451, &ZI1450);`
		5972	`ZR1228 (ZI1450, &ZI1449);`
		5973	`ZR1224 (ZI1449, &ZI1448);`
		5974	`ZR1220 (ZI1448, &ZI1447);`
		5975	`ZR1216 (ZI1447, &ZI1446);`
		5976	`ZR1212 (ZI1446, &ZI1445);`
		5977	`ZR1208 (ZI1445, &ZI1444);`
		5978	`ZR1204 (ZI1444, &ZI1443);`
		5979	`ZR1200 (ZI1443, &ZI1442);`
		5980	`ZR1196 (ZI1442, &ZI1441);`
		5981	`ZR1192 (ZI1441, &ZI1263);`
		5982	`ZR1264 (&ZI1263, &ZI1287);`
		5983	`ZR1289 (&ZI1287, &ZI1493);`
		5984	`if ((CURRENT_TERMINAL) == 354) {`
		5985	`RESTORE_LEXER;`
		5986	`goto ZL1;`
		5987	`}`
		5988	`{`
		5989
		5990	`(ZI670) = unreached_code ;`
		5991	`if ( (ZI670) ) {`
		5992	`if ( !unreached_last ) {`
		5993	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		5994	`unreached_last = 1 ;`
		5995	`}`
		5996	`} else {`
		5997	`unreached_last = 0 ;`
		5998	`}`
		5999	`}`
		6000	`{`
		6001
		6002	`(ZI493) = make_exp_stmt ( (ZI1493) ) ;`
		6003	`}`
		6004	`{`
		6005
		6006	`unreached_fall = 1 ;`
		6007	`}`
		6008	`switch (CURRENT_TERMINAL) {`
		6009	`case 77:`
		6010	`break;`
		6011	`default:`
		6012	`goto ZL1;`
		6013	`}`
		6014	`ADVANCE_LEXER;`
		6015	`{`
		6016
		6017	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6018	`}`
		6019	`ZI558 = ZI456;`
		6020	`goto ZL2_676;`
		6021	`}`
		6022	`/UNREACHED/`
		6023	`case 6:`
		6024	`{`
		6025	`IDENTIFIER ZI478;`
		6026	`IDENTIFIER ZI419;`
		6027	`EXP ZI1283;`
		6028	`EXP ZI1452;`
		6029	`EXP ZI1451;`
		6030	`EXP ZI1450;`
		6031	`EXP ZI1449;`
		6032	`EXP ZI1448;`
		6033	`EXP ZI1447;`
		6034	`EXP ZI1446;`
		6035	`EXP ZI1445;`
		6036	`EXP ZI1444;`
		6037	`EXP ZI1443;`
		6038	`EXP ZI1442;`
		6039	`EXP ZI1441;`
		6040	`EXP ZI1263;`
		6041	`EXP ZI1287;`
		6042	`EXP ZI1505;`
		6043	`int ZI670;`
		6044	`EXP ZI493;`
		6045	`EXP ZI456;`
		6046
		6047	`{`
		6048
		6049	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		6050	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		6051	`ZI478 = parse_id_template ( id, args, 0 ) ;`
		6052	`crt_templ_qualifier = 1 ;`
		6053	`RESCAN_LEXER ;`
		6054	`}`
		6055	`ADVANCE_LEXER;`
		6056	`{`
		6057
		6058	`(ZI419) = check_id ( NULL_nspace, (ZI478), 0 ) ;`
		6059	`crt_id_qualifier = qual_none ;`
		6060	`last_namespace = crt_namespace ;`
		6061	`}`
		6062	`{`
		6063
		6064	`(ZI1283) = make_id_exp ( (ZI419) ) ;`
		6065	`}`
		6066	`ZR1240 (ZI1283, &ZI1452);`
		6067	`ZR1236 (ZI1452, &ZI1451);`
		6068	`ZR1232 (ZI1451, &ZI1450);`
		6069	`ZR1228 (ZI1450, &ZI1449);`
		6070	`ZR1224 (ZI1449, &ZI1448);`
		6071	`ZR1220 (ZI1448, &ZI1447);`
		6072	`ZR1216 (ZI1447, &ZI1446);`
		6073	`ZR1212 (ZI1446, &ZI1445);`
		6074	`ZR1208 (ZI1445, &ZI1444);`
		6075	`ZR1204 (ZI1444, &ZI1443);`
		6076	`ZR1200 (ZI1443, &ZI1442);`
		6077	`ZR1196 (ZI1442, &ZI1441);`
		6078	`ZR1192 (ZI1441, &ZI1263);`
		6079	`ZR1264 (&ZI1263, &ZI1287);`
		6080	`ZR1289 (&ZI1287, &ZI1505);`
		6081	`if ((CURRENT_TERMINAL) == 354) {`
		6082	`RESTORE_LEXER;`
		6083	`goto ZL1;`
		6084	`}`
		6085	`{`
		6086
		6087	`(ZI670) = unreached_code ;`
		6088	`if ( (ZI670) ) {`
		6089	`if ( !unreached_last ) {`
		6090	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		6091	`unreached_last = 1 ;`
		6092	`}`
		6093	`} else {`
		6094	`unreached_last = 0 ;`
		6095	`}`
		6096	`}`
		6097	`{`
		6098
		6099	`(ZI493) = make_exp_stmt ( (ZI1505) ) ;`
		6100	`}`
		6101	`{`
		6102
		6103	`unreached_fall = 1 ;`
		6104	`}`
		6105	`switch (CURRENT_TERMINAL) {`
		6106	`case 77:`
		6107	`break;`
		6108	`default:`
		6109	`goto ZL1;`
		6110	`}`
		6111	`ADVANCE_LEXER;`
		6112	`{`
		6113
		6114	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6115	`}`
		6116	`ZI558 = ZI456;`
		6117	`goto ZL2_676;`
		6118	`}`
		6119	`/UNREACHED/`
		6120	`case 7:`
		6121	`{`
		6122	`IDENTIFIER ZI460;`
		6123	`IDENTIFIER ZI419;`
		6124	`TYPE ZI1265;`
		6125	`BASE_TYPE ZI511;`
		6126	`CV_SPEC ZI783;`
		6127	`TYPE ZI414;`
		6128	`SID_LIST_EXP ZI497;`
		6129	`EXP ZI1281;`
		6130	`EXP ZI1452;`
		6131	`EXP ZI1451;`
		6132	`EXP ZI1450;`
		6133	`EXP ZI1449;`
		6134	`EXP ZI1448;`
		6135	`EXP ZI1447;`
		6136	`EXP ZI1446;`
		6137	`EXP ZI1445;`
		6138	`EXP ZI1444;`
		6139	`EXP ZI1443;`
		6140	`EXP ZI1442;`
		6141	`EXP ZI1441;`
		6142	`EXP ZI1263;`
		6143	`EXP ZI1287;`
		6144	`EXP ZI1506;`
		6145	`int ZI670;`
		6146	`EXP ZI493;`
		6147	`EXP ZI456;`
		6148
		6149	`{`
		6150
		6151	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		6152	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		6153	`ZI460 = parse_type_template ( id, args, 0 ) ;`
		6154	`crt_templ_qualifier = 1 ;`
		6155	`RESCAN_LEXER ;`
		6156	`}`
		6157	`ADVANCE_LEXER;`
		6158	`{`
		6159
		6160	`(ZI419) = (ZI460) ;`
		6161	`crt_id_qualifier = qual_none ;`
		6162	`last_namespace = crt_namespace ;`
		6163	`}`
		6164	`{`
		6165
		6166	`MAKE_type_pre ( cv_none, btype_alias, crt_id_qualifier, (ZI1265) ) ;`
		6167	`COPY_id ( type_name ( (ZI1265) ), (ZI419) ) ;`
		6168	`have_type_specifier = 1 ;`
		6169	`}`
		6170	`{`
		6171	`(ZI511) = btype_none ;`
		6172	`}`
		6173	`{`
		6174	`(ZI783) = cv_none ;`
		6175	`}`
		6176	`{`
		6177
		6178	`(ZI414) = complete_pre_type ( (ZI511), (ZI1265), (ZI783), 1 ) ;`
		6179	`have_type_specifier = 0 ;`
		6180	`}`
		6181	`switch (CURRENT_TERMINAL) {`
		6182	`case 65:`
		6183	`break;`
		6184	`default:`
		6185	`goto ZL1;`
		6186	`}`
		6187	`ADVANCE_LEXER;`
		6188	`ZR500 (&ZI497);`
		6189	`switch (CURRENT_TERMINAL) {`
		6190	`case 39:`
		6191	`break;`
		6192	`case 354:`
		6193	`RESTORE_LEXER;`
		6194	`goto ZL1;`
		6195	`default:`
		6196	`goto ZL1;`
		6197	`}`
		6198	`ADVANCE_LEXER;`
		6199	`{`
		6200
		6201	`(ZI1281) = make_func_cast_exp ( (ZI414), (ZI497) ) ;`
		6202	`}`
		6203	`ZR1240 (ZI1281, &ZI1452);`
		6204	`ZR1236 (ZI1452, &ZI1451);`
		6205	`ZR1232 (ZI1451, &ZI1450);`
		6206	`ZR1228 (ZI1450, &ZI1449);`
		6207	`ZR1224 (ZI1449, &ZI1448);`
		6208	`ZR1220 (ZI1448, &ZI1447);`
		6209	`ZR1216 (ZI1447, &ZI1446);`
		6210	`ZR1212 (ZI1446, &ZI1445);`
		6211	`ZR1208 (ZI1445, &ZI1444);`
		6212	`ZR1204 (ZI1444, &ZI1443);`
		6213	`ZR1200 (ZI1443, &ZI1442);`
		6214	`ZR1196 (ZI1442, &ZI1441);`
		6215	`ZR1192 (ZI1441, &ZI1263);`
		6216	`ZR1264 (&ZI1263, &ZI1287);`
		6217	`ZR1289 (&ZI1287, &ZI1506);`
		6218	`if ((CURRENT_TERMINAL) == 354) {`
		6219	`RESTORE_LEXER;`
		6220	`goto ZL1;`
		6221	`}`
		6222	`{`
		6223
		6224	`(ZI670) = unreached_code ;`
		6225	`if ( (ZI670) ) {`
		6226	`if ( !unreached_last ) {`
		6227	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		6228	`unreached_last = 1 ;`
		6229	`}`
		6230	`} else {`
		6231	`unreached_last = 0 ;`
		6232	`}`
		6233	`}`
		6234	`{`
		6235
		6236	`(ZI493) = make_exp_stmt ( (ZI1506) ) ;`
		6237	`}`
		6238	`{`
		6239
		6240	`unreached_fall = 1 ;`
		6241	`}`
		6242	`switch (CURRENT_TERMINAL) {`
		6243	`case 77:`
		6244	`break;`
		6245	`default:`
		6246	`goto ZL1;`
		6247	`}`
		6248	`ADVANCE_LEXER;`
		6249	`{`
		6250
		6251	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6252	`}`
		6253	`ZI558 = ZI456;`
		6254	`goto ZL2_676;`
		6255	`}`
		6256	`/UNREACHED/`
		6257	`case 148:`
		6258	`{`
		6259	`EXP ZI1276;`
		6260	`EXP ZI1452;`
		6261	`EXP ZI1451;`
		6262	`EXP ZI1450;`
		6263	`EXP ZI1449;`
		6264	`EXP ZI1448;`
		6265	`EXP ZI1447;`
		6266	`EXP ZI1446;`
		6267	`EXP ZI1445;`
		6268	`EXP ZI1444;`
		6269	`EXP ZI1443;`
		6270	`EXP ZI1442;`
		6271	`EXP ZI1441;`
		6272	`EXP ZI1263;`
		6273	`EXP ZI1287;`
		6274	`EXP ZI1496;`
		6275	`int ZI670;`
		6276	`EXP ZI493;`
		6277	`EXP ZI456;`
		6278
		6279	`ADVANCE_LEXER;`
		6280	`{`
		6281
		6282	`(ZI1276) = make_this_exp () ;`
		6283	`}`
		6284	`ZR1240 (ZI1276, &ZI1452);`
		6285	`ZR1236 (ZI1452, &ZI1451);`
		6286	`ZR1232 (ZI1451, &ZI1450);`
		6287	`ZR1228 (ZI1450, &ZI1449);`
		6288	`ZR1224 (ZI1449, &ZI1448);`
		6289	`ZR1220 (ZI1448, &ZI1447);`
		6290	`ZR1216 (ZI1447, &ZI1446);`
		6291	`ZR1212 (ZI1446, &ZI1445);`
		6292	`ZR1208 (ZI1445, &ZI1444);`
		6293	`ZR1204 (ZI1444, &ZI1443);`
		6294	`ZR1200 (ZI1443, &ZI1442);`
		6295	`ZR1196 (ZI1442, &ZI1441);`
		6296	`ZR1192 (ZI1441, &ZI1263);`
		6297	`ZR1264 (&ZI1263, &ZI1287);`
		6298	`ZR1289 (&ZI1287, &ZI1496);`
		6299	`if ((CURRENT_TERMINAL) == 354) {`
		6300	`RESTORE_LEXER;`
		6301	`goto ZL1;`
		6302	`}`
		6303	`{`
		6304
		6305	`(ZI670) = unreached_code ;`
		6306	`if ( (ZI670) ) {`
		6307	`if ( !unreached_last ) {`
		6308	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		6309	`unreached_last = 1 ;`
		6310	`}`
		6311	`} else {`
		6312	`unreached_last = 0 ;`
		6313	`}`
		6314	`}`
		6315	`{`
		6316
		6317	`(ZI493) = make_exp_stmt ( (ZI1496) ) ;`
		6318	`}`
		6319	`{`
		6320
		6321	`unreached_fall = 1 ;`
		6322	`}`
		6323	`switch (CURRENT_TERMINAL) {`
		6324	`case 77:`
		6325	`break;`
		6326	`default:`
		6327	`goto ZL1;`
		6328	`}`
		6329	`ADVANCE_LEXER;`
		6330	`{`
		6331
		6332	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6333	`}`
		6334	`ZI558 = ZI456;`
		6335	`goto ZL2_676;`
		6336	`}`
		6337	`/UNREACHED/`
		6338	`case 2:`
		6339	`{`
		6340	`IDENTIFIER ZI1466;`
		6341	`EXP ZI493;`
		6342	`EXP ZI456;`
		6343
		6344	`{`
		6345
		6346	`ZI1466 = crt_token->pp_data.id.use ;`
		6347	`}`
		6348	`ADVANCE_LEXER;`
		6349	`ZR1467 (&ZI1466, &ZI493);`
		6350	`if ((CURRENT_TERMINAL) == 354) {`
		6351	`RESTORE_LEXER;`
		6352	`goto ZL1;`
		6353	`}`
		6354	`{`
		6355
		6356	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6357	`}`
		6358	`ZI558 = ZI456;`
		6359	`goto ZL2_676;`
		6360	`}`
		6361	`/UNREACHED/`
		6362	`case 152:`
		6363	`{`
		6364	`int ZI450;`
		6365	`EXP ZI1270;`
		6366	`EXP ZI1452;`
		6367	`EXP ZI1451;`
		6368	`EXP ZI1450;`
		6369	`EXP ZI1449;`
		6370	`EXP ZI1448;`
		6371	`EXP ZI1447;`
		6372	`EXP ZI1446;`
		6373	`EXP ZI1445;`
		6374	`EXP ZI1444;`
		6375	`EXP ZI1443;`
		6376	`EXP ZI1442;`
		6377	`EXP ZI1441;`
		6378	`EXP ZI1263;`
		6379	`EXP ZI1287;`
		6380	`EXP ZI1490;`
		6381	`int ZI670;`
		6382	`EXP ZI493;`
		6383	`EXP ZI456;`
		6384
		6385	`ADVANCE_LEXER;`
		6386	`{`
		6387	`(ZI450) = lex_typeid ;`
		6388	`}`
		6389	`ZR553 (ZI450, &ZI1270);`
		6390	`ZR1240 (ZI1270, &ZI1452);`
		6391	`ZR1236 (ZI1452, &ZI1451);`
		6392	`ZR1232 (ZI1451, &ZI1450);`
		6393	`ZR1228 (ZI1450, &ZI1449);`
		6394	`ZR1224 (ZI1449, &ZI1448);`
		6395	`ZR1220 (ZI1448, &ZI1447);`
		6396	`ZR1216 (ZI1447, &ZI1446);`
		6397	`ZR1212 (ZI1446, &ZI1445);`
		6398	`ZR1208 (ZI1445, &ZI1444);`
		6399	`ZR1204 (ZI1444, &ZI1443);`
		6400	`ZR1200 (ZI1443, &ZI1442);`
		6401	`ZR1196 (ZI1442, &ZI1441);`
		6402	`ZR1192 (ZI1441, &ZI1263);`
		6403	`ZR1264 (&ZI1263, &ZI1287);`
		6404	`ZR1289 (&ZI1287, &ZI1490);`
		6405	`if ((CURRENT_TERMINAL) == 354) {`
		6406	`RESTORE_LEXER;`
		6407	`goto ZL1;`
		6408	`}`
		6409	`{`
		6410
		6411	`(ZI670) = unreached_code ;`
		6412	`if ( (ZI670) ) {`
		6413	`if ( !unreached_last ) {`
		6414	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		6415	`unreached_last = 1 ;`
		6416	`}`
		6417	`} else {`
		6418	`unreached_last = 0 ;`
		6419	`}`
		6420	`}`
		6421	`{`
		6422
		6423	`(ZI493) = make_exp_stmt ( (ZI1490) ) ;`
		6424	`}`
		6425	`{`
		6426
		6427	`unreached_fall = 1 ;`
		6428	`}`
		6429	`switch (CURRENT_TERMINAL) {`
		6430	`case 77:`
		6431	`break;`
		6432	`default:`
		6433	`goto ZL1;`
		6434	`}`
		6435	`ADVANCE_LEXER;`
		6436	`{`
		6437
		6438	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6439	`}`
		6440	`ZI558 = ZI456;`
		6441	`goto ZL2_676;`
		6442	`}`
		6443	`/UNREACHED/`
		6444	`case 329:`
		6445	`{`
		6446	`int ZI450;`
		6447	`EXP ZI1269;`
		6448	`EXP ZI1452;`
		6449	`EXP ZI1451;`
		6450	`EXP ZI1450;`
		6451	`EXP ZI1449;`
		6452	`EXP ZI1448;`
		6453	`EXP ZI1447;`
		6454	`EXP ZI1446;`
		6455	`EXP ZI1445;`
		6456	`EXP ZI1444;`
		6457	`EXP ZI1443;`
		6458	`EXP ZI1442;`
		6459	`EXP ZI1441;`
		6460	`EXP ZI1263;`
		6461	`EXP ZI1287;`
		6462	`EXP ZI1489;`
		6463	`int ZI670;`
		6464	`EXP ZI493;`
		6465	`EXP ZI456;`
		6466
		6467	`ADVANCE_LEXER;`
		6468	`{`
		6469	`(ZI450) = lex_vtable ;`
		6470	`}`
		6471	`ZR553 (ZI450, &ZI1269);`
		6472	`ZR1240 (ZI1269, &ZI1452);`
		6473	`ZR1236 (ZI1452, &ZI1451);`
		6474	`ZR1232 (ZI1451, &ZI1450);`
		6475	`ZR1228 (ZI1450, &ZI1449);`
		6476	`ZR1224 (ZI1449, &ZI1448);`
		6477	`ZR1220 (ZI1448, &ZI1447);`
		6478	`ZR1216 (ZI1447, &ZI1446);`
		6479	`ZR1212 (ZI1446, &ZI1445);`
		6480	`ZR1208 (ZI1445, &ZI1444);`
		6481	`ZR1204 (ZI1444, &ZI1443);`
		6482	`ZR1200 (ZI1443, &ZI1442);`
		6483	`ZR1196 (ZI1442, &ZI1441);`
		6484	`ZR1192 (ZI1441, &ZI1263);`
		6485	`ZR1264 (&ZI1263, &ZI1287);`
		6486	`ZR1289 (&ZI1287, &ZI1489);`
		6487	`if ((CURRENT_TERMINAL) == 354) {`
		6488	`RESTORE_LEXER;`
		6489	`goto ZL1;`
		6490	`}`
		6491	`{`
		6492
		6493	`(ZI670) = unreached_code ;`
		6494	`if ( (ZI670) ) {`
		6495	`if ( !unreached_last ) {`
		6496	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		6497	`unreached_last = 1 ;`
		6498	`}`
		6499	`} else {`
		6500	`unreached_last = 0 ;`
		6501	`}`
		6502	`}`
		6503	`{`
		6504
		6505	`(ZI493) = make_exp_stmt ( (ZI1489) ) ;`
		6506	`}`
		6507	`{`
		6508
		6509	`unreached_fall = 1 ;`
		6510	`}`
		6511	`switch (CURRENT_TERMINAL) {`
		6512	`case 77:`
		6513	`break;`
		6514	`default:`
		6515	`goto ZL1;`
		6516	`}`
		6517	`ADVANCE_LEXER;`
		6518	`{`
		6519
		6520	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6521	`}`
		6522	`ZI558 = ZI456;`
		6523	`goto ZL2_676;`
		6524	`}`
		6525	`/UNREACHED/`
		6526	`case 33:`
		6527	`{`
		6528	`EXP ZI1457;`
		6529	`EXP ZI1452;`
		6530	`EXP ZI1451;`
		6531	`EXP ZI1450;`
		6532	`EXP ZI1449;`
		6533	`EXP ZI1448;`
		6534	`EXP ZI1447;`
		6535	`EXP ZI1446;`
		6536	`EXP ZI1445;`
		6537	`EXP ZI1444;`
		6538	`EXP ZI1443;`
		6539	`EXP ZI1442;`
		6540	`EXP ZI1441;`
		6541	`EXP ZI1263;`
		6542	`EXP ZI1287;`
		6543	`EXP ZI1484;`
		6544	`int ZI670;`
		6545	`EXP ZI493;`
		6546	`EXP ZI456;`
		6547
		6548	`{`
		6549	`{`
		6550	`switch (CURRENT_TERMINAL) {`
		6551	`case 33:`
		6552	`break;`
		6553	`default:`
		6554	`goto ZL1;`
		6555	`}`
		6556	`ADVANCE_LEXER;`
		6557	`}`
		6558	`}`
		6559	`ZR581 (&ZI1457);`
		6560	`if ((CURRENT_TERMINAL) == 354) {`
		6561	`RESTORE_LEXER;`
		6562	`goto ZL1;`
		6563	`}`
		6564	`{`
		6565
		6566	`(ZI1452) = make_ref_exp ( (ZI1457), 0 ) ;`
		6567	`}`
		6568	`ZR1236 (ZI1452, &ZI1451);`
		6569	`ZR1232 (ZI1451, &ZI1450);`
		6570	`ZR1228 (ZI1450, &ZI1449);`
		6571	`ZR1224 (ZI1449, &ZI1448);`
		6572	`ZR1220 (ZI1448, &ZI1447);`
		6573	`ZR1216 (ZI1447, &ZI1446);`
		6574	`ZR1212 (ZI1446, &ZI1445);`
		6575	`ZR1208 (ZI1445, &ZI1444);`
		6576	`ZR1204 (ZI1444, &ZI1443);`
		6577	`ZR1200 (ZI1443, &ZI1442);`
		6578	`ZR1196 (ZI1442, &ZI1441);`
		6579	`ZR1192 (ZI1441, &ZI1263);`
		6580	`ZR1264 (&ZI1263, &ZI1287);`
		6581	`ZR1289 (&ZI1287, &ZI1484);`
		6582	`if ((CURRENT_TERMINAL) == 354) {`
		6583	`RESTORE_LEXER;`
		6584	`goto ZL1;`
		6585	`}`
		6586	`{`
		6587
		6588	`(ZI670) = unreached_code ;`
		6589	`if ( (ZI670) ) {`
		6590	`if ( !unreached_last ) {`
		6591	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		6592	`unreached_last = 1 ;`
		6593	`}`
		6594	`} else {`
		6595	`unreached_last = 0 ;`
		6596	`}`
		6597	`}`
		6598	`{`
		6599
		6600	`(ZI493) = make_exp_stmt ( (ZI1484) ) ;`
		6601	`}`
		6602	`{`
		6603
		6604	`unreached_fall = 1 ;`
		6605	`}`
		6606	`switch (CURRENT_TERMINAL) {`
		6607	`case 77:`
		6608	`break;`
		6609	`default:`
		6610	`goto ZL1;`
		6611	`}`
		6612	`ADVANCE_LEXER;`
		6613	`{`
		6614
		6615	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6616	`}`
		6617	`ZI558 = ZI456;`
		6618	`goto ZL2_676;`
		6619	`}`
		6620	`/UNREACHED/`
		6621	`case 97: case 102: case 106: case 110: case 111:`
		6622	`case 114: case 115: case 122: case 123: case 127:`
		6623	`case 156: case 184: case 285: case 298:`
		6624	`{`
		6625	`BASE_TYPE ZI511;`
		6626	`TYPE ZI1265;`
		6627	`CV_SPEC ZI783;`
		6628	`TYPE ZI414;`
		6629	`SID_LIST_EXP ZI497;`
		6630	`EXP ZI1280;`
		6631	`EXP ZI1452;`
		6632	`EXP ZI1451;`
		6633	`EXP ZI1450;`
		6634	`EXP ZI1449;`
		6635	`EXP ZI1448;`
		6636	`EXP ZI1447;`
		6637	`EXP ZI1446;`
		6638	`EXP ZI1445;`
		6639	`EXP ZI1444;`
		6640	`EXP ZI1443;`
		6641	`EXP ZI1442;`
		6642	`EXP ZI1441;`
		6643	`EXP ZI1263;`
		6644	`EXP ZI1287;`
		6645	`EXP ZI1499;`
		6646	`int ZI670;`
		6647	`EXP ZI493;`
		6648	`EXP ZI456;`
		6649
		6650	`ZR509 (&ZI511);`
		6651	`if ((CURRENT_TERMINAL) == 354) {`
		6652	`RESTORE_LEXER;`
		6653	`goto ZL1;`
		6654	`}`
		6655	`{`
		6656
		6657	`(ZI1265) = NULL_type ;`
		6658	`have_type_specifier = 1 ;`
		6659	`}`
		6660	`{`
		6661	`(ZI783) = cv_none ;`
		6662	`}`
		6663	`{`
		6664
		6665	`(ZI414) = complete_pre_type ( (ZI511), (ZI1265), (ZI783), 1 ) ;`
		6666	`have_type_specifier = 0 ;`
		6667	`}`
		6668	`switch (CURRENT_TERMINAL) {`
		6669	`case 65:`
		6670	`break;`
		6671	`default:`
		6672	`goto ZL1;`
		6673	`}`
		6674	`ADVANCE_LEXER;`
		6675	`ZR500 (&ZI497);`
		6676	`switch (CURRENT_TERMINAL) {`
		6677	`case 39:`
		6678	`break;`
		6679	`case 354:`
		6680	`RESTORE_LEXER;`
		6681	`goto ZL1;`
		6682	`default:`
		6683	`goto ZL1;`
		6684	`}`
		6685	`ADVANCE_LEXER;`
		6686	`{`
		6687
		6688	`(ZI1280) = make_func_cast_exp ( (ZI414), (ZI497) ) ;`
		6689	`}`
		6690	`ZR1240 (ZI1280, &ZI1452);`
		6691	`ZR1236 (ZI1452, &ZI1451);`
		6692	`ZR1232 (ZI1451, &ZI1450);`
		6693	`ZR1228 (ZI1450, &ZI1449);`
		6694	`ZR1224 (ZI1449, &ZI1448);`
		6695	`ZR1220 (ZI1448, &ZI1447);`
		6696	`ZR1216 (ZI1447, &ZI1446);`
		6697	`ZR1212 (ZI1446, &ZI1445);`
		6698	`ZR1208 (ZI1445, &ZI1444);`
		6699	`ZR1204 (ZI1444, &ZI1443);`
		6700	`ZR1200 (ZI1443, &ZI1442);`
		6701	`ZR1196 (ZI1442, &ZI1441);`
		6702	`ZR1192 (ZI1441, &ZI1263);`
		6703	`ZR1264 (&ZI1263, &ZI1287);`
		6704	`ZR1289 (&ZI1287, &ZI1499);`
		6705	`if ((CURRENT_TERMINAL) == 354) {`
		6706	`RESTORE_LEXER;`
		6707	`goto ZL1;`
		6708	`}`
		6709	`{`
		6710
		6711	`(ZI670) = unreached_code ;`
		6712	`if ( (ZI670) ) {`
		6713	`if ( !unreached_last ) {`
		6714	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		6715	`unreached_last = 1 ;`
		6716	`}`
		6717	`} else {`
		6718	`unreached_last = 0 ;`
		6719	`}`
		6720	`}`
		6721	`{`
		6722
		6723	`(ZI493) = make_exp_stmt ( (ZI1499) ) ;`
		6724	`}`
		6725	`{`
		6726
		6727	`unreached_fall = 1 ;`
		6728	`}`
		6729	`switch (CURRENT_TERMINAL) {`
		6730	`case 77:`
		6731	`break;`
		6732	`default:`
		6733	`goto ZL1;`
		6734	`}`
		6735	`ADVANCE_LEXER;`
		6736	`{`
		6737
		6738	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6739	`}`
		6740	`ZI558 = ZI456;`
		6741	`goto ZL2_676;`
		6742	`}`
		6743	`/UNREACHED/`
		6744	`case 64:`
		6745	`{`
		6746	`EXP ZI493;`
		6747	`EXP ZI456;`
		6748
		6749	`ZR678 (&ZI493);`
		6750	`if ((CURRENT_TERMINAL) == 354) {`
		6751	`RESTORE_LEXER;`
		6752	`goto ZL1;`
		6753	`}`
		6754	`{`
		6755
		6756	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6757	`}`
		6758	`ZI558 = ZI456;`
		6759	`goto ZL2_676;`
		6760	`}`
		6761	`/UNREACHED/`
		6762	`case 288: case 322:`
		6763	`{`
		6764	`EXP ZI493;`
		6765	`EXP ZI456;`
		6766
		6767	`ZR776 (&ZI493);`
		6768	`if ((CURRENT_TERMINAL) == 354) {`
		6769	`RESTORE_LEXER;`
		6770	`goto ZL1;`
		6771	`}`
		6772	`{`
		6773
		6774	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6775	`}`
		6776	`ZI558 = ZI456;`
		6777	`goto ZL2_676;`
		6778	`}`
		6779	`/UNREACHED/`
		6780	`case 96: case 100: case 222:`
		6781	`{`
		6782	`EXP ZI493;`
		6783	`EXP ZI456;`
		6784
		6785	`ZR662 ();`
		6786	`ZR1440 (&ZI493);`
		6787	`if ((CURRENT_TERMINAL) == 354) {`
		6788	`RESTORE_LEXER;`
		6789	`goto ZL1;`
		6790	`}`
		6791	`{`
		6792
		6793	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6794	`}`
		6795	`ZI558 = ZI456;`
		6796	`goto ZL2_676;`
		6797	`}`
		6798	`/UNREACHED/`
		6799	`case 297: case 323:`
		6800	`{`
		6801	`EXP ZI1434;`
		6802	`EXP ZI1475;`
		6803	`int ZI670;`
		6804	`EXP ZI493;`
		6805	`EXP ZI456;`
		6806
		6807	`ZR643 (&ZI1434);`
		6808	`ZR1436 (&ZI1434, &ZI1475);`
		6809	`if ((CURRENT_TERMINAL) == 354) {`
		6810	`RESTORE_LEXER;`
		6811	`goto ZL1;`
		6812	`}`
		6813	`{`
		6814
		6815	`(ZI670) = unreached_code ;`
		6816	`if ( (ZI670) ) {`
		6817	`if ( !unreached_last ) {`
		6818	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		6819	`unreached_last = 1 ;`
		6820	`}`
		6821	`} else {`
		6822	`unreached_last = 0 ;`
		6823	`}`
		6824	`}`
		6825	`{`
		6826
		6827	`(ZI493) = make_exp_stmt ( (ZI1475) ) ;`
		6828	`}`
		6829	`{`
		6830
		6831	`unreached_fall = 1 ;`
		6832	`}`
		6833	`switch (CURRENT_TERMINAL) {`
		6834	`case 77:`
		6835	`break;`
		6836	`default:`
		6837	`goto ZL1;`
		6838	`}`
		6839	`ADVANCE_LEXER;`
		6840	`{`
		6841
		6842	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6843	`}`
		6844	`ZI558 = ZI456;`
		6845	`goto ZL2_676;`
		6846	`}`
		6847	`/UNREACHED/`
		6848	`case 101: case 107: case 125:`
		6849	`{`
		6850	`EXP ZI493;`
		6851	`EXP ZI456;`
		6852
		6853	`ZR738 (&ZI493);`
		6854	`if ((CURRENT_TERMINAL) == 354) {`
		6855	`RESTORE_LEXER;`
		6856	`goto ZL1;`
		6857	`}`
		6858	`{`
		6859
		6860	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6861	`}`
		6862	`ZI558 = ZI456;`
		6863	`goto ZL2_676;`
		6864	`}`
		6865	`/UNREACHED/`
		6866	`case 95: case 99: case 108: case 113:`
		6867	`{`
		6868	`EXP ZI493;`
		6869	`EXP ZI456;`
		6870
		6871	`ZR752 (&ZI493);`
		6872	`if ((CURRENT_TERMINAL) == 354) {`
		6873	`RESTORE_LEXER;`
		6874	`goto ZL1;`
		6875	`}`
		6876	`{`
		6877
		6878	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6879	`}`
		6880	`ZI558 = ZI456;`
		6881	`goto ZL2_676;`
		6882	`}`
		6883	`/UNREACHED/`
		6884	`case 17: case 18: case 19: case 20: case 21:`
		6885	`case 22: case 135: case 150:`
		6886	`{`
		6887	`EXP ZI1275;`
		6888	`EXP ZI1452;`
		6889	`EXP ZI1451;`
		6890	`EXP ZI1450;`
		6891	`EXP ZI1449;`
		6892	`EXP ZI1448;`
		6893	`EXP ZI1447;`
		6894	`EXP ZI1446;`
		6895	`EXP ZI1445;`
		6896	`EXP ZI1444;`
		6897	`EXP ZI1443;`
		6898	`EXP ZI1442;`
		6899	`EXP ZI1441;`
		6900	`EXP ZI1263;`
		6901	`EXP ZI1287;`
		6902	`EXP ZI1495;`
		6903	`int ZI670;`
		6904	`EXP ZI493;`
		6905	`EXP ZI456;`
		6906
		6907	`ZR437 (&ZI1275);`
		6908	`ZR1240 (ZI1275, &ZI1452);`
		6909	`ZR1236 (ZI1452, &ZI1451);`
		6910	`ZR1232 (ZI1451, &ZI1450);`
		6911	`ZR1228 (ZI1450, &ZI1449);`
		6912	`ZR1224 (ZI1449, &ZI1448);`
		6913	`ZR1220 (ZI1448, &ZI1447);`
		6914	`ZR1216 (ZI1447, &ZI1446);`
		6915	`ZR1212 (ZI1446, &ZI1445);`
		6916	`ZR1208 (ZI1445, &ZI1444);`
		6917	`ZR1204 (ZI1444, &ZI1443);`
		6918	`ZR1200 (ZI1443, &ZI1442);`
		6919	`ZR1196 (ZI1442, &ZI1441);`
		6920	`ZR1192 (ZI1441, &ZI1263);`
		6921	`ZR1264 (&ZI1263, &ZI1287);`
		6922	`ZR1289 (&ZI1287, &ZI1495);`
		6923	`if ((CURRENT_TERMINAL) == 354) {`
		6924	`RESTORE_LEXER;`
		6925	`goto ZL1;`
		6926	`}`
		6927	`{`
		6928
		6929	`(ZI670) = unreached_code ;`
		6930	`if ( (ZI670) ) {`
		6931	`if ( !unreached_last ) {`
		6932	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		6933	`unreached_last = 1 ;`
		6934	`}`
		6935	`} else {`
		6936	`unreached_last = 0 ;`
		6937	`}`
		6938	`}`
		6939	`{`
		6940
		6941	`(ZI493) = make_exp_stmt ( (ZI1495) ) ;`
		6942	`}`
		6943	`{`
		6944
		6945	`unreached_fall = 1 ;`
		6946	`}`
		6947	`switch (CURRENT_TERMINAL) {`
		6948	`case 77:`
		6949	`break;`
		6950	`default:`
		6951	`goto ZL1;`
		6952	`}`
		6953	`ADVANCE_LEXER;`
		6954	`{`
		6955
		6956	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		6957	`}`
		6958	`ZI558 = ZI456;`
		6959	`goto ZL2_676;`
		6960	`}`
		6961	`/UNREACHED/`
		6962	`case 62:`
		6963	`{`
		6964	`EXP ZI1458;`
		6965	`EXP ZI1452;`
		6966	`EXP ZI1451;`
		6967	`EXP ZI1450;`
		6968	`EXP ZI1449;`
		6969	`EXP ZI1448;`
		6970	`EXP ZI1447;`
		6971	`EXP ZI1446;`
		6972	`EXP ZI1445;`
		6973	`EXP ZI1444;`
		6974	`EXP ZI1443;`
		6975	`EXP ZI1442;`
		6976	`EXP ZI1441;`
		6977	`EXP ZI1263;`
		6978	`EXP ZI1287;`
		6979	`EXP ZI1485;`
		6980	`int ZI670;`
		6981	`EXP ZI493;`
		6982	`EXP ZI456;`
		6983
		6984	`{`
		6985	`{`
		6986	`switch (CURRENT_TERMINAL) {`
		6987	`case 62:`
		6988	`break;`
		6989	`default:`
		6990	`goto ZL1;`
		6991	`}`
		6992	`ADVANCE_LEXER;`
		6993	`}`
		6994	`}`
		6995	`ZR581 (&ZI1458);`
		6996	`if ((CURRENT_TERMINAL) == 354) {`
		6997	`RESTORE_LEXER;`
		6998	`goto ZL1;`
		6999	`}`
		7000	`{`
		7001
		7002	`(ZI1452) = make_not_exp ( (ZI1458) ) ;`
		7003	`}`
		7004	`ZR1236 (ZI1452, &ZI1451);`
		7005	`ZR1232 (ZI1451, &ZI1450);`
		7006	`ZR1228 (ZI1450, &ZI1449);`
		7007	`ZR1224 (ZI1449, &ZI1448);`
		7008	`ZR1220 (ZI1448, &ZI1447);`
		7009	`ZR1216 (ZI1447, &ZI1446);`
		7010	`ZR1212 (ZI1446, &ZI1445);`
		7011	`ZR1208 (ZI1445, &ZI1444);`
		7012	`ZR1204 (ZI1444, &ZI1443);`
		7013	`ZR1200 (ZI1443, &ZI1442);`
		7014	`ZR1196 (ZI1442, &ZI1441);`
		7015	`ZR1192 (ZI1441, &ZI1263);`
		7016	`ZR1264 (&ZI1263, &ZI1287);`
		7017	`ZR1289 (&ZI1287, &ZI1485);`
		7018	`if ((CURRENT_TERMINAL) == 354) {`
		7019	`RESTORE_LEXER;`
		7020	`goto ZL1;`
		7021	`}`
		7022	`{`
		7023
		7024	`(ZI670) = unreached_code ;`
		7025	`if ( (ZI670) ) {`
		7026	`if ( !unreached_last ) {`
		7027	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		7028	`unreached_last = 1 ;`
		7029	`}`
		7030	`} else {`
		7031	`unreached_last = 0 ;`
		7032	`}`
		7033	`}`
		7034	`{`
		7035
		7036	`(ZI493) = make_exp_stmt ( (ZI1485) ) ;`
		7037	`}`
		7038	`{`
		7039
		7040	`unreached_fall = 1 ;`
		7041	`}`
		7042	`switch (CURRENT_TERMINAL) {`
		7043	`case 77:`
		7044	`break;`
		7045	`default:`
		7046	`goto ZL1;`
		7047	`}`
		7048	`ADVANCE_LEXER;`
		7049	`{`
		7050
		7051	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		7052	`}`
		7053	`ZI558 = ZI456;`
		7054	`goto ZL2_676;`
		7055	`}`
		7056	`/UNREACHED/`
		7057	`case 141:`
		7058	`{`
		7059	`IDENTIFIER ZI478;`
		7060	`IDENTIFIER ZI419;`
		7061	`EXP ZI1283;`
		7062	`EXP ZI1452;`
		7063	`EXP ZI1451;`
		7064	`EXP ZI1450;`
		7065	`EXP ZI1449;`
		7066	`EXP ZI1448;`
		7067	`EXP ZI1447;`
		7068	`EXP ZI1446;`
		7069	`EXP ZI1445;`
		7070	`EXP ZI1444;`
		7071	`EXP ZI1443;`
		7072	`EXP ZI1442;`
		7073	`EXP ZI1441;`
		7074	`EXP ZI1263;`
		7075	`EXP ZI1287;`
		7076	`EXP ZI1503;`
		7077	`int ZI670;`
		7078	`EXP ZI493;`
		7079	`EXP ZI456;`
		7080
		7081	`parse_operator (&ZI478);`
		7082	`if ((CURRENT_TERMINAL) == 354) {`
		7083	`RESTORE_LEXER;`
		7084	`goto ZL1;`
		7085	`}`
		7086	`{`
		7087
		7088	`(ZI419) = check_id ( NULL_nspace, (ZI478), 0 ) ;`
		7089	`crt_id_qualifier = qual_none ;`
		7090	`last_namespace = crt_namespace ;`
		7091	`}`
		7092	`{`
		7093
		7094	`(ZI1283) = make_id_exp ( (ZI419) ) ;`
		7095	`}`
		7096	`ZR1240 (ZI1283, &ZI1452);`
		7097	`ZR1236 (ZI1452, &ZI1451);`
		7098	`ZR1232 (ZI1451, &ZI1450);`
		7099	`ZR1228 (ZI1450, &ZI1449);`
		7100	`ZR1224 (ZI1449, &ZI1448);`
		7101	`ZR1220 (ZI1448, &ZI1447);`
		7102	`ZR1216 (ZI1447, &ZI1446);`
		7103	`ZR1212 (ZI1446, &ZI1445);`
		7104	`ZR1208 (ZI1445, &ZI1444);`
		7105	`ZR1204 (ZI1444, &ZI1443);`
		7106	`ZR1200 (ZI1443, &ZI1442);`
		7107	`ZR1196 (ZI1442, &ZI1441);`
		7108	`ZR1192 (ZI1441, &ZI1263);`
		7109	`ZR1264 (&ZI1263, &ZI1287);`
		7110	`ZR1289 (&ZI1287, &ZI1503);`
		7111	`if ((CURRENT_TERMINAL) == 354) {`
		7112	`RESTORE_LEXER;`
		7113	`goto ZL1;`
		7114	`}`
		7115	`{`
		7116
		7117	`(ZI670) = unreached_code ;`
		7118	`if ( (ZI670) ) {`
		7119	`if ( !unreached_last ) {`
		7120	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		7121	`unreached_last = 1 ;`
		7122	`}`
		7123	`} else {`
		7124	`unreached_last = 0 ;`
		7125	`}`
		7126	`}`
		7127	`{`
		7128
		7129	`(ZI493) = make_exp_stmt ( (ZI1503) ) ;`
		7130	`}`
		7131	`{`
		7132
		7133	`unreached_fall = 1 ;`
		7134	`}`
		7135	`switch (CURRENT_TERMINAL) {`
		7136	`case 77:`
		7137	`break;`
		7138	`default:`
		7139	`goto ZL1;`
		7140	`}`
		7141	`ADVANCE_LEXER;`
		7142	`{`
		7143
		7144	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		7145	`}`
		7146	`ZI558 = ZI456;`
		7147	`goto ZL2_676;`
		7148	`}`
		7149	`/UNREACHED/`
		7150	`case 26: case 109: case 119:`
		7151	`{`
		7152	`EXP ZI493;`
		7153	`EXP ZI456;`
		7154
		7155	`ZR713 (&ZI493);`
		7156	`if ((CURRENT_TERMINAL) == 354) {`
		7157	`RESTORE_LEXER;`
		7158	`goto ZL1;`
		7159	`}`
		7160	`{`
		7161
		7162	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		7163	`}`
		7164	`ZI558 = ZI456;`
		7165	`goto ZL2_676;`
		7166	`}`
		7167	`/UNREACHED/`
		7168	`case 149:`
		7169	`{`
		7170	`EXP ZI1287;`
		7171	`EXP ZI1477;`
		7172	`int ZI670;`
		7173	`EXP ZI493;`
		7174	`EXP ZI456;`
		7175
		7176	`ZR635 (&ZI1287);`
		7177	`ZR1289 (&ZI1287, &ZI1477);`
		7178	`if ((CURRENT_TERMINAL) == 354) {`
		7179	`RESTORE_LEXER;`
		7180	`goto ZL1;`
		7181	`}`
		7182	`{`
		7183
		7184	`(ZI670) = unreached_code ;`
		7185	`if ( (ZI670) ) {`
		7186	`if ( !unreached_last ) {`
		7187	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		7188	`unreached_last = 1 ;`
		7189	`}`
		7190	`} else {`
		7191	`unreached_last = 0 ;`
		7192	`}`
		7193	`}`
		7194	`{`
		7195
		7196	`(ZI493) = make_exp_stmt ( (ZI1477) ) ;`
		7197	`}`
		7198	`{`
		7199
		7200	`unreached_fall = 1 ;`
		7201	`}`
		7202	`switch (CURRENT_TERMINAL) {`
		7203	`case 77:`
		7204	`break;`
		7205	`default:`
		7206	`goto ZL1;`
		7207	`}`
		7208	`ADVANCE_LEXER;`
		7209	`{`
		7210
		7211	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		7212	`}`
		7213	`ZI558 = ZI456;`
		7214	`goto ZL2_676;`
		7215	`}`
		7216	`/UNREACHED/`
		7217	`case 151:`
		7218	`{`
		7219	`EXP ZI493;`
		7220	`EXP ZI456;`
		7221
		7222	`ZR771 (&ZI493);`
		7223	`if ((CURRENT_TERMINAL) == 354) {`
		7224	`RESTORE_LEXER;`
		7225	`goto ZL1;`
		7226	`}`
		7227	`{`
		7228
		7229	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		7230	`}`
		7231	`ZI558 = ZI456;`
		7232	`goto ZL2_676;`
		7233	`}`
		7234	`/UNREACHED/`
		7235	`case 131: case 140:`
		7236	`{`
		7237	`int ZI1501;`
		7238	`EXP ZI1452;`
		7239	`EXP ZI1451;`
		7240	`EXP ZI1450;`
		7241	`EXP ZI1449;`
		7242	`EXP ZI1448;`
		7243	`EXP ZI1447;`
		7244	`EXP ZI1446;`
		7245	`EXP ZI1445;`
		7246	`EXP ZI1444;`
		7247	`EXP ZI1443;`
		7248	`EXP ZI1442;`
		7249	`EXP ZI1441;`
		7250	`EXP ZI1263;`
		7251	`EXP ZI1287;`
		7252	`EXP ZI1502;`
		7253	`int ZI670;`
		7254	`EXP ZI493;`
		7255	`EXP ZI456;`
		7256
		7257	`{`
		7258	`(ZI1501) = 0 ;`
		7259	`}`
		7260	`ZR1430 (&ZI1501, &ZI1452);`
		7261	`ZR1236 (ZI1452, &ZI1451);`
		7262	`ZR1232 (ZI1451, &ZI1450);`
		7263	`ZR1228 (ZI1450, &ZI1449);`
		7264	`ZR1224 (ZI1449, &ZI1448);`
		7265	`ZR1220 (ZI1448, &ZI1447);`
		7266	`ZR1216 (ZI1447, &ZI1446);`
		7267	`ZR1212 (ZI1446, &ZI1445);`
		7268	`ZR1208 (ZI1445, &ZI1444);`
		7269	`ZR1204 (ZI1444, &ZI1443);`
		7270	`ZR1200 (ZI1443, &ZI1442);`
		7271	`ZR1196 (ZI1442, &ZI1441);`
		7272	`ZR1192 (ZI1441, &ZI1263);`
		7273	`ZR1264 (&ZI1263, &ZI1287);`
		7274	`ZR1289 (&ZI1287, &ZI1502);`
		7275	`if ((CURRENT_TERMINAL) == 354) {`
		7276	`RESTORE_LEXER;`
		7277	`goto ZL1;`
		7278	`}`
		7279	`{`
		7280
		7281	`(ZI670) = unreached_code ;`
		7282	`if ( (ZI670) ) {`
		7283	`if ( !unreached_last ) {`
		7284	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		7285	`unreached_last = 1 ;`
		7286	`}`
		7287	`} else {`
		7288	`unreached_last = 0 ;`
		7289	`}`
		7290	`}`
		7291	`{`
		7292
		7293	`(ZI493) = make_exp_stmt ( (ZI1502) ) ;`
		7294	`}`
		7295	`{`
		7296
		7297	`unreached_fall = 1 ;`
		7298	`}`
		7299	`switch (CURRENT_TERMINAL) {`
		7300	`case 77:`
		7301	`break;`
		7302	`default:`
		7303	`goto ZL1;`
		7304	`}`
		7305	`ADVANCE_LEXER;`
		7306	`{`
		7307
		7308	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		7309	`}`
		7310	`ZI558 = ZI456;`
		7311	`goto ZL2_676;`
		7312	`}`
		7313	`/UNREACHED/`
		7314	`case 43: case 59: case 69: case 85:`
		7315	`{`
		7316	`int ZI450;`
		7317	`EXP ZI1459;`
		7318	`EXP ZI1452;`
		7319	`EXP ZI1451;`
		7320	`EXP ZI1450;`
		7321	`EXP ZI1449;`
		7322	`EXP ZI1448;`
		7323	`EXP ZI1447;`
		7324	`EXP ZI1446;`
		7325	`EXP ZI1445;`
		7326	`EXP ZI1444;`
		7327	`EXP ZI1443;`
		7328	`EXP ZI1442;`
		7329	`EXP ZI1441;`
		7330	`EXP ZI1263;`
		7331	`EXP ZI1287;`
		7332	`EXP ZI1486;`
		7333	`int ZI670;`
		7334	`EXP ZI493;`
		7335	`EXP ZI456;`
		7336
		7337	`{`
		7338	`(ZI450) = crt_lex_token ;`
		7339	`}`
		7340	`ZR596 ();`
		7341	`ZR581 (&ZI1459);`
		7342	`if ((CURRENT_TERMINAL) == 354) {`
		7343	`RESTORE_LEXER;`
		7344	`goto ZL1;`
		7345	`}`
		7346	`{`
		7347
		7348	`(ZI1452) = make_uminus_exp ( (ZI450), (ZI1459) ) ;`
		7349	`}`
		7350	`ZR1236 (ZI1452, &ZI1451);`
		7351	`ZR1232 (ZI1451, &ZI1450);`
		7352	`ZR1228 (ZI1450, &ZI1449);`
		7353	`ZR1224 (ZI1449, &ZI1448);`
		7354	`ZR1220 (ZI1448, &ZI1447);`
		7355	`ZR1216 (ZI1447, &ZI1446);`
		7356	`ZR1212 (ZI1446, &ZI1445);`
		7357	`ZR1208 (ZI1445, &ZI1444);`
		7358	`ZR1204 (ZI1444, &ZI1443);`
		7359	`ZR1200 (ZI1443, &ZI1442);`
		7360	`ZR1196 (ZI1442, &ZI1441);`
		7361	`ZR1192 (ZI1441, &ZI1263);`
		7362	`ZR1264 (&ZI1263, &ZI1287);`
		7363	`ZR1289 (&ZI1287, &ZI1486);`
		7364	`if ((CURRENT_TERMINAL) == 354) {`
		7365	`RESTORE_LEXER;`
		7366	`goto ZL1;`
		7367	`}`
		7368	`{`
		7369
		7370	`(ZI670) = unreached_code ;`
		7371	`if ( (ZI670) ) {`
		7372	`if ( !unreached_last ) {`
		7373	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		7374	`unreached_last = 1 ;`
		7375	`}`
		7376	`} else {`
		7377	`unreached_last = 0 ;`
		7378	`}`
		7379	`}`
		7380	`{`
		7381
		7382	`(ZI493) = make_exp_stmt ( (ZI1486) ) ;`
		7383	`}`
		7384	`{`
		7385
		7386	`unreached_fall = 1 ;`
		7387	`}`
		7388	`switch (CURRENT_TERMINAL) {`
		7389	`case 77:`
		7390	`break;`
		7391	`default:`
		7392	`goto ZL1;`
		7393	`}`
		7394	`ADVANCE_LEXER;`
		7395	`{`
		7396
		7397	`(ZI456) = add_compound_stmt ( (ZI558), (ZI493) ) ;`
		7398	`}`
		7399	`ZI558 = ZI456;`
		7400	`goto ZL2_676;`
		7401	`}`
		7402	`/UNREACHED/`
		7403	`default:`
		7404	`{`
		7405	`ZI431 = ZI558;`
		7406	`}`
		7407	`break;`
		7408	`}`
		7409	`goto ZL0;`
		7410	`ZL1:;`
		7411	`SAVE_LEXER (354);`
		7412	`return;`
		7413	`ZL0:;`
		7414	`*ZO431 = ZI431;`
		7415	`}`
		7416
		7417	`/* END OF FILE */`

Subversion Repositories tendra.SVN

(root)/trunk/src/producers/cpp/syntax/syntax5.c – Rev 7