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

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

Subversion Repositories tendra.SVN

(root)/branches/tendra4/src/producers/cpp/syntax/syntax5.c – Rev 3