Context Navigation

source: git/Singular/grammar.cc @ 9ae5a3

spielwiese

Last change on this file since 9ae5a3 was 9ae5a3, checked in by Hans Schoenemann <hannes@…>, 6 years ago
add: polyBucket stuff
Property mode set to `100644`
File size: 149.7 KB

Line
1	/* A Bison parser, made by GNU Bison 2.4.3. */
2
3	/* Skeleton implementation for Bison's Yacc-like parsers in C
4
5	Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6	2009, 2010 Free Software Foundation, Inc.
7
8	This program is free software: you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation, either version 3 of the License, or
11	(at your option) any later version.
12
13	This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.
17
18	You should have received a copy of the GNU General Public License
19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21	/* As a special exception, you may create a larger work that contains
22	part or all of the Bison parser skeleton and distribute that work
23	under terms of your choice, so long as that work isn't itself a
24	parser generator using the skeleton or a modified version thereof
25	as a parser skeleton. Alternatively, if you modify or redistribute
26	the parser skeleton itself, you may (at your option) remove this
27	special exception, which will cause the skeleton and the resulting
28	Bison output files to be licensed under the GNU General Public
29	License without this special exception.
30
31	This special exception was added by the Free Software Foundation in
32	version 2.2 of Bison. */
33
34	/* C LALR(1) parser skeleton written by Richard Stallman, by
35	simplifying the original so-called "semantic" parser. */
36
37	/* All symbols defined below should begin with yy or YY, to avoid
38	infringing on user name space. This should be done even for local
39	variables, as they might otherwise be expanded by user macros.
40	There are some unavoidable exceptions within include files to
41	define necessary library symbols; they are noted "INFRINGES ON
42	USER NAME SPACE" below. */
43
44	/* Identify Bison output. */
45	#define YYBISON 1
46
47	/* Bison version. */
48	#define YYBISON_VERSION "2.4.3"
49
50	/* Skeleton name. */
51	#define YYSKELETON_NAME "yacc.c"
52
53	/* Pure parsers. */
54	#define YYPURE 1
55
56	/* Push parsers. */
57	#define YYPUSH 0
58
59	/* Pull parsers. */
60	#define YYPULL 1
61
62	/* Using locations. */
63	#define YYLSP_NEEDED 0
64
65
66
67	/* Copy the first part of user declarations. */
68
69	/* Line 189 of yacc.c */
70	#line 7 "grammar.y"
71
72
73	#include <stdio.h>
74	#include <stddef.h>
75	#include <stdlib.h>
76	#include <stdarg.h>
77	#include <string.h>
78
79	#include "kernel/mod2.h"
80	#include "Singular/grammar.h"
81
82	#include "misc/mylimits.h"
83	#include "omalloc/omalloc.h"
84	#include "Singular/tok.h"
85	#include "misc/options.h"
86	#include "Singular/stype.h"
87	#include "Singular/fehelp.h"
88	#include "Singular/ipid.h"
89	#include "misc/intvec.h"
90	#include "kernel/oswrapper/feread.h"
91	#include "Singular/fevoices.h"
92	#include "polys/matpol.h"
93	#include "polys/monomials/ring.h"
94	#include "kernel/GBEngine/kstd1.h"
95	#include "Singular/subexpr.h"
96	#include "Singular/ipshell.h"
97	#include "Singular/ipconv.h"
98	#include "Singular/sdb.h"
99	#include "kernel/ideals.h"
100	#include "coeffs/numbers.h"
101	#include "kernel/polys.h"
102	#include "kernel/combinatorics/stairc.h"
103	#include "kernel/oswrapper/timer.h"
104	#include "Singular/cntrlc.h"
105	#include "polys/monomials/maps.h"
106	#include "kernel/GBEngine/syz.h"
107	#include "Singular/lists.h"
108	#include "Singular/libparse.h"
109	#include "coeffs/bigintmat.h"
110
111	#if 0
112	void debug_list(leftv v)
113	{
114	idhdl r=basePackHdl;
115	idhdl h;
116	BOOLEAN found=FALSE;
117	const char *nn=v->name;
118	h=IDROOT->get(nn,myynest);
119	if (h!=NULL)
120	{
121	Print("Curr::%s, (%s)\n",nn,Tok2Cmdname((int)IDTYP(h)));
122	found=TRUE;
123	}
124	else Print("`%s` not found in IDROOT\n",nn);
125	while (r!=NULL)
126	{
127	if ((IDTYP(r)==PACKAGE_CMD)
128	\|\| (IDTYP(r)==RING_CMD))
129	{
130	h=IDPACKAGE(r)->idroot->get(nn,myynest);
131	if (h!=NULL)
132	{
133	Print("%s::%s, (%s)\n",r->id,nn,Tok2Cmdname((int)IDTYP(h)));
134	found=TRUE;
135	}
136	else Print("%s::%s not found\n",r->id,nn);
137	}
138	if (r==basePackHdl) r=IDPACKAGE(r)->idroot;
139	r=r->next;
140	if (r==basePackHdl) break;
141	}
142	if (!found)
143	{
144	listall(TRUE);
145	}
146	}
147	#endif
148
149	/* From the bison docu:
150
151	By defining the macro `YYMAXDEPTH', you can control how deep the
152	parser stack can become before a stack overflow occurs. Define the
153	macro with a value that is an integer. This value is the maximum number
154	of tokens that can be shifted (and not reduced) before overflow. It
155	must be a constant expression whose value is known at compile time.
156
157	The stack space allowed is not necessarily allocated. If you
158	specify a large value for `YYMAXDEPTH', the parser actually allocates a
159	small stack at first, and then makes it bigger by stages as needed.
160	This increasing allocation happens automatically and silently.
161	Therefore, you do not need to make `YYMAXDEPTH' painfully small merely
162	to save space for ordinary inputs that do not need much stack.
163
164	The default value of `YYMAXDEPTH', if you do not define it, is 10000.
165	*/
166	#define YYMAXDEPTH MAX_INT_VAL
167
168	extern int yylineno;
169	extern FILE* yyin;
170
171	const char * currid;
172	BOOLEAN yyInRingConstruction=FALSE;
173	BOOLEAN expected_parms;
174	int cmdtok;
175	int inerror = 0;
176
177	#define TESTSETINT(a,i) \
178	if ((a).Typ() != INT_CMD) \
179	{ \
180	WerrorS("no int expression"); \
181	YYERROR; \
182	} \
183	(i) = (int)((long)(a).Data());(a).CleanUp()
184
185	#define MYYERROR(a) { WerrorS(a); YYERROR; }
186
187	void yyerror(const char * fmt)
188	{
189
190	BOOLEAN old_errorreported=errorreported;
191	errorreported = TRUE;
192	if (currid!=NULL)
193	{
194	killid(currid,&IDROOT);
195	currid = NULL;
196	}
197	if(inerror==0)
198	{
199	{
200	if ((strlen(fmt)>1)
201	&& (strncmp(fmt,"parse",5)!=0)
202	&& (strncmp(fmt,"syntax",6)!=0))
203	WerrorS(fmt);
204	Werror( "error occurred in or before %s line %d: `%s`"
205	,VoiceName(), yylineno, my_yylinebuf);
206	}
207	if (cmdtok!=0)
208	{
209	const char *s=Tok2Cmdname(cmdtok);
210	if (expected_parms)
211	{
212	Werror("expected %s-expression. type \'help %s;\'",s,s);
213	}
214	else
215	{
216	Werror("wrong type declaration. type \'help %s;\'",s);
217	}
218	}
219	if (!old_errorreported && (lastreserved!=NULL))
220	{
221	Werror("last reserved name was `%s`",lastreserved);
222	}
223	inerror=1;
224	}
225	if ((currentVoice!=NULL)
226	&& (currentVoice->prev!=NULL)
227	&& (myynest>0)
228	#ifdef HAVE_SDB
229	&& ((sdb_flags &1)==0)
230	#endif
231	)
232	{
233	Werror("leaving %s",VoiceName());
234	}
235	}
236
237
238
239	/* Line 189 of yacc.c */
240	#line 241 "grammar.cc"
241
242	/* Enabling traces. */
243	#ifndef YYDEBUG
244	# define YYDEBUG 1
245	#endif
246
247	/* Enabling verbose error messages. */
248	#ifdef YYERROR_VERBOSE
249	# undef YYERROR_VERBOSE
250	# define YYERROR_VERBOSE 1
251	#else
252	# define YYERROR_VERBOSE 0
253	#endif
254
255	/* Enabling the token table. */
256	#ifndef YYTOKEN_TABLE
257	# define YYTOKEN_TABLE 0
258	#endif
259
260
261	/* Tokens. */
262	#ifndef YYTOKENTYPE
263	# define YYTOKENTYPE
264	/* Put the tokens into the symbol table, so that GDB and other debuggers
265	know about them. */
266	enum yytokentype {
267	DOTDOT = 258,
268	EQUAL_EQUAL = 259,
269	GE = 260,
270	LE = 261,
271	MINUSMINUS = 262,
272	NOT = 263,
273	NOTEQUAL = 264,
274	PLUSPLUS = 265,
275	COLONCOLON = 266,
276	ARROW = 267,
277	GRING_CMD = 268,
278	BIGINTMAT_CMD = 269,
279	INTMAT_CMD = 270,
280	PROC_CMD = 271,
281	RING_CMD = 272,
282	BEGIN_RING = 273,
283	BUCKET_CMD = 274,
284	IDEAL_CMD = 275,
285	MAP_CMD = 276,
286	MATRIX_CMD = 277,
287	MODUL_CMD = 278,
288	NUMBER_CMD = 279,
289	POLY_CMD = 280,
290	RESOLUTION_CMD = 281,
291	VECTOR_CMD = 282,
292	BETTI_CMD = 283,
293	E_CMD = 284,
294	FETCH_CMD = 285,
295	FREEMODULE_CMD = 286,
296	KEEPRING_CMD = 287,
297	IMAP_CMD = 288,
298	KOSZUL_CMD = 289,
299	MAXID_CMD = 290,
300	MONOM_CMD = 291,
301	PAR_CMD = 292,
302	PREIMAGE_CMD = 293,
303	VAR_CMD = 294,
304	VALTVARS = 295,
305	VMAXDEG = 296,
306	VMAXMULT = 297,
307	VNOETHER = 298,
308	VMINPOLY = 299,
309	END_RING = 300,
310	CMD_1 = 301,
311	CMD_2 = 302,
312	CMD_3 = 303,
313	CMD_12 = 304,
314	CMD_13 = 305,
315	CMD_23 = 306,
316	CMD_123 = 307,
317	CMD_M = 308,
318	ROOT_DECL = 309,
319	ROOT_DECL_LIST = 310,
320	RING_DECL = 311,
321	RING_DECL_LIST = 312,
322	EXAMPLE_CMD = 313,
323	EXPORT_CMD = 314,
324	HELP_CMD = 315,
325	KILL_CMD = 316,
326	LIB_CMD = 317,
327	LISTVAR_CMD = 318,
328	SETRING_CMD = 319,
329	TYPE_CMD = 320,
330	STRINGTOK = 321,
331	BLOCKTOK = 322,
332	INT_CONST = 323,
333	UNKNOWN_IDENT = 324,
334	RINGVAR = 325,
335	PROC_DEF = 326,
336	APPLY = 327,
337	ASSUME_CMD = 328,
338	BREAK_CMD = 329,
339	CONTINUE_CMD = 330,
340	ELSE_CMD = 331,
341	EVAL = 332,
342	QUOTE = 333,
343	FOR_CMD = 334,
344	IF_CMD = 335,
345	SYS_BREAK = 336,
346	WHILE_CMD = 337,
347	RETURN = 338,
348	PARAMETER = 339,
349	SYSVAR = 340,
350	UMINUS = 341
351	};
352	#endif
353
354
355
356	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
357
358	# define yystype YYSTYPE /* obsolescent; will be withdrawn */
359	# define YYSTYPE_IS_DECLARED 1
360	#endif
361
362
363	/* Copy the second part of user declarations. */
364
365
366	/* Line 264 of yacc.c */
367	#line 368 "grammar.cc"
368
369	#ifdef short
370	# undef short
371	#endif
372
373	#ifdef YYTYPE_UINT8
374	typedef YYTYPE_UINT8 yytype_uint8;
375	#else
376	typedef unsigned char yytype_uint8;
377	#endif
378
379	#ifdef YYTYPE_INT8
380	typedef YYTYPE_INT8 yytype_int8;
381	#elif (defined __STDC__ \|\| defined __C99__FUNC__ \
382	\|\| defined __cplusplus \|\| defined _MSC_VER)
383	typedef signed char yytype_int8;
384	#else
385	typedef short int yytype_int8;
386	#endif
387
388	#ifdef YYTYPE_UINT16
389	typedef YYTYPE_UINT16 yytype_uint16;
390	#else
391	typedef unsigned short int yytype_uint16;
392	#endif
393
394	#ifdef YYTYPE_INT16
395	typedef YYTYPE_INT16 yytype_int16;
396	#else
397	typedef short int yytype_int16;
398	#endif
399
400	#ifndef YYSIZE_T
401	# ifdef __SIZE_TYPE__
402	# define YYSIZE_T __SIZE_TYPE__
403	# elif defined size_t
404	# define YYSIZE_T size_t
405	# elif ! defined YYSIZE_T && (defined __STDC__ \|\| defined __C99__FUNC__ \
406	\|\| defined __cplusplus \|\| defined _MSC_VER)
407	# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
408	# define YYSIZE_T size_t
409	# else
410	# define YYSIZE_T unsigned int
411	# endif
412	#endif
413
414	#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
415
416	#ifndef YY_
417	# if defined YYENABLE_NLS && YYENABLE_NLS
418	# if ENABLE_NLS
419	# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
420	# define YY_(msgid) dgettext ("bison-runtime", msgid)
421	# endif
422	# endif
423	# ifndef YY_
424	# define YY_(msgid) msgid
425	# endif
426	#endif
427
428	/* Suppress unused-variable warnings by "using" E. */
429	#if ! defined lint \|\| defined __GNUC__
430	# define YYUSE(e) ((void) (e))
431	#else
432	# define YYUSE(e) /* empty */
433	#endif
434
435	/* Identity function, used to suppress warnings about constant conditions. */
436	#ifndef lint
437	# define YYID(n) (n)
438	#else
439	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
440	\|\| defined __cplusplus \|\| defined _MSC_VER)
441	static int
442	YYID (int yyi)
443	#else
444	static int
445	YYID (yyi)
446	int yyi;
447	#endif
448	{
449	return yyi;
450	}
451	#endif
452
453	#if ! defined yyoverflow \|\| YYERROR_VERBOSE
454
455	/* The parser invokes alloca or malloc; define the necessary symbols. */
456
457	# ifdef YYSTACK_USE_ALLOCA
458	# if YYSTACK_USE_ALLOCA
459	# ifdef __GNUC__
460	# define YYSTACK_ALLOC __builtin_alloca
461	# elif defined __BUILTIN_VA_ARG_INCR
462	# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
463	# elif defined _AIX
464	# define YYSTACK_ALLOC __alloca
465	# elif defined _MSC_VER
466	# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
467	# define alloca _alloca
468	# else
469	# define YYSTACK_ALLOC alloca
470	# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
471	\|\| defined __cplusplus \|\| defined _MSC_VER)
472	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
473	# ifndef _STDLIB_H
474	# define _STDLIB_H 1
475	# endif
476	# endif
477	# endif
478	# endif
479	# endif
480
481	# ifdef YYSTACK_ALLOC
482	/* Pacify GCC's `empty if-body' warning. */
483	# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
484	# ifndef YYSTACK_ALLOC_MAXIMUM
485	/* The OS might guarantee only one guard page at the bottom of the stack,
486	and a page size can be as small as 4096 bytes. So we cannot safely
487	invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
488	to allow for a few compiler-allocated temporary stack slots. */
489	# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
490	# endif
491	# else
492	# define YYSTACK_ALLOC YYMALLOC
493	# define YYSTACK_FREE YYFREE
494	# ifndef YYSTACK_ALLOC_MAXIMUM
495	# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
496	# endif
497	# if (defined __cplusplus && ! defined _STDLIB_H \
498	&& ! ((defined YYMALLOC \|\| defined malloc) \
499	&& (defined YYFREE \|\| defined free)))
500	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
501	# ifndef _STDLIB_H
502	# define _STDLIB_H 1
503	# endif
504	# endif
505	# ifndef YYMALLOC
506	# define YYMALLOC malloc
507	# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
508	\|\| defined __cplusplus \|\| defined _MSC_VER)
509	void malloc (YYSIZE_T); / INFRINGES ON USER NAME SPACE */
510	# endif
511	# endif
512	# ifndef YYFREE
513	# define YYFREE free
514	# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
515	\|\| defined __cplusplus \|\| defined _MSC_VER)
516	void free (void ); / INFRINGES ON USER NAME SPACE */
517	# endif
518	# endif
519	# endif
520	#endif /* ! defined yyoverflow \|\| YYERROR_VERBOSE */
521
522
523	#if (! defined yyoverflow \
524	&& (! defined __cplusplus \
525	\|\| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
526
527	/* A type that is properly aligned for any stack member. */
528	union yyalloc
529	{
530	yytype_int16 yyss_alloc;
531	YYSTYPE yyvs_alloc;
532	};
533
534	/* The size of the maximum gap between one aligned stack and the next. */
535	# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
536
537	/* The size of an array large to enough to hold all stacks, each with
538	N elements. */
539	# define YYSTACK_BYTES(N) \
540	((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
541	+ YYSTACK_GAP_MAXIMUM)
542
543	/* Copy COUNT objects from FROM to TO. The source and destination do
544	not overlap. */
545	# ifndef YYCOPY
546	# if defined __GNUC__ && 1 < __GNUC__
547	# define YYCOPY(To, From, Count) \
548	__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
549	# else
550	# define YYCOPY(To, From, Count) \
551	do \
552	{ \
553	YYSIZE_T yyi; \
554	for (yyi = 0; yyi < (Count); yyi++) \
555	(To)[yyi] = (From)[yyi]; \
556	} \
557	while (YYID (0))
558	# endif
559	# endif
560
561	/* Relocate STACK from its old location to the new one. The
562	local variables YYSIZE and YYSTACKSIZE give the old and new number of
563	elements in the stack, and YYPTR gives the new location of the
564	stack. Advance YYPTR to a properly aligned location for the next
565	stack. */
566	# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
567	do \
568	{ \
569	YYSIZE_T yynewbytes; \
570	YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
571	Stack = &yyptr->Stack_alloc; \
572	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
573	yyptr += yynewbytes / sizeof (*yyptr); \
574	} \
575	while (YYID (0))
576
577	#endif
578
579	/* YYFINAL -- State number of the termination state. */
580	#define YYFINAL 2
581	/* YYLAST -- Last index in YYTABLE. */
582	#define YYLAST 2583
583
584	/* YYNTOKENS -- Number of terminals. */
585	#define YYNTOKENS 103
586	/* YYNNTS -- Number of nonterminals. */
587	#define YYNNTS 44
588	/* YYNRULES -- Number of rules. */
589	#define YYNRULES 174
590	/* YYNRULES -- Number of states. */
591	#define YYNSTATES 397
592
593	/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
594	#define YYUNDEFTOK 2
595	#define YYMAXUTOK 341
596
597	#define YYTRANSLATE(YYX) \
598	((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
599
600	/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
601	static const yytype_uint8 yytranslate[] =
602	{
603	0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
604	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
605	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
606	2, 2, 2, 2, 2, 2, 2, 2, 96, 2,
607	99, 100, 2, 88, 94, 89, 101, 90, 2, 2,
608	2, 2, 2, 2, 2, 2, 2, 2, 97, 95,
609	87, 86, 2, 2, 2, 2, 2, 2, 2, 2,
610	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
611	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
612	2, 91, 2, 92, 93, 2, 102, 2, 2, 2,
613	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
614	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
615	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
616	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
617	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
618	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
619	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
620	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
621	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
622	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
623	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
624	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
625	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
626	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
627	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
628	2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
629	5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
630	15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
631	25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
632	35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
633	45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
634	55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
635	65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
636	75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
637	85, 98
638	};
639
640	#if YYDEBUG
641	/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
642	YYRHS. */
643	static const yytype_uint16 yyprhs[] =
644	{
645	0, 0, 3, 4, 7, 9, 12, 15, 17, 19,
646	21, 24, 26, 28, 30, 32, 34, 36, 38, 40,
647	43, 45, 47, 49, 51, 53, 55, 57, 59, 61,
648	64, 66, 68, 72, 76, 80, 85, 89, 91, 93,
649	95, 100, 105, 110, 114, 119, 124, 128, 133, 138,
650	143, 148, 155, 162, 169, 176, 185, 194, 203, 212,
651	216, 221, 230, 235, 244, 249, 253, 257, 261, 263,
652	265, 267, 274, 279, 286, 293, 300, 307, 314, 321,
653	325, 331, 337, 338, 344, 347, 350, 352, 355, 358,
654	362, 366, 370, 374, 378, 382, 386, 390, 394, 398,
655	401, 404, 407, 410, 412, 416, 419, 422, 425, 428,
656	437, 440, 444, 447, 449, 451, 457, 459, 461, 466,
657	468, 472, 474, 478, 480, 482, 484, 486, 489, 493,
658	496, 500, 503, 506, 510, 515, 520, 525, 530, 535,
659	540, 545, 550, 557, 564, 571, 578, 585, 592, 599,
660	603, 605, 614, 617, 622, 630, 633, 635, 637, 640,
661	643, 645, 651, 654, 660, 662, 664, 668, 674, 678,
662	682, 687, 690, 693, 698
663	};
664
665	/* YYRHS -- A `-1'-separated list of the rules' RHS. */
666	static const yytype_int16 yyrhs[] =
667	{
668	104, 0, -1, -1, 104, 105, -1, 106, -1, 108,
669	95, -1, 120, 95, -1, 146, -1, 81, -1, 95,
670	-1, 1, 95, -1, 141, -1, 142, -1, 107, -1,
671	143, -1, 144, -1, 129, -1, 130, -1, 131, -1,
672	58, 67, -1, 109, -1, 132, -1, 133, -1, 134,
673	-1, 145, -1, 136, -1, 137, -1, 139, -1, 140,
674	-1, 118, 111, -1, 70, -1, 119, -1, 110, 11,
675	110, -1, 112, 101, 110, -1, 110, 99, 100, -1,
676	110, 99, 111, 100, -1, 91, 111, 92, -1, 68,
677	-1, 85, -1, 121, -1, 16, 99, 112, 100, -1,
678	54, 99, 112, 100, -1, 55, 99, 111, 100, -1,
679	55, 99, 100, -1, 56, 99, 112, 100, -1, 57,
680	99, 111, 100, -1, 57, 99, 100, -1, 46, 99,
681	112, 100, -1, 49, 99, 112, 100, -1, 50, 99,
682	112, 100, -1, 52, 99, 112, 100, -1, 47, 99,
683	112, 94, 112, 100, -1, 49, 99, 112, 94, 112,
684	100, -1, 51, 99, 112, 94, 112, 100, -1, 52,
685	99, 112, 94, 112, 100, -1, 48, 99, 112, 94,
686	112, 94, 112, 100, -1, 50, 99, 112, 94, 112,
687	94, 112, 100, -1, 51, 99, 112, 94, 112, 94,
688	112, 100, -1, 52, 99, 112, 94, 112, 94, 112,
689	100, -1, 53, 99, 100, -1, 53, 99, 111, 100,
690	-1, 128, 99, 112, 94, 112, 94, 112, 100, -1,
691	128, 99, 112, 100, -1, 17, 99, 122, 94, 122,
692	94, 126, 100, -1, 17, 99, 112, 100, -1, 119,
693	12, 67, -1, 99, 111, 100, -1, 111, 94, 112,
694	-1, 112, -1, 117, -1, 110, -1, 112, 91, 112,
695	94, 112, 92, -1, 112, 91, 112, 92, -1, 72,
696	99, 112, 94, 46, 100, -1, 72, 99, 112, 94,
697	49, 100, -1, 72, 99, 112, 94, 50, 100, -1,
698	72, 99, 112, 94, 52, 100, -1, 72, 99, 112,
699	94, 53, 100, -1, 72, 99, 112, 94, 112, 100,
700	-1, 114, 112, 116, -1, 114, 112, 86, 112, 116,
701	-1, 115, 112, 94, 112, 116, -1, -1, 77, 99,
702	113, 112, 100, -1, 78, 99, -1, 73, 99, -1,
703	100, -1, 112, 10, -1, 112, 7, -1, 112, 88,
704	112, -1, 112, 89, 112, -1, 112, 90, 112, -1,
705	112, 93, 112, -1, 112, 87, 112, -1, 112, 96,
706	112, -1, 112, 9, 112, -1, 112, 4, 112, -1,
707	112, 3, 112, -1, 112, 97, 112, -1, 8, 112,
708	-1, 89, 112, -1, 120, 127, -1, 111, 86, -1,
709	69, -1, 102, 112, 102, -1, 54, 110, -1, 55,
710	110, -1, 56, 110, -1, 57, 110, -1, 128, 110,
711	91, 112, 92, 91, 112, 92, -1, 128, 110, -1,
712	120, 94, 110, -1, 16, 110, -1, 66, -1, 112,
713	-1, 99, 112, 94, 111, 100, -1, 69, -1, 123,
714	-1, 123, 99, 111, 100, -1, 124, -1, 124, 94,
715	125, -1, 124, -1, 99, 125, 100, -1, 86, -1,
716	22, -1, 15, -1, 14, -1, 87, 121, -1, 60,
717	66, 95, -1, 60, 95, -1, 58, 66, 95, -1,
718	59, 111, -1, 61, 110, -1, 133, 94, 110, -1,
719	63, 99, 54, 100, -1, 63, 99, 55, 100, -1,
720	63, 99, 56, 100, -1, 63, 99, 57, 100, -1,
721	63, 99, 17, 100, -1, 63, 99, 128, 100, -1,
722	63, 99, 16, 100, -1, 63, 99, 110, 100, -1,
723	63, 99, 110, 94, 54, 100, -1, 63, 99, 110,
724	94, 55, 100, -1, 63, 99, 110, 94, 56, 100,
725	-1, 63, 99, 110, 94, 57, 100, -1, 63, 99,
726	110, 94, 17, 100, -1, 63, 99, 110, 94, 128,
727	100, -1, 63, 99, 110, 94, 16, 100, -1, 63,
728	99, 100, -1, 17, -1, 135, 110, 127, 122, 94,
729	122, 94, 126, -1, 135, 110, -1, 135, 110, 127,
730	110, -1, 135, 110, 127, 110, 91, 111, 92, -1,
731	85, 121, -1, 64, -1, 32, -1, 138, 112, -1,
732	65, 112, -1, 111, -1, 80, 99, 112, 100, 67,
733	-1, 76, 67, -1, 80, 99, 112, 100, 74, -1,
734	74, -1, 75, -1, 82, 66, 67, -1, 79, 66,
735	66, 66, 67, -1, 16, 119, 67, -1, 71, 66,
736	67, -1, 71, 66, 66, 67, -1, 84, 120, -1,
737	84, 112, -1, 83, 99, 111, 100, -1, 83, 99,
738	100, -1
739	};
740
741	/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
742	static const yytype_uint16 yyrline[] =
743	{
744	0, 317, 317, 319, 353, 354, 356, 358, 362, 367,
745	369, 420, 421, 422, 423, 424, 425, 426, 427, 431,
746	434, 435, 436, 437, 438, 439, 440, 441, 442, 445,
747	452, 457, 461, 465, 469, 473, 487, 515, 539, 545,
748	551, 555, 559, 563, 567, 571, 575, 579, 583, 587,
749	591, 595, 599, 603, 607, 611, 615, 619, 623, 627,
750	631, 637, 641, 645, 649, 653, 658, 662, 673, 679,
751	684, 685, 689, 693, 697, 701, 705, 709, 713, 717,
752	721, 738, 745, 744, 762, 770, 778, 787, 791, 795,
753	799, 803, 807, 811, 815, 819, 823, 827, 831, 835,
754	847, 854, 855, 874, 875, 887, 892, 897, 901, 905,
755	941, 967, 988, 996, 1000, 1001, 1015, 1023, 1032, 1077,
756	1078, 1087, 1088, 1094, 1101, 1103, 1105, 1114, 1119, 1124,
757	1131, 1139, 1151, 1168, 1188, 1192, 1196, 1201, 1205, 1209,
758	1213, 1217, 1222, 1228, 1234, 1240, 1246, 1252, 1258, 1270,
759	1277, 1281, 1318, 1325, 1330, 1343, 1350, 1350, 1353, 1421,
760	1425, 1454, 1467, 1484, 1493, 1498, 1506, 1518, 1537, 1547,
761	1566, 1589, 1595, 1607, 1613
762	};
763	#endif
764
765	#if YYDEBUG \|\| YYERROR_VERBOSE \|\| YYTOKEN_TABLE
766	/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
767	First, the terminals, then, starting at YYNTOKENS, nonterminals. */
768	static const char *const yytname[] =
769	{
770	"$end", "error", "$undefined", "DOTDOT", "EQUAL_EQUAL", "GE", "LE",
771	"MINUSMINUS", "NOT", "NOTEQUAL", "PLUSPLUS", "COLONCOLON", "ARROW",
772	"GRING_CMD", "BIGINTMAT_CMD", "INTMAT_CMD", "PROC_CMD", "RING_CMD",
773	"BEGIN_RING", "BUCKET_CMD", "IDEAL_CMD", "MAP_CMD", "MATRIX_CMD",
774	"MODUL_CMD", "NUMBER_CMD", "POLY_CMD", "RESOLUTION_CMD", "VECTOR_CMD",
775	"BETTI_CMD", "E_CMD", "FETCH_CMD", "FREEMODULE_CMD", "KEEPRING_CMD",
776	"IMAP_CMD", "KOSZUL_CMD", "MAXID_CMD", "MONOM_CMD", "PAR_CMD",
777	"PREIMAGE_CMD", "VAR_CMD", "VALTVARS", "VMAXDEG", "VMAXMULT", "VNOETHER",
778	"VMINPOLY", "END_RING", "CMD_1", "CMD_2", "CMD_3", "CMD_12", "CMD_13",
779	"CMD_23", "CMD_123", "CMD_M", "ROOT_DECL", "ROOT_DECL_LIST", "RING_DECL",
780	"RING_DECL_LIST", "EXAMPLE_CMD", "EXPORT_CMD", "HELP_CMD", "KILL_CMD",
781	"LIB_CMD", "LISTVAR_CMD", "SETRING_CMD", "TYPE_CMD", "STRINGTOK",
782	"BLOCKTOK", "INT_CONST", "UNKNOWN_IDENT", "RINGVAR", "PROC_DEF", "APPLY",
783	"ASSUME_CMD", "BREAK_CMD", "CONTINUE_CMD", "ELSE_CMD", "EVAL", "QUOTE",
784	"FOR_CMD", "IF_CMD", "SYS_BREAK", "WHILE_CMD", "RETURN", "PARAMETER",
785	"SYSVAR", "'='", "'<'", "'+'", "'-'", "'/'", "'['", "']'", "'^'", "','",
786	"';'", "'&'", "':'", "UMINUS", "'('", "')'", "'.'", "'`'", "$accept",
787	"lines", "pprompt", "flowctrl", "example_dummy", "command", "assign",
788	"elemexpr", "exprlist", "expr", "$@1", "quote_start", "assume_start",
789	"quote_end", "expr_arithmetic", "left_value", "extendedid",
790	"declare_ip_variable", "stringexpr", "rlist", "ordername", "orderelem",
791	"OrderingList", "ordering", "cmdeq", "mat_cmd", "filecmd", "helpcmd",
792	"examplecmd", "exportcmd", "killcmd", "listcmd", "ringcmd1", "ringcmd",
793	"scriptcmd", "setrings", "setringcmd", "typecmd", "ifcmd", "whilecmd",
794	"forcmd", "proccmd", "parametercmd", "returncmd", 0
795	};
796	#endif
797
798	# ifdef YYPRINT
799	/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
800	token YYLEX-NUM. */
801	static const yytype_uint16 yytoknum[] =
802	{
803	0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
804	265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
805	275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
806	285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
807	295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
808	305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
809	315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
810	325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
811	335, 336, 337, 338, 339, 340, 61, 60, 43, 45,
812	47, 91, 93, 94, 44, 59, 38, 58, 341, 40,
813	41, 46, 96
814	};
815	# endif
816
817	/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
818	static const yytype_uint8 yyr1[] =
819	{
820	0, 103, 104, 104, 105, 105, 105, 105, 105, 105,
821	105, 106, 106, 106, 106, 106, 106, 106, 106, 107,
822	108, 108, 108, 108, 108, 108, 108, 108, 108, 109,
823	110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
824	110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
825	110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
826	110, 110, 110, 110, 110, 110, 110, 111, 111, 112,
827	112, 112, 112, 112, 112, 112, 112, 112, 112, 112,
828	112, 112, 113, 112, 114, 115, 116, 117, 117, 117,
829	117, 117, 117, 117, 117, 117, 117, 117, 117, 117,
830	117, 118, 118, 119, 119, 120, 120, 120, 120, 120,
831	120, 120, 120, 121, 122, 122, 123, 124, 124, 125,
832	125, 126, 126, 127, 128, 128, 128, 129, 130, 130,
833	131, 132, 133, 133, 134, 134, 134, 134, 134, 134,
834	134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
835	135, 136, 136, 136, 136, 137, 138, 138, 139, 140,
836	140, 141, 141, 141, 141, 141, 142, 143, 144, 144,
837	144, 145, 145, 146, 146
838	};
839
840	/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
841	static const yytype_uint8 yyr2[] =
842	{
843	0, 2, 0, 2, 1, 2, 2, 1, 1, 1,
844	2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
845	1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
846	1, 1, 3, 3, 3, 4, 3, 1, 1, 1,
847	4, 4, 4, 3, 4, 4, 3, 4, 4, 4,
848	4, 6, 6, 6, 6, 8, 8, 8, 8, 3,
849	4, 8, 4, 8, 4, 3, 3, 3, 1, 1,
850	1, 6, 4, 6, 6, 6, 6, 6, 6, 3,
851	5, 5, 0, 5, 2, 2, 1, 2, 2, 3,
852	3, 3, 3, 3, 3, 3, 3, 3, 3, 2,
853	2, 2, 2, 1, 3, 2, 2, 2, 2, 8,
854	2, 3, 2, 1, 1, 5, 1, 1, 4, 1,
855	3, 1, 3, 1, 1, 1, 1, 2, 3, 2,
856	3, 2, 2, 3, 4, 4, 4, 4, 4, 4,
857	4, 4, 6, 6, 6, 6, 6, 6, 6, 3,
858	1, 8, 2, 4, 7, 2, 1, 1, 2, 2,
859	1, 5, 2, 5, 1, 1, 3, 5, 3, 3,
860	4, 2, 2, 4, 3
861	};
862
863	/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
864	STATE-NUM when YYTABLE doesn't specify something else to do. Zero
865	means the default is an error. */
866	static const yytype_uint8 yydefact[] =
867	{
868	2, 0, 1, 0, 0, 126, 125, 0, 150, 124,
869	157, 0, 0, 0, 0, 0, 0, 0, 0, 0,
870	0, 0, 0, 0, 0, 0, 0, 0, 156, 0,
871	113, 37, 103, 30, 0, 0, 0, 164, 165, 0,
872	0, 0, 0, 0, 8, 0, 0, 0, 38, 0,
873	0, 0, 9, 0, 0, 3, 4, 13, 0, 20,
874	70, 160, 68, 0, 0, 69, 0, 31, 0, 39,
875	0, 16, 17, 18, 21, 22, 23, 0, 25, 26,
876	0, 27, 28, 11, 12, 14, 15, 24, 7, 10,
877	0, 0, 0, 0, 0, 0, 38, 99, 0, 0,
878	70, 0, 31, 0, 0, 0, 0, 0, 0, 0,
879	0, 0, 0, 70, 0, 70, 0, 70, 0, 70,
880	0, 19, 131, 0, 129, 70, 0, 159, 0, 0,
881	85, 162, 82, 84, 0, 0, 0, 0, 0, 172,
882	171, 155, 127, 100, 0, 0, 0, 5, 0, 0,
883	102, 0, 0, 0, 88, 0, 87, 0, 0, 0,
884	0, 0, 0, 0, 0, 0, 0, 0, 29, 0,
885	123, 0, 6, 101, 0, 70, 0, 70, 158, 0,
886	0, 0, 0, 0, 0, 68, 168, 0, 114, 0,
887	0, 0, 0, 0, 0, 0, 0, 59, 0, 68,
888	43, 0, 68, 46, 0, 130, 128, 0, 0, 0,
889	0, 0, 0, 149, 70, 0, 0, 169, 0, 0,
890	0, 0, 166, 174, 0, 36, 66, 104, 32, 34,
891	0, 67, 97, 96, 95, 93, 89, 90, 91, 0,
892	92, 94, 98, 33, 0, 86, 79, 0, 65, 70,
893	0, 0, 70, 0, 0, 0, 0, 0, 0, 0,
894	40, 68, 64, 0, 47, 0, 0, 0, 48, 0,
895	49, 0, 0, 50, 60, 41, 42, 44, 45, 140,
896	138, 134, 135, 136, 137, 0, 141, 139, 170, 0,
897	0, 0, 0, 173, 35, 72, 0, 0, 0, 0,
898	62, 0, 70, 114, 0, 42, 45, 0, 0, 0,
899	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
900	0, 0, 0, 0, 0, 0, 0, 0, 83, 167,
901	161, 163, 0, 80, 81, 0, 0, 0, 0, 0,
902	0, 51, 0, 52, 0, 0, 53, 0, 54, 148,
903	146, 142, 143, 144, 145, 147, 73, 74, 75, 76,
904	77, 78, 71, 0, 0, 0, 0, 115, 116, 0,
905	117, 121, 0, 0, 0, 0, 0, 0, 0, 154,
906	0, 119, 0, 0, 63, 55, 56, 57, 58, 61,
907	109, 151, 0, 122, 0, 120, 118
908	};
909
910	/* YYDEFGOTO[NTERM-NUM]. */
911	static const yytype_int16 yydefgoto[] =
912	{
913	-1, 1, 55, 56, 57, 58, 59, 60, 145, 62,
914	219, 63, 64, 246, 65, 66, 67, 68, 69, 189,
915	370, 371, 382, 372, 173, 98, 71, 72, 73, 74,
916	75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
917	85, 86, 87, 88
918	};
919
920	/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
921	STATE-NUM. */
922	#define YYPACT_NINF -362
923	static const yytype_int16 yypact[] =
924	{
925	-362, 383, -362, -84, 1887, -362, -362, 1953, -75, -362,
926	-362, -72, -58, -53, -50, -43, -28, -11, 2, 2019,
927	2085, 2151, 2217, 17, 1887, -47, 1887, 4, -362, 1887,
928	-362, -362, -362, -362, 42, 16, 36, -362, -362, 92,
929	44, 64, 99, 77, -362, 115, 88, 2283, 123, 123,
930	1887, 1887, -362, 1887, 1887, -362, -362, -362, 107, -362,
931	-2, -65, 1374, 1887, 1887, -362, 1887, 192, -52, -362,
932	2349, -362, -362, -362, -362, 129, -362, 1887, -362, -362,
933	1887, -362, -362, -362, -362, -362, -362, -362, -362, -362,
934	121, -75, 132, 135, 137, 141, -362, 23, 147, 1887,
935	210, 1374, -10, 2415, 1887, 1887, 1887, 1887, 1887, 1887,
936	1887, 1491, 1887, 262, 1557, 265, 1887, 385, 1623, 1317,
937	166, -362, 169, 170, -362, 203, 1689, 1374, 40, 1887,
938	-362, -362, -362, -362, 200, 1887, 212, 1755, 1953, 1374,
939	186, -362, -362, 23, -56, -74, 3, -362, 1887, 1821,
940	-362, 1887, 1887, 1887, -362, 1887, -362, 1887, 1887, 1887,
941	1887, 1887, 1887, 1887, 1887, 1887, 238, 554, 169, 219,
942	-362, 1887, -362, -362, 1887, 51, 1887, 76, 1374, 1887,
943	1887, 1557, 1887, 1623, 1887, 569, -362, 1887, 584, 194,
944	679, 694, 709, 181, 280, 724, 399, -362, -49, 739,
945	-362, -41, 754, -362, -40, -362, -362, 39, 41, 69,
946	79, 93, 95, -362, 33, 98, 224, -362, 849, 1887,
947	227, 864, -362, -362, -36, -362, -362, -362, -362, -362,
948	-22, 1374, 252, 163, 163, 1403, 30, 30, 23, 414,
949	18, 1389, 30, -362, 1887, -362, -362, 1887, -362, 1332,
950	509, 1887, 472, 2415, 569, 739, -19, 754, -18, 509,
951	-362, 879, -362, 2415, -362, 1887, 1887, 1887, -362, 1887,
952	-362, 1887, 1887, -362, -362, -362, -362, -362, -362, -362,
953	-362, -362, -362, -362, -362, 1495, -362, -362, -362, 2481,
954	894, 233, -35, -362, -362, -362, 1887, 909, 909, 1887,
955	-362, 924, 138, 1374, 213, -362, -362, 1887, 214, 1019,
956	1034, 1049, 1064, 524, 539, 216, 218, 221, 222, 223,
957	230, 232, 116, 118, 126, 139, 144, 1079, -362, -362,
958	-362, -362, 1094, -362, -362, 1189, 242, 1887, 2415, -15,
959	-64, -362, 1887, -362, 1887, 1887, -362, 1887, -362, -362,
960	-362, -362, -362, -362, -362, -362, -362, -362, -362, -362,
961	-362, -362, -362, 1887, 1887, -31, 256, -362, -362, 225,
962	204, -362, 246, 1204, 1219, 1234, 1249, 1264, 1359, -362,
963	-64, 258, 254, 1887, -362, -362, -362, -362, -362, -362,
964	-362, -362, 225, -362, -14, -362, -362
965	};
966
967	/* YYPGOTO[NTERM-NUM]. */
968	static const yytype_int16 yypgoto[] =
969	{
970	-362, -362, -362, -362, -362, -362, -362, -4, -1, 48,
971	-362, -362, -362, -168, -362, -362, 303, 308, 209, -249,
972	-362, -361, -80, -17, 185, 0, -362, -362, -362, -362,
973	-362, -362, -362, -362, -362, -362, -362, -362, -362, -362,
974	-362, -362, -362, -362
975	};
976
977	/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
978	positive, shift that token. If negative, reduce the rule which
979	number is the opposite. If zero, do what YYDEFACT says.
980	If YYTABLE_NINF, syntax error. */
981	#define YYTABLE_NINF -154
982	static const yytype_int16 yytable[] =
983	{
984	61, 70, 169, 100, 304, 368, 152, 153, 381, 148,
985	154, 89, 155, 156, 308, 113, 115, 117, 119, 123,
986	151, 150, 125, 122, 103, 154, 226, 104, 156, 151,
987	154, 381, 330, 156, 170, 369, 225, 154, 151, 331,
988	156, 105, 171, 172, 148, 151, 106, 70, 124, 107,
989	144, 274, 97, 151, 151, 101, 108, 186, 151, 276,
990	278, 379, 148, 151, 293, 168, 175, 101, 101, 101,
991	101, 109, 151, 177, 101, 151, 151, 127, 294, 151,
992	151, 305, 306, 120, 121, 367, 396, 148, 110, 366,
993	157, 158, 159, 160, 161, 139, 162, 149, 143, 163,
994	164, 111, 146, 126, 165, 227, 216, 217, 128, 161,
995	198, 166, 167, 201, 161, 129, 162, 204, 101, 165,
996	160, 161, 214, 162, 165, 101, 215, 285, 178, 333,
997	334, 165, 149, 286, 100, 130, 224, -110, 179, 279,
998	103, 280, 251, 132, 228, -110, -110, 185, 230, 148,
999	149, 188, 190, 191, 192, 193, 194, 195, 196, 131,
1000	199, 243, 170, 133, 202, 134, 152, 249, 180, 281,
1001	154, -152, 252, 156, 101, 149, 135, 218, 181, 282,
1002	256, 136, 258, 221, 152, 153, 101, 137, 154, 30,
1003	155, 156, 182, 283, 183, 284, 101, 184, 287, 231,
1004	232, 233, 147, 234, 169, 235, 236, 237, 238, 239,
1005	240, 241, 242, 101, 148, 104, 356, 107, 357, 101,
1006	179, 148, 250, 176, 101, 108, 358, 254, 255, 337,
1007	257, 180, 259, -153, 181, 261, 182, 149, 110, 359,
1008	183, 152, 153, 111, 360, 154, 184, 155, 156, 302,
1009	157, 158, 159, 160, 161, -154, 162, 141, 142, 154,
1010	164, 205, 156, 151, 165, 206, 220, 290, 157, 158,
1011	159, 160, 161, 148, 162, 267, 148, 163, 164, 222,
1012	171, 268, 165, 152, 153, 321, 248, 154, 263, 155,
1013	156, 288, 297, 291, 368, 298, -112, -132, -132, 301,
1014	329, 303, 149, 383, -112, -112, 339, 338, 340, 149,
1015	102, 303, 395, 309, 310, 311, 349, 312, 350, 313,
1016	314, 351, 352, 353, 244, 157, 158, 159, 160, 161,
1017	354, 162, 355, 364, 163, 164, 365, 327, 245, 165,
1018	158, 159, 160, 161, 332, 162, 384, 335, -105, 164,
1019	380, -106, 392, 165, 393, 140, -105, -105, 0, -106,
1020	-106, 149, 253, 391, 149, 0, 0, 157, 158, 159,
1021	160, 161, 0, 162, 269, 0, 163, 164, 0, 0,
1022	270, 165, 394, 2, 3, 0, 303, 0, 0, 0,
1023	373, 4, 374, 375, 0, 376, 148, 5, 6, 7,
1024	8, 0, 152, 153, 0, 9, 154, 0, 155, 156,
1025	0, 377, 378, 0, 0, 10, 0, 152, 153, 0,
1026	0, 154, 0, 155, 156, 0, 0, 0, 0, 11,
1027	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1028	22, 23, 24, 25, 26, 0, 27, 28, 29, 30,
1029	0, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1030	40, 41, 42, 43, 44, 45, 46, 47, 48, 0,
1031	49, -107, 50, 0, 51, 0, 0, 0, 52, -107,
1032	-107, 0, 53, 148, 149, 54, 157, 158, 159, 160,
1033	161, 0, 162, 272, 0, 163, 164, 0, 0, 273,
1034	165, 157, 158, 159, 160, 161, 295, 162, 296, 0,
1035	163, 164, 152, 153, 0, 165, 154, 0, 155, 156,
1036	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1037	0, 154, 0, 155, 156, 0, 0, 0, 0, 0,
1038	0, 0, 152, 153, 0, 0, 154, 0, 155, 156,
1039	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1040	0, 154, 0, 155, 156, 0, -133, -133, 0, 0,
1041	0, 149, 152, 153, 0, 0, 154, 0, 155, 156,
1042	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1043	0, 154, 0, 155, 156, 0, 157, 158, 159, 160,
1044	161, 0, 162, 299, 0, 163, 164, 0, 0, 300,
1045	165, 157, 158, 159, 160, 161, 0, 162, 345, 0,
1046	163, 164, 0, 0, 346, 165, 157, 158, 159, 160,
1047	161, 0, 162, 347, 0, 163, 164, 0, 0, 348,
1048	165, 157, 158, 159, 160, 161, 0, 162, 247, 0,
1049	163, 164, 0, 0, 0, 165, 157, 158, 159, 160,
1050	161, 0, 162, 0, 0, 163, 164, 0, 0, 260,
1051	165, 157, 158, 159, 160, 161, 0, 162, 0, 0,
1052	163, 164, 152, 153, 262, 165, 154, 0, 155, 156,
1053	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1054	0, 154, 0, 155, 156, 0, 0, 0, 0, 0,
1055	0, 0, 152, 153, 0, 0, 154, 0, 155, 156,
1056	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1057	0, 154, 0, 155, 156, 0, 0, 0, 0, 0,
1058	0, 0, 152, 153, 0, 0, 154, 0, 155, 156,
1059	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1060	0, 154, 0, 155, 156, 0, 157, 158, 159, 160,
1061	161, 0, 162, 0, 0, 163, 164, 0, 0, 264,
1062	165, 157, 158, 159, 160, 161, 0, 162, 265, 0,
1063	163, 164, 0, 0, 0, 165, 157, 158, 159, 160,
1064	161, 0, 162, 266, 0, 163, 164, 0, 0, 0,
1065	165, 157, 158, 159, 160, 161, 0, 162, 271, 0,
1066	163, 164, 0, 0, 0, 165, 157, 158, 159, 160,
1067	161, 0, 162, 0, 0, 163, 164, 0, 0, 275,
1068	165, 157, 158, 159, 160, 161, 0, 162, 0, 0,
1069	163, 164, 152, 153, 277, 165, 154, 0, 155, 156,
1070	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1071	0, 154, 0, 155, 156, 0, 0, 0, 0, 0,
1072	0, 0, 152, 153, 0, 0, 154, 0, 155, 156,
1073	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1074	0, 154, 0, 155, 156, 0, 0, 0, 0, 0,
1075	0, 0, 152, 153, 0, 0, 154, 0, 155, 156,
1076	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1077	0, 154, 0, 155, 156, 0, 157, 158, 159, 160,
1078	161, 0, 162, 289, 0, 163, 164, 0, 0, 0,
1079	165, 157, 158, 159, 160, 161, 0, 162, 0, 0,
1080	163, 164, 0, 0, 292, 165, 157, 158, 159, 160,
1081	161, 0, 162, 307, 0, 163, 164, 0, 0, 0,
1082	165, 157, 158, 159, 160, 161, 0, 162, 0, 0,
1083	163, 164, 0, 0, 328, 165, 157, 158, 159, 160,
1084	161, 0, 162, 0, 0, 163, 164, 0, 0, 245,
1085	165, 157, 158, 159, 160, 161, 336, 162, 0, 0,
1086	163, 164, 152, 153, 0, 165, 154, 0, 155, 156,
1087	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1088	0, 154, 0, 155, 156, 0, 0, 0, 0, 0,
1089	0, 0, 152, 153, 0, 0, 154, 0, 155, 156,
1090	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1091	0, 154, 0, 155, 156, 0, 0, 0, 0, 0,
1092	0, 0, 152, 153, 0, 0, 154, 0, 155, 156,
1093	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1094	0, 154, 0, 155, 156, 0, 157, 158, 159, 160,
1095	161, 0, 162, 0, 0, 163, 164, 0, 0, 341,
1096	165, 157, 158, 159, 160, 161, 0, 162, 342, 0,
1097	163, 164, 0, 0, 0, 165, 157, 158, 159, 160,
1098	161, 0, 162, 0, 0, 163, 164, 0, 0, 343,
1099	165, 157, 158, 159, 160, 161, 0, 162, 344, 0,
1100	163, 164, 0, 0, 0, 165, 157, 158, 159, 160,
1101	161, 0, 162, 0, 0, 163, 164, 0, 0, 361,
1102	165, 157, 158, 159, 160, 161, 362, 162, 0, 0,
1103	163, 164, 152, 153, 0, 165, 154, 0, 155, 156,
1104	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1105	0, 154, 0, 155, 156, 0, 0, 0, 0, 0,
1106	0, 0, 152, 153, 0, 0, 154, 0, 155, 156,
1107	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1108	0, 154, 0, 155, 156, 0, 0, 0, 0, 0,
1109	0, 0, 152, 153, 0, 0, 154, 0, 155, 156,
1110	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1111	0, 154, 0, 155, 156, 0, 157, 158, 159, 160,
1112	161, 0, 162, 363, 0, 163, 164, 0, 0, 0,
1113	165, 157, 158, 159, 160, 161, 0, 162, 0, 0,
1114	163, 164, 0, 0, 385, 165, 157, 158, 159, 160,
1115	161, 0, 162, 0, 0, 163, 164, 0, 0, 386,
1116	165, 157, 158, 159, 160, 161, 0, 162, 148, 0,
1117	163, 164, 0, 0, 387, 165, 157, 158, 159, 160,
1118	161, 0, 162, 148, 0, 163, 164, 0, 0, 388,
1119	165, 157, 158, 159, 160, 161, 0, 162, 0, 0,
1120	163, 164, 152, 153, 389, 165, 154, 0, 155, 156,
1121	0, 0, 0, 0, 0, 0, 0, 152, 153, 0,
1122	0, 154, 0, 155, 156, 0, 0, 0, 0, 0,
1123	0, 0, 152, 153, 0, 0, 154, 0, 155, 156,
1124	0, 0, 0, -108, 0, 0, 152, 0, 0, 0,
1125	154, -108, -108, 156, 0, 0, 149, 0, -111, 0,
1126	0, 0, 0, 0, 0, 0, -111, -111, 0, 0,
1127	0, 149, 0, 0, 0, 0, 0, 0, 0, 0,
1128	0, 0, 0, 0, 0, 0, 157, 158, 159, 160,
1129	161, 390, 162, 0, 0, 163, 164, 0, 0, 0,
1130	165, 157, 158, 159, 160, 161, 0, 162, 0, 0,
1131	163, 164, 0, 0, 0, 165, 157, 158, 159, 160,
1132	161, 0, 162, 0, 0, 0, 164, 0, 0, 0,
1133	165, 158, 159, 160, 161, 0, 162, 0, 0, 4,
1134	164, 0, 0, 0, 165, 5, 6, 90, 91, 5,
1135	6, 315, 316, 9, 0, 0, 0, 9, 0, 0,
1136	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1137	0, 0, 0, 0, 0, 0, 0, 11, 12, 13,
1138	14, 15, 16, 17, 18, 92, 93, 94, 95, 317,
1139	318, 319, 320, 0, 0, 0, 0, 30, 0, 31,
1140	32, 33, 0, 35, 36, 4, 0, 0, 40, 41,
1141	0, 5, 6, 90, 91, 0, 96, 0, 0, 9,
1142	50, 0, 51, 0, 0, 0, 0, 0, 0, 0,
1143	53, 197, 0, 54, 0, 0, 0, 0, 0, 0,
1144	0, 0, 0, 11, 12, 13, 14, 15, 16, 17,
1145	18, 92, 93, 94, 95, 0, 0, 0, 0, 0,
1146	0, 0, 0, 30, 0, 31, 32, 33, 0, 35,
1147	36, 4, 0, 0, 40, 41, 0, 5, 6, 90,
1148	91, 0, 96, 0, 0, 9, 50, 0, 51, 0,
1149	0, 0, 0, 0, 0, 0, 53, 200, 0, 54,
1150	0, 0, 0, 0, 0, 0, 0, 0, 0, 11,
1151	12, 13, 14, 15, 16, 17, 18, 92, 93, 94,
1152	95, 0, 0, 0, 0, 0, 0, 0, 0, 30,
1153	0, 31, 32, 33, 0, 35, 36, 4, 0, 0,
1154	40, 41, 0, 5, 6, 207, 208, 0, 96, 0,
1155	0, 9, 50, 0, 51, 0, 0, 0, 0, 0,
1156	0, 0, 53, 203, 0, 54, 0, 0, 0, 0,
1157	0, 0, 0, 0, 0, 11, 12, 13, 14, 15,
1158	16, 17, 18, 209, 210, 211, 212, 0, 0, 0,
1159	0, 0, 0, 0, 0, 30, 0, 31, 32, 33,
1160	0, 35, 36, 4, 0, 0, 40, 41, 0, 5,
1161	6, 90, 91, 0, 96, 0, 0, 9, 50, 0,
1162	51, 0, 0, 0, 0, 0, 0, 0, 53, 213,
1163	0, 54, 0, 0, 0, 0, 0, 0, 0, 0,
1164	0, 11, 12, 13, 14, 15, 16, 17, 18, 92,
1165	93, 94, 95, 0, 0, 0, 0, 0, 0, 0,
1166	0, 30, 0, 31, 32, 33, 0, 35, 36, 4,
1167	0, 0, 40, 41, 0, 5, 6, 90, 91, 0,
1168	96, 0, 0, 9, 50, 0, 51, 0, 0, 0,
1169	0, 0, 0, 0, 53, 223, 0, 54, 0, 0,
1170	0, 0, 0, 0, 0, 0, 0, 11, 12, 13,
1171	14, 15, 16, 17, 18, 92, 93, 94, 95, 0,
1172	0, 0, 0, 0, 0, 0, 0, 30, 0, 31,
1173	32, 33, 0, 35, 36, 4, 0, 0, 40, 41,
1174	0, 5, 6, 90, 91, 0, 96, 0, 0, 9,
1175	50, 0, 51, 0, 0, 0, 0, 0, 0, 0,
1176	53, 229, 0, 54, 0, 0, 0, 0, 0, 0,
1177	0, 0, 0, 11, 12, 13, 14, 15, 16, 17,
1178	18, 92, 93, 94, 95, 0, 0, 0, 0, 0,
1179	0, 0, 0, 30, 0, 31, 32, 33, 0, 35,
1180	36, 4, 0, 0, 40, 41, 0, 5, 6, 90,
1181	91, 0, 96, 0, 0, 9, 50, 0, 51, 0,
1182	0, 0, 0, 0, 0, 0, 53, 0, 0, 54,
1183	0, 0, 0, 0, 0, 0, 0, 0, 0, 11,
1184	12, 13, 14, 15, 16, 17, 18, 92, 93, 94,
1185	95, 0, 0, 0, 0, 0, 0, 0, 0, 30,
1186	0, 31, 32, 33, 0, 35, 36, 4, 0, 0,
1187	40, 41, 0, 5, 6, 90, 91, 0, 96, 0,
1188	0, 9, 50, 0, 51, 0, 0, 0, 0, 0,
1189	0, 0, 99, 0, 0, 54, 0, 0, 0, 0,
1190	0, 0, 0, 0, 0, 11, 12, 13, 14, 15,
1191	16, 17, 18, 92, 93, 94, 95, 0, 0, 0,
1192	0, 0, 0, 0, 0, 30, 0, 31, 32, 33,
1193	0, 35, 36, 4, 0, 0, 40, 41, 0, 5,
1194	6, 90, 91, 0, 96, 0, 0, 9, 50, 0,
1195	51, 0, 0, 0, 0, 0, 0, 0, 112, 0,
1196	0, 54, 0, 0, 0, 0, 0, 0, 0, 0,
1197	0, 11, 12, 13, 14, 15, 16, 17, 18, 92,
1198	93, 94, 95, 0, 0, 0, 0, 0, 0, 0,
1199	0, 30, 0, 31, 32, 33, 0, 35, 36, 4,
1200	0, 0, 40, 41, 0, 5, 6, 90, 91, 0,
1201	96, 0, 0, 9, 50, 0, 51, 0, 0, 0,
1202	0, 0, 0, 0, 114, 0, 0, 54, 0, 0,
1203	0, 0, 0, 0, 0, 0, 0, 11, 12, 13,
1204	14, 15, 16, 17, 18, 92, 93, 94, 95, 0,
1205	0, 0, 0, 0, 0, 0, 0, 30, 0, 31,
1206	32, 33, 0, 35, 36, 4, 0, 0, 40, 41,
1207	0, 5, 6, 90, 91, 0, 96, 0, 0, 9,
1208	50, 0, 51, 0, 0, 0, 0, 0, 0, 0,
1209	116, 0, 0, 54, 0, 0, 0, 0, 0, 0,
1210	0, 0, 0, 11, 12, 13, 14, 15, 16, 17,
1211	18, 92, 93, 94, 95, 0, 0, 0, 0, 0,
1212	0, 0, 0, 30, 0, 31, 32, 33, 0, 35,
1213	36, 4, 0, 0, 40, 41, 0, 5, 6, 138,
1214	91, 0, 96, 0, 0, 9, 50, 0, 51, 0,
1215	0, 0, 0, 0, 0, 0, 118, 0, 0, 54,
1216	0, 0, 0, 0, 0, 0, 0, 0, 0, 11,
1217	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1218	22, 0, 0, 0, 0, 0, 0, 0, 0, 30,
1219	0, 31, 32, 33, 0, 35, 36, 4, 0, 0,
1220	40, 41, 0, 5, 6, 90, 91, 0, 96, 0,
1221	0, 9, 50, 0, 51, 0, 0, 0, 0, 0,
1222	0, 0, 53, 0, 0, 54, 0, 0, 0, 0,
1223	0, 0, 0, 0, 0, 11, 12, 13, 14, 15,
1224	16, 17, 18, 92, 93, 94, 95, 0, 0, 0,
1225	0, 0, 0, 0, 0, 30, 0, 31, 32, 33,
1226	0, 35, 36, 4, 0, 0, 40, 41, 0, 5,
1227	6, 90, 91, 0, 96, 0, 0, 9, 50, 0,
1228	51, 0, 0, 0, 0, 0, 0, 0, 174, 0,
1229	0, 54, 0, 0, 0, 0, 0, 0, 0, 0,
1230	0, 11, 12, 13, 14, 15, 16, 17, 18, 92,
1231	93, 94, 95, 0, 0, 0, 0, 0, 0, 0,
1232	0, 30, 0, 31, 32, 33, 0, 35, 36, 4,
1233	0, 0, 40, 41, 0, 5, 6, 90, 91, 0,
1234	96, 0, 0, 9, 50, 0, 51, 0, 0, 0,
1235	0, 0, 0, 0, 187, 0, 0, 54, 0, 0,
1236	0, 0, 0, 0, 0, 0, 0, 322, 12, 13,
1237	323, 324, 16, 325, 326, 92, 93, 94, 95, 0,
1238	0, 0, 0, 0, 0, 0, 0, 30, 0, 31,
1239	32, 33, 0, 35, 36, 0, 0, 0, 40, 41,
1240	0, 0, 0, 0, 0, 0, 96, 0, 0, 0,
1241	50, 0, 51, 0, 0, 0, 0, 0, 0, 0,
1242	53, 0, 0, 54
1243	};
1244
1245	static const yytype_int16 yycheck[] =
1246	{
1247	1, 1, 12, 7, 253, 69, 3, 4, 369, 11,
1248	7, 95, 9, 10, 263, 19, 20, 21, 22, 66,
1249	94, 86, 26, 24, 99, 7, 100, 99, 10, 94,
1250	7, 392, 67, 10, 86, 99, 92, 7, 94, 74,
1251	10, 99, 94, 95, 11, 94, 99, 47, 95, 99,
1252	51, 100, 4, 94, 94, 7, 99, 67, 94, 100,
1253	100, 92, 11, 94, 100, 66, 70, 19, 20, 21,
1254	22, 99, 94, 77, 26, 94, 94, 29, 100, 94,
1255	94, 100, 100, 66, 67, 100, 100, 11, 99, 338,
1256	87, 88, 89, 90, 91, 47, 93, 99, 50, 96,
1257	97, 99, 54, 99, 101, 102, 66, 67, 66, 91,
1258	111, 63, 64, 114, 91, 99, 93, 118, 70, 101,
1259	90, 91, 126, 93, 101, 77, 126, 94, 80, 297,
1260	298, 101, 99, 100, 138, 99, 137, 86, 99, 100,
1261	99, 100, 91, 99, 148, 94, 95, 99, 149, 11,
1262	99, 103, 104, 105, 106, 107, 108, 109, 110, 67,
1263	112, 165, 86, 99, 116, 66, 3, 171, 99, 100,
1264	7, 95, 176, 10, 126, 99, 99, 129, 99, 100,
1265	181, 66, 183, 135, 3, 4, 138, 99, 7, 66,
1266	9, 10, 99, 100, 99, 100, 148, 99, 100, 151,
1267	152, 153, 95, 155, 12, 157, 158, 159, 160, 161,
1268	162, 163, 164, 165, 11, 99, 100, 99, 100, 171,
1269	99, 11, 174, 94, 176, 99, 100, 179, 180, 91,
1270	182, 99, 184, 95, 99, 187, 99, 99, 99, 100,
1271	99, 3, 4, 99, 100, 7, 99, 9, 10, 253,
1272	87, 88, 89, 90, 91, 3, 93, 48, 49, 7,
1273	97, 95, 10, 94, 101, 95, 66, 219, 87, 88,
1274	89, 90, 91, 11, 93, 94, 11, 96, 97, 67,
1275	94, 100, 101, 3, 4, 285, 67, 7, 94, 9,
1276	10, 67, 244, 66, 69, 247, 86, 94, 95, 251,
1277	67, 253, 99, 99, 94, 95, 307, 94, 94, 99,
1278	7, 263, 392, 265, 266, 267, 100, 269, 100, 271,
1279	272, 100, 100, 100, 86, 87, 88, 89, 90, 91,
1280	100, 93, 100, 91, 96, 97, 337, 289, 100, 101,
1281	88, 89, 90, 91, 296, 93, 100, 299, 86, 97,
1282	94, 86, 94, 101, 100, 47, 94, 95, -1, 94,
1283	95, 99, 177, 380, 99, -1, -1, 87, 88, 89,
1284	90, 91, -1, 93, 94, -1, 96, 97, -1, -1,
1285	100, 101, 383, 0, 1, -1, 338, -1, -1, -1,
1286	342, 8, 344, 345, -1, 347, 11, 14, 15, 16,
1287	17, -1, 3, 4, -1, 22, 7, -1, 9, 10,
1288	-1, 363, 364, -1, -1, 32, -1, 3, 4, -1,
1289	-1, 7, -1, 9, 10, -1, -1, -1, -1, 46,
1290	47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1291	57, 58, 59, 60, 61, -1, 63, 64, 65, 66,
1292	-1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1293	77, 78, 79, 80, 81, 82, 83, 84, 85, -1,
1294	87, 86, 89, -1, 91, -1, -1, -1, 95, 94,
1295	95, -1, 99, 11, 99, 102, 87, 88, 89, 90,
1296	91, -1, 93, 94, -1, 96, 97, -1, -1, 100,
1297	101, 87, 88, 89, 90, 91, 92, 93, 94, -1,
1298	96, 97, 3, 4, -1, 101, 7, -1, 9, 10,
1299	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1300	-1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1301	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1302	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1303	-1, 7, -1, 9, 10, -1, 94, 95, -1, -1,
1304	-1, 99, 3, 4, -1, -1, 7, -1, 9, 10,
1305	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1306	-1, 7, -1, 9, 10, -1, 87, 88, 89, 90,
1307	91, -1, 93, 94, -1, 96, 97, -1, -1, 100,
1308	101, 87, 88, 89, 90, 91, -1, 93, 94, -1,
1309	96, 97, -1, -1, 100, 101, 87, 88, 89, 90,
1310	91, -1, 93, 94, -1, 96, 97, -1, -1, 100,
1311	101, 87, 88, 89, 90, 91, -1, 93, 94, -1,
1312	96, 97, -1, -1, -1, 101, 87, 88, 89, 90,
1313	91, -1, 93, -1, -1, 96, 97, -1, -1, 100,
1314	101, 87, 88, 89, 90, 91, -1, 93, -1, -1,
1315	96, 97, 3, 4, 100, 101, 7, -1, 9, 10,
1316	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1317	-1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1318	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1319	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1320	-1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1321	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1322	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1323	-1, 7, -1, 9, 10, -1, 87, 88, 89, 90,
1324	91, -1, 93, -1, -1, 96, 97, -1, -1, 100,
1325	101, 87, 88, 89, 90, 91, -1, 93, 94, -1,
1326	96, 97, -1, -1, -1, 101, 87, 88, 89, 90,
1327	91, -1, 93, 94, -1, 96, 97, -1, -1, -1,
1328	101, 87, 88, 89, 90, 91, -1, 93, 94, -1,
1329	96, 97, -1, -1, -1, 101, 87, 88, 89, 90,
1330	91, -1, 93, -1, -1, 96, 97, -1, -1, 100,
1331	101, 87, 88, 89, 90, 91, -1, 93, -1, -1,
1332	96, 97, 3, 4, 100, 101, 7, -1, 9, 10,
1333	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1334	-1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1335	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1336	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1337	-1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1338	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1339	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1340	-1, 7, -1, 9, 10, -1, 87, 88, 89, 90,
1341	91, -1, 93, 94, -1, 96, 97, -1, -1, -1,
1342	101, 87, 88, 89, 90, 91, -1, 93, -1, -1,
1343	96, 97, -1, -1, 100, 101, 87, 88, 89, 90,
1344	91, -1, 93, 94, -1, 96, 97, -1, -1, -1,
1345	101, 87, 88, 89, 90, 91, -1, 93, -1, -1,
1346	96, 97, -1, -1, 100, 101, 87, 88, 89, 90,
1347	91, -1, 93, -1, -1, 96, 97, -1, -1, 100,
1348	101, 87, 88, 89, 90, 91, 92, 93, -1, -1,
1349	96, 97, 3, 4, -1, 101, 7, -1, 9, 10,
1350	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1351	-1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1352	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1353	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1354	-1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1355	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1356	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1357	-1, 7, -1, 9, 10, -1, 87, 88, 89, 90,
1358	91, -1, 93, -1, -1, 96, 97, -1, -1, 100,
1359	101, 87, 88, 89, 90, 91, -1, 93, 94, -1,
1360	96, 97, -1, -1, -1, 101, 87, 88, 89, 90,
1361	91, -1, 93, -1, -1, 96, 97, -1, -1, 100,
1362	101, 87, 88, 89, 90, 91, -1, 93, 94, -1,
1363	96, 97, -1, -1, -1, 101, 87, 88, 89, 90,
1364	91, -1, 93, -1, -1, 96, 97, -1, -1, 100,
1365	101, 87, 88, 89, 90, 91, 92, 93, -1, -1,
1366	96, 97, 3, 4, -1, 101, 7, -1, 9, 10,
1367	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1368	-1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1369	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1370	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1371	-1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1372	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1373	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1374	-1, 7, -1, 9, 10, -1, 87, 88, 89, 90,
1375	91, -1, 93, 94, -1, 96, 97, -1, -1, -1,
1376	101, 87, 88, 89, 90, 91, -1, 93, -1, -1,
1377	96, 97, -1, -1, 100, 101, 87, 88, 89, 90,
1378	91, -1, 93, -1, -1, 96, 97, -1, -1, 100,
1379	101, 87, 88, 89, 90, 91, -1, 93, 11, -1,
1380	96, 97, -1, -1, 100, 101, 87, 88, 89, 90,
1381	91, -1, 93, 11, -1, 96, 97, -1, -1, 100,
1382	101, 87, 88, 89, 90, 91, -1, 93, -1, -1,
1383	96, 97, 3, 4, 100, 101, 7, -1, 9, 10,
1384	-1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1385	-1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1386	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1387	-1, -1, -1, 86, -1, -1, 3, -1, -1, -1,
1388	7, 94, 95, 10, -1, -1, 99, -1, 86, -1,
1389	-1, -1, -1, -1, -1, -1, 94, 95, -1, -1,
1390	-1, 99, -1, -1, -1, -1, -1, -1, -1, -1,
1391	-1, -1, -1, -1, -1, -1, 87, 88, 89, 90,
1392	91, 92, 93, -1, -1, 96, 97, -1, -1, -1,
1393	101, 87, 88, 89, 90, 91, -1, 93, -1, -1,
1394	96, 97, -1, -1, -1, 101, 87, 88, 89, 90,
1395	91, -1, 93, -1, -1, -1, 97, -1, -1, -1,
1396	101, 88, 89, 90, 91, -1, 93, -1, -1, 8,
1397	97, -1, -1, -1, 101, 14, 15, 16, 17, 14,
1398	15, 16, 17, 22, -1, -1, -1, 22, -1, -1,
1399	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1400	-1, -1, -1, -1, -1, -1, -1, 46, 47, 48,
1401	49, 50, 51, 52, 53, 54, 55, 56, 57, 54,
1402	55, 56, 57, -1, -1, -1, -1, 66, -1, 68,
1403	69, 70, -1, 72, 73, 8, -1, -1, 77, 78,
1404	-1, 14, 15, 16, 17, -1, 85, -1, -1, 22,
1405	89, -1, 91, -1, -1, -1, -1, -1, -1, -1,
1406	99, 100, -1, 102, -1, -1, -1, -1, -1, -1,
1407	-1, -1, -1, 46, 47, 48, 49, 50, 51, 52,
1408	53, 54, 55, 56, 57, -1, -1, -1, -1, -1,
1409	-1, -1, -1, 66, -1, 68, 69, 70, -1, 72,
1410	73, 8, -1, -1, 77, 78, -1, 14, 15, 16,
1411	17, -1, 85, -1, -1, 22, 89, -1, 91, -1,
1412	-1, -1, -1, -1, -1, -1, 99, 100, -1, 102,
1413	-1, -1, -1, -1, -1, -1, -1, -1, -1, 46,
1414	47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1415	57, -1, -1, -1, -1, -1, -1, -1, -1, 66,
1416	-1, 68, 69, 70, -1, 72, 73, 8, -1, -1,
1417	77, 78, -1, 14, 15, 16, 17, -1, 85, -1,
1418	-1, 22, 89, -1, 91, -1, -1, -1, -1, -1,
1419	-1, -1, 99, 100, -1, 102, -1, -1, -1, -1,
1420	-1, -1, -1, -1, -1, 46, 47, 48, 49, 50,
1421	51, 52, 53, 54, 55, 56, 57, -1, -1, -1,
1422	-1, -1, -1, -1, -1, 66, -1, 68, 69, 70,
1423	-1, 72, 73, 8, -1, -1, 77, 78, -1, 14,
1424	15, 16, 17, -1, 85, -1, -1, 22, 89, -1,
1425	91, -1, -1, -1, -1, -1, -1, -1, 99, 100,
1426	-1, 102, -1, -1, -1, -1, -1, -1, -1, -1,
1427	-1, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1428	55, 56, 57, -1, -1, -1, -1, -1, -1, -1,
1429	-1, 66, -1, 68, 69, 70, -1, 72, 73, 8,
1430	-1, -1, 77, 78, -1, 14, 15, 16, 17, -1,
1431	85, -1, -1, 22, 89, -1, 91, -1, -1, -1,
1432	-1, -1, -1, -1, 99, 100, -1, 102, -1, -1,
1433	-1, -1, -1, -1, -1, -1, -1, 46, 47, 48,
1434	49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
1435	-1, -1, -1, -1, -1, -1, -1, 66, -1, 68,
1436	69, 70, -1, 72, 73, 8, -1, -1, 77, 78,
1437	-1, 14, 15, 16, 17, -1, 85, -1, -1, 22,
1438	89, -1, 91, -1, -1, -1, -1, -1, -1, -1,
1439	99, 100, -1, 102, -1, -1, -1, -1, -1, -1,
1440	-1, -1, -1, 46, 47, 48, 49, 50, 51, 52,
1441	53, 54, 55, 56, 57, -1, -1, -1, -1, -1,
1442	-1, -1, -1, 66, -1, 68, 69, 70, -1, 72,
1443	73, 8, -1, -1, 77, 78, -1, 14, 15, 16,
1444	17, -1, 85, -1, -1, 22, 89, -1, 91, -1,
1445	-1, -1, -1, -1, -1, -1, 99, -1, -1, 102,
1446	-1, -1, -1, -1, -1, -1, -1, -1, -1, 46,
1447	47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1448	57, -1, -1, -1, -1, -1, -1, -1, -1, 66,
1449	-1, 68, 69, 70, -1, 72, 73, 8, -1, -1,
1450	77, 78, -1, 14, 15, 16, 17, -1, 85, -1,
1451	-1, 22, 89, -1, 91, -1, -1, -1, -1, -1,
1452	-1, -1, 99, -1, -1, 102, -1, -1, -1, -1,
1453	-1, -1, -1, -1, -1, 46, 47, 48, 49, 50,
1454	51, 52, 53, 54, 55, 56, 57, -1, -1, -1,
1455	-1, -1, -1, -1, -1, 66, -1, 68, 69, 70,
1456	-1, 72, 73, 8, -1, -1, 77, 78, -1, 14,
1457	15, 16, 17, -1, 85, -1, -1, 22, 89, -1,
1458	91, -1, -1, -1, -1, -1, -1, -1, 99, -1,
1459	-1, 102, -1, -1, -1, -1, -1, -1, -1, -1,
1460	-1, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1461	55, 56, 57, -1, -1, -1, -1, -1, -1, -1,
1462	-1, 66, -1, 68, 69, 70, -1, 72, 73, 8,
1463	-1, -1, 77, 78, -1, 14, 15, 16, 17, -1,
1464	85, -1, -1, 22, 89, -1, 91, -1, -1, -1,
1465	-1, -1, -1, -1, 99, -1, -1, 102, -1, -1,
1466	-1, -1, -1, -1, -1, -1, -1, 46, 47, 48,
1467	49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
1468	-1, -1, -1, -1, -1, -1, -1, 66, -1, 68,
1469	69, 70, -1, 72, 73, 8, -1, -1, 77, 78,
1470	-1, 14, 15, 16, 17, -1, 85, -1, -1, 22,
1471	89, -1, 91, -1, -1, -1, -1, -1, -1, -1,
1472	99, -1, -1, 102, -1, -1, -1, -1, -1, -1,
1473	-1, -1, -1, 46, 47, 48, 49, 50, 51, 52,
1474	53, 54, 55, 56, 57, -1, -1, -1, -1, -1,
1475	-1, -1, -1, 66, -1, 68, 69, 70, -1, 72,
1476	73, 8, -1, -1, 77, 78, -1, 14, 15, 16,
1477	17, -1, 85, -1, -1, 22, 89, -1, 91, -1,
1478	-1, -1, -1, -1, -1, -1, 99, -1, -1, 102,
1479	-1, -1, -1, -1, -1, -1, -1, -1, -1, 46,
1480	47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1481	57, -1, -1, -1, -1, -1, -1, -1, -1, 66,
1482	-1, 68, 69, 70, -1, 72, 73, 8, -1, -1,
1483	77, 78, -1, 14, 15, 16, 17, -1, 85, -1,
1484	-1, 22, 89, -1, 91, -1, -1, -1, -1, -1,
1485	-1, -1, 99, -1, -1, 102, -1, -1, -1, -1,
1486	-1, -1, -1, -1, -1, 46, 47, 48, 49, 50,
1487	51, 52, 53, 54, 55, 56, 57, -1, -1, -1,
1488	-1, -1, -1, -1, -1, 66, -1, 68, 69, 70,
1489	-1, 72, 73, 8, -1, -1, 77, 78, -1, 14,
1490	15, 16, 17, -1, 85, -1, -1, 22, 89, -1,
1491	91, -1, -1, -1, -1, -1, -1, -1, 99, -1,
1492	-1, 102, -1, -1, -1, -1, -1, -1, -1, -1,
1493	-1, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1494	55, 56, 57, -1, -1, -1, -1, -1, -1, -1,
1495	-1, 66, -1, 68, 69, 70, -1, 72, 73, 8,
1496	-1, -1, 77, 78, -1, 14, 15, 16, 17, -1,
1497	85, -1, -1, 22, 89, -1, 91, -1, -1, -1,
1498	-1, -1, -1, -1, 99, -1, -1, 102, -1, -1,
1499	-1, -1, -1, -1, -1, -1, -1, 46, 47, 48,
1500	49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
1501	-1, -1, -1, -1, -1, -1, -1, 66, -1, 68,
1502	69, 70, -1, 72, 73, -1, -1, -1, 77, 78,
1503	-1, -1, -1, -1, -1, -1, 85, -1, -1, -1,
1504	89, -1, 91, -1, -1, -1, -1, -1, -1, -1,
1505	99, -1, -1, 102
1506	};
1507
1508	/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1509	symbol of state STATE-NUM. */
1510	static const yytype_uint8 yystos[] =
1511	{
1512	0, 104, 0, 1, 8, 14, 15, 16, 17, 22,
1513	32, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1514	55, 56, 57, 58, 59, 60, 61, 63, 64, 65,
1515	66, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1516	77, 78, 79, 80, 81, 82, 83, 84, 85, 87,
1517	89, 91, 95, 99, 102, 105, 106, 107, 108, 109,
1518	110, 111, 112, 114, 115, 117, 118, 119, 120, 121,
1519	128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
1520	138, 139, 140, 141, 142, 143, 144, 145, 146, 95,
1521	16, 17, 54, 55, 56, 57, 85, 112, 128, 99,
1522	110, 112, 119, 99, 99, 99, 99, 99, 99, 99,
1523	99, 99, 99, 110, 99, 110, 99, 110, 99, 110,
1524	66, 67, 111, 66, 95, 110, 99, 112, 66, 99,
1525	99, 67, 99, 99, 66, 99, 66, 99, 16, 112,
1526	120, 121, 121, 112, 111, 111, 112, 95, 11, 99,
1527	86, 94, 3, 4, 7, 9, 10, 87, 88, 89,
1528	90, 91, 93, 96, 97, 101, 112, 112, 111, 12,
1529	86, 94, 95, 127, 99, 110, 94, 110, 112, 99,
1530	99, 99, 99, 99, 99, 112, 67, 99, 112, 122,
1531	112, 112, 112, 112, 112, 112, 112, 100, 111, 112,
1532	100, 111, 112, 100, 111, 95, 95, 16, 17, 54,
1533	55, 56, 57, 100, 110, 128, 66, 67, 112, 113,
1534	66, 112, 67, 100, 111, 92, 100, 102, 110, 100,
1535	111, 112, 112, 112, 112, 112, 112, 112, 112, 112,
1536	112, 112, 112, 110, 86, 100, 116, 94, 67, 110,
1537	112, 91, 110, 127, 112, 112, 111, 112, 111, 112,
1538	100, 112, 100, 94, 100, 94, 94, 94, 100, 94,
1539	100, 94, 94, 100, 100, 100, 100, 100, 100, 100,
1540	100, 100, 100, 100, 100, 94, 100, 100, 67, 94,
1541	112, 66, 100, 100, 100, 92, 94, 112, 112, 94,
1542	100, 112, 110, 112, 122, 100, 100, 94, 122, 112,
1543	112, 112, 112, 112, 112, 16, 17, 54, 55, 56,
1544	57, 128, 46, 49, 50, 52, 53, 112, 100, 67,
1545	67, 74, 112, 116, 116, 112, 92, 91, 94, 111,
1546	94, 100, 94, 100, 94, 94, 100, 94, 100, 100,
1547	100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
1548	100, 100, 92, 94, 91, 111, 122, 100, 69, 99,
1549	123, 124, 126, 112, 112, 112, 112, 112, 112, 92,
1550	94, 124, 125, 99, 100, 100, 100, 100, 100, 100,
1551	92, 126, 94, 100, 111, 125, 100
1552	};
1553
1554	#define yyerrok (yyerrstatus = 0)
1555	#define yyclearin (yychar = YYEMPTY)
1556	#define YYEMPTY (-2)
1557	#define YYEOF 0
1558
1559	#define YYACCEPT goto yyacceptlab
1560	#define YYABORT goto yyabortlab
1561	#define YYERROR goto yyerrorlab
1562
1563
1564	/* Like YYERROR except do call yyerror. This remains here temporarily
1565	to ease the transition to the new meaning of YYERROR, for GCC.
1566	Once GCC version 2 has supplanted version 1, this can go. However,
1567	YYFAIL appears to be in use. Nevertheless, it is formally deprecated
1568	in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1569	discussed. */
1570
1571	#define YYFAIL goto yyerrlab
1572	#if defined YYFAIL
1573	/* This is here to suppress warnings from the GCC cpp's
1574	-Wunused-macros. Normally we don't worry about that warning, but
1575	some users do, and we want to make it easy for users to remove
1576	YYFAIL uses, which will produce warnings from Bison 2.5. */
1577	#endif
1578
1579	#define YYRECOVERING() (!!yyerrstatus)
1580
1581	#define YYBACKUP(Token, Value) \
1582	do \
1583	if (yychar == YYEMPTY && yylen == 1) \
1584	{ \
1585	yychar = (Token); \
1586	yylval = (Value); \
1587	yytoken = YYTRANSLATE (yychar); \
1588	YYPOPSTACK (1); \
1589	goto yybackup; \
1590	} \
1591	else \
1592	{ \
1593	yyerror (YY_("syntax error: cannot back up")); \
1594	YYERROR; \
1595	} \
1596	while (YYID (0))
1597
1598
1599	#define YYTERROR 1
1600	#define YYERRCODE 256
1601
1602
1603	/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1604	If N is 0, then set CURRENT to the empty location which ends
1605	the previous symbol: RHS[0] (always defined). */
1606
1607	#define YYRHSLOC(Rhs, K) ((Rhs)[K])
1608	#ifndef YYLLOC_DEFAULT
1609	# define YYLLOC_DEFAULT(Current, Rhs, N) \
1610	do \
1611	if (YYID (N)) \
1612	{ \
1613	(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1614	(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1615	(Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1616	(Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1617	} \
1618	else \
1619	{ \
1620	(Current).first_line = (Current).last_line = \
1621	YYRHSLOC (Rhs, 0).last_line; \
1622	(Current).first_column = (Current).last_column = \
1623	YYRHSLOC (Rhs, 0).last_column; \
1624	} \
1625	while (YYID (0))
1626	#endif
1627
1628
1629	/* YY_LOCATION_PRINT -- Print the location on the stream.
1630	This macro was not mandated originally: define only if we know
1631	we won't break user code: when these are the locations we know. */
1632
1633	#ifndef YY_LOCATION_PRINT
1634	# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1635	# define YY_LOCATION_PRINT(File, Loc) \
1636	fprintf (File, "%d.%d-%d.%d", \
1637	(Loc).first_line, (Loc).first_column, \
1638	(Loc).last_line, (Loc).last_column)
1639	# else
1640	# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1641	# endif
1642	#endif
1643
1644
1645	/* YYLEX -- calling `yylex' with the right arguments. */
1646
1647	#ifdef YYLEX_PARAM
1648	# define YYLEX yylex (&yylval, YYLEX_PARAM)
1649	#else
1650	# define YYLEX yylex (&yylval)
1651	#endif
1652
1653	/* Enable debugging if requested. */
1654	#if YYDEBUG
1655
1656	# ifndef YYFPRINTF
1657	# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1658	# define YYFPRINTF fprintf
1659	# endif
1660
1661	# define YYDPRINTF(Args) \
1662	do { \
1663	if (yydebug) \
1664	YYFPRINTF Args; \
1665	} while (YYID (0))
1666
1667	# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1668	do { \
1669	if (yydebug) \
1670	{ \
1671	YYFPRINTF (stderr, "%s ", Title); \
1672	yy_symbol_print (stderr, \
1673	Type, Value); \
1674	YYFPRINTF (stderr, "\n"); \
1675	} \
1676	} while (YYID (0))
1677
1678
1679	/*--------------------------------.
1680	\| Print this symbol on YYOUTPUT. \|
1681	`--------------------------------*/
1682
1683	/ARGSUSED/
1684	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1685	\|\| defined __cplusplus \|\| defined _MSC_VER)
1686	static void
1687	yy_symbol_value_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
1688	#else
1689	static void
1690	yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1691	FILE *yyoutput;
1692	int yytype;
1693	YYSTYPE const * const yyvaluep;
1694	#endif
1695	{
1696	if (!yyvaluep)
1697	return;
1698	# ifdef YYPRINT
1699	if (yytype < YYNTOKENS)
1700	YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1701	# else
1702	YYUSE (yyoutput);
1703	# endif
1704	switch (yytype)
1705	{
1706	default:
1707	break;
1708	}
1709	}
1710
1711
1712	/*--------------------------------.
1713	\| Print this symbol on YYOUTPUT. \|
1714	`--------------------------------*/
1715
1716	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1717	\|\| defined __cplusplus \|\| defined _MSC_VER)
1718	static void
1719	yy_symbol_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
1720	#else
1721	static void
1722	yy_symbol_print (yyoutput, yytype, yyvaluep)
1723	FILE *yyoutput;
1724	int yytype;
1725	YYSTYPE const * const yyvaluep;
1726	#endif
1727	{
1728	if (yytype < YYNTOKENS)
1729	YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1730	else
1731	YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1732
1733	yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1734	YYFPRINTF (yyoutput, ")");
1735	}
1736
1737	/*------------------------------------------------------------------.
1738	\| yy_stack_print -- Print the state stack from its BOTTOM up to its \|
1739	\| TOP (included). \|
1740	`------------------------------------------------------------------*/
1741
1742	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1743	\|\| defined __cplusplus \|\| defined _MSC_VER)
1744	static void
1745	yy_stack_print (yytype_int16 yybottom, yytype_int16 yytop)
1746	#else
1747	static void
1748	yy_stack_print (yybottom, yytop)
1749	yytype_int16 *yybottom;
1750	yytype_int16 *yytop;
1751	#endif
1752	{
1753	YYFPRINTF (stderr, "Stack now");
1754	for (; yybottom <= yytop; yybottom++)
1755	{
1756	int yybot = *yybottom;
1757	YYFPRINTF (stderr, " %d", yybot);
1758	}
1759	YYFPRINTF (stderr, "\n");
1760	}
1761
1762	# define YY_STACK_PRINT(Bottom, Top) \
1763	do { \
1764	if (yydebug) \
1765	yy_stack_print ((Bottom), (Top)); \
1766	} while (YYID (0))
1767
1768
1769	/*------------------------------------------------.
1770	\| Report that the YYRULE is going to be reduced. \|
1771	`------------------------------------------------*/
1772
1773	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1774	\|\| defined __cplusplus \|\| defined _MSC_VER)
1775	static void
1776	yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1777	#else
1778	static void
1779	yy_reduce_print (yyvsp, yyrule)
1780	YYSTYPE *yyvsp;
1781	int yyrule;
1782	#endif
1783	{
1784	int yynrhs = yyr2[yyrule];
1785	int yyi;
1786	unsigned long int yylno = yyrline[yyrule];
1787	YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1788	yyrule - 1, yylno);
1789	/* The symbols being reduced. */
1790	for (yyi = 0; yyi < yynrhs; yyi++)
1791	{
1792	YYFPRINTF (stderr, " $%d = ", yyi + 1);
1793	yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1794	&(yyvsp[(yyi + 1) - (yynrhs)])
1795	);
1796	YYFPRINTF (stderr, "\n");
1797	}
1798	}
1799
1800	# define YY_REDUCE_PRINT(Rule) \
1801	do { \
1802	if (yydebug) \
1803	yy_reduce_print (yyvsp, Rule); \
1804	} while (YYID (0))
1805
1806	/* Nonzero means print parse trace. It is left uninitialized so that
1807	multiple parsers can coexist. */
1808	int yydebug;
1809	#else /* !YYDEBUG */
1810	# define YYDPRINTF(Args)
1811	# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1812	# define YY_STACK_PRINT(Bottom, Top)
1813	# define YY_REDUCE_PRINT(Rule)
1814	#endif /* !YYDEBUG */
1815
1816
1817	/* YYINITDEPTH -- initial size of the parser's stacks. */
1818	#ifndef YYINITDEPTH
1819	# define YYINITDEPTH 200
1820	#endif
1821
1822	/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1823	if the built-in stack extension method is used).
1824
1825	Do not make this value too large; the results are undefined if
1826	YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1827	evaluated with infinite-precision integer arithmetic. */
1828
1829	#ifndef YYMAXDEPTH
1830	# define YYMAXDEPTH 10000
1831	#endif
1832
1833
1834
1835	#if YYERROR_VERBOSE
1836
1837	# ifndef yystrlen
1838	# if defined __GLIBC__ && defined _STRING_H
1839	# define yystrlen strlen
1840	# else
1841	/* Return the length of YYSTR. */
1842	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1843	\|\| defined __cplusplus \|\| defined _MSC_VER)
1844	static YYSIZE_T
1845	yystrlen (const char *yystr)
1846	#else
1847	static YYSIZE_T
1848	yystrlen (yystr)
1849	const char *yystr;
1850	#endif
1851	{
1852	YYSIZE_T yylen;
1853	for (yylen = 0; yystr[yylen]; yylen++)
1854	continue;
1855	return yylen;
1856	}
1857	# endif
1858	# endif
1859
1860	# ifndef yystpcpy
1861	# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1862	# define yystpcpy stpcpy
1863	# else
1864	/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1865	YYDEST. */
1866	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1867	\|\| defined __cplusplus \|\| defined _MSC_VER)
1868	static char *
1869	yystpcpy (char yydest, const char yysrc)
1870	#else
1871	static char *
1872	yystpcpy (yydest, yysrc)
1873	char *yydest;
1874	const char *yysrc;
1875	#endif
1876	{
1877	char *yyd = yydest;
1878	const char *yys = yysrc;
1879
1880	while ((yyd++ = yys++) != '\0')
1881	continue;
1882
1883	return yyd - 1;
1884	}
1885	# endif
1886	# endif
1887
1888	# ifndef yytnamerr
1889	/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1890	quotes and backslashes, so that it's suitable for yyerror. The
1891	heuristic is that double-quoting is unnecessary unless the string
1892	contains an apostrophe, a comma, or backslash (other than
1893	backslash-backslash). YYSTR is taken from yytname. If YYRES is
1894	null, do not copy; instead, return the length of what the result
1895	would have been. */
1896	static YYSIZE_T
1897	yytnamerr (char yyres, const char yystr)
1898	{
1899	if (*yystr == '"')
1900	{
1901	YYSIZE_T yyn = 0;
1902	char const *yyp = yystr;
1903
1904	for (;;)
1905	switch (*++yyp)
1906	{
1907	case '\'':
1908	case ',':
1909	goto do_not_strip_quotes;
1910
1911	case '\\':
1912	if (*++yyp != '\\')
1913	goto do_not_strip_quotes;
1914	/* Fall through. */
1915	default:
1916	if (yyres)
1917	yyres[yyn] = *yyp;
1918	yyn++;
1919	break;
1920
1921	case '"':
1922	if (yyres)
1923	yyres[yyn] = '\0';
1924	return yyn;
1925	}
1926	do_not_strip_quotes: ;
1927	}
1928
1929	if (! yyres)
1930	return yystrlen (yystr);
1931
1932	return yystpcpy (yyres, yystr) - yyres;
1933	}
1934	# endif
1935
1936	/* Copy into YYRESULT an error message about the unexpected token
1937	YYCHAR while in state YYSTATE. Return the number of bytes copied,
1938	including the terminating null byte. If YYRESULT is null, do not
1939	copy anything; just return the number of bytes that would be
1940	copied. As a special case, return 0 if an ordinary "syntax error"
1941	message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1942	size calculation. */
1943	static YYSIZE_T
1944	yysyntax_error (char *yyresult, int yystate, int yychar)
1945	{
1946	int yyn = yypact[yystate];
1947
1948	if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1949	return 0;
1950	else
1951	{
1952	int yytype = YYTRANSLATE (yychar);
1953	YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1954	YYSIZE_T yysize = yysize0;
1955	YYSIZE_T yysize1;
1956	int yysize_overflow = 0;
1957	enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1958	char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1959	int yyx;
1960
1961	# if 0
1962	/* This is so xgettext sees the translatable formats that are
1963	constructed on the fly. */
1964	YY_("syntax error, unexpected %s");
1965	YY_("syntax error, unexpected %s, expecting %s");
1966	YY_("syntax error, unexpected %s, expecting %s or %s");
1967	YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1968	YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1969	# endif
1970	char *yyfmt;
1971	char const *yyf;
1972	static char const yyunexpected[] = "syntax error, unexpected %s";
1973	static char const yyexpecting[] = ", expecting %s";
1974	static char const yyor[] = " or %s";
1975	char yyformat[sizeof yyunexpected
1976	+ sizeof yyexpecting - 1
1977	+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1978	* (sizeof yyor - 1))];
1979	char const *yyprefix = yyexpecting;
1980
1981	/* Start YYX at -YYN if negative to avoid negative indexes in
1982	YYCHECK. */
1983	int yyxbegin = yyn < 0 ? -yyn : 0;
1984
1985	/* Stay within bounds of both yycheck and yytname. */
1986	int yychecklim = YYLAST - yyn + 1;
1987	int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1988	int yycount = 1;
1989
1990	yyarg[0] = yytname[yytype];
1991	yyfmt = yystpcpy (yyformat, yyunexpected);
1992
1993	for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1994	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1995	{
1996	if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1997	{
1998	yycount = 1;
1999	yysize = yysize0;
2000	yyformat[sizeof yyunexpected - 1] = '\0';
2001	break;
2002	}
2003	yyarg[yycount++] = yytname[yyx];
2004	yysize1 = yysize + yytnamerr (0, yytname[yyx]);
2005	yysize_overflow \|= (yysize1 < yysize);
2006	yysize = yysize1;
2007	yyfmt = yystpcpy (yyfmt, yyprefix);
2008	yyprefix = yyor;
2009	}
2010
2011	yyf = YY_(yyformat);
2012	yysize1 = yysize + yystrlen (yyf);
2013	yysize_overflow \|= (yysize1 < yysize);
2014	yysize = yysize1;
2015
2016	if (yysize_overflow)
2017	return YYSIZE_MAXIMUM;
2018
2019	if (yyresult)
2020	{
2021	/* Avoid sprintf, as that infringes on the user's name space.
2022	Don't have undefined behavior even if the translation
2023	produced a string with the wrong number of "%s"s. */
2024	char *yyp = yyresult;
2025	int yyi = 0;
2026	while ((yyp = yyf) != '\0')
2027	{
2028	if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2029	{
2030	yyp += yytnamerr (yyp, yyarg[yyi++]);
2031	yyf += 2;
2032	}
2033	else
2034	{
2035	yyp++;
2036	yyf++;
2037	}
2038	}
2039	}
2040	return yysize;
2041	}
2042	}
2043	#endif /* YYERROR_VERBOSE */
2044
2045
2046	/*-----------------------------------------------.
2047	\| Release the memory associated to this symbol. \|
2048	`-----------------------------------------------*/
2049
2050	/ARGSUSED/
2051	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
2052	\|\| defined __cplusplus \|\| defined _MSC_VER)
2053	static void
2054	yydestruct (const char yymsg, int yytype, YYSTYPE yyvaluep)
2055	#else
2056	static void
2057	yydestruct (yymsg, yytype, yyvaluep)
2058	const char *yymsg;
2059	int yytype;
2060	YYSTYPE *yyvaluep;
2061	#endif
2062	{
2063	YYUSE (yyvaluep);
2064
2065	if (!yymsg)
2066	yymsg = "Deleting";
2067	YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2068
2069	switch (yytype)
2070	{
2071
2072	default:
2073	break;
2074	}
2075	}
2076
2077	/* Prevent warnings from -Wmissing-prototypes. */
2078	#ifdef YYPARSE_PARAM
2079	#if defined __STDC__ \|\| defined __cplusplus
2080	int yyparse (void *YYPARSE_PARAM);
2081	#else
2082	int yyparse ();
2083	#endif
2084	#else /* ! YYPARSE_PARAM */
2085	#if defined __STDC__ \|\| defined __cplusplus
2086	int yyparse (void);
2087	#else
2088	int yyparse ();
2089	#endif
2090	#endif /* ! YYPARSE_PARAM */
2091
2092
2093
2094
2095
2096	/*-------------------------.
2097	\| yyparse or yypush_parse. \|
2098	`-------------------------*/
2099
2100	#ifdef YYPARSE_PARAM
2101	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
2102	\|\| defined __cplusplus \|\| defined _MSC_VER)
2103	int
2104	yyparse (void *YYPARSE_PARAM)
2105	#else
2106	int
2107	yyparse (YYPARSE_PARAM)
2108	void *YYPARSE_PARAM;
2109	#endif
2110	#else /* ! YYPARSE_PARAM */
2111	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
2112	\|\| defined __cplusplus \|\| defined _MSC_VER)
2113	int
2114	yyparse (void)
2115	#else
2116	int
2117	yyparse ()
2118
2119	#endif
2120	#endif
2121	{
2122	/* The lookahead symbol. */
2123	int yychar;
2124
2125	/* The semantic value of the lookahead symbol. */
2126	YYSTYPE yylval;
2127
2128	/* Number of syntax errors so far. */
2129	int yynerrs;
2130
2131	int yystate;
2132	/* Number of tokens to shift before error messages enabled. */
2133	int yyerrstatus;
2134
2135	/* The stacks and their tools:
2136	`yyss': related to states.
2137	`yyvs': related to semantic values.
2138
2139	Refer to the stacks thru separate pointers, to allow yyoverflow
2140	to reallocate them elsewhere. */
2141
2142	/* The state stack. */
2143	yytype_int16 yyssa[YYINITDEPTH];
2144	yytype_int16 *yyss;
2145	yytype_int16 *yyssp;
2146
2147	/* The semantic value stack. */
2148	YYSTYPE yyvsa[YYINITDEPTH];
2149	YYSTYPE *yyvs;
2150	YYSTYPE *yyvsp;
2151
2152	YYSIZE_T yystacksize;
2153
2154	int yyn;
2155	int yyresult;
2156	/* Lookahead token as an internal (translated) token number. */
2157	int yytoken;
2158	/* The variables used to return semantic value and location from the
2159	action routines. */
2160	YYSTYPE yyval;
2161
2162	#if YYERROR_VERBOSE
2163	/* Buffer for error messages, and its allocated size. */
2164	char yymsgbuf[128];
2165	char *yymsg = yymsgbuf;
2166	YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2167	#endif
2168
2169	#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2170
2171	/* The number of symbols on the RHS of the reduced rule.
2172	Keep to zero when no symbol should be popped. */
2173	int yylen = 0;
2174
2175	yytoken = 0;
2176	yyss = yyssa;
2177	yyvs = yyvsa;
2178	yystacksize = YYINITDEPTH;
2179
2180	YYDPRINTF ((stderr, "Starting parse\n"));
2181
2182	yystate = 0;
2183	yyerrstatus = 0;
2184	yynerrs = 0;
2185	yychar = YYEMPTY; /* Cause a token to be read. */
2186
2187	/* Initialize stack pointers.
2188	Waste one element of value and location stack
2189	so that they stay on the same level as the state stack.
2190	The wasted elements are never initialized. */
2191	yyssp = yyss;
2192	yyvsp = yyvs;
2193
2194	goto yysetstate;
2195
2196	/*------------------------------------------------------------.
2197	\| yynewstate -- Push a new state, which is found in yystate. \|
2198	`------------------------------------------------------------*/
2199	yynewstate:
2200	/* In all cases, when you get here, the value and location stacks
2201	have just been pushed. So pushing a state here evens the stacks. */
2202	yyssp++;
2203
2204	yysetstate:
2205	*yyssp = yystate;
2206
2207	if (yyss + yystacksize - 1 <= yyssp)
2208	{
2209	/* Get the current used size of the three stacks, in elements. */
2210	YYSIZE_T yysize = yyssp - yyss + 1;
2211
2212	#ifdef yyoverflow
2213	{
2214	/* Give user a chance to reallocate the stack. Use copies of
2215	these so that the &'s don't force the real ones into
2216	memory. */
2217	YYSTYPE *yyvs1 = yyvs;
2218	yytype_int16 *yyss1 = yyss;
2219
2220	/* Each stack pointer address is followed by the size of the
2221	data in use in that stack, in bytes. This used to be a
2222	conditional around just the two extra args, but that might
2223	be undefined if yyoverflow is a macro. */
2224	yyoverflow (YY_("memory exhausted"),
2225	&yyss1, yysize * sizeof (*yyssp),
2226	&yyvs1, yysize * sizeof (*yyvsp),
2227	&yystacksize);
2228
2229	yyss = yyss1;
2230	yyvs = yyvs1;
2231	}
2232	#else /* no yyoverflow */
2233	# ifndef YYSTACK_RELOCATE
2234	goto yyexhaustedlab;
2235	# else
2236	/* Extend the stack our own way. */
2237	if (YYMAXDEPTH <= yystacksize)
2238	goto yyexhaustedlab;
2239	yystacksize *= 2;
2240	if (YYMAXDEPTH < yystacksize)
2241	yystacksize = YYMAXDEPTH;
2242
2243	{
2244	yytype_int16 *yyss1 = yyss;
2245	union yyalloc *yyptr =
2246	(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2247	if (! yyptr)
2248	goto yyexhaustedlab;
2249	YYSTACK_RELOCATE (yyss_alloc, yyss);
2250	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2251	# undef YYSTACK_RELOCATE
2252	if (yyss1 != yyssa)
2253	YYSTACK_FREE (yyss1);
2254	}
2255	# endif
2256	#endif /* no yyoverflow */
2257
2258	yyssp = yyss + yysize - 1;
2259	yyvsp = yyvs + yysize - 1;
2260
2261	YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2262	(unsigned long int) yystacksize));
2263
2264	if (yyss + yystacksize - 1 <= yyssp)
2265	YYABORT;
2266	}
2267
2268	YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2269
2270	if (yystate == YYFINAL)
2271	YYACCEPT;
2272
2273	goto yybackup;
2274
2275	/*-----------.
2276	\| yybackup. \|
2277	`-----------*/
2278	yybackup:
2279
2280	/* Do appropriate processing given the current state. Read a
2281	lookahead token if we need one and don't already have one. */
2282
2283	/* First try to decide what to do without reference to lookahead token. */
2284	yyn = yypact[yystate];
2285	if (yyn == YYPACT_NINF)
2286	goto yydefault;
2287
2288	/* Not known => get a lookahead token if don't already have one. */
2289
2290	/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2291	if (yychar == YYEMPTY)
2292	{
2293	YYDPRINTF ((stderr, "Reading a token: "));
2294	yychar = YYLEX;
2295	}
2296
2297	if (yychar <= YYEOF)
2298	{
2299	yychar = yytoken = YYEOF;
2300	YYDPRINTF ((stderr, "Now at end of input.\n"));
2301	}
2302	else
2303	{
2304	yytoken = YYTRANSLATE (yychar);
2305	YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2306	}
2307
2308	/* If the proper action on seeing token YYTOKEN is to reduce or to
2309	detect an error, take that action. */
2310	yyn += yytoken;
2311	if (yyn < 0 \|\| YYLAST < yyn \|\| yycheck[yyn] != yytoken)
2312	goto yydefault;
2313	yyn = yytable[yyn];
2314	if (yyn <= 0)
2315	{
2316	if (yyn == 0 \|\| yyn == YYTABLE_NINF)
2317	goto yyerrlab;
2318	yyn = -yyn;
2319	goto yyreduce;
2320	}
2321
2322	/* Count tokens shifted since error; after three, turn off error
2323	status. */
2324	if (yyerrstatus)
2325	yyerrstatus--;
2326
2327	/* Shift the lookahead token. */
2328	YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2329
2330	/* Discard the shifted token. */
2331	yychar = YYEMPTY;
2332
2333	yystate = yyn;
2334	*++yyvsp = yylval;
2335
2336	goto yynewstate;
2337
2338
2339	/*-----------------------------------------------------------.
2340	\| yydefault -- do the default action for the current state. \|
2341	`-----------------------------------------------------------*/
2342	yydefault:
2343	yyn = yydefact[yystate];
2344	if (yyn == 0)
2345	goto yyerrlab;
2346	goto yyreduce;
2347
2348
2349	/*-----------------------------.
2350	\| yyreduce -- Do a reduction. \|
2351	`-----------------------------*/
2352	yyreduce:
2353	/* yyn is the number of a rule to reduce with. */
2354	yylen = yyr2[yyn];
2355
2356	/* If YYLEN is nonzero, implement the default value of the action:
2357	`$$ = $1'.
2358
2359	Otherwise, the following line sets YYVAL to garbage.
2360	This behavior is undocumented and Bison
2361	users should not rely upon it. Assigning to YYVAL
2362	unconditionally makes the parser a bit smaller, and it avoids a
2363	GCC warning that YYVAL may be used uninitialized. */
2364	yyval = yyvsp[1-yylen];
2365
2366
2367	YY_REDUCE_PRINT (yyn);
2368	switch (yyn)
2369	{
2370	case 3:
2371
2372	/* Line 1464 of yacc.c */
2373	#line 320 "grammar.y"
2374	{
2375	if (timerv)
2376	{
2377	writeTime("used time:");
2378	startTimer();
2379	}
2380	if (rtimerv)
2381	{
2382	writeRTime("used real time:");
2383	startRTimer();
2384	}
2385	prompt_char = '>';
2386	#ifdef HAVE_SDB
2387	if (sdb_flags & 2) { sdb_flags=1; YYERROR; }
2388	#endif
2389	if(siCntrlc)
2390	{
2391	WerrorS("abort...");
2392	while((currentVoice!=NULL) && (currentVoice->prev!=NULL)) exitVoice();
2393	if (currentVoice!=NULL) currentVoice->ifsw=0;
2394	}
2395	if (errorreported) /* also catches abort... */
2396	{
2397	yyerror("");
2398	}
2399	if (inerror==2) PrintLn();
2400	errorreported = inerror = cmdtok = 0;
2401	lastreserved = currid = NULL;
2402	expected_parms = siCntrlc = FALSE;
2403	;}
2404	break;
2405
2406	case 5:
2407
2408	/* Line 1464 of yacc.c */
2409	#line 355 "grammar.y"
2410	{currentVoice->ifsw=0;;}
2411	break;
2412
2413	case 6:
2414
2415	/* Line 1464 of yacc.c */
2416	#line 357 "grammar.y"
2417	{ (yyvsp[(1) - (2)].lv).CleanUp(); currentVoice->ifsw=0;;}
2418	break;
2419
2420	case 7:
2421
2422	/* Line 1464 of yacc.c */
2423	#line 359 "grammar.y"
2424	{
2425	YYACCEPT;
2426	;}
2427	break;
2428
2429	case 8:
2430
2431	/* Line 1464 of yacc.c */
2432	#line 363 "grammar.y"
2433	{
2434	currentVoice->ifsw=0;
2435	iiDebug();
2436	;}
2437	break;
2438
2439	case 9:
2440
2441	/* Line 1464 of yacc.c */
2442	#line 368 "grammar.y"
2443	{currentVoice->ifsw=0;;}
2444	break;
2445
2446	case 10:
2447
2448	/* Line 1464 of yacc.c */
2449	#line 370 "grammar.y"
2450	{
2451	#ifdef SIQ
2452	siq=0;
2453	#endif
2454	yyInRingConstruction = FALSE;
2455	currentVoice->ifsw=0;
2456	if (inerror)
2457	{
2458	/* bison failed here*/
2459	if ((inerror!=3) && ((yyvsp[(1) - (2)].i)<UMINUS) && ((yyvsp[(1) - (2)].i)>' '))
2460	{
2461	// 1: yyerror called
2462	// 2: scanner put actual string
2463	// 3: error rule put token+\n
2464	inerror=3;
2465	Print(" error at token `%s`\n",iiTwoOps((yyvsp[(1) - (2)].i)));
2466	}
2467	/**/
2468
2469	}
2470	if (!errorreported) WerrorS("...parse error");
2471	yyerror("");
2472	yyerrok;
2473	#ifdef HAVE_SDB
2474	if ((sdb_flags & 1) && currentVoice->pi!=NULL)
2475	{
2476	currentVoice->pi->trace_flag \|=1;
2477	}
2478	else
2479	#endif
2480	if (myynest>0)
2481	{
2482	feBufferTypes t=currentVoice->Typ();
2483	//PrintS("leaving yyparse\n");
2484	exitBuffer(BT_proc);
2485	if (t==BT_example)
2486	YYACCEPT;
2487	else
2488	YYABORT;
2489	}
2490	else if (currentVoice->prev!=NULL)
2491	{
2492	exitVoice();
2493	}
2494	#ifdef HAVE_SDB
2495	if (sdb_flags &2) sdb_flags=1;
2496	#endif
2497	;}
2498	break;
2499
2500	case 18:
2501
2502	/* Line 1464 of yacc.c */
2503	#line 428 "grammar.y"
2504	{if (currentVoice!=NULL) currentVoice->ifsw=0;;}
2505	break;
2506
2507	case 19:
2508
2509	/* Line 1464 of yacc.c */
2510	#line 431 "grammar.y"
2511	{ omFree((ADDRESS)(yyvsp[(2) - (2)].name)); ;}
2512	break;
2513
2514	case 29:
2515
2516	/* Line 1464 of yacc.c */
2517	#line 446 "grammar.y"
2518	{
2519	if(iiAssign(&(yyvsp[(1) - (2)].lv),&(yyvsp[(2) - (2)].lv))) YYERROR;
2520	;}
2521	break;
2522
2523	case 30:
2524
2525	/* Line 1464 of yacc.c */
2526	#line 453 "grammar.y"
2527	{
2528	if (currRing==NULL) MYYERROR("no ring active");
2529	syMake(&(yyval.lv),omStrDup((yyvsp[(1) - (1)].name)));
2530	;}
2531	break;
2532
2533	case 31:
2534
2535	/* Line 1464 of yacc.c */
2536	#line 458 "grammar.y"
2537	{
2538	syMake(&(yyval.lv),(yyvsp[(1) - (1)].name));
2539	;}
2540	break;
2541
2542	case 32:
2543
2544	/* Line 1464 of yacc.c */
2545	#line 462 "grammar.y"
2546	{
2547	if(iiExprArith2(&(yyval.lv), &(yyvsp[(1) - (3)].lv), COLONCOLON, &(yyvsp[(3) - (3)].lv))) YYERROR;
2548	;}
2549	break;
2550
2551	case 33:
2552
2553	/* Line 1464 of yacc.c */
2554	#line 466 "grammar.y"
2555	{
2556	if(iiExprArith2(&(yyval.lv), &(yyvsp[(1) - (3)].lv), '.', &(yyvsp[(3) - (3)].lv))) YYERROR;
2557	;}
2558	break;
2559
2560	case 34:
2561
2562	/* Line 1464 of yacc.c */
2563	#line 470 "grammar.y"
2564	{
2565	if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'(')) YYERROR;
2566	;}
2567	break;
2568
2569	case 35:
2570
2571	/* Line 1464 of yacc.c */
2572	#line 474 "grammar.y"
2573	{
2574	if ((yyvsp[(1) - (4)].lv).next==NULL)
2575	{
2576	(yyvsp[(1) - (4)].lv).next=(leftv)omAllocBin(sleftv_bin);
2577	memcpy((yyvsp[(1) - (4)].lv).next,&(yyvsp[(3) - (4)].lv),sizeof(sleftv));
2578	if(iiExprArithM(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'(')) YYERROR;
2579	}
2580	else if ((yyvsp[(1) - (4)].lv).rtyp==UNKNOWN)
2581	{ // for x(i)(j)
2582	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'(',&(yyvsp[(3) - (4)].lv))) YYERROR;
2583	}
2584	else YYERROR;
2585	;}
2586	break;
2587
2588	case 36:
2589
2590	/* Line 1464 of yacc.c */
2591	#line 488 "grammar.y"
2592	{
2593	if (currRingHdl==NULL) MYYERROR("no ring active");
2594	int j = 0;
2595	memset(&(yyval.lv),0,sizeof(sleftv));
2596	(yyval.lv).rtyp=VECTOR_CMD;
2597	leftv v = &(yyvsp[(2) - (3)].lv);
2598	while (v!=NULL)
2599	{
2600	int i,t;
2601	sleftv tmp;
2602	memset(&tmp,0,sizeof(tmp));
2603	i=iiTestConvert((t=v->Typ()),POLY_CMD);
2604	if((i==0) \|\| (iiConvert(t /v->Typ()/,POLY_CMD,i,v,&tmp)))
2605	{
2606	pDelete((poly *)&(yyval.lv).data);
2607	(yyvsp[(2) - (3)].lv).CleanUp();
2608	MYYERROR("expected '[poly,...'");
2609	}
2610	poly p = (poly)tmp.CopyD(POLY_CMD);
2611	pSetCompP(p,++j);
2612	(yyval.lv).data = (void *)pAdd((poly)(yyval.lv).data,p);
2613	v->next=tmp.next;tmp.next=NULL;
2614	tmp.CleanUp();
2615	v=v->next;
2616	}
2617	(yyvsp[(2) - (3)].lv).CleanUp();
2618	;}
2619	break;
2620
2621	case 37:
2622
2623	/* Line 1464 of yacc.c */
2624	#line 516 "grammar.y"
2625	{
2626	memset(&(yyval.lv),0,sizeof((yyval.lv)));
2627	int i = atoi((yyvsp[(1) - (1)].name));
2628	/*remember not to omFree($1)
2629	because it is a part of the scanner buffer/
2630	(yyval.lv).rtyp = INT_CMD;
2631	(yyval.lv).data = (void *)(long)i;
2632
2633	/* check: out of range input */
2634	int l = strlen((yyvsp[(1) - (1)].name))+2;
2635	number n;
2636	if (l >= MAX_INT_LEN)
2637	{
2638	char tmp[MAX_INT_LEN+5];
2639	sprintf(tmp,"%d",i);
2640	if (strcmp(tmp,(yyvsp[(1) - (1)].name))!=0)
2641	{
2642	n_Read((yyvsp[(1) - (1)].name),&n,coeffs_BIGINT);
2643	(yyval.lv).rtyp=BIGINT_CMD;
2644	(yyval.lv).data = n;
2645	}
2646	}
2647	;}
2648	break;
2649
2650	case 38:
2651
2652	/* Line 1464 of yacc.c */
2653	#line 540 "grammar.y"
2654	{
2655	memset(&(yyval.lv),0,sizeof((yyval.lv)));
2656	(yyval.lv).rtyp = (yyvsp[(1) - (1)].i);
2657	(yyval.lv).data = (yyval.lv).Data();
2658	;}
2659	break;
2660
2661	case 39:
2662
2663	/* Line 1464 of yacc.c */
2664	#line 546 "grammar.y"
2665	{
2666	memset(&(yyval.lv),0,sizeof((yyval.lv)));
2667	(yyval.lv).rtyp = STRING_CMD;
2668	(yyval.lv).data = (yyvsp[(1) - (1)].name);
2669	;}
2670	break;
2671
2672	case 40:
2673
2674	/* Line 1464 of yacc.c */
2675	#line 552 "grammar.y"
2676	{
2677	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2678	;}
2679	break;
2680
2681	case 41:
2682
2683	/* Line 1464 of yacc.c */
2684	#line 556 "grammar.y"
2685	{
2686	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2687	;}
2688	break;
2689
2690	case 42:
2691
2692	/* Line 1464 of yacc.c */
2693	#line 560 "grammar.y"
2694	{
2695	if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2696	;}
2697	break;
2698
2699	case 43:
2700
2701	/* Line 1464 of yacc.c */
2702	#line 564 "grammar.y"
2703	{
2704	if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2705	;}
2706	break;
2707
2708	case 44:
2709
2710	/* Line 1464 of yacc.c */
2711	#line 568 "grammar.y"
2712	{
2713	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2714	;}
2715	break;
2716
2717	case 45:
2718
2719	/* Line 1464 of yacc.c */
2720	#line 572 "grammar.y"
2721	{
2722	if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2723	;}
2724	break;
2725
2726	case 46:
2727
2728	/* Line 1464 of yacc.c */
2729	#line 576 "grammar.y"
2730	{
2731	if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2732	;}
2733	break;
2734
2735	case 47:
2736
2737	/* Line 1464 of yacc.c */
2738	#line 580 "grammar.y"
2739	{
2740	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2741	;}
2742	break;
2743
2744	case 48:
2745
2746	/* Line 1464 of yacc.c */
2747	#line 584 "grammar.y"
2748	{
2749	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2750	;}
2751	break;
2752
2753	case 49:
2754
2755	/* Line 1464 of yacc.c */
2756	#line 588 "grammar.y"
2757	{
2758	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2759	;}
2760	break;
2761
2762	case 50:
2763
2764	/* Line 1464 of yacc.c */
2765	#line 592 "grammar.y"
2766	{
2767	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2768	;}
2769	break;
2770
2771	case 51:
2772
2773	/* Line 1464 of yacc.c */
2774	#line 596 "grammar.y"
2775	{
2776	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2777	;}
2778	break;
2779
2780	case 52:
2781
2782	/* Line 1464 of yacc.c */
2783	#line 600 "grammar.y"
2784	{
2785	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2786	;}
2787	break;
2788
2789	case 53:
2790
2791	/* Line 1464 of yacc.c */
2792	#line 604 "grammar.y"
2793	{
2794	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2795	;}
2796	break;
2797
2798	case 54:
2799
2800	/* Line 1464 of yacc.c */
2801	#line 608 "grammar.y"
2802	{
2803	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2804	;}
2805	break;
2806
2807	case 55:
2808
2809	/* Line 1464 of yacc.c */
2810	#line 612 "grammar.y"
2811	{
2812	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2813	;}
2814	break;
2815
2816	case 56:
2817
2818	/* Line 1464 of yacc.c */
2819	#line 616 "grammar.y"
2820	{
2821	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2822	;}
2823	break;
2824
2825	case 57:
2826
2827	/* Line 1464 of yacc.c */
2828	#line 620 "grammar.y"
2829	{
2830	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2831	;}
2832	break;
2833
2834	case 58:
2835
2836	/* Line 1464 of yacc.c */
2837	#line 624 "grammar.y"
2838	{
2839	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2840	;}
2841	break;
2842
2843	case 59:
2844
2845	/* Line 1464 of yacc.c */
2846	#line 628 "grammar.y"
2847	{
2848	if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2849	;}
2850	break;
2851
2852	case 60:
2853
2854	/* Line 1464 of yacc.c */
2855	#line 632 "grammar.y"
2856	{
2857	int b=iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i)); // handle branchTo
2858	if (b==TRUE) YYERROR;
2859	if (b==2) YYACCEPT;
2860	;}
2861	break;
2862
2863	case 61:
2864
2865	/* Line 1464 of yacc.c */
2866	#line 638 "grammar.y"
2867	{
2868	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2869	;}
2870	break;
2871
2872	case 62:
2873
2874	/* Line 1464 of yacc.c */
2875	#line 642 "grammar.y"
2876	{
2877	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2878	;}
2879	break;
2880
2881	case 63:
2882
2883	/* Line 1464 of yacc.c */
2884	#line 646 "grammar.y"
2885	{
2886	if(iiExprArith3(&(yyval.lv),RING_CMD,&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2887	;}
2888	break;
2889
2890	case 64:
2891
2892	/* Line 1464 of yacc.c */
2893	#line 650 "grammar.y"
2894	{
2895	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),RING_CMD)) YYERROR;
2896	;}
2897	break;
2898
2899	case 65:
2900
2901	/* Line 1464 of yacc.c */
2902	#line 654 "grammar.y"
2903	{
2904	if (iiARROW(&(yyval.lv),(yyvsp[(1) - (3)].name),(yyvsp[(3) - (3)].name))) YYERROR;
2905	omFree((ADDRESS)(yyvsp[(3) - (3)].name))
2906	;}
2907	break;
2908
2909	case 66:
2910
2911	/* Line 1464 of yacc.c */
2912	#line 658 "grammar.y"
2913	{ (yyval.lv) = (yyvsp[(2) - (3)].lv); ;}
2914	break;
2915
2916	case 67:
2917
2918	/* Line 1464 of yacc.c */
2919	#line 663 "grammar.y"
2920	{
2921	leftv v = &(yyvsp[(1) - (3)].lv);
2922	while (v->next!=NULL)
2923	{
2924	v=v->next;
2925	}
2926	v->next = (leftv)omAllocBin(sleftv_bin);
2927	memcpy(v->next,&((yyvsp[(3) - (3)].lv)),sizeof(sleftv));
2928	(yyval.lv) = (yyvsp[(1) - (3)].lv);
2929	;}
2930	break;
2931
2932	case 68:
2933
2934	/* Line 1464 of yacc.c */
2935	#line 674 "grammar.y"
2936	{
2937	(yyval.lv) = (yyvsp[(1) - (1)].lv);
2938	;}
2939	break;
2940
2941	case 69:
2942
2943	/* Line 1464 of yacc.c */
2944	#line 680 "grammar.y"
2945	{
2946	/if ($1.typ == eunknown) YYERROR;/
2947	(yyval.lv) = (yyvsp[(1) - (1)].lv);
2948	;}
2949	break;
2950
2951	case 70:
2952
2953	/* Line 1464 of yacc.c */
2954	#line 684 "grammar.y"
2955	{ (yyval.lv) = (yyvsp[(1) - (1)].lv); ;}
2956	break;
2957
2958	case 71:
2959
2960	/* Line 1464 of yacc.c */
2961	#line 686 "grammar.y"
2962	{
2963	if(iiExprArith3(&(yyval.lv),'[',&(yyvsp[(1) - (6)].lv),&(yyvsp[(3) - (6)].lv),&(yyvsp[(5) - (6)].lv))) YYERROR;
2964	;}
2965	break;
2966
2967	case 72:
2968
2969	/* Line 1464 of yacc.c */
2970	#line 690 "grammar.y"
2971	{
2972	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'[',&(yyvsp[(3) - (4)].lv))) YYERROR;
2973	;}
2974	break;
2975
2976	case 73:
2977
2978	/* Line 1464 of yacc.c */
2979	#line 694 "grammar.y"
2980	{
2981	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
2982	;}
2983	break;
2984
2985	case 74:
2986
2987	/* Line 1464 of yacc.c */
2988	#line 698 "grammar.y"
2989	{
2990	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
2991	;}
2992	break;
2993
2994	case 75:
2995
2996	/* Line 1464 of yacc.c */
2997	#line 702 "grammar.y"
2998	{
2999	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3000	;}
3001	break;
3002
3003	case 76:
3004
3005	/* Line 1464 of yacc.c */
3006	#line 706 "grammar.y"
3007	{
3008	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3009	;}
3010	break;
3011
3012	case 77:
3013
3014	/* Line 1464 of yacc.c */
3015	#line 710 "grammar.y"
3016	{
3017	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3018	;}
3019	break;
3020
3021	case 78:
3022
3023	/* Line 1464 of yacc.c */
3024	#line 714 "grammar.y"
3025	{
3026	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), 0, &(yyvsp[(5) - (6)].lv))) YYERROR;
3027	;}
3028	break;
3029
3030	case 79:
3031
3032	/* Line 1464 of yacc.c */
3033	#line 718 "grammar.y"
3034	{
3035	(yyval.lv)=(yyvsp[(2) - (3)].lv);
3036	;}
3037	break;
3038
3039	case 80:
3040
3041	/* Line 1464 of yacc.c */
3042	#line 722 "grammar.y"
3043	{
3044	#ifdef SIQ
3045	siq++;
3046	if (siq>0)
3047	{ if (iiExprArith2(&(yyval.lv),&(yyvsp[(2) - (5)].lv),'=',&(yyvsp[(4) - (5)].lv))) YYERROR; }
3048	else
3049	#endif
3050	{
3051	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3052	(yyval.lv).rtyp=NONE;
3053	if (iiAssign(&(yyvsp[(2) - (5)].lv),&(yyvsp[(4) - (5)].lv))) YYERROR;
3054	}
3055	#ifdef SIQ
3056	siq--;
3057	#endif
3058	;}
3059	break;
3060
3061	case 81:
3062
3063	/* Line 1464 of yacc.c */
3064	#line 739 "grammar.y"
3065	{
3066	iiTestAssume(&(yyvsp[(2) - (5)].lv),&(yyvsp[(4) - (5)].lv));
3067	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3068	(yyval.lv).rtyp=NONE;
3069	;}
3070	break;
3071
3072	case 82:
3073
3074	/* Line 1464 of yacc.c */
3075	#line 745 "grammar.y"
3076	{
3077	#ifdef SIQ
3078	siq--;
3079	#endif
3080	;}
3081	break;
3082
3083	case 83:
3084
3085	/* Line 1464 of yacc.c */
3086	#line 751 "grammar.y"
3087	{
3088	#ifdef SIQ
3089	if (siq<=0) (yyvsp[(4) - (5)].lv).Eval();
3090	#endif
3091	(yyval.lv)=(yyvsp[(4) - (5)].lv);
3092	#ifdef SIQ
3093	siq++;
3094	#endif
3095	;}
3096	break;
3097
3098	case 84:
3099
3100	/* Line 1464 of yacc.c */
3101	#line 763 "grammar.y"
3102	{
3103	#ifdef SIQ
3104	siq++;
3105	#endif
3106	;}
3107	break;
3108
3109	case 85:
3110
3111	/* Line 1464 of yacc.c */
3112	#line 771 "grammar.y"
3113	{
3114	#ifdef SIQ
3115	siq++;
3116	#endif
3117	;}
3118	break;
3119
3120	case 86:
3121
3122	/* Line 1464 of yacc.c */
3123	#line 779 "grammar.y"
3124	{
3125	#ifdef SIQ
3126	siq--;
3127	#endif
3128	;}
3129	break;
3130
3131	case 87:
3132
3133	/* Line 1464 of yacc.c */
3134	#line 788 "grammar.y"
3135	{
3136	if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),PLUSPLUS)) YYERROR;
3137	;}
3138	break;
3139
3140	case 88:
3141
3142	/* Line 1464 of yacc.c */
3143	#line 792 "grammar.y"
3144	{
3145	if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),MINUSMINUS)) YYERROR;
3146	;}
3147	break;
3148
3149	case 89:
3150
3151	/* Line 1464 of yacc.c */
3152	#line 796 "grammar.y"
3153	{
3154	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'+',&(yyvsp[(3) - (3)].lv))) YYERROR;
3155	;}
3156	break;
3157
3158	case 90:
3159
3160	/* Line 1464 of yacc.c */
3161	#line 800 "grammar.y"
3162	{
3163	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'-',&(yyvsp[(3) - (3)].lv))) YYERROR;
3164	;}
3165	break;
3166
3167	case 91:
3168
3169	/* Line 1464 of yacc.c */
3170	#line 804 "grammar.y"
3171	{ /* also for ,% /
3172	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3173	;}
3174	break;
3175
3176	case 92:
3177
3178	/* Line 1464 of yacc.c */
3179	#line 808 "grammar.y"
3180	{
3181	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'^',&(yyvsp[(3) - (3)].lv))) YYERROR;
3182	;}
3183	break;
3184
3185	case 93:
3186
3187	/* Line 1464 of yacc.c */
3188	#line 812 "grammar.y"
3189	{ /* also for > */
3190	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3191	;}
3192	break;
3193
3194	case 94:
3195
3196	/* Line 1464 of yacc.c */
3197	#line 816 "grammar.y"
3198	{ /* also for \|*/
3199	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3200	;}
3201	break;
3202
3203	case 95:
3204
3205	/* Line 1464 of yacc.c */
3206	#line 820 "grammar.y"
3207	{
3208	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),NOTEQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR;
3209	;}
3210	break;
3211
3212	case 96:
3213
3214	/* Line 1464 of yacc.c */
3215	#line 824 "grammar.y"
3216	{
3217	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),EQUAL_EQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR;
3218	;}
3219	break;
3220
3221	case 97:
3222
3223	/* Line 1464 of yacc.c */
3224	#line 828 "grammar.y"
3225	{
3226	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),DOTDOT,&(yyvsp[(3) - (3)].lv))) YYERROR;
3227	;}
3228	break;
3229
3230	case 98:
3231
3232	/* Line 1464 of yacc.c */
3233	#line 832 "grammar.y"
3234	{
3235	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),':',&(yyvsp[(3) - (3)].lv))) YYERROR;
3236	;}
3237	break;
3238
3239	case 99:
3240
3241	/* Line 1464 of yacc.c */
3242	#line 836 "grammar.y"
3243	{
3244	if (siq>0)
3245	{ if (iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),NOT)) YYERROR; }
3246	else
3247	{
3248	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3249	int i; TESTSETINT((yyvsp[(2) - (2)].lv),i);
3250	(yyval.lv).rtyp = INT_CMD;
3251	(yyval.lv).data = (void *)(long)(i == 0 ? 1 : 0);
3252	}
3253	;}
3254	break;
3255
3256	case 100:
3257
3258	/* Line 1464 of yacc.c */
3259	#line 848 "grammar.y"
3260	{
3261	if(iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),'-')) YYERROR;
3262	;}
3263	break;
3264
3265	case 101:
3266
3267	/* Line 1464 of yacc.c */
3268	#line 854 "grammar.y"
3269	{ (yyval.lv) = (yyvsp[(1) - (2)].lv); ;}
3270	break;
3271
3272	case 102:
3273
3274	/* Line 1464 of yacc.c */
3275	#line 856 "grammar.y"
3276	{
3277	if ((yyvsp[(1) - (2)].lv).rtyp==0)
3278	{
3279	Werror("`%s` is undefined",(yyvsp[(1) - (2)].lv).Fullname());
3280	YYERROR;
3281	}
3282	else if (((yyvsp[(1) - (2)].lv).rtyp==MODUL_CMD)
3283	// matrix m; m[2]=...
3284	&& ((yyvsp[(1) - (2)].lv).e!=NULL) && ((yyvsp[(1) - (2)].lv).e->next==NULL))
3285	{
3286	MYYERROR("matrix must have 2 indices");
3287	}
3288	(yyval.lv) = (yyvsp[(1) - (2)].lv);
3289	;}
3290	break;
3291
3292	case 104:
3293
3294	/* Line 1464 of yacc.c */
3295	#line 876 "grammar.y"
3296	{
3297	if ((yyvsp[(2) - (3)].lv).Typ()!=STRING_CMD)
3298	{
3299	MYYERROR("string expression expected");
3300	}
3301	(yyval.name) = (char *)(yyvsp[(2) - (3)].lv).CopyD(STRING_CMD);
3302	(yyvsp[(2) - (3)].lv).CleanUp();
3303	;}
3304	break;
3305
3306	case 105:
3307
3308	/* Line 1464 of yacc.c */
3309	#line 888 "grammar.y"
3310	{
3311	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3312	YYERROR;
3313	;}
3314	break;
3315
3316	case 106:
3317
3318	/* Line 1464 of yacc.c */
3319	#line 893 "grammar.y"
3320	{
3321	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3322	YYERROR;
3323	;}
3324	break;
3325
3326	case 107:
3327
3328	/* Line 1464 of yacc.c */
3329	#line 898 "grammar.y"
3330	{
3331	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3332	;}
3333	break;
3334
3335	case 108:
3336
3337	/* Line 1464 of yacc.c */
3338	#line 902 "grammar.y"
3339	{
3340	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3341	;}
3342	break;
3343
3344	case 109:
3345
3346	/* Line 1464 of yacc.c */
3347	#line 906 "grammar.y"
3348	{
3349	int r; TESTSETINT((yyvsp[(4) - (8)].lv),r);
3350	int c; TESTSETINT((yyvsp[(7) - (8)].lv),c);
3351	leftv v;
3352	idhdl h;
3353	if ((yyvsp[(1) - (8)].i) == MATRIX_CMD)
3354	{
3355	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&(currRing->idroot), TRUE)) YYERROR;
3356	v=&(yyval.lv);
3357	h=(idhdl)v->data;
3358	idDelete(&IDIDEAL(h));
3359	IDMATRIX(h) = mpNew(r,c);
3360	if (IDMATRIX(h)==NULL) YYERROR;
3361	}
3362	else if ((yyvsp[(1) - (8)].i) == INTMAT_CMD)
3363	{
3364	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3365	YYERROR;
3366	v=&(yyval.lv);
3367	h=(idhdl)v->data;
3368	delete IDINTVEC(h);
3369	IDINTVEC(h) = new intvec(r,c,0);
3370	if (IDINTVEC(h)==NULL) YYERROR;
3371	}
3372	else /* BIGINTMAT_CMD */
3373	{
3374	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3375	YYERROR;
3376	v=&(yyval.lv);
3377	h=(idhdl)v->data;
3378	delete IDBIMAT(h);
3379	IDBIMAT(h) = new bigintmat(r, c, coeffs_BIGINT);
3380	if (IDBIMAT(h)==NULL) YYERROR;
3381	}
3382	;}
3383	break;
3384
3385	case 110:
3386
3387	/* Line 1464 of yacc.c */
3388	#line 942 "grammar.y"
3389	{
3390	if ((yyvsp[(1) - (2)].i) == MATRIX_CMD)
3391	{
3392	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3393	}
3394	else if ((yyvsp[(1) - (2)].i) == INTMAT_CMD)
3395	{
3396	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3397	YYERROR;
3398	leftv v=&(yyval.lv);
3399	idhdl h;
3400	do
3401	{
3402	h=(idhdl)v->data;
3403	delete IDINTVEC(h);
3404	IDINTVEC(h) = new intvec(1,1,0);
3405	v=v->next;
3406	} while (v!=NULL);
3407	}
3408	else /* BIGINTMAT_CMD */
3409	{
3410	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3411	YYERROR;
3412	}
3413	;}
3414	break;
3415
3416	case 111:
3417
3418	/* Line 1464 of yacc.c */
3419	#line 968 "grammar.y"
3420	{
3421	int t=(yyvsp[(1) - (3)].lv).Typ();
3422	sleftv r;
3423	memset(&r,0,sizeof(sleftv));
3424	if ((BEGIN_RING<t) && (t<END_RING))
3425	{
3426	if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&(currRing->idroot), TRUE))
3427	YYERROR;
3428	}
3429	else
3430	{
3431	if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&((yyvsp[(3) - (3)].lv).req_packhdl->idroot)))
3432	YYERROR;
3433	}
3434	leftv v=&(yyvsp[(1) - (3)].lv);
3435	while (v->next!=NULL) v=v->next;
3436	v->next=(leftv)omAllocBin(sleftv_bin);
3437	memcpy(v->next,&r,sizeof(sleftv));
3438	(yyval.lv)=(yyvsp[(1) - (3)].lv);
3439	;}
3440	break;
3441
3442	case 112:
3443
3444	/* Line 1464 of yacc.c */
3445	#line 989 "grammar.y"
3446	{
3447	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3448	YYERROR;
3449	;}
3450	break;
3451
3452	case 115:
3453
3454	/* Line 1464 of yacc.c */
3455	#line 1002 "grammar.y"
3456	{
3457	leftv v = &(yyvsp[(2) - (5)].lv);
3458	while (v->next!=NULL)
3459	{
3460	v=v->next;
3461	}
3462	v->next = (leftv)omAllocBin(sleftv_bin);
3463	memcpy(v->next,&((yyvsp[(4) - (5)].lv)),sizeof(sleftv));
3464	(yyval.lv) = (yyvsp[(2) - (5)].lv);
3465	;}
3466	break;
3467
3468	case 116:
3469
3470	/* Line 1464 of yacc.c */
3471	#line 1016 "grammar.y"
3472	{
3473	// let rInit take care of any errors
3474	(yyval.i)=rOrderName((yyvsp[(1) - (1)].name));
3475	;}
3476	break;
3477
3478	case 117:
3479
3480	/* Line 1464 of yacc.c */
3481	#line 1024 "grammar.y"
3482	{
3483	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3484	intvec *iv = new intvec(2);
3485	(*iv)[0] = 1;
3486	(*iv)[1] = (yyvsp[(1) - (1)].i);
3487	(yyval.lv).rtyp = INTVEC_CMD;
3488	(yyval.lv).data = (void *)iv;
3489	;}
3490	break;
3491
3492	case 118:
3493
3494	/* Line 1464 of yacc.c */
3495	#line 1033 "grammar.y"
3496	{
3497	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3498	leftv sl = &(yyvsp[(3) - (4)].lv);
3499	int slLength;
3500	{
3501	slLength = exprlist_length(sl);
3502	int l = 2 + slLength;
3503	intvec *iv = new intvec(l);
3504	(*iv)[0] = slLength;
3505	(*iv)[1] = (yyvsp[(1) - (4)].i);
3506
3507	int i = 2;
3508	while ((i<l) && (sl!=NULL))
3509	{
3510	if (sl->Typ() == INT_CMD)
3511	{
3512	(*iv)[i++] = (int)((long)(sl->Data()));
3513	}
3514	else if ((sl->Typ() == INTVEC_CMD)
3515	\|\|(sl->Typ() == INTMAT_CMD))
3516	{
3517	intvec ivv = (intvec )(sl->Data());
3518	int ll = 0,l = ivv->length();
3519	for (; l>0; l--)
3520	{
3521	(iv)[i++] = (ivv)[ll++];
3522	}
3523	}
3524	else
3525	{
3526	delete iv;
3527	(yyvsp[(3) - (4)].lv).CleanUp();
3528	MYYERROR("wrong type in ordering");
3529	}
3530	sl = sl->next;
3531	}
3532	(yyval.lv).rtyp = INTVEC_CMD;
3533	(yyval.lv).data = (void *)iv;
3534	}
3535	(yyvsp[(3) - (4)].lv).CleanUp();
3536	;}
3537	break;
3538
3539	case 120:
3540
3541	/* Line 1464 of yacc.c */
3542	#line 1079 "grammar.y"
3543	{
3544	(yyval.lv) = (yyvsp[(1) - (3)].lv);
3545	(yyval.lv).next = (sleftv *)omAllocBin(sleftv_bin);
3546	memcpy((yyval.lv).next,&(yyvsp[(3) - (3)].lv),sizeof(sleftv));
3547	;}
3548	break;
3549
3550	case 122:
3551
3552	/* Line 1464 of yacc.c */
3553	#line 1089 "grammar.y"
3554	{
3555	(yyval.lv) = (yyvsp[(2) - (3)].lv);
3556	;}
3557	break;
3558
3559	case 123:
3560
3561	/* Line 1464 of yacc.c */
3562	#line 1095 "grammar.y"
3563	{
3564	expected_parms = TRUE;
3565	;}
3566	break;
3567
3568	case 124:
3569
3570	/* Line 1464 of yacc.c */
3571	#line 1102 "grammar.y"
3572	{ (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3573	break;
3574
3575	case 125:
3576
3577	/* Line 1464 of yacc.c */
3578	#line 1104 "grammar.y"
3579	{ (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3580	break;
3581
3582	case 126:
3583
3584	/* Line 1464 of yacc.c */
3585	#line 1106 "grammar.y"
3586	{ (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3587	break;
3588
3589	case 127:
3590
3591	/* Line 1464 of yacc.c */
3592	#line 1115 "grammar.y"
3593	{ newFile((yyvsp[(2) - (2)].name)); omFree((yyvsp[(2) - (2)].name)); ;}
3594	break;
3595
3596	case 128:
3597
3598	/* Line 1464 of yacc.c */
3599	#line 1120 "grammar.y"
3600	{
3601	feHelp((yyvsp[(2) - (3)].name));
3602	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3603	;}
3604	break;
3605
3606	case 129:
3607
3608	/* Line 1464 of yacc.c */
3609	#line 1125 "grammar.y"
3610	{
3611	feHelp(NULL);
3612	;}
3613	break;
3614
3615	case 130:
3616
3617	/* Line 1464 of yacc.c */
3618	#line 1132 "grammar.y"
3619	{
3620	singular_example((yyvsp[(2) - (3)].name));
3621	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3622	;}
3623	break;
3624
3625	case 131:
3626
3627	/* Line 1464 of yacc.c */
3628	#line 1140 "grammar.y"
3629	{
3630	if (basePack!=(yyvsp[(2) - (2)].lv).req_packhdl)
3631	{
3632	if(iiExport(&(yyvsp[(2) - (2)].lv),0,currPack)) YYERROR;
3633	}
3634	else
3635	if (iiExport(&(yyvsp[(2) - (2)].lv),0)) YYERROR;
3636	;}
3637	break;
3638
3639	case 132:
3640
3641	/* Line 1464 of yacc.c */
3642	#line 1152 "grammar.y"
3643	{
3644	leftv v=&(yyvsp[(2) - (2)].lv);
3645	if (v->rtyp!=IDHDL)
3646	{
3647	if (v->name!=NULL)
3648	{
3649	Werror("`%s` is undefined in kill",v->name);
3650	omFree((ADDRESS)v->name); v->name=NULL;
3651	}
3652	else WerrorS("kill what ?");
3653	}
3654	else
3655	{
3656	killhdl((idhdl)v->data,v->req_packhdl);
3657	}
3658	;}
3659	break;
3660
3661	case 133:
3662
3663	/* Line 1464 of yacc.c */
3664	#line 1169 "grammar.y"
3665	{
3666	leftv v=&(yyvsp[(3) - (3)].lv);
3667	if (v->rtyp!=IDHDL)
3668	{
3669	if (v->name!=NULL)
3670	{
3671	Werror("`%s` is undefined in kill",v->name);
3672	omFree((ADDRESS)v->name); v->name=NULL;
3673	}
3674	else WerrorS("kill what ?");
3675	}
3676	else
3677	{
3678	killhdl((idhdl)v->data,v->req_packhdl);
3679	}
3680	;}
3681	break;
3682
3683	case 134:
3684
3685	/* Line 1464 of yacc.c */
3686	#line 1189 "grammar.y"
3687	{
3688	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3689	;}
3690	break;
3691
3692	case 135:
3693
3694	/* Line 1464 of yacc.c */
3695	#line 1193 "grammar.y"
3696	{
3697	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3698	;}
3699	break;
3700
3701	case 136:
3702
3703	/* Line 1464 of yacc.c */
3704	#line 1197 "grammar.y"
3705	{
3706	if ((yyvsp[(3) - (4)].i)==QRING_CMD) (yyvsp[(3) - (4)].i)=RING_CMD;
3707	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3708	;}
3709	break;
3710
3711	case 137:
3712
3713	/* Line 1464 of yacc.c */
3714	#line 1202 "grammar.y"
3715	{
3716	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3717	;}
3718	break;
3719
3720	case 138:
3721
3722	/* Line 1464 of yacc.c */
3723	#line 1206 "grammar.y"
3724	{
3725	list_cmd(RING_CMD,NULL,"// ",TRUE);
3726	;}
3727	break;
3728
3729	case 139:
3730
3731	/* Line 1464 of yacc.c */
3732	#line 1210 "grammar.y"
3733	{
3734	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3735	;}
3736	break;
3737
3738	case 140:
3739
3740	/* Line 1464 of yacc.c */
3741	#line 1214 "grammar.y"
3742	{
3743	list_cmd(PROC_CMD,NULL,"// ",TRUE);
3744	;}
3745	break;
3746
3747	case 141:
3748
3749	/* Line 1464 of yacc.c */
3750	#line 1218 "grammar.y"
3751	{
3752	list_cmd(0,(yyvsp[(3) - (4)].lv).Fullname(),"// ",TRUE);
3753	(yyvsp[(3) - (4)].lv).CleanUp();
3754	;}
3755	break;
3756
3757	case 142:
3758
3759	/* Line 1464 of yacc.c */
3760	#line 1223 "grammar.y"
3761	{
3762	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3763	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3764	(yyvsp[(3) - (6)].lv).CleanUp();
3765	;}
3766	break;
3767
3768	case 143:
3769
3770	/* Line 1464 of yacc.c */
3771	#line 1229 "grammar.y"
3772	{
3773	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3774	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3775	(yyvsp[(3) - (6)].lv).CleanUp();
3776	;}
3777	break;
3778
3779	case 144:
3780
3781	/* Line 1464 of yacc.c */
3782	#line 1235 "grammar.y"
3783	{
3784	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3785	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3786	(yyvsp[(3) - (6)].lv).CleanUp();
3787	;}
3788	break;
3789
3790	case 145:
3791
3792	/* Line 1464 of yacc.c */
3793	#line 1241 "grammar.y"
3794	{
3795	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3796	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3797	(yyvsp[(3) - (6)].lv).CleanUp();
3798	;}
3799	break;
3800
3801	case 146:
3802
3803	/* Line 1464 of yacc.c */
3804	#line 1247 "grammar.y"
3805	{
3806	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3807	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3808	(yyvsp[(3) - (6)].lv).CleanUp();
3809	;}
3810	break;
3811
3812	case 147:
3813
3814	/* Line 1464 of yacc.c */
3815	#line 1253 "grammar.y"
3816	{
3817	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3818	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3819	(yyvsp[(3) - (6)].lv).CleanUp();
3820	;}
3821	break;
3822
3823	case 148:
3824
3825	/* Line 1464 of yacc.c */
3826	#line 1259 "grammar.y"
3827	{
3828	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3829	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3830	(yyvsp[(3) - (6)].lv).CleanUp();
3831	;}
3832	break;
3833
3834	case 149:
3835
3836	/* Line 1464 of yacc.c */
3837	#line 1271 "grammar.y"
3838	{
3839	list_cmd(-1,NULL,"// ",TRUE);
3840	;}
3841	break;
3842
3843	case 150:
3844
3845	/* Line 1464 of yacc.c */
3846	#line 1277 "grammar.y"
3847	{ yyInRingConstruction = TRUE; ;}
3848	break;
3849
3850	case 151:
3851
3852	/* Line 1464 of yacc.c */
3853	#line 1286 "grammar.y"
3854	{
3855	const char *ring_name = (yyvsp[(2) - (8)].lv).name;
3856	ring b=
3857	rInit(&(yyvsp[(4) - (8)].lv), /* characteristik and list of parameters*/
3858	&(yyvsp[(6) - (8)].lv), /* names of ringvariables */
3859	&(yyvsp[(8) - (8)].lv)); /* ordering */
3860	idhdl newRingHdl=NULL;
3861
3862	if (b!=NULL)
3863	{
3864	newRingHdl=enterid(ring_name, myynest, RING_CMD,
3865	&((yyvsp[(2) - (8)].lv).req_packhdl->idroot),FALSE);
3866	(yyvsp[(2) - (8)].lv).CleanUp();
3867	if (newRingHdl!=NULL)
3868	{
3869	IDRING(newRingHdl)=b;
3870	}
3871	else
3872	{
3873	rKill(b);
3874	}
3875	}
3876	yyInRingConstruction = FALSE;
3877	if (newRingHdl==NULL)
3878	{
3879	MYYERROR("cannot make ring");
3880	}
3881	else
3882	{
3883	rSetHdl(newRingHdl);
3884	}
3885	;}
3886	break;
3887
3888	case 152:
3889
3890	/* Line 1464 of yacc.c */
3891	#line 1319 "grammar.y"
3892	{
3893	const char *ring_name = (yyvsp[(2) - (2)].lv).name;
3894	if (!inerror) rDefault(ring_name);
3895	yyInRingConstruction = FALSE;
3896	(yyvsp[(2) - (2)].lv).CleanUp();
3897	;}
3898	break;
3899
3900	case 153:
3901
3902	/* Line 1464 of yacc.c */
3903	#line 1326 "grammar.y"
3904	{
3905	yyInRingConstruction = FALSE;
3906	if (iiAssignCR(&(yyvsp[(2) - (4)].lv),&(yyvsp[(4) - (4)].lv))) YYERROR;
3907	;}
3908	break;
3909
3910	case 154:
3911
3912	/* Line 1464 of yacc.c */
3913	#line 1331 "grammar.y"
3914	{
3915	yyInRingConstruction = FALSE;
3916	sleftv tmp;
3917	(yyvsp[(4) - (7)].lv).next=(leftv)omAlloc(sizeof(sleftv));
3918	memcpy((yyvsp[(4) - (7)].lv).next,&(yyvsp[(6) - (7)].lv),sizeof(sleftv));
3919	memset(&(yyvsp[(6) - (7)].lv),0,sizeof(sleftv));
3920	if (iiExprArithM(&tmp,&(yyvsp[(4) - (7)].lv),'[')) YYERROR;
3921	if (iiAssignCR(&(yyvsp[(2) - (7)].lv),&tmp)) YYERROR;
3922	;}
3923	break;
3924
3925	case 155:
3926
3927	/* Line 1464 of yacc.c */
3928	#line 1344 "grammar.y"
3929	{
3930	if (((yyvsp[(1) - (2)].i)!=LIB_CMD)\|\|(jjLOAD((yyvsp[(2) - (2)].name),TRUE))) YYERROR;
3931	omFree((yyvsp[(2) - (2)].name));
3932	;}
3933	break;
3934
3935	case 158:
3936
3937	/* Line 1464 of yacc.c */
3938	#line 1354 "grammar.y"
3939	{
3940	if (((yyvsp[(1) - (2)].i)==KEEPRING_CMD) && (myynest==0))
3941	MYYERROR("only inside a proc allowed");
3942	const char * n=(yyvsp[(2) - (2)].lv).Name();
3943	if (((yyvsp[(2) - (2)].lv).Typ()==RING_CMD)
3944	&& ((yyvsp[(2) - (2)].lv).rtyp==IDHDL))
3945	{
3946	idhdl h=(idhdl)(yyvsp[(2) - (2)].lv).data;
3947	if ((yyvsp[(2) - (2)].lv).e!=NULL) h=rFindHdl((ring)(yyvsp[(2) - (2)].lv).Data(),NULL);
3948	//Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
3949	if ((yyvsp[(1) - (2)].i)==KEEPRING_CMD)
3950	{
3951	if (h!=NULL)
3952	{
3953	if (IDLEV(h)!=0)
3954	{
3955	if (iiExport(&(yyvsp[(2) - (2)].lv),myynest-1)) YYERROR;
3956	#if 1
3957	idhdl p=IDRING(h)->idroot;
3958	idhdl root=p;
3959	int prevlev=myynest-1;
3960	while (p!=NULL)
3961	{
3962	if (IDLEV(p)==myynest)
3963	{
3964	idhdl old=root->get(IDID(p),prevlev);
3965	if (old!=NULL)
3966	{
3967	if (BVERBOSE(V_REDEFINE))
3968	Warn("redefining %s",IDID(p));
3969	killhdl2(old,&root,IDRING(h));
3970	IDRING(h)->idroot=root;
3971	}
3972	IDLEV(p)=prevlev;
3973	}
3974	p=IDNEXT(p);
3975	}
3976	#endif
3977	}
3978	iiLocalRing[myynest-1]=IDRING(h);
3979	}
3980	else
3981	{
3982	Werror("%s is no identifier",n);
3983	(yyvsp[(2) - (2)].lv).CleanUp();
3984	YYERROR;
3985	}
3986	}
3987	if (h!=NULL) rSetHdl(h);
3988	else
3989	{
3990	Werror("cannot find the name of the basering %s",n);
3991	(yyvsp[(2) - (2)].lv).CleanUp();
3992	YYERROR;
3993	}
3994	(yyvsp[(2) - (2)].lv).CleanUp();
3995	}
3996	else
3997	{
3998	Werror("%s is no name of a ring/qring",n);
3999	(yyvsp[(2) - (2)].lv).CleanUp();
4000	YYERROR;
4001	}
4002	;}
4003	break;
4004
4005	case 159:
4006
4007	/* Line 1464 of yacc.c */
4008	#line 1422 "grammar.y"
4009	{
4010	type_cmd(&((yyvsp[(2) - (2)].lv)));
4011	;}
4012	break;
4013
4014	case 160:
4015
4016	/* Line 1464 of yacc.c */
4017	#line 1426 "grammar.y"
4018	{
4019	//Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
4020	#ifdef SIQ
4021	if ((yyvsp[(1) - (1)].lv).rtyp!=COMMAND)
4022	{
4023	#endif
4024	if ((yyvsp[(1) - (1)].lv).Typ()==UNKNOWN)
4025	{
4026	if ((yyvsp[(1) - (1)].lv).name!=NULL)
4027	{
4028	Werror("`%s` is undefined",(yyvsp[(1) - (1)].lv).name);
4029	omFree((ADDRESS)(yyvsp[(1) - (1)].lv).name);
4030	}
4031	YYERROR;
4032	}
4033	#ifdef SIQ
4034	}
4035	#endif
4036	(yyvsp[(1) - (1)].lv).Print(&sLastPrinted);
4037	(yyvsp[(1) - (1)].lv).CleanUp(currRing);
4038	if (errorreported) YYERROR;
4039	;}
4040	break;
4041
4042	case 161:
4043
4044	/* Line 1464 of yacc.c */
4045	#line 1455 "grammar.y"
4046	{
4047	int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4048	if (i!=0)
4049	{
4050	newBuffer( (yyvsp[(5) - (5)].name), BT_if);
4051	}
4052	else
4053	{
4054	omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4055	currentVoice->ifsw=1;
4056	}
4057	;}
4058	break;
4059
4060	case 162:
4061
4062	/* Line 1464 of yacc.c */
4063	#line 1468 "grammar.y"
4064	{
4065	if (currentVoice->ifsw==1)
4066	{
4067	currentVoice->ifsw=0;
4068	newBuffer( (yyvsp[(2) - (2)].name), BT_else);
4069	}
4070	else
4071	{
4072	if (currentVoice->ifsw!=2)
4073	{
4074	Warn("`else` without `if` in level %d",myynest);
4075	}
4076	omFree((ADDRESS)(yyvsp[(2) - (2)].name));
4077	}
4078	currentVoice->ifsw=0;
4079	;}
4080	break;
4081
4082	case 163:
4083
4084	/* Line 1464 of yacc.c */
4085	#line 1485 "grammar.y"
4086	{
4087	int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4088	if (i)
4089	{
4090	if (exitBuffer(BT_break)) YYERROR;
4091	}
4092	currentVoice->ifsw=0;
4093	;}
4094	break;
4095
4096	case 164:
4097
4098	/* Line 1464 of yacc.c */
4099	#line 1494 "grammar.y"
4100	{
4101	if (exitBuffer(BT_break)) YYERROR;
4102	currentVoice->ifsw=0;
4103	;}
4104	break;
4105
4106	case 165:
4107
4108	/* Line 1464 of yacc.c */
4109	#line 1499 "grammar.y"
4110	{
4111	if (contBuffer(BT_break)) YYERROR;
4112	currentVoice->ifsw=0;
4113	;}
4114	break;
4115
4116	case 166:
4117
4118	/* Line 1464 of yacc.c */
4119	#line 1507 "grammar.y"
4120	{
4121	/* -> if(!$2) break; $3; continue;*/
4122	char * s = (char *)omAlloc( strlen((yyvsp[(2) - (3)].name)) + strlen((yyvsp[(3) - (3)].name)) + 36);
4123	sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,(yyvsp[(2) - (3)].name),(yyvsp[(3) - (3)].name));
4124	newBuffer(s,BT_break);
4125	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4126	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4127	;}
4128	break;
4129
4130	case 167:
4131
4132	/* Line 1464 of yacc.c */
4133	#line 1519 "grammar.y"
4134	{
4135	/* $2 */
4136	/* if (!$3) break; $5; $4; continue; */
4137	char * s = (char *)omAlloc( strlen((yyvsp[(3) - (5)].name))+strlen((yyvsp[(4) - (5)].name))+strlen((yyvsp[(5) - (5)].name))+36);
4138	sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
4139	,(yyvsp[(3) - (5)].name),(yyvsp[(5) - (5)].name),(yyvsp[(4) - (5)].name));
4140	omFree((ADDRESS)(yyvsp[(3) - (5)].name));
4141	omFree((ADDRESS)(yyvsp[(4) - (5)].name));
4142	omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4143	newBuffer(s,BT_break);
4144	s = (char *)omAlloc( strlen((yyvsp[(2) - (5)].name)) + 3);
4145	sprintf(s,"%s;\n",(yyvsp[(2) - (5)].name));
4146	omFree((ADDRESS)(yyvsp[(2) - (5)].name));
4147	newBuffer(s,BT_if);
4148	;}
4149	break;
4150
4151	case 168:
4152
4153	/* Line 1464 of yacc.c */
4154	#line 1538 "grammar.y"
4155	{
4156	idhdl h = enterid((yyvsp[(2) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4157	if (h==NULL) {omFree((ADDRESS)(yyvsp[(2) - (3)].name));omFree((ADDRESS)(yyvsp[(3) - (3)].name)); YYERROR;}
4158	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(2) - (3)].name), 0, 0);
4159	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+31);;
4160	sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",(yyvsp[(3) - (3)].name));
4161	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4162	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4163	;}
4164	break;
4165
4166	case 169:
4167
4168	/* Line 1464 of yacc.c */
4169	#line 1548 "grammar.y"
4170	{
4171	idhdl h = enterid((yyvsp[(1) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4172	if (h==NULL)
4173	{
4174	omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4175	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4176	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4177	YYERROR;
4178	}
4179	char *args=iiProcArgs((yyvsp[(2) - (3)].name),FALSE);
4180	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4181	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (3)].name), 0, 0);
4182	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+strlen(args)+14);;
4183	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(3) - (3)].name));
4184	omFree((ADDRESS)args);
4185	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4186	omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4187	;}
4188	break;
4189
4190	case 170:
4191
4192	/* Line 1464 of yacc.c */
4193	#line 1567 "grammar.y"
4194	{
4195	omFree((ADDRESS)(yyvsp[(3) - (4)].name));
4196	idhdl h = enterid((yyvsp[(1) - (4)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4197	if (h==NULL)
4198	{
4199	omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4200	omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4201	omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4202	YYERROR;
4203	}
4204	char *args=iiProcArgs((yyvsp[(2) - (4)].name),FALSE);
4205	omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4206	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (4)].name), 0, 0);
4207	omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4208	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(4) - (4)].name))+strlen(args)+14);;
4209	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(4) - (4)].name));
4210	omFree((ADDRESS)args);
4211	omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4212	;}
4213	break;
4214
4215	case 171:
4216
4217	/* Line 1464 of yacc.c */
4218	#line 1590 "grammar.y"
4219	{
4220	// decl. of type proc p(int i)
4221	if ((yyvsp[(1) - (2)].i)==PARAMETER) { if (iiParameter(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4222	else { if (iiAlias(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4223	;}
4224	break;
4225
4226	case 172:
4227
4228	/* Line 1464 of yacc.c */
4229	#line 1596 "grammar.y"
4230	{
4231	// decl. of type proc p(i)
4232	sleftv tmp_expr;
4233	if ((yyvsp[(1) - (2)].i)==ALIAS_CMD) MYYERROR("alias requires a type");
4234	if ((iiDeclCommand(&tmp_expr,&(yyvsp[(2) - (2)].lv),myynest,DEF_CMD,&IDROOT))
4235	\|\| (iiParameter(&tmp_expr)))
4236	YYERROR;
4237	;}
4238	break;
4239
4240	case 173:
4241
4242	/* Line 1464 of yacc.c */
4243	#line 1608 "grammar.y"
4244	{
4245	iiRETURNEXPR.Copy(&(yyvsp[(3) - (4)].lv));
4246	(yyvsp[(3) - (4)].lv).CleanUp();
4247	if (exitBuffer(BT_proc)) YYERROR;
4248	;}
4249	break;
4250
4251	case 174:
4252
4253	/* Line 1464 of yacc.c */
4254	#line 1614 "grammar.y"
4255	{
4256	if ((yyvsp[(1) - (3)].i)==RETURN)
4257	{
4258	iiRETURNEXPR.Init();
4259	iiRETURNEXPR.rtyp=NONE;
4260	if (exitBuffer(BT_proc)) YYERROR;
4261	}
4262	;}
4263	break;
4264
4265
4266
4267	/* Line 1464 of yacc.c */
4268	#line 4269 "grammar.cc"
4269	default: break;
4270	}
4271	YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4272
4273	YYPOPSTACK (yylen);
4274	yylen = 0;
4275	YY_STACK_PRINT (yyss, yyssp);
4276
4277	*++yyvsp = yyval;
4278
4279	/* Now `shift' the result of the reduction. Determine what state
4280	that goes to, based on the state we popped back to and the rule
4281	number reduced by. */
4282
4283	yyn = yyr1[yyn];
4284
4285	yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4286	if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4287	yystate = yytable[yystate];
4288	else
4289	yystate = yydefgoto[yyn - YYNTOKENS];
4290
4291	goto yynewstate;
4292
4293
4294	/*------------------------------------.
4295	\| yyerrlab -- here on detecting error \|
4296	`------------------------------------*/
4297	yyerrlab:
4298	/* If not already recovering from an error, report this error. */
4299	if (!yyerrstatus)
4300	{
4301	++yynerrs;
4302	#if ! YYERROR_VERBOSE
4303	yyerror (YY_("syntax error"));
4304	#else
4305	{
4306	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
4307	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
4308	{
4309	YYSIZE_T yyalloc = 2 * yysize;
4310	if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
4311	yyalloc = YYSTACK_ALLOC_MAXIMUM;
4312	if (yymsg != yymsgbuf)
4313	YYSTACK_FREE (yymsg);
4314	yymsg = (char *) YYSTACK_ALLOC (yyalloc);
4315	if (yymsg)
4316	yymsg_alloc = yyalloc;
4317	else
4318	{
4319	yymsg = yymsgbuf;
4320	yymsg_alloc = sizeof yymsgbuf;
4321	}
4322	}
4323
4324	if (0 < yysize && yysize <= yymsg_alloc)
4325	{
4326	(void) yysyntax_error (yymsg, yystate, yychar);
4327	yyerror (yymsg);
4328	}
4329	else
4330	{
4331	yyerror (YY_("syntax error"));
4332	if (yysize != 0)
4333	goto yyexhaustedlab;
4334	}
4335	}
4336	#endif
4337	}
4338
4339
4340
4341	if (yyerrstatus == 3)
4342	{
4343	/* If just tried and failed to reuse lookahead token after an
4344	error, discard it. */
4345
4346	if (yychar <= YYEOF)
4347	{
4348	/* Return failure if at end of input. */
4349	if (yychar == YYEOF)
4350	YYABORT;
4351	}
4352	else
4353	{
4354	yydestruct ("Error: discarding",
4355	yytoken, &yylval);
4356	yychar = YYEMPTY;
4357	}
4358	}
4359
4360	/* Else will try to reuse lookahead token after shifting the error
4361	token. */
4362	goto yyerrlab1;
4363
4364
4365	/*---------------------------------------------------.
4366	\| yyerrorlab -- error raised explicitly by YYERROR. \|
4367	`---------------------------------------------------*/
4368	yyerrorlab:
4369
4370	/* Pacify compilers like GCC when the user code never invokes
4371	YYERROR and the label yyerrorlab therefore never appears in user
4372	code. */
4373	if (/CONSTCOND/ 0)
4374	goto yyerrorlab;
4375
4376	/* Do not reclaim the symbols of the rule which action triggered
4377	this YYERROR. */
4378	YYPOPSTACK (yylen);
4379	yylen = 0;
4380	YY_STACK_PRINT (yyss, yyssp);
4381	yystate = *yyssp;
4382	goto yyerrlab1;
4383
4384
4385	/*-------------------------------------------------------------.
4386	\| yyerrlab1 -- common code for both syntax error and YYERROR. \|
4387	`-------------------------------------------------------------*/
4388	yyerrlab1:
4389	yyerrstatus = 3; /* Each real token shifted decrements this. */
4390
4391	for (;;)
4392	{
4393	yyn = yypact[yystate];
4394	if (yyn != YYPACT_NINF)
4395	{
4396	yyn += YYTERROR;
4397	if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4398	{
4399	yyn = yytable[yyn];
4400	if (0 < yyn)
4401	break;
4402	}
4403	}
4404
4405	/* Pop the current state because it cannot handle the error token. */
4406	if (yyssp == yyss)
4407	YYABORT;
4408
4409
4410	yydestruct ("Error: popping",
4411	yystos[yystate], yyvsp);
4412	YYPOPSTACK (1);
4413	yystate = *yyssp;
4414	YY_STACK_PRINT (yyss, yyssp);
4415	}
4416
4417	*++yyvsp = yylval;
4418
4419
4420	/* Shift the error token. */
4421	YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4422
4423	yystate = yyn;
4424	goto yynewstate;
4425
4426
4427	/*-------------------------------------.
4428	\| yyacceptlab -- YYACCEPT comes here. \|
4429	`-------------------------------------*/
4430	yyacceptlab:
4431	yyresult = 0;
4432	goto yyreturn;
4433
4434	/*-----------------------------------.
4435	\| yyabortlab -- YYABORT comes here. \|
4436	`-----------------------------------*/
4437	yyabortlab:
4438	yyresult = 1;
4439	goto yyreturn;
4440
4441	#if !defined(yyoverflow) \|\| YYERROR_VERBOSE
4442	/*-------------------------------------------------.
4443	\| yyexhaustedlab -- memory exhaustion comes here. \|
4444	`-------------------------------------------------*/
4445	yyexhaustedlab:
4446	yyerror (YY_("memory exhausted"));
4447	yyresult = 2;
4448	/* Fall through. */
4449	#endif
4450
4451	yyreturn:
4452	if (yychar != YYEMPTY)
4453	yydestruct ("Cleanup: discarding lookahead",
4454	yytoken, &yylval);
4455	/* Do not reclaim the symbols of the rule which action triggered
4456	this YYABORT or YYACCEPT. */
4457	YYPOPSTACK (yylen);
4458	YY_STACK_PRINT (yyss, yyssp);
4459	while (yyssp != yyss)
4460	{
4461	yydestruct ("Cleanup: popping",
4462	yystos[*yyssp], yyvsp);
4463	YYPOPSTACK (1);
4464	}
4465	#ifndef yyoverflow
4466	if (yyss != yyssa)
4467	YYSTACK_FREE (yyss);
4468	#endif
4469	#if YYERROR_VERBOSE
4470	if (yymsg != yymsgbuf)
4471	YYSTACK_FREE (yymsg);
4472	#endif
4473	/* Make sure YYID is used. */
4474	return YYID (yyresult);
4475	}
4476
4477
4478

Note: See TracBrowser for help on using the repository browser.

Download in other formats: