/Users/deen/code/yugabyte-db/build/debugcov-clang-dynamic-arm64-ninja/postgres_build/src/interfaces/ecpg/preproc/pgc.c

Line	Count	Source (jump to first uncovered line)
1		#line 1 "pgc.c"
2		/*-------------------------------------------------------------------------
3		*
4		* pgc.l
5		* lexical scanner for ecpg
6		*
7		* This is a modified version of src/backend/parser/scan.l
8		*
9		*
10		* Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
11		* Portions Copyright (c) 1994, Regents of the University of California
12		*
13		*
14		* IDENTIFICATION
15		* src/interfaces/ecpg/preproc/pgc.l
16		*
17		*-------------------------------------------------------------------------
18		*/
19		#include "postgres_fe.h"
20
21		#include <ctype.h>
22		#include <limits.h>
23
24		#include "common/string.h"
25
26		#include "extern.h"
27		#include "preproc.h"
28
29		#line 29 "pgc.c"
30
31		#define YY_INT_ALIGNED short int
32
33		/* A lexical scanner generated by flex */
34
35		#define yy_create_buffer base_yy_create_buffer
36		#define yy_delete_buffer base_yy_delete_buffer
37		#define yy_flex_debug base_yy_flex_debug
38		#define yy_init_buffer base_yy_init_buffer
39		#define yy_flush_buffer base_yy_flush_buffer
40		#define yy_load_buffer_state base_yy_load_buffer_state
41		#define yy_switch_to_buffer base_yy_switch_to_buffer
42		#define yyin base_yyin
43		#define yyleng base_yyleng
44		#define yylex base_yylex
45		#define yylineno base_yylineno
46		#define yyout base_yyout
47		#define yyrestart base_yyrestart
48		#define yytext base_yytext
49		#define yywrap base_yywrap
50		#define yyalloc base_yyalloc
51		#define yyrealloc base_yyrealloc
52		#define yyfree base_yyfree
53
54		#define FLEX_SCANNER
55		#define YY_FLEX_MAJOR_VERSION 2
56		#define YY_FLEX_MINOR_VERSION 6
57		#define YY_FLEX_SUBMINOR_VERSION 3
58		#if YY_FLEX_SUBMINOR_VERSION > 0
59		#define FLEX_BETA
60		#endif
61
62	0	#define yy_create_buffer base_yy_create_buffer
63
64		#define yy_delete_buffer base_yy_delete_buffer
65
66		#define yy_scan_buffer base_yy_scan_buffer
67
68	0	#define yy_scan_string base_yy_scan_string
69
70		#define yy_scan_bytes base_yy_scan_bytes
71
72		#define yy_init_buffer base_yy_init_buffer
73
74		#define yy_flush_buffer base_yy_flush_buffer
75
76		#define yy_load_buffer_state base_yy_load_buffer_state
77
78	0	#define yy_switch_to_buffer base_yy_switch_to_buffer
79
80		#define yypush_buffer_state base_yypush_buffer_state
81
82		#define yypop_buffer_state base_yypop_buffer_state
83
84		#define yyensure_buffer_stack base_yyensure_buffer_stack
85
86		#define yylex base_yylex
87
88		#define yyrestart base_yyrestart
89
90		#define yylex_init base_yylex_init
91
92		#define yylex_init_extra base_yylex_init_extra
93
94		#define yylex_destroy base_yylex_destroy
95
96		#define yyget_debug base_yyget_debug
97
98		#define yyset_debug base_yyset_debug
99
100		#define yyget_extra base_yyget_extra
101
102		#define yyset_extra base_yyset_extra
103
104		#define yyget_in base_yyget_in
105
106		#define yyset_in base_yyset_in
107
108		#define yyget_out base_yyget_out
109
110		#define yyset_out base_yyset_out
111
112		#define yyget_leng base_yyget_leng
113
114		#define yyget_text base_yyget_text
115
116		#define yyget_lineno base_yyget_lineno
117
118		#define yyset_lineno base_yyset_lineno
119
120		#define yywrap base_yywrap
121
122		#define yyalloc base_yyalloc
123
124		#define yyrealloc base_yyrealloc
125
126		#define yyfree base_yyfree
127
128	0	#define yytext base_yytext
129
130		#define yyleng base_yyleng
131
132	0	#define yyin base_yyin
133
134		#define yyout base_yyout
135
136		#define yy_flex_debug base_yy_flex_debug
137
138	0	#define yylineno base_yylineno
139
140		/* First, we deal with platform-specific or compiler-specific issues. */
141
142		/* begin standard C headers. */
143		#include <stdio.h>
144		#include <string.h>
145		#include <errno.h>
146		#include <stdlib.h>
147
148		/* end standard C headers. */
149
150		/* flex integer type definitions */
151
152		#ifndef FLEXINT_H
153		#define FLEXINT_H
154
155		/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
156
157		#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
158
159		/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
160		* if you want the limit (max/min) macros for int types.
161		*/
162		#ifndef __STDC_LIMIT_MACROS
163		#define __STDC_LIMIT_MACROS 1
164		#endif
165
166		#include <inttypes.h>
167		typedef int8_t flex_int8_t;
168		typedef uint8_t flex_uint8_t;
169		typedef int16_t flex_int16_t;
170		typedef uint16_t flex_uint16_t;
171		typedef int32_t flex_int32_t;
172		typedef uint32_t flex_uint32_t;
173		#else
174		typedef signed char flex_int8_t;
175		typedef short int flex_int16_t;
176		typedef int flex_int32_t;
177		typedef unsigned char flex_uint8_t;
178		typedef unsigned short int flex_uint16_t;
179		typedef unsigned int flex_uint32_t;
180
181		/* Limits of integral types. */
182		#ifndef INT8_MIN
183		#define INT8_MIN (-128)
184		#endif
185		#ifndef INT16_MIN
186		#define INT16_MIN (-32767-1)
187		#endif
188		#ifndef INT32_MIN
189		#define INT32_MIN (-2147483647-1)
190		#endif
191		#ifndef INT8_MAX
192		#define INT8_MAX (127)
193		#endif
194		#ifndef INT16_MAX
195		#define INT16_MAX (32767)
196		#endif
197		#ifndef INT32_MAX
198		#define INT32_MAX (2147483647)
199		#endif
200		#ifndef UINT8_MAX
201		#define UINT8_MAX (255U)
202		#endif
203		#ifndef UINT16_MAX
204		#define UINT16_MAX (65535U)
205		#endif
206		#ifndef UINT32_MAX
207		#define UINT32_MAX (4294967295U)
208		#endif
209
210		#endif /* ! C99 */
211
212		#endif /* ! FLEXINT_H */
213
214		/* TODO: this is always defined, so inline it */
215		#define yyconst const
216
217		#if defined(__GNUC__) && __GNUC__ >= 3
218		#define yynoreturn __attribute__((__noreturn__))
219		#else
220		#define yynoreturn
221		#endif
222
223		/* Returned upon end-of-file. */
224		#define YY_NULL 0
225
226		/* Promotes a possibly negative, possibly signed char to an
227		* integer in range [0..255] for use as an array index.
228		*/
229	0	#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
230
231		/* Enter a start condition. This macro really ought to take a parameter,
232		* but we do it the disgusting crufty way forced on us by the ()-less
233		* definition of BEGIN.
234		*/
235	0	#define BEGIN (yy_start) = 1 + 2 *
236		/* Translate the current start state into a value that can be later handed
237		* to BEGIN to return to the state. The YYSTATE alias is for lex
238		* compatibility.
239		*/
240		#define YY_START (((yy_start) - 1) / 2)
241		#define YYSTATE YY_START
242		/* Action number for EOF rule of a given start state. */
243		#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
244		/* Special action meaning "start processing a new file". */
245		#define YY_NEW_FILE base_yyrestart(base_yyin )
246	0	#define YY_END_OF_BUFFER_CHAR 0
247
248		/* Size of default input buffer. */
249		#ifndef YY_BUF_SIZE
250		#ifdef __ia64__
251		/* On IA-64, the buffer size is 16k, not 8k.
252		* Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
253		* Ditto for the __ia64__ case accordingly.
254		*/
255		#define YY_BUF_SIZE 32768
256		#else
257	0	#define YY_BUF_SIZE 16384
258		#endif /* __ia64__ */
259		#endif
260
261		/* The state buf must be large enough to hold one state per character in the main buffer.
262		*/
263		#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
264
265		#ifndef YY_TYPEDEF_YY_BUFFER_STATE
266		#define YY_TYPEDEF_YY_BUFFER_STATE
267		typedef struct yy_buffer_state *YY_BUFFER_STATE;
268		#endif
269
270		#ifndef YY_TYPEDEF_YY_SIZE_T
271		#define YY_TYPEDEF_YY_SIZE_T
272		typedef size_t yy_size_t;
273		#endif
274
275		extern int base_yyleng;
276
277		extern FILE base_yyin, base_yyout;
278
279	0	#define EOB_ACT_CONTINUE_SCAN 0
280	0	#define EOB_ACT_END_OF_FILE 1
281	0	#define EOB_ACT_LAST_MATCH 2
282
283		/* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
284		* access to the local variable yy_act. Since yyless() is a macro, it would break
285		* existing scanners that call yyless() from OUTSIDE base_yylex.
286		* One obvious solution it to make yy_act a global. I tried that, and saw
287		* a 5% performance hit in a non-base_yylineno scanner, because yy_act is
288		* normally declared as a register variable-- so it is not worth it.
289		*/
290		#define YY_LESS_LINENO(n) \
291		do { \
292		int yyl;\
293		for ( yyl = n; yyl < base_yyleng; ++yyl )\
294		if ( base_yytext[yyl] == '\n' )\
295		--base_yylineno;\
296		}while(0)
297		#define YY_LINENO_REWIND_TO(dst) \
298		do {\
299		const char *p;\
300		for ( p = yy_cp-1; p >= (dst); --p)\
301		if ( *p == '\n' )\
302		--base_yylineno;\
303		}while(0)
304
305		/* Return all but the first "n" matched characters back to the input stream. */
306		#define yyless(n) \
307		do \
308		{ \
309		/* Undo effects of setting up base_yytext. */ \
310		int yyless_macro_arg = (n); \
311		YY_LESS_LINENO(yyless_macro_arg);\
312		*yy_cp = (yy_hold_char); \
313		YY_RESTORE_YY_MORE_OFFSET \
314		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
315		YY_DO_BEFORE_ACTION; /* set up base_yytext again */ \
316		} \
317		while ( 0 )
318		#define unput(c) yyunput( c, (yytext_ptr) )
319
320		#ifndef YY_STRUCT_YY_BUFFER_STATE
321		#define YY_STRUCT_YY_BUFFER_STATE
322		struct yy_buffer_state
323		{
324		FILE *yy_input_file;
325
326		char yy_ch_buf; / input buffer */
327		char yy_buf_pos; / current position in input buffer */
328
329		/* Size of input buffer in bytes, not including room for EOB
330		* characters.
331		*/
332		int yy_buf_size;
333
334		/* Number of characters read into yy_ch_buf, not including EOB
335		* characters.
336		*/
337		int yy_n_chars;
338
339		/* Whether we "own" the buffer - i.e., we know we created it,
340		* and can realloc() it to grow it, and should free() it to
341		* delete it.
342		*/
343		int yy_is_our_buffer;
344
345		/* Whether this is an "interactive" input source; if so, and
346		* if we're using stdio for input, then we want to use getc()
347		* instead of fread(), to make sure we stop fetching input after
348		* each newline.
349		*/
350		int yy_is_interactive;
351
352		/* Whether we're considered to be at the beginning of a line.
353		* If so, '^' rules will be active on the next match, otherwise
354		* not.
355		*/
356		int yy_at_bol;
357
358		int yy_bs_lineno; /*< The line count. /
359		int yy_bs_column; /*< The column count. /
360
361		/* Whether to try to fill the input buffer when we reach the
362		* end of it.
363		*/
364		int yy_fill_buffer;
365
366		int yy_buffer_status;
367
368	0	#define YY_BUFFER_NEW 0
369		#define YY_BUFFER_NORMAL 1
370		/* When an EOF's been seen but there's still some text to process
371		* then we mark the buffer as YY_EOF_PENDING, to indicate that we
372		* shouldn't try reading from the input source any more. We might
373		* still have a bunch of tokens to match, though, because of
374		* possible backing-up.
375		*
376		* When we actually see the EOF, we change the status to "new"
377		* (via base_yyrestart()), so that the user can continue scanning by
378		* just pointing base_yyin at a new input file.
379		*/
380	0	#define YY_BUFFER_EOF_PENDING 2
381
382		};
383		#endif /* !YY_STRUCT_YY_BUFFER_STATE */
384
385		/* Stack of input buffers. */
386		static size_t yy_buffer_stack_top = 0; /*< index of top of stack. /
387		static size_t yy_buffer_stack_max = 0; /*< capacity of stack. /
388		static YY_BUFFER_STATE * yy_buffer_stack = NULL; /*< Stack as an array. /
389
390		/* We provide macros for accessing buffer states in case in the
391		* future we want to put the buffer states in a more general
392		* "scanner state".
393		*
394		* Returns the top of the stack, or NULL.
395		*/
396	0	#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
397	0	? (yy_buffer_stack)[(yy_buffer_stack_top)] \
398	0	: NULL)
399		/* Same as previous macro, but useful when we know that the buffer stack is not
400		* NULL or when we need an lvalue. For internal use only.
401		*/
402	0	#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
403
404		/* yy_hold_char holds the character lost when base_yytext is formed. */
405		static char yy_hold_char;
406		static int yy_n_chars; /* number of characters read into yy_ch_buf */
407		int base_yyleng;
408
409		/* Points to current character in buffer. */
410		static char *yy_c_buf_p = NULL;
411		static int yy_init = 0; /* whether we need to initialize */
412		static int yy_start = 0; /* start state number */
413
414		/* Flag which is used to allow base_yywrap()'s to do buffer switches
415		* instead of setting up a fresh base_yyin. A bit of a hack ...
416		*/
417		static int yy_did_buffer_switch_on_eof;
418
419		void base_yyrestart ( FILE *input_file );
420		void base_yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
421		YY_BUFFER_STATE base_yy_create_buffer ( FILE *file, int size );
422		void base_yy_delete_buffer ( YY_BUFFER_STATE b );
423		void base_yy_flush_buffer ( YY_BUFFER_STATE b );
424		void base_yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
425		void base_yypop_buffer_state ( void );
426
427		static void base_yyensure_buffer_stack ( void );
428		static void base_yy_load_buffer_state ( void );
429		static void base_yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
430		#define YY_FLUSH_BUFFER base_yy_flush_buffer(YY_CURRENT_BUFFER )
431
432		YY_BUFFER_STATE base_yy_scan_buffer ( char *base, yy_size_t size );
433		YY_BUFFER_STATE base_yy_scan_string ( const char *yy_str );
434		YY_BUFFER_STATE base_yy_scan_bytes ( const char *bytes, int len );
435
436		void *base_yyalloc ( yy_size_t );
437		void base_yyrealloc ( void , yy_size_t );
438		void base_yyfree ( void * );
439
440		#define yy_new_buffer base_yy_create_buffer
441		#define yy_set_interactive(is_interactive) \
442		{ \
443		if ( ! YY_CURRENT_BUFFER ){ \
444		base_yyensure_buffer_stack (); \
445		YY_CURRENT_BUFFER_LVALUE = \
446		base_yy_create_buffer(base_yyin,YY_BUF_SIZE ); \
447		} \
448		YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
449		}
450		#define yy_set_bol(at_bol) \
451		{ \
452		if ( ! YY_CURRENT_BUFFER ){\
453		base_yyensure_buffer_stack (); \
454		YY_CURRENT_BUFFER_LVALUE = \
455		base_yy_create_buffer(base_yyin,YY_BUF_SIZE ); \
456		} \
457		YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
458		}
459		#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
460
461		/* Begin user sect3 */
462
463		#define base_yywrap() (/CONSTCOND/1)
464		#define YY_SKIP_YYWRAP
465		typedef flex_uint8_t YY_CHAR;
466
467		FILE base_yyin = NULL, base_yyout = NULL;
468
469		typedef int yy_state_type;
470
471		extern int base_yylineno;
472		int base_yylineno = 1;
473
474		extern char *base_yytext;
475		#ifdef yytext_ptr
476		#undef yytext_ptr
477		#endif
478	0	#define yytext_ptr base_yytext
479
480		static yy_state_type yy_get_previous_state ( void );
481		static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
482		static int yy_get_next_buffer ( void );
483		static void yynoreturn yy_fatal_error ( const char* msg );
484
485		/* Done after the current pattern has been matched and before the
486		* corresponding action - sets up base_yytext.
487		*/
488		#define YY_DO_BEFORE_ACTION \
489		(yytext_ptr) = yy_bp; \
490		base_yyleng = (int) (yy_cp - yy_bp); \
491		(yy_hold_char) = *yy_cp; \
492		*yy_cp = '\0'; \
493		(yy_c_buf_p) = yy_cp;
494		#define YY_NUM_RULES 151
495		#define YY_END_OF_BUFFER 152
496		/* This struct is not used in this scanner,
497		but its presence is necessary. */
498		struct yy_trans_info
499		{
500		flex_int32_t yy_verify;
501		flex_int32_t yy_nxt;
502		};
503		static const flex_int16_t yy_accept[831] =
504		{ 0,
505		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
506		0, 0, 0, 0, 15, 15, 0, 0, 0, 0,
507		0, 0, 0, 0, 14, 14, 0, 0, 0, 0,
508		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
509		0, 0, 0, 0, 152, 150, 120, 98, 98, 120,
510		56, 120, 80, 92, 120, 22, 96, 97, 91, 94,
511		90, 95, 120, 93, 70, 70, 88, 89, 120, 103,
512		120, 86, 86, 101, 102, 99, 120, 100, 78, 1,
513		1, 68, 49, 68, 66, 67, 68, 23, 67, 67,
514		67, 67, 70, 67, 67, 67, 67, 77, 77, 77,
515
516		77, 77, 77, 149, 149, 149, 149, 145, 145, 144,
517		143, 142, 126, 126, 15, 12, 8, 8, 9, 9,
518		9, 9, 55, 51, 57, 52, 57, 14, 19, 36,
519		36, 28, 42, 35, 30, 26, 26, 35, 46, 46,
520		48, 141, 141, 139, 98, 98, 139, 139, 53, 32,
521		0, 0, 112, 0, 0, 0, 0, 0, 0, 0,
522		117, 108, 0, 87, 115, 109, 113, 110, 114, 104,
523		119, 72, 2, 0, 116, 72, 70, 0, 82, 106,
524		111, 105, 86, 86, 107, 1, 0, 68, 65, 68,
525		0, 0, 44, 69, 43, 1, 59, 72, 3, 72,
526
527		70, 74, 58, 60, 76, 62, 64, 61, 63, 77,
528		11, 24, 21, 0, 18, 0, 148, 0, 0, 0,
529		144, 142, 0, 0, 125, 15, 12, 12, 13, 8,
530		10, 7, 4, 10, 6, 5, 55, 54, 57, 14,
531		19, 19, 20, 36, 28, 28, 33, 29, 38, 39,
532		38, 38, 38, 35, 30, 30, 31, 26, 26, 27,
533		34, 46, 45, 47, 0, 0, 140, 0, 0, 0,
534		0, 0, 0, 0, 0, 0, 0, 85, 85, 0,
535		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
536		0, 0, 0, 0, 118, 2, 0, 81, 72, 0,
537
538		73, 82, 86, 68, 68, 43, 1, 1, 3, 72,
539		70, 75, 76, 0, 0, 0, 50, 25, 147, 146,
540		12, 17, 13, 12, 4, 5, 19, 16, 20, 19,
541		28, 41, 29, 28, 39, 0, 0, 40, 30, 31,
542		30, 26, 27, 26, 47, 0, 0, 0, 0, 0,
543		0, 0, 0, 0, 85, 85, 0, 0, 0, 0,
544		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
545		0, 0, 86, 68, 0, 72, 70, 76, 0, 0,
546		0, 76, 147, 147, 146, 146, 12, 12, 12, 12,
547		19, 19, 19, 19, 28, 28, 28, 28, 39, 0,
548
549		0, 40, 30, 30, 30, 30, 26, 26, 26, 26,
550		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
551		0, 0, 0, 85, 85, 0, 0, 0, 0, 0,
552		0, 0, 0, 0, 0, 0, 134, 0, 0, 0,
553		0, 0, 0, 0, 86, 68, 68, 0, 72, 72,
554		76, 0, 0, 0, 0, 12, 12, 12, 12, 12,
555		19, 19, 16, 19, 19, 28, 28, 28, 28, 28,
556		0, 0, 30, 30, 30, 30, 30, 26, 26, 26,
557		26, 26, 0, 0, 0, 0, 0, 0, 0, 41,
558		0, 0, 0, 0, 0, 0, 0, 0, 0, 85,
559
560		85, 0, 0, 0, 0, 0, 0, 0, 0, 0,
561		134, 0, 136, 0, 130, 0, 0, 124, 0, 86,
562		68, 0, 0, 72, 0, 0, 0, 0, 76, 76,
563		12, 19, 28, 0, 37, 30, 26, 0, 0, 0,
564		0, 0, 0, 0, 0, 0, 0, 122, 0, 138,
565		130, 132, 0, 124, 0, 79, 71, 0, 0, 0,
566		0, 0, 76, 0, 0, 0, 0, 0, 0, 0,
567		83, 83, 122, 132, 128, 79, 79, 86, 86, 86,
568		86, 71, 76, 0, 0, 0, 0, 0, 0, 0,
569		0, 0, 83, 83, 83, 0, 83, 0, 128, 0,
570
571		0, 0, 86, 86, 86, 86, 86, 86, 71, 76,
572		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
573		0, 0, 0, 0, 0, 0, 0, 0, 86, 86,
574		86, 86, 86, 86, 86, 86, 0, 0, 0, 0,
575		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
576		0, 0, 0, 86, 86, 86, 86, 86, 86, 86,
577		86, 133, 0, 0, 0, 0, 0, 0, 0, 0,
578		53, 0, 0, 0, 0, 0, 0, 0, 0, 0,
579		32, 0, 0, 0, 0, 0, 0, 0, 0, 0,
580		86, 133, 0, 135, 86, 86, 86, 86, 86, 0,
581
582		129, 0, 0, 0, 0, 0, 0, 0, 0, 0,
583		0, 0, 0, 0, 0, 0, 41, 0, 41, 0,
584		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
585		0, 84, 84, 0, 0, 123, 86, 0, 137, 129,
586		86, 86, 123, 131, 0, 53, 0, 0, 0, 0,
587		0, 53, 53, 0, 0, 0, 0, 0, 0, 0,
588		32, 32, 0, 0, 0, 0, 0, 32, 32, 84,
589		84, 84, 84, 121, 0, 121, 131, 86, 0, 0,
590		0, 0, 0, 0, 0, 0, 32, 0, 0, 41,
591		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
592
593		0, 127, 127, 53, 0, 0, 0, 0, 0, 0,
594		0, 0, 32, 32, 0, 0, 32, 0, 0, 0,
595		0, 0, 0, 0, 0, 0, 0, 0, 0, 0
596		} ;
597
598		static const YY_CHAR yy_ec[256] =
599		{ 0,
600		1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
601		1, 2, 4, 1, 1, 1, 1, 1, 1, 1,
602		1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
603		1, 2, 5, 6, 7, 8, 9, 10, 11, 12,
604		13, 14, 15, 16, 17, 18, 19, 20, 21, 21,
605		21, 21, 21, 21, 21, 22, 22, 23, 24, 25,
606		26, 27, 28, 28, 29, 30, 31, 32, 33, 34,
607		35, 35, 36, 35, 35, 37, 38, 39, 40, 41,
608		42, 43, 44, 45, 46, 35, 35, 47, 35, 35,
609		48, 49, 50, 51, 52, 28, 29, 30, 31, 32,
610
611		33, 34, 35, 35, 53, 35, 35, 37, 38, 39,
612		40, 41, 42, 43, 44, 45, 54, 35, 35, 55,
613		35, 35, 56, 57, 58, 28, 1, 59, 59, 59,
614		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
615		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
616		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
617		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
618		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
619		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
620		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
621
622		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
623		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
624		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
625		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
626		59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
627		59, 59, 59, 59, 59
628		} ;
629
630		static const YY_CHAR yy_meta[60] =
631		{ 0,
632		1, 2, 3, 3, 4, 5, 4, 6, 7, 4,
633		8, 9, 9, 10, 7, 1, 11, 12, 13, 14,
634		14, 14, 15, 16, 17, 18, 19, 4, 20, 20,
635		20, 20, 20, 20, 21, 21, 21, 21, 21, 21,
636		21, 21, 21, 21, 21, 21, 21, 12, 22, 9,
637		4, 21, 21, 21, 21, 1, 4, 1, 21
638		} ;
639
640		static const flex_int16_t yy_base[922] =
641		{ 0,
642		0, 0, 0, 0, 59, 0, 113, 117, 122, 125,
643		149, 0, 208, 0, 1805, 1803, 263, 316, 116, 117,
644		1805, 1803, 263, 268, 1758, 1753, 273, 283, 1752, 1748,
645		1747, 1745, 260, 264, 131, 140, 373, 0, 294, 303,
646		1748, 1747, 1740, 1739, 1745, 5228, 5228, 297, 343, 1717,
647		5228, 257, 316, 1716, 1730, 5228, 5228, 5228, 289, 106,
648		5228, 302, 337, 342, 415, 420, 5228, 5228, 1713, 1711,
649		1708, 0, 232, 5228, 5228, 5228, 1675, 5228, 5228, 442,
650		448, 1704, 5228, 466, 439, 0, 0, 5228, 5228, 1712,
651		436, 1712, 445, 269, 311, 1697, 1695, 0, 1705, 1700,
652
653		1690, 1690, 1684, 1660, 0, 5228, 0, 5228, 484, 5228,
654		5228, 0, 5228, 494, 0, 497, 0, 0, 320, 1665,
655		341, 1654, 0, 1657, 5228, 5228, 275, 0, 503, 0,
656		0, 522, 483, 0, 532, 542, 538, 1641, 0, 0,
657		1639, 5228, 507, 5228, 5228, 5228, 436, 316, 548, 558,
658		564, 459, 5228, 612, 538, 540, 1609, 83, 400, 1592,
659		5228, 5228, 460, 5228, 5228, 5228, 5228, 5228, 5228, 1612,
660		5228, 560, 0, 1612, 5228, 563, 568, 588, 0, 5228,
661		5228, 5228, 0, 1572, 5228, 670, 477, 0, 0, 673,
662		430, 494, 5228, 344, 1591, 726, 5228, 578, 0, 664,
663
664		673, 687, 5228, 5228, 539, 0, 0, 0, 0, 0,
665		5228, 5228, 5228, 471, 5228, 1574, 5228, 1580, 1557, 708,
666		5228, 0, 713, 718, 5228, 0, 744, 753, 1546, 0,
667		502, 5228, 0, 508, 5228, 0, 0, 5228, 5228, 0,
668		756, 763, 1541, 0, 782, 785, 5228, 1534, 5228, 333,
669		0, 0, 0, 0, 788, 804, 1528, 807, 814, 1525,
670		5228, 0, 5228, 1533, 725, 810, 5228, 1496, 1493, 824,
671		1507, 1490, 833, 836, 1504, 1487, 862, 5228, 0, 1504,
672		0, 791, 531, 1476, 1469, 657, 1457, 1466, 1459, 807,
673		1455, 686, 1455, 1433, 5228, 0, 1454, 5228, 824, 834,
674
675		841, 0, 1420, 913, 1431, 1436, 0, 966, 0, 847,
676		853, 863, 696, 1412, 0, 908, 5228, 5228, 931, 941,
677		945, 5228, 1420, 949, 0, 0, 957, 5228, 1417, 984,
678		993, 5228, 1412, 996, 527, 0, 0, 0, 1003, 1410,
679		1022, 1025, 1407, 1028, 1415, 1390, 1031, 1373, 1047, 1397,
680		1050, 1369, 1043, 975, 1057, 1066, 1377, 1374, 1362, 1361,
681		1363, 1360, 1349, 1346, 726, 1348, 1344, 745, 1334, 1331,
682		1324, 1324, 1069, 1111, 1054, 1061, 1066, 721, 1105, 1129,
683		1139, 1146, 1087, 5228, 1149, 5228, 1155, 1167, 1173, 1178,
684		1189, 1184, 1195, 1200, 1205, 1211, 1216, 1221, 5228, 0,
685
686		0, 5228, 1228, 1232, 1238, 1244, 1248, 1254, 1260, 1264,
687		1270, 1276, 1280, 1283, 1286, 1324, 1304, 1292, 1308, 1314,
688		1339, 1316, 1345, 1331, 1362, 578, 1376, 1310, 1306, 1293,
689		680, 1301, 1300, 1285, 717, 1288, 1349, 1367, 1290, 1289,
690		1287, 722, 1279, 1371, 1263, 0, 1421, 1366, 1379, 1383,
691		841, 1478, 1405, 1535, 1416, 1439, 1450, 1460, 1488, 1456,
692		1505, 1508, 1529, 1589, 1593, 1600, 1605, 1610, 1621, 1616,
693		0, 0, 1626, 1637, 1642, 1647, 1653, 1658, 1663, 1674,
694		1679, 1669, 1557, 1262, 1685, 1690, 1273, 1695, 1706, 1711,
695		1716, 1744, 1764, 1769, 1272, 1285, 662, 1284, 1780, 1789,
696
697		1793, 0, 1258, 1246, 1244, 0, 1241, 1225, 1237, 1227,
698		1466, 1472, 5228, 1701, 1511, 1220, 1221, 1632, 1202, 1206,
699		858, 1754, 1767, 1784, 1842, 0, 0, 1220, 919, 1899,
700		1817, 1822, 1852, 0, 5228, 1869, 1872, 1192, 1833, 1186,
701		1917, 1920, 1936, 1185, 1188, 0, 1177, 1776, 1798, 5228,
702		1828, 1858, 1152, 1892, 1146, 1989, 1884, 1160, 1157, 755,
703		2015, 0, 2073, 0, 1942, 1948, 1132, 2062, 1952, 1121,
704		1955, 1958, 1939, 1981, 1984, 2122, 0, 1114, 108, 842,
705		1106, 1979, 2176, 0, 2094, 246, 1110, 2102, 2001, 2111,
706		2234, 2012, 2024, 2028, 2034, 1088, 2037, 1085, 2099, 1086,
707
708		880, 1071, 1071, 910, 1070, 765, 1067, 1065, 5228, 0,
709		0, 1059, 1048, 790, 2237, 2133, 0, 1061, 2241, 2244,
710		2149, 0, 1049, 1032, 1030, 1006, 990, 976, 767, 950,
711		936, 796, 924, 899, 892, 893, 890, 855, 936, 833,
712		832, 2261, 841, 2282, 2299, 2302, 822, 2318, 866, 895,
713		966, 793, 790, 780, 2107, 2265, 767, 766, 745, 936,
714		741, 2129, 2322, 716, 689, 686, 2338, 2348, 2358, 2364,
715		5228, 2368, 2384, 2394, 2404, 2420, 2423, 2439, 2442, 2374,
716		5228, 2459, 2469, 2480, 2496, 660, 658, 640, 957, 641,
717		562, 2159, 2334, 5228, 2499, 2167, 557, 541, 2170, 2502,
718
719		2253, 481, 426, 2507, 2517, 2527, 2537, 2547, 2565, 2575,
720		2585, 2595, 2605, 2621, 2624, 2640, 2643, 2660, 0, 355,
721		2663, 2679, 2696, 2699, 2718, 2735, 2745, 2756, 2766, 2776,
722		2788, 2445, 2512, 307, 286, 2533, 2543, 2772, 5228, 2553,
723		2601, 283, 2611, 2627, 2798, 2804, 2808, 2820, 2824, 2836,
724		2869, 2881, 0, 2892, 2897, 2902, 2914, 2924, 2950, 2960,
725		2930, 5228, 2970, 2986, 2990, 3006, 3009, 3026, 0, 2646,
726		2689, 2724, 2728, 2782, 100, 2814, 2830, 2853, 3045, 3055,
727		3065, 3075, 3085, 3101, 3111, 3133, 3121, 3149, 3159, 3169,
728		3179, 3189, 3207, 3217, 3227, 3237, 3247, 3263, 3273, 3283,
729
730		3294, 2857, 2861, 3311, 3322, 3332, 3343, 3360, 3370, 3388,
731		3391, 3408, 3424, 0, 3427, 3446, 3457, 3482, 3485, 3504,
732		3515, 3531, 3549, 3553, 3572, 3576, 3598, 3608, 3625, 5228,
733		3679, 3701, 3723, 3745, 3767, 3789, 3811, 3833, 3855, 3877,
734		3899, 3921, 3943, 3960, 3978, 3992, 3999, 4015, 4036, 4058,
735		4080, 4097, 4117, 4138, 4160, 4182, 4204, 4226, 4247, 4269,
736		4291, 1035, 4312, 4330, 4349, 470, 4366, 4387, 4406, 4420,
737		4438, 4454, 544, 828, 995, 4468, 586, 4488, 4509, 4531,
738		4553, 998, 1002, 1023, 4575, 4597, 4619, 4641, 4663, 4680,
739		4701, 4723, 4745, 1024, 1086, 4767, 4789, 4811, 4833, 4855,
740
741		1103, 1115, 4876, 1120, 1147, 1191, 4897, 4919, 4941, 4963,
742		4985, 5007, 5029, 5051, 5073, 5095, 5117, 5139, 5161, 5183,
743		5205
744		} ;
745
746		static const flex_int16_t yy_def[922] =
747		{ 0,
748		831, 831, 830, 3, 830, 5, 832, 832, 833, 833,
749		830, 11, 830, 13, 834, 834, 835, 835, 18, 18,
750		836, 836, 837, 837, 838, 838, 839, 839, 840, 840,
751		840, 840, 840, 840, 841, 841, 830, 37, 842, 842,
752		836, 836, 840, 840, 830, 830, 830, 830, 830, 830,
753		830, 843, 830, 830, 830, 830, 830, 830, 830, 830,
754		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
755		830, 844, 844, 830, 830, 830, 830, 830, 830, 830,
756		830, 845, 830, 843, 846, 845, 845, 830, 830, 845,
757		830, 845, 830, 847, 845, 845, 845, 848, 848, 848,
758
759		848, 848, 848, 849, 850, 830, 851, 830, 830, 830,
760		830, 852, 830, 853, 854, 830, 855, 855, 830, 830,
761		830, 830, 856, 830, 830, 830, 830, 857, 830, 858,
762		858, 830, 859, 860, 830, 830, 830, 860, 861, 861,
763		862, 830, 863, 830, 830, 830, 830, 830, 830, 830,
764		830, 843, 830, 830, 154, 830, 830, 830, 830, 830,
765		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
766		830, 830, 864, 865, 830, 830, 830, 830, 866, 830,
767		830, 830, 844, 844, 830, 830, 843, 845, 845, 154,
768		154, 830, 830, 830, 867, 868, 830, 830, 869, 830,
769
770		830, 830, 830, 830, 870, 845, 845, 845, 845, 848,
771		830, 830, 830, 830, 830, 849, 830, 850, 851, 830,
772		830, 852, 830, 853, 830, 854, 830, 830, 830, 855,
773		830, 830, 871, 830, 830, 872, 856, 830, 830, 857,
774		830, 830, 830, 858, 830, 830, 830, 830, 830, 830,
775		873, 874, 875, 860, 830, 830, 830, 830, 830, 830,
776		830, 861, 830, 876, 830, 863, 830, 830, 830, 830,
777		830, 830, 830, 830, 830, 830, 154, 830, 277, 277,
778		154, 277, 154, 154, 154, 277, 830, 830, 830, 830,
779		830, 830, 830, 830, 830, 864, 865, 830, 830, 830,
780
781		830, 866, 844, 277, 304, 867, 868, 868, 869, 830,
782		830, 830, 870, 830, 877, 878, 830, 830, 830, 830,
783		830, 830, 830, 879, 871, 872, 830, 830, 830, 880,
784		830, 830, 830, 881, 830, 882, 883, 884, 830, 830,
785		885, 830, 830, 886, 876, 830, 887, 830, 830, 830,
786		888, 830, 889, 277, 277, 277, 154, 154, 154, 154,
787		277, 277, 830, 830, 830, 830, 830, 830, 830, 830,
788		830, 830, 844, 889, 830, 830, 830, 890, 878, 878,
789		878, 878, 830, 830, 830, 830, 891, 879, 879, 879,
790		892, 880, 880, 880, 893, 881, 881, 881, 830, 894,
791
792		895, 830, 896, 885, 885, 885, 897, 886, 886, 886,
793		830, 887, 887, 887, 887, 830, 898, 888, 888, 888,
794		888, 830, 889, 899, 889, 277, 889, 154, 154, 154,
795		154, 277, 277, 830, 830, 830, 830, 830, 830, 830,
796		830, 830, 830, 830, 844, 374, 277, 830, 830, 830,
797		890, 900, 878, 830, 878, 891, 891, 891, 891, 879,
798		892, 892, 892, 892, 880, 893, 893, 893, 893, 881,
799		901, 902, 896, 896, 896, 896, 885, 897, 897, 897,
800		897, 886, 830, 830, 887, 887, 830, 898, 898, 898,
801		898, 898, 888, 888, 830, 899, 830, 277, 889, 889,
802
803		889, 154, 154, 154, 154, 277, 277, 830, 830, 830,
804		830, 830, 830, 830, 830, 830, 830, 830, 830, 844,
805		447, 830, 830, 830, 900, 525, 525, 525, 525, 903,
806		891, 892, 893, 904, 830, 896, 897, 830, 887, 830,
807		898, 898, 888, 830, 154, 277, 830, 830, 830, 830,
808		830, 830, 830, 830, 830, 844, 830, 830, 525, 525,
809		525, 525, 903, 905, 830, 887, 830, 898, 888, 830,
810		154, 830, 830, 830, 830, 830, 576, 844, 844, 844,
811		844, 830, 830, 906, 830, 830, 830, 887, 830, 898,
812		888, 830, 277, 830, 277, 277, 830, 830, 830, 830,
813
814		830, 830, 844, 844, 844, 844, 844, 844, 830, 583,
815		902, 830, 830, 830, 887, 830, 907, 830, 898, 888,
816		830, 908, 830, 277, 830, 830, 830, 830, 844, 844,
817		844, 844, 844, 844, 844, 844, 830, 830, 830, 830,
818		830, 887, 830, 909, 898, 888, 830, 910, 277, 830,
819		830, 830, 830, 844, 844, 844, 844, 844, 844, 844,
820		844, 830, 830, 830, 830, 830, 887, 830, 911, 887,
821		830, 909, 909, 912, 909, 898, 888, 830, 913, 888,
822		830, 910, 910, 914, 910, 277, 830, 830, 830, 830,
823		844, 830, 830, 830, 844, 844, 844, 844, 844, 830,
824
825		830, 830, 830, 887, 887, 830, 887, 887, 915, 909,
826		909, 830, 909, 909, 898, 830, 916, 898, 908, 830,
827		888, 888, 830, 888, 888, 917, 910, 910, 830, 910,
828		910, 277, 830, 830, 830, 830, 844, 830, 830, 830,
829		844, 844, 830, 830, 915, 887, 915, 915, 918, 915,
830		915, 912, 907, 898, 898, 830, 898, 898, 919, 919,
831		888, 830, 917, 917, 920, 917, 917, 914, 908, 277,
832		830, 277, 830, 830, 830, 830, 830, 844, 915, 915,
833		915, 830, 915, 915, 915, 915, 898, 919, 919, 921,
834		919, 919, 919, 917, 917, 917, 830, 917, 917, 917,
835
836		917, 830, 830, 918, 915, 919, 919, 830, 919, 919,
837		919, 919, 920, 908, 917, 915, 921, 919, 917, 915,
838		919, 917, 915, 919, 917, 915, 919, 917, 919, 0,
839		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
840		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
841		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
842		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
843		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
844		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
845		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
846
847		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
848		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
849		830
850		} ;
851
852		static const flex_int16_t yy_nxt[5288] =
853		{ 0,
854		47, 48, 49, 48, 50, 51, 52, 53, 54, 55,
855		56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
856		66, 66, 67, 68, 69, 70, 71, 47, 72, 72,
857		72, 72, 73, 72, 72, 72, 72, 72, 72, 72,
858		72, 72, 72, 72, 72, 72, 72, 74, 47, 75,
859		47, 72, 72, 72, 72, 76, 77, 78, 72, 79,
860		80, 81, 80, 82, 83, 84, 85, 86, 87, 88,
861		89, 89, 86, 86, 89, 90, 91, 92, 93, 93,
862		93, 94, 89, 95, 96, 97, 87, 98, 99, 98,
863		98, 100, 98, 98, 98, 98, 98, 101, 98, 98,
864
865		98, 98, 98, 98, 102, 103, 89, 79, 89, 86,
866		98, 98, 102, 103, 79, 87, 79, 98, 105, 290,
867		166, 291, 105, 109, 109, 109, 109, 109, 109, 121,
868		121, 167, 802, 140, 122, 122, 106, 107, 141, 106,
869		106, 107, 140, 106, 604, 110, 605, 141, 110, 111,
870		111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
871		111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
872		111, 111, 111, 111, 111, 111, 111, 112, 112, 112,
873		112, 112, 112, 112, 112, 112, 112, 112, 112, 112,
874		112, 112, 112, 112, 112, 112, 111, 111, 111, 111,
875
876		112, 112, 112, 112, 111, 111, 111, 112, 113, 113,
877		113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
878		113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
879		113, 113, 113, 113, 113, 113, 114, 114, 114, 114,
880		114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
881		114, 114, 114, 114, 114, 113, 113, 113, 113, 114,
882		114, 114, 114, 113, 113, 113, 114, 118, 126, 118,
883		137, 118, 118, 126, 137, 131, 119, 118, 184, 118,
884		239, 120, 612, 132, 613, 131, 184, 118, 118, 118,
885		118, 203, 155, 132, 204, 145, 146, 145, 151, 151,
886
887		151, 147, 163, 152, 145, 146, 145, 164, 138, 156,
888		147, 127, 138, 118, 165, 778, 127, 775, 168, 118,
889		118, 133, 118, 239, 118, 118, 148, 169, 170, 119,
890		118, 133, 118, 231, 120, 148, 206, 207, 232, 774,
891		118, 118, 118, 118, 151, 151, 151, 157, 158, 152,
892		171, 159, 335, 335, 234, 173, 172, 172, 172, 235,
893		174, 160, 269, 194, 194, 194, 118, 175, 159, 160,
894		269, 760, 118, 142, 142, 142, 142, 142, 142, 142,
895		142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
896		142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
897
898		142, 143, 143, 143, 143, 143, 143, 143, 143, 143,
899		143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
900		142, 142, 142, 142, 143, 143, 143, 143, 142, 142,
901		142, 143, 176, 292, 177, 177, 177, 176, 293, 177,
902		177, 177, 745, 186, 186, 186, 193, 178, 187, 186,
903		186, 186, 178, 197, 187, 198, 198, 198, 194, 194,
904		194, 179, 200, 283, 201, 201, 201, 284, 158, 179,
905		190, 268, 190, 163, 190, 190, 317, 202, 164, 190,
906		190, 318, 190, 302, 190, 220, 220, 220, 268, 302,
907		190, 190, 190, 190, 155, 223, 223, 223, 227, 228,
908
909		228, 191, 250, 250, 241, 242, 242, 221, 265, 265,
910		265, 156, 191, 229, 744, 231, 190, 225, 192, 243,
911		232, 234, 190, 245, 246, 246, 235, 286, 251, 192,
912		267, 287, 247, 255, 256, 256, 252, 253, 248, 258,
913		259, 259, 247, 258, 259, 259, 399, 399, 257, 270,
914		270, 270, 247, 238, 260, 314, 315, 336, 260, 273,
915		274, 274, 357, 336, 271, 151, 151, 151, 247, 358,
916		152, 283, 742, 286, 275, 284, 285, 287, 288, 172,
917		172, 172, 299, 299, 299, 176, 316, 177, 177, 177,
918		741, 426, 178, 272, 737, 178, 498, 198, 198, 198,
919
920		178, 272, 300, 276, 300, 378, 378, 301, 301, 301,
921		202, 276, 277, 277, 278, 279, 277, 277, 277, 277,
922		277, 277, 277, 277, 277, 277, 277, 277, 277, 277,
923		280, 277, 277, 277, 277, 277, 277, 277, 277, 277,
924		281, 281, 281, 281, 281, 281, 281, 281, 281, 281,
925		281, 281, 281, 281, 281, 281, 281, 281, 281, 277,
926		282, 277, 277, 277, 281, 281, 281, 277, 277, 277,
927		277, 186, 186, 186, 736, 497, 187, 304, 734, 304,
928		277, 304, 304, 310, 310, 310, 304, 304, 361, 304,
929		200, 305, 311, 311, 311, 362, 202, 304, 304, 304,
930
931		304, 312, 733, 312, 732, 202, 301, 301, 301, 220,
932		220, 220, 314, 315, 223, 223, 223, 369, 702, 223,
933		223, 223, 701, 304, 370, 505, 265, 265, 265, 304,
934		308, 221, 308, 505, 308, 308, 225, 314, 315, 308,
935		308, 225, 308, 316, 308, 227, 228, 228, 267, 700,
936		308, 308, 308, 308, 321, 321, 321, 241, 242, 242,
937		229, 436, 509, 322, 327, 327, 327, 517, 316, 323,
938		509, 528, 243, 328, 699, 517, 308, 697, 436, 329,
939		439, 561, 308, 245, 246, 246, 331, 331, 331, 255,
940		256, 256, 354, 355, 356, 332, 633, 439, 248, 696,
941
942		695, 333, 654, 634, 257, 339, 339, 339, 258, 259,
943		259, 265, 265, 265, 332, 342, 342, 342, 691, 654,
944		340, 640, 690, 260, 332, 270, 270, 270, 641, 689,
945		343, 657, 681, 267, 273, 274, 274, 349, 349, 349,
946		271, 337, 366, 299, 299, 299, 332, 337, 657, 275,
947		367, 671, 350, 301, 301, 301, 178, 314, 315, 366,
948		301, 301, 301, 666, 375, 665, 376, 376, 376, 272,
949		200, 374, 377, 377, 377, 606, 305, 272, 276, 202,
950		607, 276, 301, 301, 301, 202, 276, 663, 316, 276,
951		277, 277, 277, 277, 277, 277, 277, 277, 277, 277,
952
953		277, 277, 277, 277, 277, 277, 277, 277, 277, 379,
954		379, 379, 686, 614, 277, 277, 277, 304, 627, 304,
955		686, 304, 304, 662, 381, 661, 304, 304, 660, 304,
956		659, 305, 383, 383, 383, 560, 561, 304, 304, 304,
957		304, 687, 385, 385, 385, 630, 321, 321, 321, 687,
958		389, 228, 228, 631, 384, 322, 658, 382, 327, 327,
959		327, 323, 630, 304, 386, 390, 562, 328, 656, 304,
960		308, 664, 308, 329, 308, 308, 354, 355, 356, 308,
961		308, 698, 308, 655, 308, 393, 242, 242, 664, 698,
962		308, 308, 308, 308, 331, 331, 331, 397, 246, 246,
963
964		394, 688, 735, 332, 339, 339, 339, 653, 338, 333,
965		735, 400, 398, 332, 338, 401, 308, 400, 688, 340,
966		652, 401, 308, 405, 256, 256, 342, 342, 342, 409,
967		259, 259, 413, 270, 270, 332, 402, 471, 406, 651,
968		264, 343, 402, 471, 410, 424, 425, 414, 349, 349,
969		349, 419, 274, 274, 264, 264, 426, 332, 354, 355,
970		356, 280, 650, 350, 649, 648, 420, 354, 355, 356,
971		444, 444, 444, 448, 448, 448, 415, 644, 375, 639,
972		449, 449, 449, 450, 415, 377, 377, 377, 383, 383,
973		383, 427, 276, 202, 637, 421, 636, 635, 202, 472,
974
975		276, 632, 638, 421, 629, 472, 379, 379, 379, 628,
976		384, 637, 445, 424, 425, 446, 534, 446, 626, 446,
977		446, 381, 534, 625, 447, 446, 624, 446, 535, 305,
978		379, 379, 379, 564, 535, 446, 446, 446, 446, 564,
979		379, 379, 379, 614, 608, 381, 603, 379, 379, 379,
980		385, 385, 385, 592, 382, 452, 457, 321, 321, 427,
981		584, 446, 453, 454, 589, 458, 584, 446, 389, 228,
982		228, 459, 386, 528, 389, 228, 228, 522, 382, 389,
983		228, 228, 576, 390, 575, 393, 242, 242, 382, 390,
984		462, 327, 327, 455, 460, 382, 393, 242, 242, 463,
985
986		394, 393, 242, 242, 611, 464, 467, 331, 331, 572,
987		611, 394, 397, 246, 246, 468, 465, 397, 246, 246,
988		571, 469, 397, 246, 246, 570, 567, 398, 565, 474,
989		339, 339, 398, 405, 256, 256, 528, 470, 475, 405,
990		256, 256, 556, 555, 476, 405, 256, 256, 406, 479,
991		342, 342, 553, 552, 406, 409, 259, 259, 480, 548,
992		477, 409, 259, 259, 481, 409, 259, 259, 547, 546,
993		410, 483, 483, 483, 506, 545, 410, 413, 270, 270,
994		482, 413, 270, 270, 413, 270, 270, 413, 270, 270,
995		502, 502, 414, 419, 274, 274, 414, 353, 497, 485,
996
997		544, 540, 414, 538, 520, 489, 349, 349, 420, 419,
998		274, 274, 518, 484, 490, 419, 274, 274, 486, 516,
999		491, 415, 515, 514, 420, 415, 510, 508, 415, 415,
1000		493, 415, 507, 415, 506, 504, 415, 421, 503, 415,
1001		419, 274, 274, 502, 497, 421, 495, 424, 425, 492,
1002		511, 511, 511, 421, 487, 420, 443, 492, 426, 421,
1003		442, 421, 441, 280, 424, 425, 440, 421, 512, 512,
1004		512, 494, 444, 444, 444, 426, 438, 499, 500, 501,
1005		280, 437, 435, 522, 421, 523, 523, 523, 434, 426,
1006		513, 433, 421, 427, 280, 432, 375, 431, 524, 524,
1007
1008		524, 430, 524, 524, 524, 429, 379, 379, 379, 428,
1009		427, 202, 422, 417, 519, 202, 416, 379, 379, 379,
1010		411, 452, 263, 407, 427, 304, 403, 304, 395, 304,
1011		304, 454, 381, 391, 447, 304, 387, 304, 315, 521,
1012		457, 321, 321, 193, 374, 304, 304, 304, 304, 458,
1013		373, 457, 321, 321, 382, 459, 298, 389, 228, 228,
1014		458, 457, 321, 321, 372, 382, 459, 511, 511, 511,
1015		458, 304, 460, 512, 512, 512, 459, 304, 525, 526,
1016		379, 379, 525, 525, 525, 371, 368, 525, 525, 457,
1017		321, 321, 365, 525, 528, 513, 364, 363, 458, 360,
1018
1019		525, 525, 525, 525, 531, 525, 462, 327, 327, 462,
1020		327, 327, 551, 551, 551, 463, 359, 353, 463, 352,
1021		351, 464, 348, 347, 464, 346, 525, 529, 525, 292,
1022		462, 327, 327, 525, 525, 525, 379, 379, 379, 463,
1023		263, 344, 380, 380, 341, 464, 380, 380, 380, 380,
1024		334, 381, 380, 380, 380, 380, 380, 330, 483, 483,
1025		483, 380, 324, 530, 530, 530, 530, 530, 530, 530,
1026		530, 530, 530, 530, 530, 530, 530, 530, 530, 530,
1027		530, 530, 380, 320, 382, 319, 530, 530, 530, 530,
1028		462, 327, 327, 530, 393, 242, 242, 217, 193, 463,
1029
1030		484, 467, 331, 331, 303, 532, 467, 331, 331, 465,
1031		468, 467, 331, 331, 298, 468, 469, 397, 246, 246,
1032		468, 469, 467, 331, 331, 295, 469, 474, 339, 339,
1033		294, 468, 470, 554, 554, 554, 475, 533, 474, 339,
1034		339, 289, 476, 474, 339, 339, 263, 475, 474, 339,
1035		339, 261, 475, 476, 405, 256, 256, 475, 476, 479,
1036		342, 342, 238, 536, 479, 342, 342, 236, 480, 477,
1037		409, 259, 259, 480, 481, 479, 342, 342, 233, 481,
1038		479, 342, 342, 217, 480, 482, 413, 270, 270, 480,
1039		481, 413, 270, 270, 215, 537, 489, 349, 349, 214,
1040
1041		213, 485, 549, 549, 549, 490, 414, 489, 349, 349,
1042		212, 491, 489, 349, 349, 211, 490, 489, 349, 349,
1043		209, 490, 491, 208, 550, 199, 490, 491, 196, 189,
1044		415, 185, 541, 539, 182, 415, 181, 180, 415, 162,
1045		492, 161, 153, 415, 830, 489, 349, 349, 492, 150,
1046		150, 492, 149, 149, 490, 136, 492, 136, 135, 492,
1047		491, 492, 135, 129, 492, 419, 274, 274, 129, 492,
1048		419, 274, 274, 557, 557, 557, 542, 573, 573, 573,
1049		493, 499, 500, 501, 522, 420, 558, 558, 558, 492,
1050		499, 500, 501, 426, 499, 500, 501, 492, 280, 549,
1051
1052		549, 549, 426, 524, 524, 524, 426, 280, 124, 421,
1053		124, 280, 543, 116, 421, 116, 202, 421, 457, 321,
1054		321, 550, 421, 462, 327, 327, 830, 458, 427, 551,
1055		551, 551, 463, 531, 413, 270, 270, 427, 532, 830,
1056		830, 427, 525, 526, 379, 379, 525, 525, 525, 414,
1057		830, 525, 525, 467, 331, 331, 830, 525, 559, 574,
1058		574, 574, 468, 566, 525, 525, 525, 525, 533, 525,
1059		474, 339, 339, 479, 342, 342, 830, 830, 415, 475,
1060		830, 830, 480, 830, 830, 536, 415, 830, 537, 830,
1061		525, 529, 525, 554, 554, 554, 830, 525, 525, 525,
1062
1063		379, 379, 379, 582, 582, 582, 830, 380, 830, 830,
1064		380, 380, 380, 380, 830, 453, 454, 380, 489, 349,
1065		349, 489, 349, 349, 830, 380, 830, 490, 830, 830,
1066		490, 830, 830, 541, 830, 830, 491, 419, 274, 274,
1067		573, 573, 573, 585, 585, 585, 455, 830, 382, 413,
1068		270, 270, 420, 419, 274, 274, 593, 594, 595, 597,
1069		597, 597, 492, 568, 414, 492, 569, 830, 420, 830,
1070		492, 830, 830, 492, 586, 830, 588, 587, 830, 830,
1071		591, 421, 574, 574, 574, 599, 599, 599, 830, 421,
1072		577, 577, 577, 415, 587, 830, 830, 421, 609, 609,
1073
1074		609, 415, 616, 616, 616, 421, 596, 830, 830, 598,
1075		830, 617, 830, 621, 621, 621, 830, 618, 830, 830,
1076		578, 579, 622, 830, 580, 593, 594, 595, 623, 597,
1077		597, 597, 830, 830, 581, 593, 594, 595, 597, 597,
1078		597, 580, 581, 583, 583, 583, 583, 583, 583, 583,
1079		583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1080		583, 583, 830, 489, 349, 349, 583, 583, 583, 583,
1081		830, 830, 490, 583, 379, 379, 379, 830, 491, 830,
1082		830, 380, 830, 830, 380, 380, 380, 380, 830, 453,
1083		454, 380, 590, 830, 830, 585, 585, 585, 830, 380,
1084
1085		599, 599, 599, 413, 270, 270, 830, 492, 692, 692,
1086		692, 830, 489, 349, 349, 492, 830, 830, 414, 830,
1087		455, 490, 382, 577, 577, 577, 586, 491, 830, 587,
1088		692, 692, 692, 830, 616, 616, 616, 830, 830, 619,
1089		830, 830, 615, 617, 830, 830, 587, 415, 830, 618,
1090		621, 621, 621, 600, 586, 415, 492, 601, 830, 622,
1091		692, 692, 692, 830, 492, 623, 830, 602, 740, 740,
1092		740, 743, 743, 743, 601, 602, 525, 526, 379, 379,
1093		525, 525, 525, 610, 527, 525, 525, 527, 527, 527,
1094		527, 525, 560, 561, 527, 610, 610, 610, 525, 525,
1095
1096		525, 525, 527, 525, 610, 610, 610, 610, 610, 610,
1097		610, 610, 610, 610, 610, 610, 610, 610, 610, 610,
1098		610, 610, 610, 562, 525, 529, 525, 610, 610, 610,
1099		610, 525, 525, 525, 610, 419, 274, 274, 413, 270,
1100		270, 830, 489, 349, 349, 419, 274, 274, 830, 830,
1101		420, 490, 830, 414, 740, 740, 740, 491, 830, 830,
1102		420, 830, 667, 668, 668, 830, 693, 693, 693, 642,
1103		830, 669, 830, 830, 620, 830, 646, 670, 830, 421,
1104		830, 645, 415, 673, 616, 616, 492, 421, 694, 421,
1105		415, 830, 674, 830, 492, 830, 830, 421, 675, 830,
1106
1107		489, 349, 349, 677, 678, 678, 415, 830, 830, 490,
1108		830, 830, 679, 830, 415, 491, 830, 830, 680, 683,
1109		621, 621, 830, 693, 693, 693, 830, 830, 684, 830,
1110		830, 676, 830, 830, 685, 693, 693, 693, 830, 667,
1111		668, 668, 830, 830, 492, 694, 830, 421, 669, 668,
1112		668, 668, 492, 830, 670, 421, 830, 694, 617, 705,
1113		706, 706, 830, 830, 703, 413, 270, 270, 412, 673,
1114		616, 616, 830, 830, 707, 419, 274, 274, 674, 830,
1115		709, 830, 830, 415, 675, 673, 616, 616, 830, 830,
1116		726, 415, 830, 272, 674, 711, 712, 712, 830, 830,
1117
1118		675, 272, 830, 708, 674, 673, 616, 616, 830, 415,
1119		713, 708, 830, 830, 674, 830, 830, 415, 830, 421,
1120		714, 715, 716, 716, 677, 678, 678, 421, 830, 830,
1121		717, 830, 830, 679, 830, 830, 718, 830, 830, 680,
1122		716, 716, 716, 722, 723, 723, 770, 771, 772, 719,
1123		830, 830, 418, 830, 830, 720, 830, 830, 724, 830,
1124		683, 621, 621, 830, 830, 492, 830, 830, 421, 684,
1125		683, 621, 621, 492, 830, 685, 421, 830, 830, 684,
1126		830, 728, 729, 729, 276, 685, 830, 725, 830, 830,
1127		684, 830, 276, 830, 830, 725, 730, 683, 621, 621,
1128
1129		738, 738, 738, 738, 738, 738, 684, 830, 413, 270,
1130		270, 830, 731, 773, 773, 773, 830, 746, 413, 270,
1131		270, 830, 739, 414, 830, 739, 830, 746, 270, 270,
1132		270, 830, 830, 414, 743, 743, 743, 671, 413, 270,
1133		270, 830, 830, 271, 776, 776, 776, 746, 413, 270,
1134		270, 830, 415, 485, 740, 740, 740, 746, 830, 830,
1135		415, 830, 415, 414, 830, 830, 748, 668, 668, 830,
1136		415, 830, 272, 830, 830, 749, 673, 616, 616, 486,
1137		272, 750, 415, 830, 830, 752, 673, 616, 616, 830,
1138		415, 675, 415, 830, 830, 752, 616, 616, 616, 830,
1139
1140		415, 675, 777, 777, 777, 753, 673, 616, 616, 830,
1141		751, 618, 743, 743, 743, 752, 830, 830, 751, 830,
1142		830, 714, 673, 616, 616, 715, 716, 716, 777, 777,
1143		777, 674, 830, 830, 717, 830, 830, 714, 830, 830,
1144		718, 716, 716, 716, 755, 756, 756, 770, 771, 772,
1145		719, 830, 830, 490, 830, 830, 720, 830, 830, 757,
1146		830, 489, 349, 349, 419, 274, 274, 830, 830, 492,
1147		490, 830, 830, 761, 830, 830, 759, 492, 830, 420,
1148		419, 274, 274, 830, 830, 276, 830, 830, 758, 761,
1149		773, 773, 773, 276, 830, 420, 758, 349, 349, 349,
1150
1151		419, 274, 274, 830, 830, 492, 762, 830, 421, 761,
1152		830, 830, 350, 492, 830, 493, 421, 830, 830, 419,
1153		274, 274, 830, 830, 421, 770, 771, 772, 761, 773,
1154		773, 773, 421, 830, 420, 830, 764, 678, 678, 830,
1155		830, 276, 830, 830, 421, 765, 683, 621, 621, 276,
1156		494, 766, 421, 830, 830, 768, 830, 683, 621, 621,
1157		830, 685, 830, 421, 830, 830, 768, 621, 621, 621,
1158		830, 421, 685, 738, 738, 738, 769, 683, 621, 621,
1159		767, 830, 623, 776, 776, 776, 768, 830, 767, 683,
1160		621, 621, 731, 830, 830, 739, 830, 830, 684, 748,
1161
1162		668, 668, 830, 830, 731, 413, 270, 270, 749, 748,
1163		668, 668, 830, 830, 779, 776, 776, 776, 749, 830,
1164		414, 748, 668, 668, 779, 781, 782, 782, 830, 830,
1165		749, 777, 777, 777, 749, 830, 779, 748, 668, 668,
1166		783, 830, 830, 751, 830, 830, 749, 830, 830, 415,
1167		830, 751, 785, 751, 803, 803, 803, 415, 803, 803,
1168		803, 751, 803, 803, 803, 751, 830, 830, 830, 784,
1169		748, 668, 668, 751, 830, 830, 830, 784, 830, 749,
1170		830, 751, 711, 712, 712, 779, 830, 830, 830, 751,
1171		830, 674, 830, 489, 349, 349, 830, 713, 489, 349,
1172
1173		349, 786, 787, 349, 349, 349, 830, 787, 491, 830,
1174		830, 830, 762, 491, 751, 489, 349, 349, 350, 830,
1175		830, 830, 751, 830, 787, 489, 349, 349, 830, 830,
1176		541, 419, 274, 274, 787, 830, 830, 492, 830, 830,
1177		491, 830, 492, 830, 830, 492, 420, 276, 830, 830,
1178		492, 789, 716, 716, 830, 276, 542, 830, 830, 492,
1179		790, 789, 716, 716, 830, 830, 791, 492, 830, 492,
1180		790, 764, 678, 678, 830, 421, 793, 492, 830, 830,
1181		765, 830, 830, 421, 830, 830, 794, 764, 678, 678,
1182		830, 796, 797, 797, 830, 792, 765, 830, 830, 830,
1183
1184		765, 830, 794, 792, 830, 792, 798, 764, 678, 678,
1185		764, 678, 678, 792, 830, 767, 765, 830, 830, 765,
1186		830, 830, 800, 767, 830, 794, 830, 728, 729, 729,
1187		830, 767, 830, 830, 830, 799, 684, 830, 830, 767,
1188		830, 801, 730, 799, 830, 830, 748, 668, 668, 830,
1189		830, 767, 830, 830, 767, 749, 748, 668, 668, 767,
1190		830, 785, 767, 830, 830, 804, 748, 668, 668, 830,
1191		830, 779, 830, 830, 830, 804, 668, 668, 668, 830,
1192		830, 779, 830, 830, 830, 753, 748, 668, 668, 830,
1193		751, 703, 830, 830, 830, 804, 830, 830, 751, 830,
1194
1195		751, 785, 748, 668, 668, 830, 830, 830, 751, 830,
1196		751, 804, 748, 668, 668, 830, 830, 779, 751, 830,
1197		272, 749, 489, 349, 349, 830, 830, 785, 272, 830,
1198		751, 490, 830, 786, 748, 668, 668, 491, 751, 830,
1199		830, 830, 830, 749, 830, 830, 751, 830, 830, 779,
1200		789, 716, 716, 830, 751, 830, 751, 830, 830, 790,
1201		789, 716, 716, 830, 751, 793, 492, 830, 830, 790,
1202		807, 808, 808, 830, 492, 793, 805, 830, 751, 790,
1203		789, 716, 716, 830, 830, 809, 751, 830, 830, 790,
1204		789, 716, 716, 830, 792, 811, 830, 830, 830, 790,
1205
1206		830, 830, 792, 830, 792, 793, 830, 830, 789, 716,
1207		716, 830, 792, 830, 810, 830, 830, 790, 764, 678,
1208		678, 812, 810, 811, 792, 830, 830, 765, 764, 678,
1209		678, 830, 792, 800, 792, 830, 830, 813, 764, 678,
1210		678, 830, 792, 794, 830, 830, 830, 813, 716, 716,
1211		716, 830, 792, 794, 830, 830, 830, 814, 830, 830,
1212		792, 830, 767, 720, 764, 678, 678, 830, 830, 830,
1213		767, 830, 767, 813, 764, 678, 678, 830, 830, 800,
1214		767, 830, 767, 813, 764, 678, 678, 830, 830, 794,
1215		767, 830, 276, 765, 830, 764, 678, 678, 830, 800,
1216
1217		276, 830, 830, 830, 765, 801, 830, 830, 767, 830,
1218		794, 830, 781, 782, 782, 830, 767, 830, 767, 830,
1219		830, 749, 830, 748, 668, 668, 767, 783, 767, 830,
1220		830, 830, 749, 789, 716, 716, 767, 815, 779, 767,
1221		830, 830, 817, 830, 789, 716, 716, 767, 793, 830,
1222		830, 830, 816, 817, 830, 830, 784, 830, 830, 793,
1223		830, 716, 716, 716, 784, 830, 830, 751, 830, 830,
1224		814, 789, 716, 716, 830, 751, 720, 792, 830, 830,
1225		817, 830, 830, 830, 830, 792, 811, 830, 792, 789,
1226		716, 716, 789, 716, 716, 830, 792, 830, 817, 830,
1227
1228		830, 790, 830, 830, 793, 276, 830, 811, 830, 789,
1229		716, 716, 830, 276, 830, 792, 830, 830, 790, 830,
1230		812, 830, 830, 792, 793, 796, 797, 797, 764, 678,
1231		678, 830, 830, 792, 765, 830, 792, 765, 830, 830,
1232		798, 792, 830, 794, 792, 830, 830, 748, 668, 668,
1233		830, 818, 830, 792, 830, 830, 749, 819, 807, 808,
1234		808, 792, 779, 830, 830, 830, 830, 790, 830, 799,
1235		830, 830, 767, 809, 820, 830, 830, 799, 830, 830,
1236		767, 830, 830, 789, 716, 716, 764, 678, 678, 830,
1237		830, 751, 790, 830, 830, 765, 830, 830, 793, 751,
1238
1239		830, 794, 810, 830, 830, 748, 668, 668, 830, 830,
1240		810, 830, 821, 822, 749, 830, 789, 716, 716, 830,
1241		779, 830, 830, 830, 830, 790, 830, 792, 830, 830,
1242		767, 793, 764, 678, 678, 792, 830, 830, 767, 830,
1243		830, 765, 830, 824, 823, 830, 830, 794, 830, 751,
1244		748, 668, 668, 830, 789, 716, 716, 751, 830, 749,
1245		792, 830, 830, 790, 830, 779, 830, 830, 792, 793,
1246		830, 825, 830, 764, 678, 678, 767, 748, 668, 668,
1247		830, 826, 765, 830, 767, 830, 749, 830, 794, 830,
1248		830, 830, 779, 827, 751, 830, 830, 830, 792, 789,
1249
1250		716, 716, 751, 830, 828, 830, 792, 830, 790, 764,
1251		678, 678, 830, 830, 793, 830, 830, 767, 765, 830,
1252		830, 751, 830, 830, 794, 767, 789, 716, 716, 751,
1253		829, 830, 830, 830, 830, 790, 830, 830, 830, 830,
1254		830, 793, 830, 792, 830, 830, 830, 830, 830, 830,
1255		830, 792, 830, 767, 830, 830, 830, 830, 830, 830,
1256		830, 767, 830, 830, 830, 830, 830, 830, 830, 830,
1257		792, 830, 830, 830, 830, 830, 830, 830, 792, 46,
1258		46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
1259		46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
1260
1261		46, 104, 104, 104, 104, 104, 104, 104, 104, 104,
1262		104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
1263		104, 104, 104, 108, 108, 108, 108, 108, 108, 108,
1264		108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
1265		108, 108, 108, 108, 108, 115, 115, 115, 115, 115,
1266		115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
1267		115, 115, 115, 115, 115, 115, 115, 117, 117, 117,
1268		117, 117, 117, 117, 117, 117, 117, 117, 117, 117,
1269		117, 117, 117, 117, 117, 117, 117, 117, 117, 123,
1270		123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1271
1272		123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1273		123, 125, 125, 125, 125, 125, 125, 125, 125, 125,
1274		125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
1275		125, 125, 125, 128, 128, 128, 128, 128, 128, 128,
1276		128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1277		128, 128, 128, 128, 128, 130, 130, 130, 130, 130,
1278		130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
1279		130, 130, 130, 130, 130, 130, 130, 134, 134, 134,
1280		134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
1281		134, 134, 134, 134, 134, 134, 134, 134, 134, 139,
1282
1283		139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
1284		139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
1285		139, 144, 144, 144, 144, 144, 144, 144, 144, 144,
1286		144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
1287		144, 144, 144, 154, 154, 154, 154, 154, 154, 154,
1288		154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1289		154, 154, 154, 154, 154, 183, 830, 830, 830, 830,
1290		830, 830, 830, 183, 830, 830, 830, 830, 830, 183,
1291		183, 188, 830, 830, 188, 830, 830, 188, 188, 830,
1292		188, 830, 830, 830, 188, 188, 188, 195, 830, 830,
1293
1294		830, 830, 830, 830, 830, 195, 830, 830, 830, 830,
1295		830, 195, 195, 205, 830, 830, 205, 830, 205, 205,
1296		210, 830, 830, 830, 830, 830, 830, 830, 210, 830,
1297		830, 830, 830, 830, 210, 210, 216, 216, 216, 216,
1298		830, 216, 216, 216, 216, 216, 216, 216, 216, 216,
1299		216, 216, 830, 216, 830, 216, 216, 216, 218, 218,
1300		218, 218, 830, 218, 218, 218, 218, 218, 218, 218,
1301		218, 218, 218, 218, 218, 218, 218, 218, 218, 218,
1302		219, 219, 219, 219, 219, 219, 219, 219, 219, 219,
1303		219, 219, 219, 219, 219, 219, 219, 219, 830, 219,
1304
1305		219, 219, 222, 830, 830, 830, 830, 830, 830, 830,
1306		222, 830, 830, 830, 830, 830, 222, 222, 224, 224,
1307		830, 830, 224, 830, 830, 830, 830, 830, 830, 830,
1308		224, 830, 224, 830, 830, 830, 224, 224, 226, 226,
1309		226, 226, 226, 226, 226, 830, 226, 226, 226, 226,
1310		226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
1311		230, 230, 230, 230, 230, 230, 230, 230, 230, 830,
1312		230, 230, 830, 230, 230, 230, 230, 230, 230, 230,
1313		230, 230, 237, 237, 237, 237, 830, 237, 237, 237,
1314		237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
1315
1316		237, 237, 237, 237, 240, 240, 240, 240, 240, 240,
1317		240, 830, 240, 240, 240, 240, 240, 240, 240, 240,
1318		240, 240, 240, 240, 240, 240, 244, 244, 244, 244,
1319		244, 244, 244, 830, 244, 244, 244, 244, 244, 244,
1320		244, 244, 244, 244, 244, 244, 244, 249, 249, 249,
1321		249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
1322		249, 249, 249, 249, 249, 249, 249, 249, 249, 254,
1323		254, 254, 254, 254, 254, 254, 830, 254, 254, 254,
1324		254, 254, 254, 254, 254, 254, 254, 254, 254, 254,
1325		254, 262, 262, 262, 262, 262, 830, 262, 262, 262,
1326
1327		262, 262, 262, 262, 262, 262, 262, 262, 262, 262,
1328		262, 262, 262, 266, 266, 830, 830, 266, 830, 830,
1329		830, 830, 830, 830, 830, 266, 830, 266, 830, 830,
1330		830, 266, 266, 296, 830, 830, 296, 830, 830, 296,
1331		296, 830, 296, 830, 830, 830, 296, 296, 296, 297,
1332		297, 297, 297, 297, 297, 297, 297, 297, 297, 297,
1333		297, 297, 297, 297, 297, 297, 297, 297, 297, 297,
1334		297, 306, 830, 830, 830, 830, 830, 830, 830, 306,
1335		830, 830, 830, 830, 830, 306, 306, 307, 307, 830,
1336		307, 307, 307, 307, 307, 307, 307, 307, 307, 307,
1337
1338		307, 307, 307, 307, 307, 307, 307, 307, 307, 309,
1339		830, 830, 309, 830, 830, 309, 309, 830, 309, 830,
1340		830, 830, 309, 309, 309, 313, 830, 830, 830, 830,
1341		313, 313, 830, 313, 830, 830, 830, 830, 830, 313,
1342		313, 325, 830, 830, 325, 830, 830, 325, 325, 830,
1343		325, 830, 830, 830, 325, 325, 325, 326, 830, 830,
1344		326, 830, 830, 326, 326, 830, 326, 830, 830, 830,
1345		326, 326, 326, 345, 830, 830, 830, 830, 830, 830,
1346		830, 345, 830, 830, 830, 830, 830, 345, 345, 380,
1347		380, 830, 830, 380, 380, 830, 380, 380, 380, 380,
1348
1349		380, 380, 830, 830, 830, 830, 380, 380, 380, 388,
1350		388, 388, 388, 388, 388, 388, 388, 388, 388, 388,
1351		388, 388, 388, 388, 388, 388, 388, 388, 388, 388,
1352		388, 392, 392, 392, 392, 392, 392, 392, 392, 392,
1353		392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
1354		392, 392, 392, 396, 396, 396, 396, 396, 396, 396,
1355		396, 396, 396, 396, 396, 396, 396, 396, 396, 396,
1356		396, 396, 396, 396, 396, 404, 404, 404, 404, 404,
1357		404, 404, 404, 404, 404, 404, 404, 404, 404, 404,
1358		404, 404, 404, 404, 404, 404, 404, 408, 408, 408,
1359
1360		408, 408, 408, 408, 408, 408, 408, 408, 408, 408,
1361		408, 408, 408, 408, 408, 408, 408, 408, 408, 412,
1362		412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
1363		412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
1364		412, 418, 418, 418, 418, 418, 418, 418, 418, 418,
1365		418, 418, 418, 418, 418, 418, 418, 418, 418, 418,
1366		418, 418, 418, 423, 423, 423, 423, 423, 423, 423,
1367		423, 423, 423, 423, 423, 423, 423, 423, 423, 423,
1368		423, 423, 423, 423, 423, 451, 830, 830, 830, 830,
1369		451, 451, 830, 451, 830, 830, 830, 830, 830, 451,
1370
1371		451, 456, 456, 456, 456, 456, 456, 456, 456, 456,
1372		456, 456, 456, 456, 456, 456, 456, 456, 456, 456,
1373		456, 456, 456, 461, 461, 461, 461, 461, 461, 461,
1374		461, 461, 461, 461, 461, 461, 461, 461, 461, 461,
1375		461, 461, 461, 461, 461, 466, 466, 466, 466, 466,
1376		466, 466, 466, 466, 466, 466, 466, 466, 466, 466,
1377		466, 466, 466, 466, 466, 466, 466, 473, 473, 473,
1378		473, 473, 473, 473, 473, 473, 473, 473, 473, 473,
1379		473, 473, 473, 473, 473, 473, 473, 473, 473, 478,
1380		478, 478, 478, 478, 478, 478, 478, 478, 478, 478,
1381
1382		478, 478, 478, 478, 478, 478, 478, 478, 478, 478,
1383		478, 488, 488, 488, 488, 488, 488, 488, 488, 488,
1384		488, 488, 488, 488, 488, 488, 488, 488, 488, 488,
1385		488, 488, 488, 496, 496, 496, 496, 496, 496, 496,
1386		496, 496, 496, 496, 496, 830, 496, 496, 496, 496,
1387		496, 496, 496, 496, 496, 527, 527, 527, 527, 527,
1388		527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
1389		527, 527, 527, 527, 527, 527, 527, 563, 563, 830,
1390		830, 563, 563, 830, 563, 563, 563, 563, 563, 563,
1391		830, 830, 830, 830, 563, 563, 563, 643, 643, 643,
1392
1393		643, 643, 643, 643, 830, 643, 643, 643, 643, 643,
1394		643, 643, 643, 643, 643, 643, 643, 643, 643, 647,
1395		647, 647, 647, 647, 647, 647, 830, 647, 647, 647,
1396		647, 647, 647, 647, 647, 647, 647, 647, 647, 647,
1397		647, 672, 672, 672, 672, 672, 672, 672, 672, 672,
1398		672, 672, 672, 672, 672, 672, 672, 672, 672, 672,
1399		672, 672, 672, 682, 682, 682, 682, 682, 682, 682,
1400		682, 682, 682, 682, 682, 682, 682, 682, 682, 682,
1401		682, 682, 682, 682, 682, 704, 704, 704, 704, 704,
1402		704, 704, 704, 704, 704, 704, 704, 704, 704, 704,
1403
1404		704, 704, 704, 704, 704, 704, 704, 710, 710, 710,
1405		710, 710, 710, 710, 710, 710, 710, 710, 710, 710,
1406		710, 710, 710, 710, 710, 710, 710, 710, 710, 721,
1407		721, 721, 721, 721, 721, 721, 721, 721, 721, 721,
1408		721, 721, 721, 721, 721, 721, 721, 721, 721, 721,
1409		721, 727, 727, 727, 727, 727, 727, 727, 727, 727,
1410		727, 727, 727, 727, 727, 727, 727, 727, 727, 727,
1411		727, 727, 727, 747, 747, 747, 747, 747, 747, 747,
1412		747, 747, 747, 747, 747, 747, 747, 747, 747, 747,
1413		747, 747, 747, 747, 747, 754, 754, 754, 754, 754,
1414
1415		754, 754, 754, 754, 754, 754, 754, 754, 754, 754,
1416		754, 754, 754, 754, 754, 754, 754, 763, 763, 763,
1417		763, 763, 763, 763, 763, 763, 763, 763, 763, 763,
1418		763, 763, 763, 763, 763, 763, 763, 763, 763, 780,
1419		780, 780, 780, 780, 780, 780, 780, 780, 780, 780,
1420		780, 780, 780, 780, 780, 780, 780, 780, 780, 780,
1421		780, 788, 788, 788, 788, 788, 788, 788, 788, 788,
1422		788, 788, 788, 788, 788, 788, 788, 788, 788, 788,
1423		788, 788, 788, 795, 795, 795, 795, 795, 795, 795,
1424		795, 795, 795, 795, 795, 795, 795, 795, 795, 795,
1425
1426		795, 795, 795, 795, 795, 806, 806, 806, 806, 806,
1427		806, 806, 806, 806, 806, 806, 806, 806, 806, 806,
1428		806, 806, 806, 806, 806, 806, 806, 45, 830, 830,
1429		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1430		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1431		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1432		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1433		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1434		830, 830, 830, 830, 830, 830, 830
1435		} ;
1436
1437		static const flex_int16_t yy_chk[5288] =
1438		{ 0,
1439		3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1440		3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1441		3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1442		3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1443		3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1444		3, 3, 3, 3, 3, 3, 3, 3, 3, 5,
1445		5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1446		5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1447		5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1448		5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1449
1450		5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1451		5, 5, 5, 5, 5, 5, 5, 5, 7, 158,
1452		60, 158, 8, 9, 9, 9, 10, 10, 10, 19,
1453		20, 60, 775, 35, 19, 20, 7, 7, 35, 7,
1454		8, 8, 36, 8, 579, 9, 579, 36, 10, 11,
1455		11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
1456		11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
1457		11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
1458		11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
1459		11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
1460
1461		11, 11, 11, 11, 11, 11, 11, 11, 13, 13,
1462		13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1463		13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1464		13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1465		13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1466		13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1467		13, 13, 13, 13, 13, 13, 13, 17, 23, 17,
1468		33, 17, 17, 24, 34, 27, 17, 17, 73, 17,
1469		127, 17, 586, 27, 586, 28, 73, 17, 17, 17,
1470		17, 94, 52, 28, 94, 39, 39, 39, 48, 48,
1471
1472		48, 39, 59, 48, 40, 40, 40, 59, 33, 52,
1473		40, 23, 34, 17, 59, 742, 24, 735, 62, 17,
1474		18, 27, 18, 127, 18, 18, 39, 62, 62, 18,
1475		18, 28, 18, 119, 18, 40, 95, 95, 119, 734,
1476		18, 18, 18, 18, 49, 49, 49, 53, 53, 49,
1477		63, 53, 250, 250, 121, 64, 63, 63, 63, 121,
1478		64, 53, 148, 194, 194, 194, 18, 64, 53, 53,
1479		148, 720, 18, 37, 37, 37, 37, 37, 37, 37,
1480		37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
1481		37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
1482
1483		37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
1484		37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
1485		37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
1486		37, 37, 65, 159, 65, 65, 65, 66, 159, 66,
1487		66, 66, 703, 80, 80, 80, 85, 65, 80, 81,
1488		81, 81, 66, 91, 81, 91, 91, 91, 85, 85,
1489		85, 65, 93, 191, 93, 93, 93, 191, 147, 65,
1490		84, 147, 84, 163, 84, 84, 214, 93, 163, 84,
1491		84, 214, 84, 866, 84, 109, 109, 109, 147, 866,
1492		84, 84, 84, 84, 152, 114, 114, 114, 116, 116,
1493
1494		116, 84, 133, 133, 129, 129, 129, 109, 143, 143,
1495		143, 152, 187, 116, 702, 231, 84, 114, 84, 129,
1496		231, 234, 84, 132, 132, 132, 234, 192, 133, 187,
1497		143, 192, 132, 135, 135, 135, 133, 133, 132, 137,
1498		137, 137, 135, 136, 136, 136, 335, 335, 135, 149,
1499		149, 149, 136, 149, 137, 205, 205, 873, 136, 150,
1500		150, 150, 283, 873, 149, 151, 151, 151, 150, 283,
1501		151, 155, 698, 156, 150, 155, 155, 156, 156, 172,
1502		172, 172, 176, 176, 176, 177, 205, 177, 177, 177,
1503		697, 426, 172, 149, 691, 176, 426, 198, 198, 198,
1504
1505		177, 149, 178, 150, 178, 877, 877, 178, 178, 178,
1506		198, 150, 154, 154, 154, 154, 154, 154, 154, 154,
1507		154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1508		154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1509		154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1510		154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1511		154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1512		154, 186, 186, 186, 690, 497, 186, 190, 688, 190,
1513		497, 190, 190, 200, 200, 200, 190, 190, 286, 190,
1514		201, 190, 201, 201, 201, 286, 200, 190, 190, 190,
1515
1516		190, 202, 687, 202, 686, 201, 202, 202, 202, 220,
1517		220, 220, 313, 313, 223, 223, 223, 292, 666, 224,
1518		224, 224, 665, 190, 292, 431, 265, 265, 265, 190,
1519		196, 220, 196, 431, 196, 196, 223, 378, 378, 196,
1520		196, 224, 196, 313, 196, 227, 227, 227, 265, 664,
1521		196, 196, 196, 196, 228, 228, 228, 241, 241, 241,
1522		227, 365, 435, 228, 242, 242, 242, 442, 378, 228,
1523		435, 560, 241, 242, 661, 442, 196, 659, 365, 242,
1524		368, 560, 196, 245, 245, 245, 246, 246, 246, 255,
1525		255, 255, 282, 282, 282, 246, 606, 368, 245, 658,
1526
1527		657, 246, 629, 606, 255, 256, 256, 256, 258, 258,
1528		258, 266, 266, 266, 256, 259, 259, 259, 654, 629,
1529		256, 614, 653, 258, 259, 270, 270, 270, 614, 652,
1530		259, 632, 647, 266, 273, 273, 273, 274, 274, 274,
1531		270, 874, 290, 299, 299, 299, 274, 874, 632, 273,
1532		290, 643, 274, 300, 300, 300, 299, 451, 451, 290,
1533		301, 301, 301, 641, 310, 640, 310, 310, 310, 270,
1534		311, 521, 311, 311, 311, 580, 521, 270, 273, 310,
1535		580, 274, 312, 312, 312, 311, 273, 638, 451, 274,
1536		277, 277, 277, 277, 277, 277, 277, 277, 277, 277,
1537
1538		277, 277, 277, 277, 277, 277, 277, 277, 277, 316,
1539		316, 316, 649, 601, 277, 277, 277, 304, 601, 304,
1540		649, 304, 304, 637, 316, 636, 304, 304, 635, 304,
1541		634, 304, 319, 319, 319, 529, 529, 304, 304, 304,
1542		304, 650, 320, 320, 320, 604, 321, 321, 321, 650,
1543		324, 324, 324, 604, 319, 321, 633, 316, 327, 327,
1544		327, 321, 604, 304, 320, 324, 529, 327, 631, 304,
1545		308, 639, 308, 327, 308, 308, 354, 354, 354, 308,
1546		308, 660, 308, 630, 308, 330, 330, 330, 639, 660,
1547		308, 308, 308, 308, 331, 331, 331, 334, 334, 334,
1548
1549		330, 651, 689, 331, 339, 339, 339, 628, 875, 331,
1550		689, 882, 334, 339, 875, 883, 308, 882, 651, 339,
1551		627, 883, 308, 341, 341, 341, 342, 342, 342, 344,
1552		344, 344, 347, 347, 347, 342, 884, 894, 341, 626,
1553		862, 342, 884, 894, 344, 353, 353, 347, 349, 349,
1554		349, 351, 351, 351, 862, 862, 353, 349, 355, 355,
1555		355, 353, 625, 349, 624, 623, 351, 356, 356, 356,
1556		373, 373, 373, 375, 375, 375, 347, 618, 376, 613,
1557		376, 376, 376, 377, 347, 377, 377, 377, 383, 383,
1558		383, 353, 349, 376, 612, 351, 608, 607, 377, 895,
1559
1560		349, 605, 612, 351, 603, 895, 379, 379, 379, 602,
1561		383, 612, 373, 374, 374, 374, 901, 374, 600, 374,
1562		374, 379, 901, 598, 374, 374, 596, 374, 902, 374,
1563		380, 380, 380, 904, 902, 374, 374, 374, 374, 904,
1564		381, 381, 381, 587, 581, 380, 578, 382, 382, 382,
1565		385, 385, 385, 570, 379, 381, 387, 387, 387, 374,
1566		905, 374, 382, 382, 567, 387, 905, 374, 388, 388,
1567		388, 387, 385, 559, 389, 389, 389, 558, 380, 390,
1568		390, 390, 555, 388, 553, 392, 392, 392, 381, 389,
1569		391, 391, 391, 382, 390, 382, 393, 393, 393, 391,
1570
1571		392, 394, 394, 394, 906, 391, 395, 395, 395, 547,
1572		906, 393, 396, 396, 396, 395, 394, 397, 397, 397,
1573		545, 395, 398, 398, 398, 544, 540, 396, 538, 403,
1574		403, 403, 397, 404, 404, 404, 528, 398, 403, 405,
1575		405, 405, 520, 519, 403, 406, 406, 406, 404, 407,
1576		407, 407, 517, 516, 405, 408, 408, 408, 407, 510,
1577		406, 409, 409, 409, 407, 410, 410, 410, 509, 508,
1578		408, 411, 411, 411, 507, 505, 409, 412, 412, 412,
1579		410, 413, 413, 413, 414, 414, 414, 415, 415, 415,
1580		504, 503, 412, 418, 418, 418, 413, 498, 496, 414,
1581
1582		495, 487, 415, 484, 445, 417, 417, 417, 418, 419,
1583		419, 419, 443, 411, 417, 420, 420, 420, 415, 441,
1584		417, 412, 440, 439, 419, 413, 436, 434, 414, 412,
1585		420, 415, 433, 413, 432, 430, 414, 418, 429, 415,
1586		421, 421, 421, 428, 424, 418, 422, 423, 423, 417,
1587		437, 437, 437, 419, 416, 421, 372, 417, 423, 420,
1588		371, 419, 370, 423, 425, 425, 369, 420, 438, 438,
1589		438, 421, 444, 444, 444, 425, 367, 427, 427, 427,
1590		425, 366, 364, 448, 421, 448, 448, 448, 363, 427,
1591		438, 362, 421, 423, 427, 361, 449, 360, 449, 449,
1592
1593		449, 359, 450, 450, 450, 358, 453, 453, 453, 357,
1594		425, 449, 352, 350, 444, 450, 348, 455, 455, 455,
1595		346, 453, 345, 343, 427, 447, 340, 447, 333, 447,
1596		447, 453, 455, 329, 447, 447, 323, 447, 314, 447,
1597		456, 456, 456, 306, 305, 447, 447, 447, 447, 456,
1598		303, 457, 457, 457, 453, 456, 297, 460, 460, 460,
1599		457, 458, 458, 458, 294, 455, 457, 511, 511, 511,
1600		458, 447, 460, 512, 512, 512, 458, 447, 452, 452,
1601		452, 452, 452, 452, 452, 293, 291, 452, 452, 459,
1602		459, 459, 289, 452, 452, 512, 288, 287, 459, 285,
1603
1604		452, 452, 452, 452, 459, 452, 461, 461, 461, 462,
1605		462, 462, 515, 515, 515, 461, 284, 280, 462, 276,
1606		275, 461, 272, 271, 462, 269, 452, 452, 452, 268,
1607		463, 463, 463, 452, 452, 452, 454, 454, 454, 463,
1608		264, 260, 454, 454, 257, 463, 454, 454, 454, 454,
1609		248, 454, 454, 454, 454, 454, 454, 243, 483, 483,
1610		483, 454, 229, 454, 454, 454, 454, 454, 454, 454,
1611		454, 454, 454, 454, 454, 454, 454, 454, 454, 454,
1612		454, 454, 454, 219, 454, 218, 454, 454, 454, 454,
1613		464, 464, 464, 454, 465, 465, 465, 216, 195, 464,
1614
1615		483, 466, 466, 466, 184, 464, 467, 467, 467, 465,
1616		466, 468, 468, 468, 174, 467, 466, 470, 470, 470,
1617		468, 467, 469, 469, 469, 170, 468, 473, 473, 473,
1618		160, 469, 470, 518, 518, 518, 473, 469, 474, 474,
1619		474, 157, 473, 475, 475, 475, 141, 474, 476, 476,
1620		476, 138, 475, 474, 477, 477, 477, 476, 475, 478,
1621		478, 478, 124, 476, 479, 479, 479, 122, 478, 477,
1622		482, 482, 482, 479, 478, 480, 480, 480, 120, 479,
1623		481, 481, 481, 104, 480, 482, 485, 485, 485, 481,
1624		480, 486, 486, 486, 103, 481, 488, 488, 488, 102,
1625
1626		101, 485, 514, 514, 514, 488, 486, 489, 489, 489,
1627		100, 488, 490, 490, 490, 99, 489, 491, 491, 491,
1628		97, 490, 489, 96, 514, 92, 491, 490, 90, 82,
1629		485, 77, 491, 486, 71, 486, 70, 69, 485, 55,
1630		488, 54, 50, 486, 45, 492, 492, 492, 488, 44,
1631		43, 489, 42, 41, 492, 32, 490, 31, 30, 489,
1632		492, 491, 29, 26, 490, 493, 493, 493, 25, 491,
1633		494, 494, 494, 522, 522, 522, 492, 548, 548, 548,
1634		493, 499, 499, 499, 523, 494, 523, 523, 523, 492,
1635		500, 500, 500, 499, 501, 501, 501, 492, 499, 549,
1636
1637		549, 549, 500, 524, 524, 524, 501, 500, 22, 493,
1638		21, 501, 494, 16, 494, 15, 524, 493, 531, 531,
1639		531, 549, 494, 532, 532, 532, 0, 531, 499, 551,
1640		551, 551, 532, 531, 539, 539, 539, 500, 532, 0,
1641		0, 501, 525, 525, 525, 525, 525, 525, 525, 539,
1642		0, 525, 525, 533, 533, 533, 0, 525, 525, 552,
1643		552, 552, 533, 539, 525, 525, 525, 525, 533, 525,
1644		536, 536, 536, 537, 537, 537, 0, 0, 539, 536,
1645		0, 0, 537, 0, 0, 536, 539, 0, 537, 0,
1646		525, 525, 525, 554, 554, 554, 0, 525, 525, 525,
1647
1648		530, 530, 530, 557, 557, 557, 0, 530, 0, 0,
1649		530, 530, 530, 530, 0, 530, 530, 530, 541, 541,
1650		541, 542, 542, 542, 0, 530, 0, 541, 0, 0,
1651		542, 0, 0, 541, 0, 0, 542, 543, 543, 543,
1652		573, 573, 573, 565, 565, 565, 530, 0, 530, 566,
1653		566, 566, 543, 569, 569, 569, 571, 571, 571, 572,
1654		572, 572, 541, 542, 566, 542, 543, 0, 569, 0,
1655		541, 0, 0, 542, 565, 0, 566, 565, 0, 0,
1656		569, 543, 574, 574, 574, 575, 575, 575, 0, 543,
1657		556, 556, 556, 566, 565, 0, 0, 569, 582, 582,
1658
1659		582, 566, 589, 589, 589, 569, 571, 0, 0, 572,
1660		0, 589, 0, 592, 592, 592, 0, 589, 0, 0,
1661		556, 556, 592, 0, 556, 593, 593, 593, 592, 594,
1662		594, 594, 0, 0, 556, 595, 595, 595, 597, 597,
1663		597, 556, 556, 561, 561, 561, 561, 561, 561, 561,
1664		561, 561, 561, 561, 561, 561, 561, 561, 561, 561,
1665		561, 561, 0, 568, 568, 568, 561, 561, 561, 561,
1666		0, 0, 568, 561, 563, 563, 563, 0, 568, 0,
1667		0, 563, 0, 0, 563, 563, 563, 563, 0, 563,
1668		563, 563, 568, 0, 0, 585, 585, 585, 0, 563,
1669
1670		599, 599, 599, 588, 588, 588, 0, 568, 655, 655,
1671		655, 0, 590, 590, 590, 568, 0, 0, 588, 0,
1672		563, 590, 563, 576, 576, 576, 585, 590, 0, 585,
1673		662, 662, 662, 0, 616, 616, 616, 0, 0, 590,
1674		0, 0, 588, 616, 0, 0, 585, 588, 0, 616,
1675		621, 621, 621, 576, 576, 588, 590, 576, 0, 621,
1676		692, 692, 692, 0, 590, 621, 0, 576, 696, 696,
1677		696, 699, 699, 699, 576, 576, 583, 583, 583, 583,
1678		583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1679		583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1680
1681		583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1682		583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1683		583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1684		583, 583, 583, 583, 583, 591, 591, 591, 615, 615,
1685		615, 0, 619, 619, 619, 620, 620, 620, 0, 0,
1686		591, 619, 0, 615, 701, 701, 701, 619, 0, 0,
1687		620, 0, 642, 642, 642, 0, 656, 656, 656, 615,
1688		0, 642, 0, 0, 591, 0, 620, 642, 0, 591,
1689		0, 619, 615, 644, 644, 644, 619, 591, 656, 620,
1690		615, 0, 644, 0, 619, 0, 0, 620, 644, 0,
1691
1692		645, 645, 645, 646, 646, 646, 642, 0, 0, 645,
1693		0, 0, 646, 0, 642, 645, 0, 0, 646, 648,
1694		648, 648, 0, 663, 663, 663, 0, 0, 648, 0,
1695		0, 645, 0, 0, 648, 693, 693, 693, 0, 667,
1696		667, 667, 0, 0, 645, 663, 0, 646, 667, 668,
1697		668, 668, 645, 0, 667, 646, 0, 693, 668, 669,
1698		669, 669, 0, 0, 668, 670, 670, 670, 669, 672,
1699		672, 672, 0, 0, 669, 680, 680, 680, 672, 0,
1700		670, 0, 0, 667, 672, 673, 673, 673, 0, 0,
1701		680, 667, 0, 668, 673, 674, 674, 674, 0, 0,
1702
1703		673, 668, 0, 669, 674, 675, 675, 675, 0, 670,
1704		674, 669, 0, 0, 675, 0, 0, 670, 0, 680,
1705		675, 676, 676, 676, 677, 677, 677, 680, 0, 0,
1706		676, 0, 0, 677, 0, 0, 676, 0, 0, 677,
1707		678, 678, 678, 679, 679, 679, 732, 732, 732, 678,
1708		0, 0, 679, 0, 0, 678, 0, 0, 679, 0,
1709		682, 682, 682, 0, 0, 676, 0, 0, 677, 682,
1710		683, 683, 683, 676, 0, 682, 677, 0, 0, 683,
1711		0, 684, 684, 684, 678, 683, 0, 679, 0, 0,
1712		684, 0, 678, 0, 0, 679, 684, 685, 685, 685,
1713
1714		695, 695, 695, 700, 700, 700, 685, 0, 704, 704,
1715		704, 0, 685, 733, 733, 733, 0, 704, 705, 705,
1716		705, 0, 695, 704, 0, 700, 0, 705, 706, 706,
1717		706, 0, 0, 705, 736, 736, 736, 706, 707, 707,
1718		707, 0, 0, 706, 737, 737, 737, 707, 708, 708,
1719		708, 0, 704, 707, 740, 740, 740, 708, 0, 0,
1720		704, 0, 705, 708, 0, 0, 709, 709, 709, 0,
1721		705, 0, 706, 0, 0, 709, 710, 710, 710, 708,
1722		706, 709, 707, 0, 0, 710, 711, 711, 711, 0,
1723		707, 710, 708, 0, 0, 711, 712, 712, 712, 0,
1724
1725		708, 711, 741, 741, 741, 712, 713, 713, 713, 0,
1726		709, 712, 743, 743, 743, 713, 0, 0, 709, 0,
1727		0, 713, 714, 714, 714, 715, 715, 715, 744, 744,
1728		744, 714, 0, 0, 715, 0, 0, 714, 0, 0,
1729		715, 716, 716, 716, 717, 717, 717, 770, 770, 770,
1730		716, 0, 0, 717, 0, 0, 716, 0, 0, 717,
1731		0, 718, 718, 718, 721, 721, 721, 0, 0, 715,
1732		718, 0, 0, 721, 0, 0, 718, 715, 0, 721,
1733		722, 722, 722, 0, 0, 716, 0, 0, 717, 722,
1734		771, 771, 771, 716, 0, 722, 717, 723, 723, 723,
1735
1736		724, 724, 724, 0, 0, 718, 723, 0, 721, 724,
1737		0, 0, 723, 718, 0, 724, 721, 0, 0, 725,
1738		725, 725, 0, 0, 722, 772, 772, 772, 725, 773,
1739		773, 773, 722, 0, 725, 0, 726, 726, 726, 0,
1740		0, 723, 0, 0, 724, 726, 727, 727, 727, 723,
1741		725, 726, 724, 0, 0, 727, 0, 728, 728, 728,
1742		0, 727, 0, 725, 0, 0, 728, 729, 729, 729,
1743		0, 725, 728, 738, 738, 738, 729, 730, 730, 730,
1744		726, 0, 729, 774, 774, 774, 730, 0, 726, 731,
1745		731, 731, 730, 0, 0, 738, 0, 0, 731, 745,
1746
1747		745, 745, 0, 0, 731, 746, 746, 746, 745, 747,
1748		747, 747, 0, 0, 745, 776, 776, 776, 747, 0,
1749		746, 748, 748, 748, 747, 749, 749, 749, 0, 0,
1750		748, 777, 777, 777, 749, 0, 748, 750, 750, 750,
1751		749, 0, 0, 745, 0, 0, 750, 0, 0, 746,
1752		0, 745, 750, 747, 778, 778, 778, 746, 802, 802,
1753		802, 747, 803, 803, 803, 748, 0, 0, 0, 749,
1754		751, 751, 751, 748, 0, 0, 0, 749, 0, 751,
1755		0, 750, 752, 752, 752, 751, 0, 0, 0, 750,
1756		0, 752, 0, 754, 754, 754, 0, 752, 755, 755,
1757
1758		755, 751, 754, 756, 756, 756, 0, 755, 754, 0,
1759		0, 0, 756, 755, 751, 757, 757, 757, 756, 0,
1760		0, 0, 751, 0, 757, 758, 758, 758, 0, 0,
1761		757, 761, 761, 761, 758, 0, 0, 754, 0, 0,
1762		758, 0, 755, 0, 0, 754, 761, 756, 0, 0,
1763		755, 759, 759, 759, 0, 756, 758, 0, 0, 757,
1764		759, 760, 760, 760, 0, 0, 759, 757, 0, 758,
1765		760, 763, 763, 763, 0, 761, 760, 758, 0, 0,
1766		763, 0, 0, 761, 0, 0, 763, 764, 764, 764,
1767		0, 765, 765, 765, 0, 759, 764, 0, 0, 0,
1768
1769		765, 0, 764, 759, 0, 760, 765, 766, 766, 766,
1770		767, 767, 767, 760, 0, 763, 766, 0, 0, 767,
1771		0, 0, 766, 763, 0, 767, 0, 768, 768, 768,
1772		0, 764, 0, 0, 0, 765, 768, 0, 0, 764,
1773		0, 767, 768, 765, 0, 0, 779, 779, 779, 0,
1774		0, 766, 0, 0, 767, 779, 780, 780, 780, 766,
1775		0, 779, 767, 0, 0, 780, 781, 781, 781, 0,
1776		0, 780, 0, 0, 0, 781, 782, 782, 782, 0,
1777		0, 781, 0, 0, 0, 782, 783, 783, 783, 0,
1778		779, 782, 0, 0, 0, 783, 0, 0, 779, 0,
1779
1780		780, 783, 784, 784, 784, 0, 0, 0, 780, 0,
1781		781, 784, 785, 785, 785, 0, 0, 784, 781, 0,
1782		782, 785, 787, 787, 787, 0, 0, 785, 782, 0,
1783		783, 787, 0, 784, 786, 786, 786, 787, 783, 0,
1784		0, 0, 0, 786, 0, 0, 784, 0, 0, 786,
1785		788, 788, 788, 0, 784, 0, 785, 0, 0, 788,
1786		789, 789, 789, 0, 785, 788, 787, 0, 0, 789,
1787		790, 790, 790, 0, 787, 789, 786, 0, 786, 790,
1788		791, 791, 791, 0, 0, 790, 786, 0, 0, 791,
1789		792, 792, 792, 0, 788, 791, 0, 0, 0, 792,
1790
1791		0, 0, 788, 0, 789, 792, 0, 0, 793, 793,
1792		793, 0, 789, 0, 790, 0, 0, 793, 794, 794,
1793		794, 792, 790, 793, 791, 0, 0, 794, 795, 795,
1794		795, 0, 791, 794, 792, 0, 0, 795, 796, 796,
1795		796, 0, 792, 795, 0, 0, 0, 796, 797, 797,
1796		797, 0, 793, 796, 0, 0, 0, 797, 0, 0,
1797		793, 0, 794, 797, 798, 798, 798, 0, 0, 0,
1798		794, 0, 795, 798, 799, 799, 799, 0, 0, 798,
1799		795, 0, 796, 799, 800, 800, 800, 0, 0, 799,
1800		796, 0, 797, 800, 0, 801, 801, 801, 0, 800,
1801
1802		797, 0, 0, 0, 801, 799, 0, 0, 798, 0,
1803		801, 0, 804, 804, 804, 0, 798, 0, 799, 0,
1804		0, 804, 0, 805, 805, 805, 799, 804, 800, 0,
1805		0, 0, 805, 806, 806, 806, 800, 801, 805, 801,
1806		0, 0, 806, 0, 807, 807, 807, 801, 806, 0,
1807		0, 0, 805, 807, 0, 0, 804, 0, 0, 807,
1808		0, 808, 808, 808, 804, 0, 0, 805, 0, 0,
1809		808, 809, 809, 809, 0, 805, 808, 806, 0, 0,
1810		809, 0, 0, 0, 0, 806, 809, 0, 807, 810,
1811		810, 810, 811, 811, 811, 0, 807, 0, 810, 0,
1812
1813		0, 811, 0, 0, 810, 808, 0, 811, 0, 812,
1814		812, 812, 0, 808, 0, 809, 0, 0, 812, 0,
1815		810, 0, 0, 809, 812, 813, 813, 813, 815, 815,
1816		815, 0, 0, 810, 813, 0, 811, 815, 0, 0,
1817		813, 810, 0, 815, 811, 0, 0, 816, 816, 816,
1818		0, 812, 0, 812, 0, 0, 816, 815, 817, 817,
1819		817, 812, 816, 0, 0, 0, 0, 817, 0, 813,
1820		0, 0, 815, 817, 816, 0, 0, 813, 0, 0,
1821		815, 0, 0, 818, 818, 818, 819, 819, 819, 0,
1822		0, 816, 818, 0, 0, 819, 0, 0, 818, 816,
1823
1824		0, 819, 817, 0, 0, 820, 820, 820, 0, 0,
1825		817, 0, 818, 819, 820, 0, 821, 821, 821, 0,
1826		820, 0, 0, 0, 0, 821, 0, 818, 0, 0,
1827		819, 821, 822, 822, 822, 818, 0, 0, 819, 0,
1828		0, 822, 0, 821, 820, 0, 0, 822, 0, 820,
1829		823, 823, 823, 0, 824, 824, 824, 820, 0, 823,
1830		821, 0, 0, 824, 0, 823, 0, 0, 821, 824,
1831		0, 822, 0, 825, 825, 825, 822, 826, 826, 826,
1832		0, 823, 825, 0, 822, 0, 826, 0, 825, 0,
1833		0, 0, 826, 824, 823, 0, 0, 0, 824, 827,
1834
1835		827, 827, 823, 0, 825, 0, 824, 0, 827, 828,
1836		828, 828, 0, 0, 827, 0, 0, 825, 828, 0,
1837		0, 826, 0, 0, 828, 825, 829, 829, 829, 826,
1838		827, 0, 0, 0, 0, 829, 0, 0, 0, 0,
1839		0, 829, 0, 827, 0, 0, 0, 0, 0, 0,
1840		0, 827, 0, 828, 0, 0, 0, 0, 0, 0,
1841		0, 828, 0, 0, 0, 0, 0, 0, 0, 0,
1842		829, 0, 0, 0, 0, 0, 0, 0, 829, 831,
1843		831, 831, 831, 831, 831, 831, 831, 831, 831, 831,
1844		831, 831, 831, 831, 831, 831, 831, 831, 831, 831,
1845
1846		831, 832, 832, 832, 832, 832, 832, 832, 832, 832,
1847		832, 832, 832, 832, 832, 832, 832, 832, 832, 832,
1848		832, 832, 832, 833, 833, 833, 833, 833, 833, 833,
1849		833, 833, 833, 833, 833, 833, 833, 833, 833, 833,
1850		833, 833, 833, 833, 833, 834, 834, 834, 834, 834,
1851		834, 834, 834, 834, 834, 834, 834, 834, 834, 834,
1852		834, 834, 834, 834, 834, 834, 834, 835, 835, 835,
1853		835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
1854		835, 835, 835, 835, 835, 835, 835, 835, 835, 836,
1855		836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
1856
1857		836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
1858		836, 837, 837, 837, 837, 837, 837, 837, 837, 837,
1859		837, 837, 837, 837, 837, 837, 837, 837, 837, 837,
1860		837, 837, 837, 838, 838, 838, 838, 838, 838, 838,
1861		838, 838, 838, 838, 838, 838, 838, 838, 838, 838,
1862		838, 838, 838, 838, 838, 839, 839, 839, 839, 839,
1863		839, 839, 839, 839, 839, 839, 839, 839, 839, 839,
1864		839, 839, 839, 839, 839, 839, 839, 840, 840, 840,
1865		840, 840, 840, 840, 840, 840, 840, 840, 840, 840,
1866		840, 840, 840, 840, 840, 840, 840, 840, 840, 841,
1867
1868		841, 841, 841, 841, 841, 841, 841, 841, 841, 841,
1869		841, 841, 841, 841, 841, 841, 841, 841, 841, 841,
1870		841, 842, 842, 842, 842, 842, 842, 842, 842, 842,
1871		842, 842, 842, 842, 842, 842, 842, 842, 842, 842,
1872		842, 842, 842, 843, 843, 843, 843, 843, 843, 843,
1873		843, 843, 843, 843, 843, 843, 843, 843, 843, 843,
1874		843, 843, 843, 843, 843, 844, 0, 0, 0, 0,
1875		0, 0, 0, 844, 0, 0, 0, 0, 0, 844,
1876		844, 845, 0, 0, 845, 0, 0, 845, 845, 0,
1877		845, 0, 0, 0, 845, 845, 845, 846, 0, 0,
1878
1879		0, 0, 0, 0, 0, 846, 0, 0, 0, 0,
1880		0, 846, 846, 847, 0, 0, 847, 0, 847, 847,
1881		848, 0, 0, 0, 0, 0, 0, 0, 848, 0,
1882		0, 0, 0, 0, 848, 848, 849, 849, 849, 849,
1883		0, 849, 849, 849, 849, 849, 849, 849, 849, 849,
1884		849, 849, 0, 849, 0, 849, 849, 849, 850, 850,
1885		850, 850, 0, 850, 850, 850, 850, 850, 850, 850,
1886		850, 850, 850, 850, 850, 850, 850, 850, 850, 850,
1887		851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
1888		851, 851, 851, 851, 851, 851, 851, 851, 0, 851,
1889
1890		851, 851, 852, 0, 0, 0, 0, 0, 0, 0,
1891		852, 0, 0, 0, 0, 0, 852, 852, 853, 853,
1892		0, 0, 853, 0, 0, 0, 0, 0, 0, 0,
1893		853, 0, 853, 0, 0, 0, 853, 853, 854, 854,
1894		854, 854, 854, 854, 854, 0, 854, 854, 854, 854,
1895		854, 854, 854, 854, 854, 854, 854, 854, 854, 854,
1896		855, 855, 855, 855, 855, 855, 855, 855, 855, 0,
1897		855, 855, 0, 855, 855, 855, 855, 855, 855, 855,
1898		855, 855, 856, 856, 856, 856, 0, 856, 856, 856,
1899		856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
1900
1901		856, 856, 856, 856, 857, 857, 857, 857, 857, 857,
1902		857, 0, 857, 857, 857, 857, 857, 857, 857, 857,
1903		857, 857, 857, 857, 857, 857, 858, 858, 858, 858,
1904		858, 858, 858, 0, 858, 858, 858, 858, 858, 858,
1905		858, 858, 858, 858, 858, 858, 858, 859, 859, 859,
1906		859, 859, 859, 859, 859, 859, 859, 859, 859, 859,
1907		859, 859, 859, 859, 859, 859, 859, 859, 859, 860,
1908		860, 860, 860, 860, 860, 860, 0, 860, 860, 860,
1909		860, 860, 860, 860, 860, 860, 860, 860, 860, 860,
1910		860, 861, 861, 861, 861, 861, 0, 861, 861, 861,
1911
1912		861, 861, 861, 861, 861, 861, 861, 861, 861, 861,
1913		861, 861, 861, 863, 863, 0, 0, 863, 0, 0,
1914		0, 0, 0, 0, 0, 863, 0, 863, 0, 0,
1915		0, 863, 863, 864, 0, 0, 864, 0, 0, 864,
1916		864, 0, 864, 0, 0, 0, 864, 864, 864, 865,
1917		865, 865, 865, 865, 865, 865, 865, 865, 865, 865,
1918		865, 865, 865, 865, 865, 865, 865, 865, 865, 865,
1919		865, 867, 0, 0, 0, 0, 0, 0, 0, 867,
1920		0, 0, 0, 0, 0, 867, 867, 868, 868, 0,
1921		868, 868, 868, 868, 868, 868, 868, 868, 868, 868,
1922
1923		868, 868, 868, 868, 868, 868, 868, 868, 868, 869,
1924		0, 0, 869, 0, 0, 869, 869, 0, 869, 0,
1925		0, 0, 869, 869, 869, 870, 0, 0, 0, 0,
1926		870, 870, 0, 870, 0, 0, 0, 0, 0, 870,
1927		870, 871, 0, 0, 871, 0, 0, 871, 871, 0,
1928		871, 0, 0, 0, 871, 871, 871, 872, 0, 0,
1929		872, 0, 0, 872, 872, 0, 872, 0, 0, 0,
1930		872, 872, 872, 876, 0, 0, 0, 0, 0, 0,
1931		0, 876, 0, 0, 0, 0, 0, 876, 876, 878,
1932		878, 0, 0, 878, 878, 0, 878, 878, 878, 878,
1933
1934		878, 878, 0, 0, 0, 0, 878, 878, 878, 879,
1935		879, 879, 879, 879, 879, 879, 879, 879, 879, 879,
1936		879, 879, 879, 879, 879, 879, 879, 879, 879, 879,
1937		879, 880, 880, 880, 880, 880, 880, 880, 880, 880,
1938		880, 880, 880, 880, 880, 880, 880, 880, 880, 880,
1939		880, 880, 880, 881, 881, 881, 881, 881, 881, 881,
1940		881, 881, 881, 881, 881, 881, 881, 881, 881, 881,
1941		881, 881, 881, 881, 881, 885, 885, 885, 885, 885,
1942		885, 885, 885, 885, 885, 885, 885, 885, 885, 885,
1943		885, 885, 885, 885, 885, 885, 885, 886, 886, 886,
1944
1945		886, 886, 886, 886, 886, 886, 886, 886, 886, 886,
1946		886, 886, 886, 886, 886, 886, 886, 886, 886, 887,
1947		887, 887, 887, 887, 887, 887, 887, 887, 887, 887,
1948		887, 887, 887, 887, 887, 887, 887, 887, 887, 887,
1949		887, 888, 888, 888, 888, 888, 888, 888, 888, 888,
1950		888, 888, 888, 888, 888, 888, 888, 888, 888, 888,
1951		888, 888, 888, 889, 889, 889, 889, 889, 889, 889,
1952		889, 889, 889, 889, 889, 889, 889, 889, 889, 889,
1953		889, 889, 889, 889, 889, 890, 0, 0, 0, 0,
1954		890, 890, 0, 890, 0, 0, 0, 0, 0, 890,
1955
1956		890, 891, 891, 891, 891, 891, 891, 891, 891, 891,
1957		891, 891, 891, 891, 891, 891, 891, 891, 891, 891,
1958		891, 891, 891, 892, 892, 892, 892, 892, 892, 892,
1959		892, 892, 892, 892, 892, 892, 892, 892, 892, 892,
1960		892, 892, 892, 892, 892, 893, 893, 893, 893, 893,
1961		893, 893, 893, 893, 893, 893, 893, 893, 893, 893,
1962		893, 893, 893, 893, 893, 893, 893, 896, 896, 896,
1963		896, 896, 896, 896, 896, 896, 896, 896, 896, 896,
1964		896, 896, 896, 896, 896, 896, 896, 896, 896, 897,
1965		897, 897, 897, 897, 897, 897, 897, 897, 897, 897,
1966
1967		897, 897, 897, 897, 897, 897, 897, 897, 897, 897,
1968		897, 898, 898, 898, 898, 898, 898, 898, 898, 898,
1969		898, 898, 898, 898, 898, 898, 898, 898, 898, 898,
1970		898, 898, 898, 899, 899, 899, 899, 899, 899, 899,
1971		899, 899, 899, 899, 899, 0, 899, 899, 899, 899,
1972		899, 899, 899, 899, 899, 900, 900, 900, 900, 900,
1973		900, 900, 900, 900, 900, 900, 900, 900, 900, 900,
1974		900, 900, 900, 900, 900, 900, 900, 903, 903, 0,
1975		0, 903, 903, 0, 903, 903, 903, 903, 903, 903,
1976		0, 0, 0, 0, 903, 903, 903, 907, 907, 907,
1977
1978		907, 907, 907, 907, 0, 907, 907, 907, 907, 907,
1979		907, 907, 907, 907, 907, 907, 907, 907, 907, 908,
1980		908, 908, 908, 908, 908, 908, 0, 908, 908, 908,
1981		908, 908, 908, 908, 908, 908, 908, 908, 908, 908,
1982		908, 909, 909, 909, 909, 909, 909, 909, 909, 909,
1983		909, 909, 909, 909, 909, 909, 909, 909, 909, 909,
1984		909, 909, 909, 910, 910, 910, 910, 910, 910, 910,
1985		910, 910, 910, 910, 910, 910, 910, 910, 910, 910,
1986		910, 910, 910, 910, 910, 911, 911, 911, 911, 911,
1987		911, 911, 911, 911, 911, 911, 911, 911, 911, 911,
1988
1989		911, 911, 911, 911, 911, 911, 911, 912, 912, 912,
1990		912, 912, 912, 912, 912, 912, 912, 912, 912, 912,
1991		912, 912, 912, 912, 912, 912, 912, 912, 912, 913,
1992		913, 913, 913, 913, 913, 913, 913, 913, 913, 913,
1993		913, 913, 913, 913, 913, 913, 913, 913, 913, 913,
1994		913, 914, 914, 914, 914, 914, 914, 914, 914, 914,
1995		914, 914, 914, 914, 914, 914, 914, 914, 914, 914,
1996		914, 914, 914, 915, 915, 915, 915, 915, 915, 915,
1997		915, 915, 915, 915, 915, 915, 915, 915, 915, 915,
1998		915, 915, 915, 915, 915, 916, 916, 916, 916, 916,
1999
2000		916, 916, 916, 916, 916, 916, 916, 916, 916, 916,
2001		916, 916, 916, 916, 916, 916, 916, 917, 917, 917,
2002		917, 917, 917, 917, 917, 917, 917, 917, 917, 917,
2003		917, 917, 917, 917, 917, 917, 917, 917, 917, 918,
2004		918, 918, 918, 918, 918, 918, 918, 918, 918, 918,
2005		918, 918, 918, 918, 918, 918, 918, 918, 918, 918,
2006		918, 919, 919, 919, 919, 919, 919, 919, 919, 919,
2007		919, 919, 919, 919, 919, 919, 919, 919, 919, 919,
2008		919, 919, 919, 920, 920, 920, 920, 920, 920, 920,
2009		920, 920, 920, 920, 920, 920, 920, 920, 920, 920,
2010
2011		920, 920, 920, 920, 920, 921, 921, 921, 921, 921,
2012		921, 921, 921, 921, 921, 921, 921, 921, 921, 921,
2013		921, 921, 921, 921, 921, 921, 921, 830, 830, 830,
2014		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
2015		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
2016		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
2017		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
2018		830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
2019		830, 830, 830, 830, 830, 830, 830
2020		} ;
2021
2022		/* Table of booleans, true if rule could match eol. */
2023		static const flex_int32_t yy_rule_can_match_eol[152] =
2024		{ 0,
2025		1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1,
2026		1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0,
2027		0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0,
2028		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1,
2029		0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
2030		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2031		0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
2032		1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, };
2033
2034		static yy_state_type yy_last_accepting_state;
2035		static char *yy_last_accepting_cpos;
2036
2037		extern int base_yy_flex_debug;
2038		int base_yy_flex_debug = 0;
2039
2040		/* The intent behind this definition is that it'll catch
2041		* any uses of REJECT which flex missed.
2042		*/
2043		#define REJECT reject_used_but_not_detected
2044		#define yymore() yymore_used_but_not_detected
2045	0	#define YY_MORE_ADJ 0
2046		#define YY_RESTORE_YY_MORE_OFFSET
2047		char *base_yytext;
2048		#line 1 "pgc.l"
2049
2050		#line 31 "pgc.l"
2051		extern YYSTYPE base_yylval;
2052
2053		static int xcdepth = 0; /* depth of nesting in slash-star comments */
2054		static char dolqstart = NULL; / current $foo$ quote start string */
2055		static YY_BUFFER_STATE scanbufhandle;
2056		static char *scanbuf;
2057
2058		/*
2059		* literalbuf is used to accumulate literal values when multiple rules
2060		* are needed to parse a single literal. Call startlit to reset buffer
2061		* to empty, addlit to add text. Note that the buffer is permanently
2062		* malloc'd to the largest size needed so far in the current run.
2063		*/
2064		static char literalbuf = NULL; / expandable buffer */
2065		static int literallen; /* actual current length */
2066		static int literalalloc; /* current allocated buffer size */
2067
2068		/* Used for detecting global state together with braces_open */
2069		static int parenths_open;
2070
2071		/* Used to tell parse_include() whether the command was #include or #include_next */
2072		static bool include_next;
2073
2074	0	#define startlit() (literalbuf[0] = '\0', literallen = 0)
2075		static void addlit(char *ytext, int yleng);
2076		static void addlitchar (unsigned char);
2077		static void parse_include (void);
2078		static bool ecpg_isspace(char ch);
2079		static bool isdefine(void);
2080		static bool isinformixdefine(void);
2081
2082		char *token_start;
2083		static int state_before;
2084
2085		struct _yy_buffer
2086		{
2087		YY_BUFFER_STATE buffer;
2088		long lineno;
2089		char *filename;
2090		struct _yy_buffer *next;
2091		} *yy_buffer = NULL;
2092
2093		static char *old;
2094
2095		#define MAX_NESTED_IF 128
2096		static short preproc_tos;
2097		static short ifcond;
2098		static struct _if_value
2099		{
2100		short condition;
2101		short else_branch;
2102		} stacked_if_value[MAX_NESTED_IF];
2103
2104		/* LCOV_EXCL_START */
2105
2106		#line 2106 "pgc.c"
2107		#define YY_NO_INPUT 1
2108
2109		/*
2110		* OK, here is a short description of lex/flex rules behavior.
2111		* The longest pattern which matches an input string is always chosen.
2112		* For equal-length patterns, the first occurring in the rules list is chosen.
2113		* INITIAL is the starting state, to which all non-conditional rules apply.
2114		* Exclusive states change parsing rules while the state is active. When in
2115		* an exclusive state, only those rules defined for that state apply.
2116		*
2117		* We use exclusive states for quoted strings, extended comments,
2118		* and to eliminate parsing troubles for numeric strings.
2119		* Exclusive states:
2120		* <xb> bit string literal
2121		* <xcc> extended C-style comments in C
2122		* <xcsql> extended C-style comments in SQL
2123		* <xd> delimited identifiers (double-quoted identifiers) - thomas 1997-10-27
2124		* <xh> hexadecimal numeric string - thomas 1997-11-16
2125		* <xq> standard quoted strings - thomas 1997-07-30
2126		* <xqc> standard quoted strings in C - michael
2127		* <xe> extended quoted strings (support backslash escape sequences)
2128		* <xn> national character quoted strings
2129		* <xdolq> $foo$ quoted strings
2130		* <xui> quoted identifier with Unicode escapes
2131		* <xus> quoted string with Unicode escapes
2132		*/
2133
2134		/* Bit string
2135		*/
2136		/* Hexadecimal number */
2137		/* National character */
2138		/* Quoted string that allows backslash escapes */
2139		/* C version of hex number */
2140		/* Extended quote
2141		* xqdouble implements embedded quote, ''''
2142		*/
2143		/* $foo$ style quotes ("dollar quoting")
2144		* The quoted string starts with $foo$ where "foo" is an optional string
2145		* in the form of an identifier, except that it may not contain "$",
2146		* and extends to the first occurrence of an identical string.
2147		* There is no processing of the quoted text.
2148		*
2149		* {dolqfailed} is an error rule to avoid scanner backup when {dolqdelim}
2150		* fails to match its trailing "$".
2151		*/
2152		/* Double quote
2153		* Allows embedded spaces and other special characters into identifiers.
2154		*/
2155		/* Unicode escapes */
2156		/* (The ecpg scanner is not backup-free, so the fail rules in scan.l are not needed here, but could be added if desired.) */
2157		/* Quoted identifier with Unicode escapes */
2158		/* Quoted string with Unicode escapes */
2159		/* special stuff for C strings */
2160		/* C-style comments
2161		*
2162		* The "extended comment" syntax closely resembles allowable operator syntax.
2163		* The tricky part here is to get lex to recognize a string starting with
2164		* slash-star as a comment, when interpreting it as an operator would produce
2165		* a longer match --- remember lex will prefer a longer match! Also, if we
2166		* have something like plus-slash-star, lex will think this is a 3-character
2167		* operator whereas we want to see it as a + operator and a comment start.
2168		* The solution is two-fold:
2169		* 1. append {op_chars}* to xcstart so that it matches as much text as
2170		* {operator} would. Then the tie-breaker (first matching rule of same
2171		* length) ensures xcstart wins. We put back the extra stuff with yyless()
2172		* in case it contains a star-slash that should terminate the comment.
2173		* 2. In the operator rule, check for slash-star within the operator, and
2174		* if found throw it back with yyless(). This handles the plus-slash-star
2175		* problem.
2176		* Dash-dash comments have similar interactions with the operator rule.
2177		*/
2178		/* Assorted special-case operators and operator-like tokens */
2179		/*
2180		* These operator-like tokens (unlike the above ones) also match the {operator}
2181		* rule, which means that they might be overridden by a longer match if they
2182		* are followed by a comment start or a + or - character. Accordingly, if you
2183		* add to this list, you must also add corresponding code to the {operator}
2184		* block to return the correct token in such cases. (This is not needed in
2185		* psqlscan.l since the token value is ignored there.)
2186		*/
2187		/*
2188		* "self" is the set of chars that should be returned as single-character
2189		* tokens. "op_chars" is the set of chars that can make up "Op" tokens,
2190		* which can be one or more characters long (but if a single-char token
2191		* appears in the "self" set, it is not to be returned as an Op). Note
2192		* that the sets overlap, but each has some chars that are not in the other.
2193		*
2194		* If you change either set, adjust the character lists appearing in the
2195		* rule for "operator"!
2196		*/
2197		/* we no longer allow unary minus in numbers.
2198		* instead we pass it separately to parser. there it gets
2199		* coerced via doNegate() -- Leon aug 20 1999
2200		*
2201		* {realfail1} and {realfail2} are added to prevent the need for scanner
2202		* backup when the {real} rule fails to match completely.
2203		*/
2204		/*
2205		* In order to make the world safe for Windows and Mac clients as well as
2206		* Unix ones, we accept either \n or \r as a newline. A DOS-style \r\n
2207		* sequence will be seen as two successive newlines, but that doesn't cause
2208		* any problems. SQL-style comments, which start with -- and extend to the
2209		* next newline, are treated as equivalent to a single whitespace character.
2210		*
2211		* NOTE a fine point: if there is no newline following --, we will absorb
2212		* everything to the end of the input as a comment. This is correct. Older
2213		* versions of Postgres failed to recognize -- as a comment if the input
2214		* did not end with a newline.
2215		*
2216		* XXX perhaps \f (formfeed) should be treated as a newline as well?
2217		*
2218		* XXX if you change the set of whitespace characters, fix ecpg_isspace()
2219		* to agree.
2220		*/
2221		/*
2222		* SQL requires at least one newline in the whitespace separating
2223		* string literals that are to be concatenated. Silly, but who are we
2224		* to argue? Note that {whitespace_with_newline} should not have * after
2225		* it, whereas {whitespace} should generally have a * after it...
2226		*/
2227		/* special characters for other dbms */
2228		/* we have to react differently in compat mode */
2229		/* some stuff needed for ecpg */
2230		/* we might want to parse all cpp include files */
2231		/* take care of cpp lines, they may also be continuated */
2232		/* first a general line for all commands not starting with "i" */
2233		/* and then the other commands starting with "i", we have to add these
2234		* separately because the cppline production would match on "include" too */
2235		/*
2236		* Dollar quoted strings are totally opaque, and no escaping is done on them.
2237		* Other quoted strings must allow some special characters such as single-quote
2238		* and newline.
2239		* Embedded single-quotes are implemented both in the SQL standard
2240		* style of two adjacent single quotes "''" and in the Postgres/Java style
2241		* of escaped-quote "\'".
2242		* Other embedded escaped characters are matched explicitly and the leading
2243		* backslash is dropped from the string. - thomas 1997-09-24
2244		* Note that xcstart must appear before operator, as explained above!
2245		* Also whitespace (comment) must appear before operator.
2246		*/
2247		#line 2247 "pgc.c"
2248
2249		#define INITIAL 0
2250	0	#define C 1
2251		#define SQL 2
2252		#define incl 3
2253		#define def 4
2254		#define def_ident 5
2255		#define undef 6
2256		#define xb 7
2257		#define xcc 8
2258		#define xcsql 9
2259		#define xd 10
2260		#define xdc 11
2261		#define xh 12
2262		#define xe 13
2263		#define xn 14
2264		#define xq 15
2265		#define xqc 16
2266		#define xdolq 17
2267		#define xcond 18
2268		#define xskip 19
2269		#define xui 20
2270		#define xus 21
2271
2272		#ifndef YY_NO_UNISTD_H
2273		/* Special case for "unistd.h", since it is non-ANSI. We include it way
2274		* down here because we want the user's section 1 to have been scanned first.
2275		* The user has a chance to override it with an option.
2276		*/
2277		#include <unistd.h>
2278		#endif
2279
2280		#ifndef YY_EXTRA_TYPE
2281		#define YY_EXTRA_TYPE void *
2282		#endif
2283
2284		static int yy_init_globals ( void );
2285
2286		/* Accessor methods to globals.
2287		These are made visible to non-reentrant scanners for convenience. */
2288
2289		int base_yylex_destroy ( void );
2290
2291		int base_yyget_debug ( void );
2292
2293		void base_yyset_debug ( int debug_flag );
2294
2295		YY_EXTRA_TYPE base_yyget_extra ( void );
2296
2297		void base_yyset_extra ( YY_EXTRA_TYPE user_defined );
2298
2299		FILE *base_yyget_in ( void );
2300
2301		void base_yyset_in ( FILE * _in_str );
2302
2303		FILE *base_yyget_out ( void );
2304
2305		void base_yyset_out ( FILE * _out_str );
2306
2307		int base_yyget_leng ( void );
2308
2309		char *base_yyget_text ( void );
2310
2311		int base_yyget_lineno ( void );
2312
2313		void base_yyset_lineno ( int _line_number );
2314
2315		/* Macros after this point can all be overridden by user definitions in
2316		* section 1.
2317		*/
2318
2319		#ifndef YY_SKIP_YYWRAP
2320		#ifdef __cplusplus
2321		extern "C" int base_yywrap ( void );
2322		#else
2323		extern int base_yywrap ( void );
2324		#endif
2325		#endif
2326
2327		#ifndef YY_NO_UNPUT
2328
2329		static void yyunput ( int c, char *buf_ptr );
2330
2331		#endif
2332
2333		#ifndef yytext_ptr
2334		static void yy_flex_strncpy ( char , const char , int );
2335		#endif
2336
2337		#ifdef YY_NEED_STRLEN
2338		static int yy_flex_strlen ( const char * );
2339		#endif
2340
2341		#ifndef YY_NO_INPUT
2342		#ifdef __cplusplus
2343		static int yyinput ( void );
2344		#else
2345		static int input ( void );
2346		#endif
2347
2348		#endif
2349
2350		/* Amount of stuff to slurp up with each read. */
2351		#ifndef YY_READ_BUF_SIZE
2352		#ifdef __ia64__
2353		/* On IA-64, the buffer size is 16k, not 8k */
2354		#define YY_READ_BUF_SIZE 16384
2355		#else
2356	0	#define YY_READ_BUF_SIZE 8192
2357		#endif /* __ia64__ */
2358		#endif
2359
2360		/* Copy whatever the last rule matched to the standard output. */
2361		#ifndef ECHO
2362		/* This used to be an fputs(), but since the string might contain NUL's,
2363		* we now use fwrite().
2364		*/
2365		#define ECHO do { if (fwrite( base_yytext, (size_t) base_yyleng, 1, base_yyout )) {} } while (0)
2366		#endif
2367
2368		/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
2369		* is returned in "result".
2370		*/
2371		#ifndef YY_INPUT
2372		#define YY_INPUT(buf,result,max_size) \
2373	0	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
2374	0	{ \
2375	0	int c = '*'; \
2376	0	int n; \
2377	0	for ( n = 0; n < max_size && \
2378	0	(c = getc( base_yyin )) != EOF && c != '\n'; ++n ) \
2379	0	buf[n] = (char) c; \
2380	0	if ( c == '\n' ) \
2381	0	buf[n++] = (char) c; \
2382	0	if ( c == EOF && ferror( base_yyin ) ) \
2383	0	YY_FATAL_ERROR( "input in flex scanner failed" ); \
2384	0	result = n; \
2385	0	} \
2386	0	else \
2387	0	{ \
2388	0	errno=0; \
2389	0	while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, base_yyin)) == 0 && ferror(base_yyin)) \
2390	0	{ \
2391	0	if( errno != EINTR) \
2392	0	{ \
2393	0	YY_FATAL_ERROR( "input in flex scanner failed" ); \
2394	0	break; \
2395	0	} \
2396	0	errno=0; \
2397	0	clearerr(base_yyin); \
2398	0	} \
2399	0	}\
2400		\
2401
2402		#endif
2403
2404		/* No semi-colon after return; correct usage is to write "yyterminate();" -
2405		* we don't want an extra ';' after the "return" because that will cause
2406		* some compilers to complain about unreachable statements.
2407		*/
2408		#ifndef yyterminate
2409		#define yyterminate() return YY_NULL
2410		#endif
2411
2412		/* Number of entries by which start-condition stack grows. */
2413		#ifndef YY_START_STACK_INCR
2414		#define YY_START_STACK_INCR 25
2415		#endif
2416
2417		/* Report a fatal error. */
2418		#ifndef YY_FATAL_ERROR
2419	0	#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
2420		#endif
2421
2422		/* end tables serialization structures and prototypes */
2423
2424		/* Default declaration of generated scanner - a define so the user can
2425		* easily add parameters.
2426		*/
2427		#ifndef YY_DECL
2428		#define YY_DECL_IS_OURS 1
2429
2430		extern int base_yylex (void);
2431
2432		#define YY_DECL int base_yylex (void)
2433		#endif /* !YY_DECL */
2434
2435		/* Code executed at the beginning of each rule, after base_yytext and base_yyleng
2436		* have been set up.
2437		*/
2438		#ifndef YY_USER_ACTION
2439		#define YY_USER_ACTION
2440		#endif
2441
2442		/* Code executed at the end of each rule. */
2443		#ifndef YY_BREAK
2444		#define YY_BREAK /LINTED/break;
2445		#endif
2446
2447		#define YY_RULE_SETUP \
2448		YY_USER_ACTION
2449
2450		/** The main scanner function which does all the work.
2451		*/
2452		YY_DECL
2453		{
2454		yy_state_type yy_current_state;
2455		char yy_cp, yy_bp;
2456		int yy_act;
2457
2458		if ( !(yy_init) )
2459		{
2460		(yy_init) = 1;
2461
2462		#ifdef YY_USER_INIT
2463		YY_USER_INIT;
2464		#endif
2465
2466		if ( ! (yy_start) )
2467		(yy_start) = 1; /* first start state */
2468
2469		if ( ! base_yyin )
2470		base_yyin = stdin;
2471
2472		if ( ! base_yyout )
2473		base_yyout = stdout;
2474
2475		if ( ! YY_CURRENT_BUFFER ) {
2476		base_yyensure_buffer_stack ();
2477		YY_CURRENT_BUFFER_LVALUE =
2478		base_yy_create_buffer(base_yyin,YY_BUF_SIZE );
2479		}
2480
2481		base_yy_load_buffer_state( );
2482		}
2483
2484		{
2485		#line 388 "pgc.l"
2486
2487
2488
2489		#line 392 "pgc.l"
2490		/* code to execute during start of each call of yylex() */
2491		token_start = NULL;
2492
2493
2494		#line 2494 "pgc.c"
2495
2496		while ( /CONSTCOND/1 ) /* loops until end-of-file is reached */
2497		{
2498		yy_cp = (yy_c_buf_p);
2499
2500		/* Support of base_yytext. */
2501		*yy_cp = (yy_hold_char);
2502
2503		/* yy_bp points to the position in yy_ch_buf of the start of
2504		* the current run.
2505		*/
2506		yy_bp = yy_cp;
2507
2508		yy_current_state = (yy_start);
2509		yy_match:
2510		do
2511		{
2512		YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
2513		if ( yy_accept[yy_current_state] )
2514		{
2515		(yy_last_accepting_state) = yy_current_state;
2516		(yy_last_accepting_cpos) = yy_cp;
2517		}
2518		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2519		{
2520		yy_current_state = (int) yy_def[yy_current_state];
2521		if ( yy_current_state >= 831 )
2522		yy_c = yy_meta[yy_c];
2523		}
2524		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
2525		++yy_cp;
2526		}
2527		while ( yy_current_state != 830 );
2528		yy_cp = (yy_last_accepting_cpos);
2529		yy_current_state = (yy_last_accepting_state);
2530
2531		yy_find_action:
2532		yy_act = yy_accept[yy_current_state];
2533
2534		YY_DO_BEFORE_ACTION;
2535
2536		if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
2537		{
2538		int yyl;
2539		for ( yyl = 0; yyl < base_yyleng; ++yyl )
2540		if ( base_yytext[yyl] == '\n' )
2541
2542		base_yylineno++;
2543		;
2544		}
2545
2546		do_action: /* This label is used only to access EOF actions. */
2547
2548		switch ( yy_act )
2549		{ /* beginning of action switch */
2550		case 0: /* must back up */
2551		/* undo the effects of YY_DO_BEFORE_ACTION */
2552		*yy_cp = (yy_hold_char);
2553		yy_cp = (yy_last_accepting_cpos);
2554		yy_current_state = (yy_last_accepting_state);
2555		goto yy_find_action;
2556
2557		case 1:
2558		/* rule 1 can match eol */
2559		YY_RULE_SETUP
2560		#line 396 "pgc.l"
2561		{ /* ignore */ }
2562		YY_BREAK
2563		case 2:
2564		YY_RULE_SETUP
2565		#line 398 "pgc.l"
2566		{
2567		token_start = yytext;
2568		state_before = YYSTATE;
2569		xcdepth = 0;
2570		BEGIN(xcc);
2571		/* Put back any characters past slash-star; see above */
2572		yyless(2);
2573		fputs("/*", yyout);
2574		}
2575		YY_BREAK
2576		case 3:
2577		YY_RULE_SETUP
2578		#line 407 "pgc.l"
2579		{
2580		token_start = yytext;
2581		state_before = YYSTATE;
2582		xcdepth = 0;
2583		BEGIN(xcsql);
2584		/* Put back any characters past slash-star; see above */
2585		yyless(2);
2586		fputs("/*", yyout);
2587		}
2588		YY_BREAK
2589		case 4:
2590		YY_RULE_SETUP
2591		#line 416 "pgc.l"
2592		{ ECHO; }
2593		YY_BREAK
2594		case 5:
2595		YY_RULE_SETUP
2596		#line 417 "pgc.l"
2597		{
2598		xcdepth++;
2599		/* Put back any characters past slash-star; see above */
2600		yyless(2);
2601		fputs("/_*", yyout);
2602		}
2603		YY_BREAK
2604		case 6:
2605		YY_RULE_SETUP
2606		#line 423 "pgc.l"
2607		{
2608		if (xcdepth <= 0)
2609		{
2610		ECHO;
2611		BEGIN(state_before);
2612		token_start = NULL;
2613		}
2614		else
2615		{
2616		xcdepth--;
2617		fputs("*_/", yyout);
2618		}
2619		}
2620		YY_BREAK
2621		case 7:
2622		YY_RULE_SETUP
2623		#line 436 "pgc.l"
2624		{
2625		ECHO;
2626		BEGIN(state_before);
2627		token_start = NULL;
2628		}
2629		YY_BREAK
2630		case 8:
2631		/* rule 8 can match eol */
2632		YY_RULE_SETUP
2633		#line 441 "pgc.l"
2634		{ ECHO; }
2635		YY_BREAK
2636		case 9:
2637		YY_RULE_SETUP
2638		#line 442 "pgc.l"
2639		{ ECHO; }
2640		YY_BREAK
2641		case 10:
2642		YY_RULE_SETUP
2643		#line 443 "pgc.l"
2644		{ ECHO; }
2645		YY_BREAK
2646		case YY_STATE_EOF(xcc):
2647		case YY_STATE_EOF(xcsql):
2648		#line 445 "pgc.l"
2649		{ mmfatal(PARSE_ERROR, "unterminated /* comment"); }
2650		YY_BREAK
2651		case 11:
2652		YY_RULE_SETUP
2653		#line 447 "pgc.l"
2654		{
2655		token_start = yytext;
2656		BEGIN(xb);
2657		startlit();
2658		addlitchar('b');
2659		}
2660		YY_BREAK
2661		case 12:
2662		/* rule 12 can match eol */
2663		#line 454 "pgc.l"
2664		case 13:
2665		/* rule 13 can match eol */
2666		YY_RULE_SETUP
2667		#line 454 "pgc.l"
2668		{
2669		yyless(1);
2670		BEGIN(SQL);
2671		if (literalbuf[strspn(literalbuf, "01") + 1] != '\0')
2672		mmerror(PARSE_ERROR, ET_ERROR, "invalid bit string literal");
2673		base_yylval.str = mm_strdup(literalbuf);
2674		return BCONST;
2675		}
2676		YY_BREAK
2677		case 14:
2678		/* rule 14 can match eol */
2679		#line 464 "pgc.l"
2680		case 15:
2681		/* rule 15 can match eol */
2682		YY_RULE_SETUP
2683		#line 464 "pgc.l"
2684		{ addlit(yytext, yyleng); }
2685		YY_BREAK
2686		case 16:
2687		/* rule 16 can match eol */
2688		#line 466 "pgc.l"
2689		case 17:
2690		/* rule 17 can match eol */
2691		YY_RULE_SETUP
2692		#line 466 "pgc.l"
2693		{ /* ignore */ }
2694		YY_BREAK
2695		case YY_STATE_EOF(xb):
2696		#line 467 "pgc.l"
2697		{ mmfatal(PARSE_ERROR, "unterminated bit string literal"); }
2698		YY_BREAK
2699		case 18:
2700		YY_RULE_SETUP
2701		#line 469 "pgc.l"
2702		{
2703		token_start = yytext;
2704		BEGIN(xh);
2705		startlit();
2706		addlitchar('x');
2707		}
2708		YY_BREAK
2709		case 19:
2710		/* rule 19 can match eol */
2711		#line 476 "pgc.l"
2712		case 20:
2713		/* rule 20 can match eol */
2714		YY_RULE_SETUP
2715		#line 476 "pgc.l"
2716		{
2717		yyless(1);
2718		BEGIN(SQL);
2719		base_yylval.str = mm_strdup(literalbuf);
2720		return XCONST;
2721		}
2722		YY_BREAK
2723		case YY_STATE_EOF(xh):
2724		#line 483 "pgc.l"
2725		{ mmfatal(PARSE_ERROR, "unterminated hexadecimal string literal"); }
2726		YY_BREAK
2727		case 21:
2728		YY_RULE_SETUP
2729		#line 484 "pgc.l"
2730		{
2731		/* National character.
2732		* Transfer it as-is to the backend.
2733		*/
2734		token_start = yytext;
2735		state_before = YYSTATE;
2736		BEGIN(xn);
2737		startlit();
2738		}
2739		YY_BREAK
2740		case 22:
2741		YY_RULE_SETUP
2742		#line 493 "pgc.l"
2743		{
2744		token_start = yytext;
2745		state_before = YYSTATE;
2746		BEGIN(xqc);
2747		startlit();
2748		}
2749		YY_BREAK
2750		case 23:
2751		YY_RULE_SETUP
2752		#line 499 "pgc.l"
2753		{
2754		token_start = yytext;
2755		state_before = YYSTATE;
2756		BEGIN(xq);
2757		startlit();
2758		}
2759		YY_BREAK
2760		case 24:
2761		YY_RULE_SETUP
2762		#line 505 "pgc.l"
2763		{
2764		token_start = yytext;
2765		state_before = YYSTATE;
2766		BEGIN(xe);
2767		startlit();
2768		}
2769		YY_BREAK
2770		case 25:
2771		YY_RULE_SETUP
2772		#line 511 "pgc.l"
2773		{
2774		token_start = yytext;
2775		state_before = YYSTATE;
2776		BEGIN(xus);
2777		startlit();
2778		addlit(yytext, yyleng);
2779		}
2780		YY_BREAK
2781		case 26:
2782		/* rule 26 can match eol */
2783		#line 519 "pgc.l"
2784		case 27:
2785		/* rule 27 can match eol */
2786		YY_RULE_SETUP
2787		#line 519 "pgc.l"
2788		{
2789		yyless(1);
2790		BEGIN(state_before);
2791		base_yylval.str = mm_strdup(literalbuf);
2792		return SCONST;
2793		}
2794		YY_BREAK
2795		case 28:
2796		/* rule 28 can match eol */
2797		#line 526 "pgc.l"
2798		case 29:
2799		/* rule 29 can match eol */
2800		YY_RULE_SETUP
2801		#line 526 "pgc.l"
2802		{
2803		yyless(1);
2804		BEGIN(state_before);
2805		base_yylval.str = mm_strdup(literalbuf);
2806		return ECONST;
2807		}
2808		YY_BREAK
2809		case 30:
2810		/* rule 30 can match eol */
2811		#line 533 "pgc.l"
2812		case 31:
2813		/* rule 31 can match eol */
2814		YY_RULE_SETUP
2815		#line 533 "pgc.l"
2816		{
2817		yyless(1);
2818		BEGIN(state_before);
2819		base_yylval.str = mm_strdup(literalbuf);
2820		return NCONST;
2821		}
2822		YY_BREAK
2823		case 32:
2824		/* rule 32 can match eol */
2825		YY_RULE_SETUP
2826		#line 539 "pgc.l"
2827		{
2828		addlit(yytext, yyleng);
2829		BEGIN(state_before);
2830		base_yylval.str = mm_strdup(literalbuf);
2831		return UCONST;
2832		}
2833		YY_BREAK
2834		case 33:
2835		YY_RULE_SETUP
2836		#line 545 "pgc.l"
2837		{ addlitchar('\''); }
2838		YY_BREAK
2839		case 34:
2840		YY_RULE_SETUP
2841		#line 546 "pgc.l"
2842		{
2843		addlitchar('\\');
2844		addlitchar('\'');
2845		}
2846		YY_BREAK
2847		case 35:
2848		/* rule 35 can match eol */
2849		YY_RULE_SETUP
2850		#line 550 "pgc.l"
2851		{ addlit(yytext, yyleng); }
2852		YY_BREAK
2853		case 36:
2854		/* rule 36 can match eol */
2855		YY_RULE_SETUP
2856		#line 551 "pgc.l"
2857		{ addlit(yytext, yyleng); }
2858		YY_BREAK
2859		case 37:
2860		YY_RULE_SETUP
2861		#line 552 "pgc.l"
2862		{ addlit(yytext, yyleng); }
2863		YY_BREAK
2864		case 38:
2865		/* rule 38 can match eol */
2866		YY_RULE_SETUP
2867		#line 553 "pgc.l"
2868		{ addlit(yytext, yyleng); }
2869		YY_BREAK
2870		case 39:
2871		YY_RULE_SETUP
2872		#line 554 "pgc.l"
2873		{ addlit(yytext, yyleng); }
2874		YY_BREAK
2875		case 40:
2876		YY_RULE_SETUP
2877		#line 555 "pgc.l"
2878		{ addlit(yytext, yyleng); }
2879		YY_BREAK
2880		case 41:
2881		/* rule 41 can match eol */
2882		YY_RULE_SETUP
2883		#line 556 "pgc.l"
2884		{ /* ignore */ }
2885		YY_BREAK
2886		case 42:
2887		YY_RULE_SETUP
2888		#line 557 "pgc.l"
2889		{
2890		/* This is only needed for \ just before EOF */
2891		addlitchar(yytext[0]);
2892		}
2893		YY_BREAK
2894		case YY_STATE_EOF(xq):
2895		case YY_STATE_EOF(xqc):
2896		case YY_STATE_EOF(xe):
2897		case YY_STATE_EOF(xn):
2898		case YY_STATE_EOF(xus):
2899		#line 561 "pgc.l"
2900		{ mmfatal(PARSE_ERROR, "unterminated quoted string"); }
2901		YY_BREAK
2902		case 43:
2903		YY_RULE_SETUP
2904		#line 562 "pgc.l"
2905		{
2906		/* throw back all but the initial "$" */
2907		yyless(1);
2908		/* and treat it as {other} */
2909		return yytext[0];
2910		}
2911		YY_BREAK
2912		case 44:
2913		YY_RULE_SETUP
2914		#line 568 "pgc.l"
2915		{
2916		token_start = yytext;
2917		if (dolqstart)
2918		free(dolqstart);
2919		dolqstart = mm_strdup(yytext);
2920		BEGIN(xdolq);
2921		startlit();
2922		addlit(yytext, yyleng);
2923		}
2924		YY_BREAK
2925		case 45:
2926		YY_RULE_SETUP
2927		#line 577 "pgc.l"
2928		{
2929		if (strcmp(yytext, dolqstart) == 0)
2930		{
2931		addlit(yytext, yyleng);
2932		free(dolqstart);
2933		dolqstart = NULL;
2934		BEGIN(SQL);
2935		base_yylval.str = mm_strdup(literalbuf);
2936		return DOLCONST;
2937		}
2938		else
2939		{
2940		/*
2941		* When we fail to match $...$ to dolqstart, transfer
2942		* the $... part to the output, but put back the final
2943		* $ for rescanning. Consider $delim$...$junk$delim$
2944		*/
2945		addlit(yytext, yyleng-1);
2946		yyless(yyleng-1);
2947		}
2948		}
2949		YY_BREAK
2950		case 46:
2951		/* rule 46 can match eol */
2952		YY_RULE_SETUP
2953		#line 598 "pgc.l"
2954		{ addlit(yytext, yyleng); }
2955		YY_BREAK
2956		case 47:
2957		YY_RULE_SETUP
2958		#line 599 "pgc.l"
2959		{ addlit(yytext, yyleng); }
2960		YY_BREAK
2961		case 48:
2962		YY_RULE_SETUP
2963		#line 600 "pgc.l"
2964		{
2965		/* single quote or dollar sign */
2966		addlitchar(yytext[0]);
2967		}
2968		YY_BREAK
2969		case YY_STATE_EOF(xdolq):
2970		#line 604 "pgc.l"
2971		{ base_yyerror("unterminated dollar-quoted string"); }
2972		YY_BREAK
2973		case 49:
2974		YY_RULE_SETUP
2975		#line 605 "pgc.l"
2976		{
2977		state_before = YYSTATE;
2978		BEGIN(xd);
2979		startlit();
2980		}
2981		YY_BREAK
2982		case 50:
2983		YY_RULE_SETUP
2984		#line 610 "pgc.l"
2985		{
2986		state_before = YYSTATE;
2987		BEGIN(xui);
2988		startlit();
2989		addlit(yytext, yyleng);
2990		}
2991		YY_BREAK
2992		case 51:
2993		YY_RULE_SETUP
2994		#line 616 "pgc.l"
2995		{
2996		BEGIN(state_before);
2997		if (literallen == 0)
2998		mmerror(PARSE_ERROR, ET_ERROR, "zero-length delimited identifier");
2999		/* The backend will truncate the identifier here. We do not as it does not change the result. */
3000		base_yylval.str = mm_strdup(literalbuf);
3001		return CSTRING;
3002		}
3003		YY_BREAK
3004		case 52:
3005		YY_RULE_SETUP
3006		#line 624 "pgc.l"
3007		{
3008		BEGIN(state_before);
3009		base_yylval.str = mm_strdup(literalbuf);
3010		return CSTRING;
3011		}
3012		YY_BREAK
3013		case 53:
3014		/* rule 53 can match eol */
3015		YY_RULE_SETUP
3016		#line 629 "pgc.l"
3017		{
3018		BEGIN(state_before);
3019		if (literallen == 2) /* "U&" */
3020		mmerror(PARSE_ERROR, ET_ERROR, "zero-length delimited identifier");
3021		/* The backend will truncate the identifier here. We do not as it does not change the result. */
3022		addlit(yytext, yyleng);
3023		base_yylval.str = mm_strdup(literalbuf);
3024		return UIDENT;
3025		}
3026		YY_BREAK
3027		case 54:
3028		YY_RULE_SETUP
3029		#line 638 "pgc.l"
3030		{ addlitchar('"'); }
3031		YY_BREAK
3032		case 55:
3033		/* rule 55 can match eol */
3034		YY_RULE_SETUP
3035		#line 639 "pgc.l"
3036		{ addlit(yytext, yyleng); }
3037		YY_BREAK
3038		case YY_STATE_EOF(xd):
3039		case YY_STATE_EOF(xdc):
3040		case YY_STATE_EOF(xui):
3041		#line 640 "pgc.l"
3042		{ mmfatal(PARSE_ERROR, "unterminated quoted identifier"); }
3043		YY_BREAK
3044		case 56:
3045		YY_RULE_SETUP
3046		#line 641 "pgc.l"
3047		{
3048		state_before = YYSTATE;
3049		BEGIN(xdc);
3050		startlit();
3051		}
3052		YY_BREAK
3053		case 57:
3054		/* rule 57 can match eol */
3055		YY_RULE_SETUP
3056		#line 646 "pgc.l"
3057		{ addlit(yytext, yyleng); }
3058		YY_BREAK
3059		case 58:
3060		YY_RULE_SETUP
3061		#line 647 "pgc.l"
3062		{ return TYPECAST; }
3063		YY_BREAK
3064		case 59:
3065		YY_RULE_SETUP
3066		#line 648 "pgc.l"
3067		{ return DOT_DOT; }
3068		YY_BREAK
3069		case 60:
3070		YY_RULE_SETUP
3071		#line 649 "pgc.l"
3072		{ return COLON_EQUALS; }
3073		YY_BREAK
3074		case 61:
3075		YY_RULE_SETUP
3076		#line 650 "pgc.l"
3077		{ return EQUALS_GREATER; }
3078		YY_BREAK
3079		case 62:
3080		YY_RULE_SETUP
3081		#line 651 "pgc.l"
3082		{ return LESS_EQUALS; }
3083		YY_BREAK
3084		case 63:
3085		YY_RULE_SETUP
3086		#line 652 "pgc.l"
3087		{ return GREATER_EQUALS; }
3088		YY_BREAK
3089		case 64:
3090		YY_RULE_SETUP
3091		#line 653 "pgc.l"
3092		{ return NOT_EQUALS; }
3093		YY_BREAK
3094		case 65:
3095		YY_RULE_SETUP
3096		#line 654 "pgc.l"
3097		{ return NOT_EQUALS; }
3098		YY_BREAK
3099		case 66:
3100		YY_RULE_SETUP
3101		#line 655 "pgc.l"
3102		{
3103		/* are we simulating Informix? */
3104		if (INFORMIX_MODE)
3105		{
3106		unput(':');
3107		}
3108		else
3109		return yytext[0];
3110		}
3111		YY_BREAK
3112		case 67:
3113		YY_RULE_SETUP
3114		#line 664 "pgc.l"
3115		{ /*
3116		* We may find a ';' inside a structure
3117		* definition in a TYPE or VAR statement.
3118		* This is not an EOL marker.
3119		*/
3120		if (yytext[0] == ';' && struct_level == 0)
3121		BEGIN(C);
3122		return yytext[0];
3123		}
3124		YY_BREAK
3125		case 68:
3126		YY_RULE_SETUP
3127		#line 673 "pgc.l"
3128		{
3129		/*
3130		* Check for embedded slash-star or dash-dash; those
3131		* are comment starts, so operator must stop there.
3132		* Note that slash-star or dash-dash at the first
3133		* character will match a prior rule, not this one.
3134		*/
3135		int nchars = yyleng;
3136		char slashstar = strstr(yytext, "/");
3137		char *dashdash = strstr(yytext, "--");
3138
3139		if (slashstar && dashdash)
3140		{
3141		/* if both appear, take the first one */
3142		if (slashstar > dashdash)
3143		slashstar = dashdash;
3144		}
3145		else if (!slashstar)
3146		slashstar = dashdash;
3147		if (slashstar)
3148		nchars = slashstar - yytext;
3149
3150		/*
3151		* For SQL compatibility, '+' and '-' cannot be the
3152		* last char of a multi-char operator unless the operator
3153		* contains chars that are not in SQL operators.
3154		* The idea is to lex '=-' as two operators, but not
3155		* to forbid operator names like '?-' that could not be
3156		* sequences of SQL operators.
3157		*/
3158		if (nchars > 1 &&
3159		(yytext[nchars - 1] == '+' \|\|
3160		yytext[nchars - 1] == '-'))
3161		{
3162		int ic;
3163
3164		for (ic = nchars - 2; ic >= 0; ic--)
3165		{
3166		char c = yytext[ic];
3167		if (c == '~' \|\| c == '!' \|\| c == '@' \|\|
3168		c == '#' \|\| c == '^' \|\| c == '&' \|\|
3169		c == '\|' \|\| c == '`' \|\| c == '?' \|\|
3170		c == '%')
3171		break;
3172		}
3173		if (ic < 0)
3174		{
3175		/*
3176		* didn't find a qualifying character, so remove
3177		* all trailing [+-]
3178		*/
3179		do {
3180		nchars--;
3181		} while (nchars > 1 &&
3182		(yytext[nchars - 1] == '+' \|\|
3183		yytext[nchars - 1] == '-'));
3184		}
3185		}
3186
3187		if (nchars < yyleng)
3188		{
3189		/* Strip the unwanted chars from the token */
3190		yyless(nchars);
3191		/*
3192		* If what we have left is only one char, and it's
3193		* one of the characters matching "self", then
3194		* return it as a character token the same way
3195		* that the "self" rule would have.
3196		*/
3197		if (nchars == 1 &&
3198		strchr(",()[].;:+-*/%^<>=", yytext[0]))
3199		return yytext[0];
3200		/*
3201		* Likewise, if what we have left is two chars, and
3202		* those match the tokens ">=", "<=", "=>", "<>" or
3203		* "!=", then we must return the appropriate token
3204		* rather than the generic Op.
3205		*/
3206		if (nchars == 2)
3207		{
3208		if (yytext[0] == '=' && yytext[1] == '>')
3209		return EQUALS_GREATER;
3210		if (yytext[0] == '>' && yytext[1] == '=')
3211		return GREATER_EQUALS;
3212		if (yytext[0] == '<' && yytext[1] == '=')
3213		return LESS_EQUALS;
3214		if (yytext[0] == '<' && yytext[1] == '>')
3215		return NOT_EQUALS;
3216		if (yytext[0] == '!' && yytext[1] == '=')
3217		return NOT_EQUALS;
3218		}
3219		}
3220
3221		base_yylval.str = mm_strdup(yytext);
3222		return Op;
3223		}
3224		YY_BREAK
3225		case 69:
3226		YY_RULE_SETUP
3227		#line 769 "pgc.l"
3228		{
3229		base_yylval.ival = atol(yytext+1);
3230		return PARAM;
3231		}
3232		YY_BREAK
3233		case 70:
3234		YY_RULE_SETUP
3235		#line 773 "pgc.l"
3236		{
3237		int val;
3238		char* endptr;
3239
3240		errno = 0;
3241		val = strtoint(yytext, &endptr, 10);
3242		if (*endptr != '\0' \|\| errno == ERANGE)
3243		{
3244		errno = 0;
3245		base_yylval.str = mm_strdup(yytext);
3246		return FCONST;
3247		}
3248		base_yylval.ival = val;
3249		return ICONST;
3250		}
3251		YY_BREAK
3252		case 71:
3253		YY_RULE_SETUP
3254		#line 788 "pgc.l"
3255		{
3256		base_yylval.str = mm_strdup(yytext);
3257		return IP;
3258		}
3259		YY_BREAK
3260		case 72:
3261		YY_RULE_SETUP
3262		#line 792 "pgc.l"
3263		{
3264		base_yylval.str = mm_strdup(yytext);
3265		return FCONST;
3266		}
3267		YY_BREAK
3268		case 73:
3269		YY_RULE_SETUP
3270		#line 796 "pgc.l"
3271		{
3272		base_yylval.str = mm_strdup(yytext);
3273		return FCONST;
3274		}
3275		YY_BREAK
3276		case 74:
3277		YY_RULE_SETUP
3278		#line 800 "pgc.l"
3279		{
3280		yyless(yyleng-1);
3281		base_yylval.str = mm_strdup(yytext);
3282		return FCONST;
3283		}
3284		YY_BREAK
3285		case 75:
3286		YY_RULE_SETUP
3287		#line 805 "pgc.l"
3288		{
3289		yyless(yyleng-2);
3290		base_yylval.str = mm_strdup(yytext);
3291		return FCONST;
3292		}
3293		YY_BREAK
3294		case 76:
3295		/* rule 76 can match eol */
3296		YY_RULE_SETUP
3297		#line 810 "pgc.l"
3298		{
3299		base_yylval.str = mm_strdup(yytext+1);
3300		return CVARIABLE;
3301		}
3302		YY_BREAK
3303		case 77:
3304		YY_RULE_SETUP
3305		#line 814 "pgc.l"
3306		{
3307		const ScanKeyword *keyword;
3308
3309		if (!isdefine())
3310		{
3311		/* Is it an SQL/ECPG keyword? */
3312		keyword = ScanECPGKeywordLookup(yytext);
3313		if (keyword != NULL)
3314		return keyword->value;
3315
3316		/* Is it a C keyword? */
3317		keyword = ScanCKeywordLookup(yytext);
3318		if (keyword != NULL)
3319		return keyword->value;
3320
3321		/*
3322		* None of the above. Return it as an identifier.
3323		*
3324		* The backend will attempt to truncate and case-fold
3325		* the identifier, but I see no good reason for ecpg
3326		* to do so; that's just another way that ecpg could get
3327		* out of step with the backend.
3328		*/
3329		base_yylval.str = mm_strdup(yytext);
3330		return IDENT;
3331		}
3332		}
3333		YY_BREAK
3334		case 78:
3335		YY_RULE_SETUP
3336		#line 841 "pgc.l"
3337		{ return yytext[0]; }
3338		YY_BREAK
3339		case 79:
3340		/* rule 79 can match eol */
3341		YY_RULE_SETUP
3342		#line 842 "pgc.l"
3343		{ BEGIN(SQL); return SQL_START; }
3344		YY_BREAK
3345		case 80:
3346		YY_RULE_SETUP
3347		#line 843 "pgc.l"
3348		{
3349		/* are we simulating Informix? */
3350		if (INFORMIX_MODE)
3351		{
3352		BEGIN(SQL);
3353		return SQL_START;
3354		}
3355		else
3356		return S_ANYTHING;
3357		}
3358		YY_BREAK
3359		case 81:
3360		/* rule 81 can match eol */
3361		YY_RULE_SETUP
3362		#line 853 "pgc.l"
3363		{ ECHO; }
3364		YY_BREAK
3365		case 82:
3366		YY_RULE_SETUP
3367		#line 854 "pgc.l"
3368		{
3369		char* endptr;
3370
3371		errno = 0;
3372		base_yylval.ival = strtoul((char *)yytext,&endptr,16);
3373		if (*endptr != '\0' \|\| errno == ERANGE)
3374		{
3375		errno = 0;
3376		base_yylval.str = mm_strdup(yytext);
3377		return SCONST;
3378		}
3379		return ICONST;
3380		}
3381		YY_BREAK
3382		case 83:
3383		/* rule 83 can match eol */
3384		YY_RULE_SETUP
3385		#line 867 "pgc.l"
3386		{
3387		if (system_includes)
3388		{
3389		include_next = false;
3390		BEGIN(incl);
3391		}
3392		else
3393		{
3394		base_yylval.str = mm_strdup(yytext);
3395		return CPP_LINE;
3396		}
3397		}
3398		YY_BREAK
3399		case 84:
3400		/* rule 84 can match eol */
3401		YY_RULE_SETUP
3402		#line 879 "pgc.l"
3403		{
3404		if (system_includes)
3405		{
3406		include_next = true;
3407		BEGIN(incl);
3408		}
3409		else
3410		{
3411		base_yylval.str = mm_strdup(yytext);
3412		return CPP_LINE;
3413		}
3414		}
3415		YY_BREAK
3416		case 85:
3417		/* rule 85 can match eol */
3418		YY_RULE_SETUP
3419		#line 891 "pgc.l"
3420		{
3421		base_yylval.str = mm_strdup(yytext);
3422		return CPP_LINE;
3423		}
3424		YY_BREAK
3425		case 86:
3426		YY_RULE_SETUP
3427		#line 895 "pgc.l"
3428		{
3429		const ScanKeyword *keyword;
3430
3431		/*
3432		* Try to detect a function name:
3433		* look for identifiers at the global scope
3434		* keep the last identifier before the first '(' and '{' */
3435		if (braces_open == 0 && parenths_open == 0)
3436		{
3437		if (current_function)
3438		free(current_function);
3439		current_function = mm_strdup(yytext);
3440		}
3441		/* Informix uses SQL defines only in SQL space */
3442		/* however, some defines have to be taken care of for compatibility */
3443		if ((!INFORMIX_MODE \|\| !isinformixdefine()) && !isdefine())
3444		{
3445		keyword = ScanCKeywordLookup(yytext);
3446		if (keyword != NULL)
3447		return keyword->value;
3448		else
3449		{
3450		base_yylval.str = mm_strdup(yytext);
3451		return IDENT;
3452		}
3453		}
3454		}
3455		YY_BREAK
3456		case 87:
3457		YY_RULE_SETUP
3458		#line 922 "pgc.l"
3459		{ mmerror(PARSE_ERROR, ET_ERROR, "nested /* ... */ comments"); }
3460		YY_BREAK
3461		case 88:
3462		YY_RULE_SETUP
3463		#line 923 "pgc.l"
3464		{ return ':'; }
3465		YY_BREAK
3466		case 89:
3467		YY_RULE_SETUP
3468		#line 924 "pgc.l"
3469		{ return ';'; }
3470		YY_BREAK
3471		case 90:
3472		YY_RULE_SETUP
3473		#line 925 "pgc.l"
3474		{ return ','; }
3475		YY_BREAK
3476		case 91:
3477		YY_RULE_SETUP
3478		#line 926 "pgc.l"
3479		{ return '*'; }
3480		YY_BREAK
3481		case 92:
3482		YY_RULE_SETUP
3483		#line 927 "pgc.l"
3484		{ return '%'; }
3485		YY_BREAK
3486		case 93:
3487		YY_RULE_SETUP
3488		#line 928 "pgc.l"
3489		{ return '/'; }
3490		YY_BREAK
3491		case 94:
3492		YY_RULE_SETUP
3493		#line 929 "pgc.l"
3494		{ return '+'; }
3495		YY_BREAK
3496		case 95:
3497		YY_RULE_SETUP
3498		#line 930 "pgc.l"
3499		{ return '-'; }
3500		YY_BREAK
3501		case 96:
3502		YY_RULE_SETUP
3503		#line 931 "pgc.l"
3504		{ parenths_open++; return '('; }
3505		YY_BREAK
3506		case 97:
3507		YY_RULE_SETUP
3508		#line 932 "pgc.l"
3509		{ parenths_open--; return ')'; }
3510		YY_BREAK
3511		case 98:
3512		/* rule 98 can match eol */
3513		YY_RULE_SETUP
3514		#line 933 "pgc.l"
3515		{ ECHO; }
3516		YY_BREAK
3517		case 99:
3518		YY_RULE_SETUP
3519		#line 934 "pgc.l"
3520		{ return '{'; }
3521		YY_BREAK
3522		case 100:
3523		YY_RULE_SETUP
3524		#line 935 "pgc.l"
3525		{ return '}'; }
3526		YY_BREAK
3527		case 101:
3528		YY_RULE_SETUP
3529		#line 936 "pgc.l"
3530		{ return '['; }
3531		YY_BREAK
3532		case 102:
3533		YY_RULE_SETUP
3534		#line 937 "pgc.l"
3535		{ return ']'; }
3536		YY_BREAK
3537		case 103:
3538		YY_RULE_SETUP
3539		#line 938 "pgc.l"
3540		{ return '='; }
3541		YY_BREAK
3542		case 104:
3543		YY_RULE_SETUP
3544		#line 939 "pgc.l"
3545		{ return S_MEMBER; }
3546		YY_BREAK
3547		case 105:
3548		YY_RULE_SETUP
3549		#line 940 "pgc.l"
3550		{ return S_RSHIFT; }
3551		YY_BREAK
3552		case 106:
3553		YY_RULE_SETUP
3554		#line 941 "pgc.l"
3555		{ return S_LSHIFT; }
3556		YY_BREAK
3557		case 107:
3558		YY_RULE_SETUP
3559		#line 942 "pgc.l"
3560		{ return S_OR; }
3561		YY_BREAK
3562		case 108:
3563		YY_RULE_SETUP
3564		#line 943 "pgc.l"
3565		{ return S_AND; }
3566		YY_BREAK
3567		case 109:
3568		YY_RULE_SETUP
3569		#line 944 "pgc.l"
3570		{ return S_INC; }
3571		YY_BREAK
3572		case 110:
3573		YY_RULE_SETUP
3574		#line 945 "pgc.l"
3575		{ return S_DEC; }
3576		YY_BREAK
3577		case 111:
3578		YY_RULE_SETUP
3579		#line 946 "pgc.l"
3580		{ return S_EQUAL; }
3581		YY_BREAK
3582		case 112:
3583		YY_RULE_SETUP
3584		#line 947 "pgc.l"
3585		{ return S_NEQUAL; }
3586		YY_BREAK
3587		case 113:
3588		YY_RULE_SETUP
3589		#line 948 "pgc.l"
3590		{ return S_ADD; }
3591		YY_BREAK
3592		case 114:
3593		YY_RULE_SETUP
3594		#line 949 "pgc.l"
3595		{ return S_SUB; }
3596		YY_BREAK
3597		case 115:
3598		YY_RULE_SETUP
3599		#line 950 "pgc.l"
3600		{ return S_MUL; }
3601		YY_BREAK
3602		case 116:
3603		YY_RULE_SETUP
3604		#line 951 "pgc.l"
3605		{ return S_DIV; }
3606		YY_BREAK
3607		case 117:
3608		YY_RULE_SETUP
3609		#line 952 "pgc.l"
3610		{ return S_MOD; }
3611		YY_BREAK
3612		case 118:
3613		YY_RULE_SETUP
3614		#line 953 "pgc.l"
3615		{ return S_MEMPOINT; }
3616		YY_BREAK
3617		case 119:
3618		YY_RULE_SETUP
3619		#line 954 "pgc.l"
3620		{ return S_DOTPOINT; }
3621		YY_BREAK
3622		case 120:
3623		YY_RULE_SETUP
3624		#line 955 "pgc.l"
3625		{ return S_ANYTHING; }
3626		YY_BREAK
3627		case 121:
3628		/* rule 121 can match eol */
3629		YY_RULE_SETUP
3630		#line 956 "pgc.l"
3631		{ BEGIN(def_ident); }
3632		YY_BREAK
3633		case 122:
3634		/* rule 122 can match eol */
3635		YY_RULE_SETUP
3636		#line 957 "pgc.l"
3637		{
3638		/* are we simulating Informix? */
3639		if (INFORMIX_MODE)
3640		{
3641		BEGIN(def_ident);
3642		}
3643		else
3644		{
3645		yyless(1);
3646		return S_ANYTHING;
3647		}
3648		}
3649		YY_BREAK
3650		case 123:
3651		/* rule 123 can match eol */
3652		YY_RULE_SETUP
3653		#line 969 "pgc.l"
3654		{ BEGIN(undef); }
3655		YY_BREAK
3656		case 124:
3657		/* rule 124 can match eol */
3658		YY_RULE_SETUP
3659		#line 970 "pgc.l"
3660		{
3661		/* are we simulating Informix? */
3662		if (INFORMIX_MODE)
3663		{
3664		BEGIN(undef);
3665		}
3666		else
3667		{
3668		yyless(1);
3669		return S_ANYTHING;
3670		}
3671		}
3672		YY_BREAK
3673		case 125:
3674		/* rule 125 can match eol */
3675		YY_RULE_SETUP
3676		#line 982 "pgc.l"
3677		{
3678		struct _defines ptr, ptr2 = NULL;
3679		int i;
3680
3681		/*
3682		* Skip the ";" and trailing whitespace. Note that yytext
3683		* contains at least one non-space character plus the ";"
3684		*/
3685		for (i = strlen(yytext)-2;
3686		i > 0 && ecpg_isspace(yytext[i]);
3687		i-- )
3688		;
3689		yytext[i+1] = '\0';
3690
3691
3692		for (ptr = defines; ptr != NULL; ptr2 = ptr, ptr = ptr->next)
3693		{
3694		if (strcmp(yytext, ptr->old) == 0)
3695		{
3696		if (ptr2 == NULL)
3697		defines = ptr->next;
3698		else
3699		ptr2->next = ptr->next;
3700		free(ptr->new);
3701		free(ptr->old);
3702		free(ptr);
3703		break;
3704		}
3705		}
3706
3707		BEGIN(C);
3708		}
3709		YY_BREAK
3710		case 126:
3711		/* rule 126 can match eol */
3712		YY_RULE_SETUP
3713		#line 1014 "pgc.l"
3714		{
3715		mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL UNDEF command");
3716		yyterminate();
3717		}
3718		YY_BREAK
3719		case 127:
3720		/* rule 127 can match eol */
3721		YY_RULE_SETUP
3722		#line 1018 "pgc.l"
3723		{ BEGIN(incl); }
3724		YY_BREAK
3725		case 128:
3726		/* rule 128 can match eol */
3727		YY_RULE_SETUP
3728		#line 1019 "pgc.l"
3729		{
3730		/* are we simulating Informix? */
3731		if (INFORMIX_MODE)
3732		{
3733		BEGIN(incl);
3734		}
3735		else
3736		{
3737		yyless(1);
3738		return S_ANYTHING;
3739		}
3740		}
3741		YY_BREAK
3742		case 129:
3743		/* rule 129 can match eol */
3744		YY_RULE_SETUP
3745		#line 1031 "pgc.l"
3746		{ ifcond = true; BEGIN(xcond); }
3747		YY_BREAK
3748		case 130:
3749		/* rule 130 can match eol */
3750		YY_RULE_SETUP
3751		#line 1032 "pgc.l"
3752		{
3753		/* are we simulating Informix? */
3754		if (INFORMIX_MODE)
3755		{
3756		ifcond = true;
3757		BEGIN(xcond);
3758		}
3759		else
3760		{
3761		yyless(1);
3762		return S_ANYTHING;
3763		}
3764		}
3765		YY_BREAK
3766		case 131:
3767		/* rule 131 can match eol */
3768		YY_RULE_SETUP
3769		#line 1045 "pgc.l"
3770		{ ifcond = false; BEGIN(xcond); }
3771		YY_BREAK
3772		case 132:
3773		/* rule 132 can match eol */
3774		YY_RULE_SETUP
3775		#line 1046 "pgc.l"
3776		{
3777		/* are we simulating Informix? */
3778		if (INFORMIX_MODE)
3779		{
3780		ifcond = false;
3781		BEGIN(xcond);
3782		}
3783		else
3784		{
3785		yyless(1);
3786		return S_ANYTHING;
3787		}
3788		}
3789		YY_BREAK
3790		case 133:
3791		/* rule 133 can match eol */
3792		YY_RULE_SETUP
3793		#line 1059 "pgc.l"
3794		{ /* pop stack */
3795		if ( preproc_tos == 0 ) {
3796		mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
3797		}
3798		else if ( stacked_if_value[preproc_tos].else_branch )
3799		mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
3800		else
3801		preproc_tos--;
3802
3803		ifcond = true; BEGIN(xcond);
3804		}
3805		YY_BREAK
3806		case 134:
3807		/* rule 134 can match eol */
3808		YY_RULE_SETUP
3809		#line 1070 "pgc.l"
3810		{
3811		/* are we simulating Informix? */
3812		if (INFORMIX_MODE)
3813		{
3814		if (preproc_tos == 0)
3815		mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
3816		else if (stacked_if_value[preproc_tos].else_branch)
3817		mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
3818		else
3819		preproc_tos--;
3820
3821		ifcond = true;
3822		BEGIN(xcond);
3823		}
3824		else
3825		{
3826		yyless(1);
3827		return S_ANYTHING;
3828		}
3829		}
3830		YY_BREAK
3831		case 135:
3832		/* rule 135 can match eol */
3833		YY_RULE_SETUP
3834		#line 1091 "pgc.l"
3835		{ /* only exec sql endif pops the stack, so take care of duplicated 'else' */
3836		if (stacked_if_value[preproc_tos].else_branch)
3837		mmfatal(PARSE_ERROR, "more than one EXEC SQL ELSE");
3838		else
3839		{
3840		stacked_if_value[preproc_tos].else_branch = true;
3841		stacked_if_value[preproc_tos].condition =
3842		(stacked_if_value[preproc_tos-1].condition &&
3843		!stacked_if_value[preproc_tos].condition);
3844
3845		if (stacked_if_value[preproc_tos].condition)
3846		BEGIN(C);
3847		else
3848		BEGIN(xskip);
3849		}
3850		}
3851		YY_BREAK
3852		case 136:
3853		/* rule 136 can match eol */
3854		YY_RULE_SETUP
3855		#line 1107 "pgc.l"
3856		{
3857		/* are we simulating Informix? */
3858		if (INFORMIX_MODE)
3859		{
3860		if (stacked_if_value[preproc_tos].else_branch)
3861		mmfatal(PARSE_ERROR, "more than one EXEC SQL ELSE");
3862		else
3863		{
3864		stacked_if_value[preproc_tos].else_branch = true;
3865		stacked_if_value[preproc_tos].condition =
3866		(stacked_if_value[preproc_tos-1].condition &&
3867		!stacked_if_value[preproc_tos].condition);
3868
3869		if (stacked_if_value[preproc_tos].condition)
3870		BEGIN(C);
3871		else
3872		BEGIN(xskip);
3873		}
3874		}
3875		else
3876		{
3877		yyless(1);
3878		return S_ANYTHING;
3879		}
3880		}
3881		YY_BREAK
3882		case 137:
3883		/* rule 137 can match eol */
3884		YY_RULE_SETUP
3885		#line 1132 "pgc.l"
3886		{
3887		if (preproc_tos == 0)
3888		mmfatal(PARSE_ERROR, "unmatched EXEC SQL ENDIF");
3889		else
3890		preproc_tos--;
3891
3892		if (stacked_if_value[preproc_tos].condition)
3893		BEGIN(C);
3894		else
3895		BEGIN(xskip);
3896		}
3897		YY_BREAK
3898		case 138:
3899		/* rule 138 can match eol */
3900		YY_RULE_SETUP
3901		#line 1143 "pgc.l"
3902		{
3903		/* are we simulating Informix? */
3904		if (INFORMIX_MODE)
3905		{
3906		if (preproc_tos == 0)
3907		mmfatal(PARSE_ERROR, "unmatched EXEC SQL ENDIF");
3908		else
3909		preproc_tos--;
3910
3911		if (stacked_if_value[preproc_tos].condition)
3912		BEGIN(C);
3913		else
3914		BEGIN(xskip);
3915		}
3916		else
3917		{
3918		yyless(1);
3919		return S_ANYTHING;
3920		}
3921		}
3922		YY_BREAK
3923		case 139:
3924		YY_RULE_SETUP
3925		#line 1164 "pgc.l"
3926		{ /* ignore */ }
3927		YY_BREAK
3928		case 140:
3929		/* rule 140 can match eol */
3930		YY_RULE_SETUP
3931		#line 1166 "pgc.l"
3932		{
3933		if (preproc_tos >= MAX_NESTED_IF-1)
3934		mmfatal(PARSE_ERROR, "too many nested EXEC SQL IFDEF conditions");
3935		else
3936		{
3937		struct _defines *defptr;
3938		unsigned int i;
3939
3940		/*
3941		* Skip the ";" and trailing whitespace. Note that yytext
3942		* contains at least one non-space character plus the ";"
3943		*/
3944		for (i = strlen(yytext)-2;
3945		i > 0 && ecpg_isspace(yytext[i]);
3946		i-- )
3947		;
3948		yytext[i+1] = '\0';
3949
3950		for (defptr = defines;
3951		defptr != NULL && strcmp(yytext, defptr->old) != 0;
3952		defptr = defptr->next);
3953
3954		preproc_tos++;
3955		stacked_if_value[preproc_tos].else_branch = false;
3956		stacked_if_value[preproc_tos].condition =
3957		(defptr ? ifcond : !ifcond) && stacked_if_value[preproc_tos-1].condition;
3958		}
3959
3960		if (stacked_if_value[preproc_tos].condition)
3961		BEGIN(C);
3962		else
3963		BEGIN(xskip);
3964		}
3965		YY_BREAK
3966		case 141:
3967		/* rule 141 can match eol */
3968		YY_RULE_SETUP
3969		#line 1200 "pgc.l"
3970		{
3971		mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL IFDEF command");
3972		yyterminate();
3973		}
3974		YY_BREAK
3975		case 142:
3976		YY_RULE_SETUP
3977		#line 1204 "pgc.l"
3978		{
3979		old = mm_strdup(yytext);
3980		BEGIN(def);
3981		startlit();
3982		}
3983		YY_BREAK
3984		case 143:
3985		/* rule 143 can match eol */
3986		YY_RULE_SETUP
3987		#line 1209 "pgc.l"
3988		{
3989		mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL DEFINE command");
3990		yyterminate();
3991		}
3992		YY_BREAK
3993		case 144:
3994		/* rule 144 can match eol */
3995		YY_RULE_SETUP
3996		#line 1213 "pgc.l"
3997		{
3998		struct _defines ptr, this;
3999
4000		for (ptr = defines; ptr != NULL; ptr = ptr->next)
4001		{
4002		if (strcmp(old, ptr->old) == 0)
4003		{
4004		free(ptr->new);
4005		ptr->new = mm_strdup(literalbuf);
4006		}
4007		}
4008		if (ptr == NULL)
4009		{
4010		this = (struct _defines *) mm_alloc(sizeof(struct _defines));
4011
4012		/* initial definition */
4013		this->old = old;
4014		this->new = mm_strdup(literalbuf);
4015		this->next = defines;
4016		this->used = NULL;
4017		defines = this;
4018		}
4019
4020		BEGIN(C);
4021		}
4022		YY_BREAK
4023		case 145:
4024		/* rule 145 can match eol */
4025		YY_RULE_SETUP
4026		#line 1238 "pgc.l"
4027		{ addlit(yytext, yyleng); }
4028		YY_BREAK
4029		case 146:
4030		/* rule 146 can match eol */
4031		YY_RULE_SETUP
4032		#line 1239 "pgc.l"
4033		{ parse_include(); }
4034		YY_BREAK
4035		case 147:
4036		/* rule 147 can match eol */
4037		YY_RULE_SETUP
4038		#line 1240 "pgc.l"
4039		{ parse_include(); }
4040		YY_BREAK
4041		case 148:
4042		/* rule 148 can match eol */
4043		YY_RULE_SETUP
4044		#line 1241 "pgc.l"
4045		{ parse_include(); }
4046		YY_BREAK
4047		case 149:
4048		/* rule 149 can match eol */
4049		YY_RULE_SETUP
4050		#line 1242 "pgc.l"
4051		{
4052		mmfatal(PARSE_ERROR, "syntax error in EXEC SQL INCLUDE command");
4053		yyterminate();
4054		}
4055		YY_BREAK
4056		case YY_STATE_EOF(INITIAL):
4057		case YY_STATE_EOF(C):
4058		case YY_STATE_EOF(SQL):
4059		case YY_STATE_EOF(incl):
4060		case YY_STATE_EOF(def):
4061		case YY_STATE_EOF(def_ident):
4062		case YY_STATE_EOF(undef):
4063		case YY_STATE_EOF(xcond):
4064		case YY_STATE_EOF(xskip):
4065		#line 1247 "pgc.l"
4066		{
4067		if (yy_buffer == NULL)
4068		{
4069		if ( preproc_tos > 0 )
4070		{
4071		preproc_tos = 0;
4072		mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
4073		}
4074		yyterminate();
4075		}
4076		else
4077		{
4078		struct _yy_buffer *yb = yy_buffer;
4079		int i;
4080		struct _defines *ptr;
4081
4082		for (ptr = defines; ptr; ptr = ptr->next)
4083		if (ptr->used == yy_buffer)
4084		{
4085		ptr->used = NULL;
4086		break;
4087		}
4088
4089		if (yyin != NULL)
4090		fclose(yyin);
4091
4092		yy_delete_buffer( YY_CURRENT_BUFFER );
4093		yy_switch_to_buffer(yy_buffer->buffer);
4094
4095		yylineno = yy_buffer->lineno;
4096
4097		/* We have to output the filename only if we change files here */
4098		i = strcmp(input_filename, yy_buffer->filename);
4099
4100		free(input_filename);
4101		input_filename = yy_buffer->filename;
4102
4103		yy_buffer = yy_buffer->next;
4104		free(yb);
4105
4106		if (i != 0)
4107		output_line_number();
4108
4109		}
4110		}
4111		YY_BREAK
4112		case 150:
4113		/* rule 150 can match eol */
4114		YY_RULE_SETUP
4115		#line 1292 "pgc.l"
4116		{ mmfatal(PARSE_ERROR, "internal error: unreachable state; please report this to <pgsql-bugs@postgresql.org>"); }
4117		YY_BREAK
4118		case 151:
4119		YY_RULE_SETUP
4120		#line 1294 "pgc.l"
4121		YY_FATAL_ERROR( "flex scanner jammed" );
4122		YY_BREAK
4123		#line 4123 "pgc.c"
4124
4125		case YY_END_OF_BUFFER:
4126		{
4127		/* Amount of text matched not including the EOB char. */
4128		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
4129
4130		/* Undo the effects of YY_DO_BEFORE_ACTION. */
4131		*yy_cp = (yy_hold_char);
4132		YY_RESTORE_YY_MORE_OFFSET
4133
4134		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
4135		{
4136		/* We're scanning a new file or input source. It's
4137		* possible that this happened because the user
4138		* just pointed base_yyin at a new source and called
4139		* base_yylex(). If so, then we have to assure
4140		* consistency between YY_CURRENT_BUFFER and our
4141		* globals. Here is the right place to do so, because
4142		* this is the first action (other than possibly a
4143		* back-up) that will match for the new input source.
4144		*/
4145		(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
4146		YY_CURRENT_BUFFER_LVALUE->yy_input_file = base_yyin;
4147		YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
4148		}
4149
4150		/* Note that here we test for yy_c_buf_p "<=" to the position
4151		* of the first EOB in the buffer, since yy_c_buf_p will
4152		* already have been incremented past the NUL character
4153		* (since all states make transitions on EOB to the
4154		* end-of-buffer state). Contrast this with the test
4155		* in input().
4156		*/
4157		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
4158		{ /* This was really a NUL. */
4159		yy_state_type yy_next_state;
4160
4161		(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
4162
4163		yy_current_state = yy_get_previous_state( );
4164
4165		/* Okay, we're now positioned to make the NUL
4166		* transition. We couldn't have
4167		* yy_get_previous_state() go ahead and do it
4168		* for us because it doesn't know how to deal
4169		* with the possibility of jamming (and we don't
4170		* want to build jamming into it because then it
4171		* will run more slowly).
4172		*/
4173
4174		yy_next_state = yy_try_NUL_trans( yy_current_state );
4175
4176		yy_bp = (yytext_ptr) + YY_MORE_ADJ;
4177
4178		if ( yy_next_state )
4179		{
4180		/* Consume the NUL. */
4181		yy_cp = ++(yy_c_buf_p);
4182		yy_current_state = yy_next_state;
4183		goto yy_match;
4184		}
4185
4186		else
4187		{
4188		yy_cp = (yy_last_accepting_cpos);
4189		yy_current_state = (yy_last_accepting_state);
4190		goto yy_find_action;
4191		}
4192		}
4193
4194		else switch ( yy_get_next_buffer( ) )
4195		{
4196		case EOB_ACT_END_OF_FILE:
4197		{
4198		(yy_did_buffer_switch_on_eof) = 0;
4199
4200		if ( base_yywrap( ) )
4201		{
4202		/* Note: because we've taken care in
4203		* yy_get_next_buffer() to have set up
4204		* base_yytext, we can now set up
4205		* yy_c_buf_p so that if some total
4206		* hoser (like flex itself) wants to
4207		* call the scanner after we return the
4208		* YY_NULL, it'll still work - another
4209		* YY_NULL will get returned.
4210		*/
4211		(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
4212
4213		yy_act = YY_STATE_EOF(YY_START);
4214		goto do_action;
4215		}
4216
4217		else
4218		{
4219		if ( ! (yy_did_buffer_switch_on_eof) )
4220		YY_NEW_FILE;
4221		}
4222		break;
4223		}
4224
4225		case EOB_ACT_CONTINUE_SCAN:
4226		(yy_c_buf_p) =
4227		(yytext_ptr) + yy_amount_of_matched_text;
4228
4229		yy_current_state = yy_get_previous_state( );
4230
4231		yy_cp = (yy_c_buf_p);
4232		yy_bp = (yytext_ptr) + YY_MORE_ADJ;
4233		goto yy_match;
4234
4235		case EOB_ACT_LAST_MATCH:
4236		(yy_c_buf_p) =
4237		&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
4238
4239		yy_current_state = yy_get_previous_state( );
4240
4241		yy_cp = (yy_c_buf_p);
4242		yy_bp = (yytext_ptr) + YY_MORE_ADJ;
4243		goto yy_find_action;
4244		}
4245		break;
4246		}
4247
4248		default:
4249		YY_FATAL_ERROR(
4250		"fatal flex scanner internal error--no action found" );
4251		} /* end of action switch */
4252		} /* end of scanning one token */
4253		} /* end of user's declarations */
4254		} /* end of base_yylex */
4255
4256		/* yy_get_next_buffer - try to read in a new buffer
4257		*
4258		* Returns a code representing an action:
4259		* EOB_ACT_LAST_MATCH -
4260		* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
4261		* EOB_ACT_END_OF_FILE - end of file
4262		*/
4263		static int yy_get_next_buffer (void)
4264	0	{
4265	0	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
4266	0	char *source = (yytext_ptr);
4267	0	int number_to_move, i;
4268	0	int ret_val;
4269
4270	0	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
4271	0	YY_FATAL_ERROR(
4272	0	"fatal flex scanner internal error--end of buffer missed" );
4273
4274	0	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
4275	0	{ /* Don't try to fill the buffer, so this is an EOF. */
4276	0	if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
4277	0	{
4278		/* We matched a single character, the EOB, so
4279		* treat this as a final EOF.
4280		*/
4281	0	return EOB_ACT_END_OF_FILE;
4282	0	}
4283
4284	0	else
4285	0	{
4286		/* We matched some text prior to the EOB, first
4287		* process it.
4288		*/
4289	0	return EOB_ACT_LAST_MATCH;
4290	0	}
4291	0	}
4292
4293		/* Try to read more data. */
4294
4295		/* First move last chars to start of buffer. */
4296	0	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
4297
4298	0	for ( i = 0; i < number_to_move; ++i )
4299	0	(dest++) = (source++);
4300
4301	0	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
4302		/* don't do the read, it's not guaranteed to return an EOF,
4303		* just force an EOF
4304		*/
4305	0	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
4306
4307	0	else
4308	0	{
4309	0	int num_to_read =
4310	0	YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
4311
4312	0	while ( num_to_read <= 0 )
4313	0	{ /* Not enough room in the buffer - grow it. */
4314
4315		/* just a shorter name for the current buffer */
4316	0	YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
4317
4318	0	int yy_c_buf_p_offset =
4319	0	(int) ((yy_c_buf_p) - b->yy_ch_buf);
4320
4321	0	if ( b->yy_is_our_buffer )
4322	0	{
4323	0	int new_size = b->yy_buf_size * 2;
4324
4325	0	if ( new_size <= 0 )
4326	0	b->yy_buf_size += b->yy_buf_size / 8;
4327	0	else
4328	0	b->yy_buf_size *= 2;
4329
4330	0	b->yy_ch_buf = (char *)
4331		/* Include room in for 2 EOB chars. */
4332	0	base_yyrealloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2) );
4333	0	}
4334	0	else
4335		/* Can't grow it, we don't own it. */
4336	0	b->yy_ch_buf = NULL;
4337
4338	0	if ( ! b->yy_ch_buf )
4339	0	YY_FATAL_ERROR(
4340	0	"fatal error - scanner input buffer overflow" );
4341
4342	0	(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
4343
4344	0	num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
4345	0	number_to_move - 1;
4346
4347	0	}
4348
4349	0	if ( num_to_read > YY_READ_BUF_SIZE )
4350	0	num_to_read = YY_READ_BUF_SIZE;
4351
4352		/* Read in more data. */
4353	0	YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
4354	0	(yy_n_chars), num_to_read );
4355
4356	0	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4357	0	}
4358
4359	0	if ( (yy_n_chars) == 0 )
4360	0	{
4361	0	if ( number_to_move == YY_MORE_ADJ )
4362	0	{
4363	0	ret_val = EOB_ACT_END_OF_FILE;
4364	0	base_yyrestart(base_yyin );
4365	0	}
4366
4367	0	else
4368	0	{
4369	0	ret_val = EOB_ACT_LAST_MATCH;
4370	0	YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
4371	0	YY_BUFFER_EOF_PENDING;
4372	0	}
4373	0	}
4374
4375	0	else
4376	0	ret_val = EOB_ACT_CONTINUE_SCAN;
4377
4378	0	if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
4379		/* Extend the array by 50%, plus the number we really need. */
4380	0	int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
4381	0	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char ) base_yyrealloc((void ) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size );
4382	0	if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
4383	0	YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
4384	0	}
4385
4386	0	(yy_n_chars) += number_to_move;
4387	0	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
4388	0	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
4389
4390	0	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
4391
4392	0	return ret_val;
4393	0	}
4394
4395		/* yy_get_previous_state - get the state just before the EOB char was reached */
4396
4397		static yy_state_type yy_get_previous_state (void)
4398	0	{
4399	0	yy_state_type yy_current_state;
4400	0	char *yy_cp;
4401
4402	0	yy_current_state = (yy_start);
4403
4404	0	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
4405	0	{
4406	0	YY_CHAR yy_c = (yy_cp ? yy_ec[YY_SC_TO_UI(yy_cp)] : 1);
4407	0	if ( yy_accept[yy_current_state] )
4408	0	{
4409	0	(yy_last_accepting_state) = yy_current_state;
4410	0	(yy_last_accepting_cpos) = yy_cp;
4411	0	}
4412	0	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
4413	0	{
4414	0	yy_current_state = (int) yy_def[yy_current_state];
4415	0	if ( yy_current_state >= 831 )
4416	0	yy_c = yy_meta[yy_c];
4417	0	}
4418	0	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
4419	0	}
4420
4421	0	return yy_current_state;
4422	0	}
4423
4424		/* yy_try_NUL_trans - try to make a transition on the NUL character
4425		*
4426		* synopsis
4427		* next_state = yy_try_NUL_trans( current_state );
4428		*/
4429		static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
4430	0	{
4431	0	int yy_is_jam;
4432	0	char *yy_cp = (yy_c_buf_p);
4433
4434	0	YY_CHAR yy_c = 1;
4435	0	if ( yy_accept[yy_current_state] )
4436	0	{
4437	0	(yy_last_accepting_state) = yy_current_state;
4438	0	(yy_last_accepting_cpos) = yy_cp;
4439	0	}
4440	0	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
4441	0	{
4442	0	yy_current_state = (int) yy_def[yy_current_state];
4443	0	if ( yy_current_state >= 831 )
4444	0	yy_c = yy_meta[yy_c];
4445	0	}
4446	0	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
4447	0	yy_is_jam = (yy_current_state == 830);
4448
4449	0	return yy_is_jam ? 0 : yy_current_state;
4450	0	}
4451
4452		#ifndef YY_NO_UNPUT
4453
4454		static void yyunput (int c, char * yy_bp )
4455	0	{
4456	0	char *yy_cp;
4457
4458	0	yy_cp = (yy_c_buf_p);
4459
4460		/* undo effects of setting up base_yytext */
4461	0	*yy_cp = (yy_hold_char);
4462
4463	0	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
4464	0	{ /* need to shift things up to make room */
4465		/* +2 for EOB chars. */
4466	0	int number_to_move = (yy_n_chars) + 2;
4467	0	char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
4468	0	YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
4469	0	char *source =
4470	0	&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
4471
4472	0	while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
4473	0	--dest = --source;
4474
4475	0	yy_cp += (int) (dest - source);
4476	0	yy_bp += (int) (dest - source);
4477	0	YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
4478	0	(yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
4479
4480	0	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
4481	0	YY_FATAL_ERROR( "flex scanner push-back overflow" );
4482	0	}
4483
4484	0	*--yy_cp = (char) c;
4485
4486	0	if ( c == '\n' ){
4487	0	--base_yylineno;
4488	0	}
4489
4490	0	(yytext_ptr) = yy_bp;
4491	0	(yy_hold_char) = *yy_cp;
4492	0	(yy_c_buf_p) = yy_cp;
4493	0	}
4494
4495		#endif
4496
4497		#ifndef YY_NO_INPUT
4498		#ifdef __cplusplus
4499		static int yyinput (void)
4500		#else
4501		static int input (void)
4502		#endif
4503
4504		{
4505		int c;
4506
4507		*(yy_c_buf_p) = (yy_hold_char);
4508
4509		if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
4510		{
4511		/* yy_c_buf_p now points to the character we want to return.
4512		* If this occurs before the EOB characters, then it's a
4513		* valid NUL; if not, then we've hit the end of the buffer.
4514		*/
4515		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
4516		/* This was really a NUL. */
4517		*(yy_c_buf_p) = '\0';
4518
4519		else
4520		{ /* need more input */
4521		int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
4522		++(yy_c_buf_p);
4523
4524		switch ( yy_get_next_buffer( ) )
4525		{
4526		case EOB_ACT_LAST_MATCH:
4527		/* This happens because yy_g_n_b()
4528		* sees that we've accumulated a
4529		* token and flags that we need to
4530		* try matching the token before
4531		* proceeding. But for input(),
4532		* there's no matching to consider.
4533		* So convert the EOB_ACT_LAST_MATCH
4534		* to EOB_ACT_END_OF_FILE.
4535		*/
4536
4537		/* Reset buffer status. */
4538		base_yyrestart(base_yyin );
4539
4540		/FALLTHROUGH/
4541
4542		case EOB_ACT_END_OF_FILE:
4543		{
4544		if ( base_yywrap( ) )
4545		return 0;
4546
4547		if ( ! (yy_did_buffer_switch_on_eof) )
4548		YY_NEW_FILE;
4549		#ifdef __cplusplus
4550		return yyinput();
4551		#else
4552		return input();
4553		#endif
4554		}
4555
4556		case EOB_ACT_CONTINUE_SCAN:
4557		(yy_c_buf_p) = (yytext_ptr) + offset;
4558		break;
4559		}
4560		}
4561		}
4562
4563		c = (unsigned char ) (yy_c_buf_p); /* cast for 8-bit char's */
4564		(yy_c_buf_p) = '\0'; / preserve base_yytext */
4565		(yy_hold_char) = *++(yy_c_buf_p);
4566
4567		if ( c == '\n' )
4568
4569		base_yylineno++;
4570		;
4571
4572		return c;
4573		}
4574		#endif /* ifndef YY_NO_INPUT */
4575
4576		/** Immediately switch to a different input stream.
4577		* @param input_file A readable stream.
4578		*
4579		* @note This function does not reset the start condition to @c INITIAL .
4580		*/
4581		void base_yyrestart (FILE * input_file )
4582	0	{
4583
4584	0	if ( ! YY_CURRENT_BUFFER ){
4585	0	base_yyensure_buffer_stack ();
4586	0	YY_CURRENT_BUFFER_LVALUE =
4587	0	base_yy_create_buffer(base_yyin,YY_BUF_SIZE );
4588	0	}
4589
4590	0	base_yy_init_buffer(YY_CURRENT_BUFFER,input_file );
4591	0	base_yy_load_buffer_state( );
4592	0	}
4593
4594		/** Switch to a different input buffer.
4595		* @param new_buffer The new input buffer.
4596		*
4597		*/
4598		void base_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
4599	0	{
4600
4601		/* TODO. We should be able to replace this entire function body
4602		* with
4603		* base_yypop_buffer_state();
4604		* base_yypush_buffer_state(new_buffer);
4605		*/
4606	0	base_yyensure_buffer_stack ();
4607	0	if ( YY_CURRENT_BUFFER == new_buffer )
4608	0	return;
4609
4610	0	if ( YY_CURRENT_BUFFER )
4611	0	{
4612		/* Flush out information for old buffer. */
4613	0	*(yy_c_buf_p) = (yy_hold_char);
4614	0	YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
4615	0	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4616	0	}
4617
4618	0	YY_CURRENT_BUFFER_LVALUE = new_buffer;
4619	0	base_yy_load_buffer_state( );
4620
4621		/* We don't actually know whether we did this switch during
4622		* EOF (base_yywrap()) processing, but the only time this flag
4623		* is looked at is after base_yywrap() is called, so it's safe
4624		* to go ahead and always set it.
4625		*/
4626	0	(yy_did_buffer_switch_on_eof) = 1;
4627	0	}
4628
4629		static void base_yy_load_buffer_state (void)
4630	0	{
4631	0	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
4632	0	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
4633	0	base_yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
4634	0	(yy_hold_char) = *(yy_c_buf_p);
4635	0	}
4636
4637		/** Allocate and initialize an input buffer state.
4638		* @param file A readable stream.
4639		* @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
4640		*
4641		* @return the allocated buffer state.
4642		*/
4643		YY_BUFFER_STATE base_yy_create_buffer (FILE * file, int size )
4644	0	{
4645	0	YY_BUFFER_STATE b;
4646
4647	0	b = (YY_BUFFER_STATE) base_yyalloc(sizeof( struct yy_buffer_state ) );
4648	0	if ( ! b )
4649	0	YY_FATAL_ERROR( "out of dynamic memory in base_yy_create_buffer()" );
4650
4651	0	b->yy_buf_size = size;
4652
4653		/* yy_ch_buf has to be 2 characters longer than the size given because
4654		* we need to put in 2 end-of-buffer characters.
4655		*/
4656	0	b->yy_ch_buf = (char *) base_yyalloc((yy_size_t) (b->yy_buf_size + 2) );
4657	0	if ( ! b->yy_ch_buf )
4658	0	YY_FATAL_ERROR( "out of dynamic memory in base_yy_create_buffer()" );
4659
4660	0	b->yy_is_our_buffer = 1;
4661
4662	0	base_yy_init_buffer(b,file );
4663
4664	0	return b;
4665	0	}
4666
4667		/** Destroy the buffer.
4668		* @param b a buffer created with base_yy_create_buffer()
4669		*
4670		*/
4671		void base_yy_delete_buffer (YY_BUFFER_STATE b )
4672	0	{
4673
4674	0	if ( ! b )
4675	0	return;
4676
4677	0	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
4678	0	YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
4679
4680	0	if ( b->yy_is_our_buffer )
4681	0	base_yyfree((void *) b->yy_ch_buf );
4682
4683	0	base_yyfree((void *) b );
4684	0	}
4685
4686		/* Initializes or reinitializes a buffer.
4687		* This function is sometimes called more than once on the same buffer,
4688		* such as during a base_yyrestart() or at EOF.
4689		*/
4690		static void base_yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
4691
4692	0	{
4693	0	int oerrno = errno;
4694
4695	0	base_yy_flush_buffer(b );
4696
4697	0	b->yy_input_file = file;
4698	0	b->yy_fill_buffer = 1;
4699
4700		/* If b is the current buffer, then base_yy_init_buffer was _probably_
4701		* called from base_yyrestart() or through yy_get_next_buffer.
4702		* In that case, we don't want to reset the lineno or column.
4703		*/
4704	0	if (b != YY_CURRENT_BUFFER){
4705	0	b->yy_bs_lineno = 1;
4706	0	b->yy_bs_column = 0;
4707	0	}
4708
4709	0	b->yy_is_interactive = 0;
4710
4711	0	errno = oerrno;
4712	0	}
4713
4714		/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
4715		* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
4716		*
4717		*/
4718		void base_yy_flush_buffer (YY_BUFFER_STATE b )
4719	0	{
4720	0	if ( ! b )
4721	0	return;
4722
4723	0	b->yy_n_chars = 0;
4724
4725		/* We always need two end-of-buffer characters. The first causes
4726		* a transition to the end-of-buffer state. The second causes
4727		* a jam in that state.
4728		*/
4729	0	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
4730	0	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
4731
4732	0	b->yy_buf_pos = &b->yy_ch_buf[0];
4733
4734	0	b->yy_at_bol = 1;
4735	0	b->yy_buffer_status = YY_BUFFER_NEW;
4736
4737	0	if ( b == YY_CURRENT_BUFFER )
4738	0	base_yy_load_buffer_state( );
4739	0	}
4740
4741		/** Pushes the new state onto the stack. The new state becomes
4742		* the current state. This function will allocate the stack
4743		* if necessary.
4744		* @param new_buffer The new state.
4745		*
4746		*/
4747		void base_yypush_buffer_state (YY_BUFFER_STATE new_buffer )
4748	0	{
4749	0	if (new_buffer == NULL)
4750	0	return;
4751
4752	0	base_yyensure_buffer_stack();
4753
4754		/* This block is copied from base_yy_switch_to_buffer. */
4755	0	if ( YY_CURRENT_BUFFER )
4756	0	{
4757		/* Flush out information for old buffer. */
4758	0	*(yy_c_buf_p) = (yy_hold_char);
4759	0	YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
4760	0	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4761	0	}
4762
4763		/* Only push if top exists. Otherwise, replace top. */
4764	0	if (YY_CURRENT_BUFFER)
4765	0	(yy_buffer_stack_top)++;
4766	0	YY_CURRENT_BUFFER_LVALUE = new_buffer;
4767
4768		/* copied from base_yy_switch_to_buffer. */
4769	0	base_yy_load_buffer_state( );
4770	0	(yy_did_buffer_switch_on_eof) = 1;
4771	0	}
4772
4773		/** Removes and deletes the top of the stack, if present.
4774		* The next element becomes the new top.
4775		*
4776		*/
4777		void base_yypop_buffer_state (void)
4778	0	{
4779	0	if (!YY_CURRENT_BUFFER)
4780	0	return;
4781
4782	0	base_yy_delete_buffer(YY_CURRENT_BUFFER );
4783	0	YY_CURRENT_BUFFER_LVALUE = NULL;
4784	0	if ((yy_buffer_stack_top) > 0)
4785	0	--(yy_buffer_stack_top);
4786
4787	0	if (YY_CURRENT_BUFFER) {
4788	0	base_yy_load_buffer_state( );
4789	0	(yy_did_buffer_switch_on_eof) = 1;
4790	0	}
4791	0	}
4792
4793		/* Allocates the stack if it does not exist.
4794		* Guarantees space for at least one push.
4795		*/
4796		static void base_yyensure_buffer_stack (void)
4797	0	{
4798	0	yy_size_t num_to_alloc;
4799
4800	0	if (!(yy_buffer_stack)) {
4801
4802		/* First allocation is just for 2 elements, since we don't know if this
4803		* scanner will even need a stack. We use 2 instead of 1 to avoid an
4804		* immediate realloc on the next call.
4805		*/
4806	0	num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
4807	0	(yy_buffer_stack) = (struct yy_buffer_state**)base_yyalloc
4808	0	(num_to_alloc * sizeof(struct yy_buffer_state*)
4809	0	);
4810	0	if ( ! (yy_buffer_stack) )
4811	0	YY_FATAL_ERROR( "out of dynamic memory in base_yyensure_buffer_stack()" );
4812
4813	0	memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
4814
4815	0	(yy_buffer_stack_max) = num_to_alloc;
4816	0	(yy_buffer_stack_top) = 0;
4817	0	return;
4818	0	}
4819
4820	0	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
4821
4822		/* Increase the buffer to prepare for a possible push. */
4823	0	yy_size_t grow_size = 8 /* arbitrary grow size */;
4824
4825	0	num_to_alloc = (yy_buffer_stack_max) + grow_size;
4826	0	(yy_buffer_stack) = (struct yy_buffer_state**)base_yyrealloc
4827	0	((yy_buffer_stack),
4828	0	num_to_alloc * sizeof(struct yy_buffer_state*)
4829	0	);
4830	0	if ( ! (yy_buffer_stack) )
4831	0	YY_FATAL_ERROR( "out of dynamic memory in base_yyensure_buffer_stack()" );
4832
4833		/* zero only the new slots.*/
4834	0	memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
4835	0	(yy_buffer_stack_max) = num_to_alloc;
4836	0	}
4837	0	}
4838
4839		/** Setup the input buffer state to scan directly from a user-specified character buffer.
4840		* @param base the character buffer
4841		* @param size the size in bytes of the character buffer
4842		*
4843		* @return the newly allocated buffer state object.
4844		*/
4845		YY_BUFFER_STATE base_yy_scan_buffer (char * base, yy_size_t size )
4846	0	{
4847	0	YY_BUFFER_STATE b;
4848
4849	0	if ( size < 2 \|\|
4850	0	base[size-2] != YY_END_OF_BUFFER_CHAR \|\|
4851	0	base[size-1] != YY_END_OF_BUFFER_CHAR )
4852		/* They forgot to leave room for the EOB's. */
4853	0	return NULL;
4854
4855	0	b = (YY_BUFFER_STATE) base_yyalloc(sizeof( struct yy_buffer_state ) );
4856	0	if ( ! b )
4857	0	YY_FATAL_ERROR( "out of dynamic memory in base_yy_scan_buffer()" );
4858
4859	0	b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
4860	0	b->yy_buf_pos = b->yy_ch_buf = base;
4861	0	b->yy_is_our_buffer = 0;
4862	0	b->yy_input_file = NULL;
4863	0	b->yy_n_chars = b->yy_buf_size;
4864	0	b->yy_is_interactive = 0;
4865	0	b->yy_at_bol = 1;
4866	0	b->yy_fill_buffer = 0;
4867	0	b->yy_buffer_status = YY_BUFFER_NEW;
4868
4869	0	base_yy_switch_to_buffer(b );
4870
4871	0	return b;
4872	0	}
4873
4874		/** Setup the input buffer state to scan a string. The next call to base_yylex() will
4875		* scan from a @e copy of @a str.
4876		* @param yystr a NUL-terminated string to scan
4877		*
4878		* @return the newly allocated buffer state object.
4879		* @note If you want to scan bytes that may contain NUL values, then use
4880		* base_yy_scan_bytes() instead.
4881		*/
4882		YY_BUFFER_STATE base_yy_scan_string (const char * yystr )
4883	0	{
4884
4885	0	return base_yy_scan_bytes(yystr,(int) strlen(yystr) );
4886	0	}
4887
4888		/** Setup the input buffer state to scan the given bytes. The next call to base_yylex() will
4889		* scan from a @e copy of @a bytes.
4890		* @param yybytes the byte buffer to scan
4891		* @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
4892		*
4893		* @return the newly allocated buffer state object.
4894		*/
4895		YY_BUFFER_STATE base_yy_scan_bytes (const char * yybytes, int _yybytes_len )
4896	0	{
4897	0	YY_BUFFER_STATE b;
4898	0	char *buf;
4899	0	yy_size_t n;
4900	0	int i;
4901
4902		/* Get memory for full buffer, including space for trailing EOB's. */
4903	0	n = (yy_size_t) (_yybytes_len + 2);
4904	0	buf = (char *) base_yyalloc(n );
4905	0	if ( ! buf )
4906	0	YY_FATAL_ERROR( "out of dynamic memory in base_yy_scan_bytes()" );
4907
4908	0	for ( i = 0; i < _yybytes_len; ++i )
4909	0	buf[i] = yybytes[i];
4910
4911	0	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
4912
4913	0	b = base_yy_scan_buffer(buf,n );
4914	0	if ( ! b )
4915	0	YY_FATAL_ERROR( "bad buffer in base_yy_scan_bytes()" );
4916
4917		/* It's okay to grow etc. this buffer, and we should throw it
4918		* away when we're done.
4919		*/
4920	0	b->yy_is_our_buffer = 1;
4921
4922	0	return b;
4923	0	}
4924
4925		#ifndef YY_EXIT_FAILURE
4926	0	#define YY_EXIT_FAILURE 2
4927		#endif
4928
4929		static void yynoreturn yy_fatal_error (const char* msg )
4930	0	{
4931	0	(void) fprintf( stderr, "%s\n", msg );
4932	0	exit( YY_EXIT_FAILURE );
4933	0	}
4934
4935		/* Redefine yyless() so it works in section 3 code. */
4936
4937		#undef yyless
4938		#define yyless(n) \
4939		do \
4940		{ \
4941		/* Undo effects of setting up base_yytext. */ \
4942		int yyless_macro_arg = (n); \
4943		YY_LESS_LINENO(yyless_macro_arg);\
4944		base_yytext[base_yyleng] = (yy_hold_char); \
4945		(yy_c_buf_p) = base_yytext + yyless_macro_arg; \
4946		(yy_hold_char) = *(yy_c_buf_p); \
4947		*(yy_c_buf_p) = '\0'; \
4948		base_yyleng = yyless_macro_arg; \
4949		} \
4950		while ( 0 )
4951
4952		/* Accessor methods (get/set functions) to struct members. */
4953
4954		/** Get the current line number.
4955		*
4956		*/
4957		int base_yyget_lineno (void)
4958	0	{
4959
4960	0	return base_yylineno;
4961	0	}
4962
4963		/** Get the input stream.
4964		*
4965		*/
4966		FILE *base_yyget_in (void)
4967	0	{
4968	0	return base_yyin;
4969	0	}
4970
4971		/** Get the output stream.
4972		*
4973		*/
4974		FILE *base_yyget_out (void)
4975	0	{
4976	0	return base_yyout;
4977	0	}
4978
4979		/** Get the length of the current token.
4980		*
4981		*/
4982		int base_yyget_leng (void)
4983	0	{
4984	0	return base_yyleng;
4985	0	}
4986
4987		/** Get the current token.
4988		*
4989		*/
4990
4991		char *base_yyget_text (void)
4992	0	{
4993	0	return base_yytext;
4994	0	}
4995
4996		/** Set the current line number.
4997		* @param _line_number line number
4998		*
4999		*/
5000		void base_yyset_lineno (int _line_number )
5001	0	{
5002
5003	0	base_yylineno = _line_number;
5004	0	}
5005
5006		/** Set the input stream. This does not discard the current
5007		* input buffer.
5008		* @param _in_str A readable stream.
5009		*
5010		* @see base_yy_switch_to_buffer
5011		*/
5012		void base_yyset_in (FILE * _in_str )
5013	0	{
5014	0	base_yyin = _in_str ;
5015	0	}
5016
5017		void base_yyset_out (FILE * _out_str )
5018	0	{
5019	0	base_yyout = _out_str ;
5020	0	}
5021
5022		int base_yyget_debug (void)
5023	0	{
5024	0	return base_yy_flex_debug;
5025	0	}
5026
5027		void base_yyset_debug (int _bdebug )
5028	0	{
5029	0	base_yy_flex_debug = _bdebug ;
5030	0	}
5031
5032		static int yy_init_globals (void)
5033	0	{
5034		/* Initialization is the same as for the non-reentrant scanner.
5035		* This function is called from base_yylex_destroy(), so don't allocate here.
5036		*/
5037
5038		/* We do not touch base_yylineno unless the option is enabled. */
5039	0	base_yylineno = 1;
5040
5041	0	(yy_buffer_stack) = NULL;
5042	0	(yy_buffer_stack_top) = 0;
5043	0	(yy_buffer_stack_max) = 0;
5044	0	(yy_c_buf_p) = NULL;
5045	0	(yy_init) = 0;
5046	0	(yy_start) = 0;
5047
5048		/* Defined in main.c */
5049		#ifdef YY_STDINIT
5050		base_yyin = stdin;
5051		base_yyout = stdout;
5052		#else
5053	0	base_yyin = NULL;
5054	0	base_yyout = NULL;
5055	0	#endif
5056
5057		/* For future reference: Set errno on error, since we are called by
5058		* base_yylex_init()
5059		*/
5060	0	return 0;
5061	0	}
5062
5063		/* base_yylex_destroy is for both reentrant and non-reentrant scanners. */
5064		int base_yylex_destroy (void)
5065	0	{
5066
5067		/* Pop the buffer stack, destroying each element. */
5068	0	while(YY_CURRENT_BUFFER){
5069	0	base_yy_delete_buffer(YY_CURRENT_BUFFER );
5070	0	YY_CURRENT_BUFFER_LVALUE = NULL;
5071	0	base_yypop_buffer_state();
5072	0	}
5073
5074		/* Destroy the stack itself. */
5075	0	base_yyfree((yy_buffer_stack) );
5076	0	(yy_buffer_stack) = NULL;
5077
5078		/* Reset the globals. This is important in a non-reentrant scanner so the next time
5079		* base_yylex() is called, initialization will occur. */
5080	0	yy_init_globals( );
5081
5082	0	return 0;
5083	0	}
5084
5085		/*
5086		* Internal utility routines.
5087		*/
5088
5089		#ifndef yytext_ptr
5090		static void yy_flex_strncpy (char* s1, const char * s2, int n )
5091		{
5092
5093		int i;
5094		for ( i = 0; i < n; ++i )
5095		s1[i] = s2[i];
5096		}
5097		#endif
5098
5099		#ifdef YY_NEED_STRLEN
5100		static int yy_flex_strlen (const char * s )
5101		{
5102		int n;
5103		for ( n = 0; s[n]; ++n )
5104		;
5105
5106		return n;
5107		}
5108		#endif
5109
5110		void *base_yyalloc (yy_size_t size )
5111	0	{
5112	0	return malloc(size);
5113	0	}
5114
5115		void base_yyrealloc (void ptr, yy_size_t size )
5116	0	{
5117
5118		/* The cast to (char *) in the following accommodates both
5119		* implementations that use char* generic pointers, and those
5120		* that use void* generic pointers. It works with the latter
5121		* because both ANSI C and C++ allow castless assignment from
5122		* any pointer type to void*, and deal with argument conversions
5123		* as though doing an assignment.
5124		*/
5125	0	return realloc(ptr, size);
5126	0	}
5127
5128		void base_yyfree (void * ptr )
5129	0	{
5130	0	free( (char ) ptr ); / see base_yyrealloc() for (char ) cast /
5131	0	}
5132
5133		#define YYTABLES_NAME "yytables"
5134
5135		#line 1294 "pgc.l"
5136
5137
5138		/* LCOV_EXCL_STOP */
5139
5140		void
5141		lex_init(void)
5142	0	{
5143	0	braces_open = 0;
5144	0	parenths_open = 0;
5145	0	current_function = NULL;
5146
5147	0	preproc_tos = 0;
5148	0	yylineno = 1;
5149	0	ifcond = true;
5150	0	stacked_if_value[preproc_tos].condition = ifcond;
5151	0	stacked_if_value[preproc_tos].else_branch = false;
5152
5153		/* initialize literal buffer to a reasonable but expansible size */
5154	0	if (literalbuf == NULL)
5155	0	{
5156	0	literalalloc = 1024;
5157	0	literalbuf = (char *) malloc(literalalloc);
5158	0	}
5159	0	startlit();
5160
5161	0	BEGIN(C);
5162	0	}
5163
5164		static void
5165		addlit(char *ytext, int yleng)
5166	0	{
5167		/* enlarge buffer if needed */
5168	0	if ((literallen+yleng) >= literalalloc)
5169	0	{
5170	0	do
5171	0	literalalloc *= 2;
5172	0	while ((literallen+yleng) >= literalalloc);
5173	0	literalbuf = (char *) realloc(literalbuf, literalalloc);
5174	0	}
5175		/* append new data, add trailing null */
5176	0	memcpy(literalbuf+literallen, ytext, yleng);
5177	0	literallen += yleng;
5178	0	literalbuf[literallen] = '\0';
5179	0	}
5180
5181		static void
5182		addlitchar(unsigned char ychar)
5183	0	{
5184		/* enlarge buffer if needed */
5185	0	if ((literallen+1) >= literalalloc)
5186	0	{
5187	0	literalalloc *= 2;
5188	0	literalbuf = (char *) realloc(literalbuf, literalalloc);
5189	0	}
5190		/* append new data, add trailing null */
5191	0	literalbuf[literallen] = ychar;
5192	0	literallen += 1;
5193	0	literalbuf[literallen] = '\0';
5194	0	}
5195
5196		static void
5197		parse_include(void)
5198	0	{
5199		/* got the include file name */
5200	0	struct _yy_buffer *yb;
5201	0	struct _include_path *ip;
5202	0	char inc_file[MAXPGPATH];
5203	0	unsigned int i;
5204
5205	0	yb = mm_alloc(sizeof(struct _yy_buffer));
5206
5207	0	yb->buffer = YY_CURRENT_BUFFER;
5208	0	yb->lineno = yylineno;
5209	0	yb->filename = input_filename;
5210	0	yb->next = yy_buffer;
5211
5212	0	yy_buffer = yb;
5213
5214		/*
5215		* skip the ";" if there is one and trailing whitespace. Note that
5216		* yytext contains at least one non-space character plus the ";"
5217		*/
5218	0	for (i = strlen(yytext)-2;
5219	0	i > 0 && ecpg_isspace(yytext[i]);
5220	0	i--)
5221	0	;
5222
5223	0	if (yytext[i] == ';')
5224	0	i--;
5225
5226	0	yytext[i+1] = '\0';
5227
5228	0	yyin = NULL;
5229
5230		/* If file name is enclosed in '"' remove these and look only in '.' */
5231		/* Informix does look into all include paths though, except filename starts with '/' */
5232	0	if (yytext[0] == '"' && yytext[i] == '"' &&
5233	0	((compat != ECPG_COMPAT_INFORMIX && compat != ECPG_COMPAT_INFORMIX_SE) \|\| yytext[1] == '/'))
5234	0	{
5235	0	yytext[i] = '\0';
5236	0	memmove(yytext, yytext+1, strlen(yytext));
5237
5238	0	strlcpy(inc_file, yytext, sizeof(inc_file));
5239	0	yyin = fopen(inc_file, "r");
5240	0	if (!yyin)
5241	0	{
5242	0	if (strcmp(inc_file + strlen(inc_file) - 2, ".h") != 0)
5243	0	{
5244	0	strcat(inc_file, ".h");
5245	0	yyin = fopen(inc_file, "r");
5246	0	}
5247	0	}
5248
5249	0	}
5250	0	else
5251	0	{
5252	0	if ((yytext[0] == '"' && yytext[i] == '"') \|\| (yytext[0] == '<' && yytext[i] == '>'))
5253	0	{
5254	0	yytext[i] = '\0';
5255	0	memmove(yytext, yytext+1, strlen(yytext));
5256	0	}
5257
5258	0	for (ip = include_paths; yyin == NULL && ip != NULL; ip = ip->next)
5259	0	{
5260	0	if (strlen(ip->path) + strlen(yytext) + 3 > MAXPGPATH)
5261	0	{
5262	0	fprintf(stderr, _("Error: include path \"%s/%s\" is too long on line %d, skipping\n"), ip->path, yytext, yylineno);
5263	0	continue;
5264	0	}
5265	0	snprintf (inc_file, sizeof(inc_file), "%s/%s", ip->path, yytext);
5266	0	yyin = fopen(inc_file, "r");
5267	0	if (!yyin)
5268	0	{
5269	0	if (strcmp(inc_file + strlen(inc_file) - 2, ".h") != 0)
5270	0	{
5271	0	strcat(inc_file, ".h");
5272	0	yyin = fopen( inc_file, "r" );
5273	0	}
5274	0	}
5275		/* if the command was "include_next" we have to disregard the first hit */
5276	0	if (yyin && include_next)
5277	0	{
5278	0	fclose (yyin);
5279	0	yyin = NULL;
5280	0	include_next = false;
5281	0	}
5282	0	}
5283	0	}
5284	0	if (!yyin)
5285	0	mmfatal(NO_INCLUDE_FILE, "could not open include file \"%s\" on line %d", yytext, yylineno);
5286
5287	0	input_filename = mm_strdup(inc_file);
5288	0	yy_switch_to_buffer(yy_create_buffer(yyin,YY_BUF_SIZE ));
5289	0	yylineno = 1;
5290	0	output_line_number();
5291
5292	0	BEGIN(C);
5293	0	}
5294
5295		/*
5296		* ecpg_isspace() --- return true if flex scanner considers char whitespace
5297		*/
5298		static bool
5299		ecpg_isspace(char ch)
5300	0	{
5301	0	if (ch == ' ' \|\|
5302	0	ch == '\t' \|\|
5303	0	ch == '\n' \|\|
5304	0	ch == '\r' \|\|
5305	0	ch == '\f')
5306	0	return true;
5307	0	return false;
5308	0	}
5309
5310		static bool isdefine(void)
5311	0	{
5312	0	struct _defines *ptr;
5313
5314		/* is it a define? */
5315	0	for (ptr = defines; ptr; ptr = ptr->next)
5316	0	{
5317	0	if (strcmp(yytext, ptr->old) == 0 && ptr->used == NULL)
5318	0	{
5319	0	struct _yy_buffer *yb;
5320
5321	0	yb = mm_alloc(sizeof(struct _yy_buffer));
5322
5323	0	yb->buffer = YY_CURRENT_BUFFER;
5324	0	yb->lineno = yylineno;
5325	0	yb->filename = mm_strdup(input_filename);
5326	0	yb->next = yy_buffer;
5327
5328	0	ptr->used = yy_buffer = yb;
5329
5330	0	yy_scan_string(ptr->new);
5331	0	return true;
5332	0	}
5333	0	}
5334
5335	0	return false;
5336	0	}
5337
5338		static bool isinformixdefine(void)
5339	0	{
5340	0	const char *new = NULL;
5341
5342	0	if (strcmp(yytext, "dec_t") == 0)
5343	0	new = "decimal";
5344	0	else if (strcmp(yytext, "intrvl_t") == 0)
5345	0	new = "interval";
5346	0	else if (strcmp(yytext, "dtime_t") == 0)
5347	0	new = "timestamp";
5348
5349	0	if (new)
5350	0	{
5351	0	struct _yy_buffer *yb;
5352
5353	0	yb = mm_alloc(sizeof(struct _yy_buffer));
5354
5355	0	yb->buffer = YY_CURRENT_BUFFER;
5356	0	yb->lineno = yylineno;
5357	0	yb->filename = mm_strdup(input_filename);
5358	0	yb->next = yy_buffer;
5359	0	yy_buffer = yb;
5360
5361	0	yy_scan_string(new);
5362	0	return true;
5363	0	}
5364
5365	0	return false;
5366	0	}
5367
5368		/*
5369		* Called before any actual parsing is done
5370		*/
5371		void
5372		scanner_init(const char *str)
5373		{
5374		Size slen = strlen(str);
5375
5376		/*
5377		* Might be left over after ereport()
5378		*/
5379		if (YY_CURRENT_BUFFER)
5380		yy_delete_buffer(YY_CURRENT_BUFFER);
5381
5382		/*
5383		* Make a scan buffer with special termination needed by flex.
5384		*/
5385		scanbuf = mm_alloc(slen + 2);
5386		memcpy(scanbuf, str, slen);
5387		scanbuf[slen] = scanbuf[slen + 1] = YY_END_OF_BUFFER_CHAR;
5388		scanbufhandle = yy_scan_buffer(scanbuf, slen + 2);
5389
5390		/* initialize literal buffer to a reasonable but expansible size */
5391		literalalloc = 128;
5392		literalbuf = (char *) mm_alloc(literalalloc);
5393		startlit();
5394
5395		BEGIN(INITIAL);
5396		}
5397
5398
5399		/*
5400		* Called after parsing is done to clean up after scanner_init()
5401		*/
5402		void
5403		scanner_finish(void)
5404		{
5405		yy_delete_buffer(scanbufhandle);
5406		free(scanbuf);
5407		}
5408

YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

Coverage Report

Created: 2022-03-09 17:30