Prevent transmission of spurious promo char to other engine
[xboard.git] / parser.c
1
2 #line 3 "parser.c"
3
4 #define  YY_INT_ALIGNED short int
5
6 /* A lexical scanner generated by flex */
7
8 #define FLEX_SCANNER
9 #define YY_FLEX_MAJOR_VERSION 2
10 #define YY_FLEX_MINOR_VERSION 5
11 #define YY_FLEX_SUBMINOR_VERSION 34
12 #if YY_FLEX_SUBMINOR_VERSION > 0
13 #define FLEX_BETA
14 #endif
15
16 /* First, we deal with  platform-specific or compiler-specific issues. */
17
18 /* begin standard C headers. */
19 #include <stdio.h>
20 #include <string.h>
21 #include <errno.h>
22 #include <stdlib.h>
23
24 /* end standard C headers. */
25
26 /* flex integer type definitions */
27
28 #ifndef FLEXINT_H
29 #define FLEXINT_H
30
31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
32
33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
34
35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
36  * if you want the limit (max/min) macros for int types. 
37  */
38 #ifndef __STDC_LIMIT_MACROS
39 #define __STDC_LIMIT_MACROS 1
40 #endif
41
42 #include <inttypes.h>
43 typedef int8_t flex_int8_t;
44 typedef uint8_t flex_uint8_t;
45 typedef int16_t flex_int16_t;
46 typedef uint16_t flex_uint16_t;
47 typedef int32_t flex_int32_t;
48 typedef uint32_t flex_uint32_t;
49 #else
50 typedef signed char flex_int8_t;
51 typedef short int flex_int16_t;
52 typedef int flex_int32_t;
53 typedef unsigned char flex_uint8_t; 
54 typedef unsigned short int flex_uint16_t;
55 typedef unsigned int flex_uint32_t;
56 #endif /* ! C99 */
57
58 /* Limits of integral types. */
59 #ifndef INT8_MIN
60 #define INT8_MIN               (-128)
61 #endif
62 #ifndef INT16_MIN
63 #define INT16_MIN              (-32767-1)
64 #endif
65 #ifndef INT32_MIN
66 #define INT32_MIN              (-2147483647-1)
67 #endif
68 #ifndef INT8_MAX
69 #define INT8_MAX               (127)
70 #endif
71 #ifndef INT16_MAX
72 #define INT16_MAX              (32767)
73 #endif
74 #ifndef INT32_MAX
75 #define INT32_MAX              (2147483647)
76 #endif
77 #ifndef UINT8_MAX
78 #define UINT8_MAX              (255U)
79 #endif
80 #ifndef UINT16_MAX
81 #define UINT16_MAX             (65535U)
82 #endif
83 #ifndef UINT32_MAX
84 #define UINT32_MAX             (4294967295U)
85 #endif
86
87 #endif /* ! FLEXINT_H */
88
89 #ifdef __cplusplus
90
91 /* The "const" storage-class-modifier is valid. */
92 #define YY_USE_CONST
93
94 #else   /* ! __cplusplus */
95
96 /* C99 requires __STDC__ to be defined as 1. */
97 #if defined (__STDC__)
98
99 #define YY_USE_CONST
100
101 #endif  /* defined (__STDC__) */
102 #endif  /* ! __cplusplus */
103
104 #ifdef YY_USE_CONST
105 #define yyconst const
106 #else
107 #define yyconst
108 #endif
109
110 /* Returned upon end-of-file. */
111 #define YY_NULL 0
112
113 /* Promotes a possibly negative, possibly signed char to an unsigned
114  * integer for use as an array index.  If the signed char is negative,
115  * we want to instead treat it as an 8-bit unsigned char, hence the
116  * double cast.
117  */
118 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
119
120 /* Enter a start condition.  This macro really ought to take a parameter,
121  * but we do it the disgusting crufty way forced on us by the ()-less
122  * definition of BEGIN.
123  */
124 #define BEGIN (yy_start) = 1 + 2 *
125
126 /* Translate the current start state into a value that can be later handed
127  * to BEGIN to return to the state.  The YYSTATE alias is for lex
128  * compatibility.
129  */
130 #define YY_START (((yy_start) - 1) / 2)
131 #define YYSTATE YY_START
132
133 /* Action number for EOF rule of a given start state. */
134 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
135
136 /* Special action meaning "start processing a new file". */
137 #define YY_NEW_FILE yyrestart(yyin  )
138
139 #define YY_END_OF_BUFFER_CHAR 0
140
141 /* Size of default input buffer. */
142 #ifndef YY_BUF_SIZE
143 #define YY_BUF_SIZE 16384
144 #endif
145
146 /* The state buf must be large enough to hold one state per character in the main buffer.
147  */
148 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
149
150 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
151 #define YY_TYPEDEF_YY_BUFFER_STATE
152 typedef struct yy_buffer_state *YY_BUFFER_STATE;
153 #endif
154
155 extern int yyleng;
156
157 extern FILE *yyin, *yyout;
158
159 #define EOB_ACT_CONTINUE_SCAN 0
160 #define EOB_ACT_END_OF_FILE 1
161 #define EOB_ACT_LAST_MATCH 2
162
163     #define YY_LESS_LINENO(n)
164     
165 /* Return all but the first "n" matched characters back to the input stream. */
166 #define yyless(n) \
167         do \
168                 { \
169                 /* Undo effects of setting up yytext. */ \
170         int yyless_macro_arg = (n); \
171         YY_LESS_LINENO(yyless_macro_arg);\
172                 *yy_cp = (yy_hold_char); \
173                 YY_RESTORE_YY_MORE_OFFSET \
174                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
175                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
176                 } \
177         while ( 0 )
178
179 #define unput(c) yyunput( c, (yytext_ptr)  )
180
181 /* The following is because we cannot portably get our hands on size_t
182  * (without autoconf's help, which isn't available because we want
183  * flex-generated scanners to compile on their own).
184  * Given that the standard has decreed that size_t exists since 1989,
185  * I guess we can afford to depend on it. Manoj.
186  */
187
188 #ifndef YY_TYPEDEF_YY_SIZE_T
189 #define YY_TYPEDEF_YY_SIZE_T
190 typedef size_t yy_size_t;
191 #endif
192
193 #ifndef YY_STRUCT_YY_BUFFER_STATE
194 #define YY_STRUCT_YY_BUFFER_STATE
195 struct yy_buffer_state
196         {
197         FILE *yy_input_file;
198
199         char *yy_ch_buf;                /* input buffer */
200         char *yy_buf_pos;               /* current position in input buffer */
201
202         /* Size of input buffer in bytes, not including room for EOB
203          * characters.
204          */
205         yy_size_t yy_buf_size;
206
207         /* Number of characters read into yy_ch_buf, not including EOB
208          * characters.
209          */
210         int yy_n_chars;
211
212         /* Whether we "own" the buffer - i.e., we know we created it,
213          * and can realloc() it to grow it, and should free() it to
214          * delete it.
215          */
216         int yy_is_our_buffer;
217
218         /* Whether this is an "interactive" input source; if so, and
219          * if we're using stdio for input, then we want to use getc()
220          * instead of fread(), to make sure we stop fetching input after
221          * each newline.
222          */
223         int yy_is_interactive;
224
225         /* Whether we're considered to be at the beginning of a line.
226          * If so, '^' rules will be active on the next match, otherwise
227          * not.
228          */
229         int yy_at_bol;
230
231     int yy_bs_lineno; /**< The line count. */
232     int yy_bs_column; /**< The column count. */
233     
234         /* Whether to try to fill the input buffer when we reach the
235          * end of it.
236          */
237         int yy_fill_buffer;
238
239         int yy_buffer_status;
240
241 #define YY_BUFFER_NEW 0
242 #define YY_BUFFER_NORMAL 1
243         /* When an EOF's been seen but there's still some text to process
244          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
245          * shouldn't try reading from the input source any more.  We might
246          * still have a bunch of tokens to match, though, because of
247          * possible backing-up.
248          *
249          * When we actually see the EOF, we change the status to "new"
250          * (via yyrestart()), so that the user can continue scanning by
251          * just pointing yyin at a new input file.
252          */
253 #define YY_BUFFER_EOF_PENDING 2
254
255         };
256 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
257
258 /* Stack of input buffers. */
259 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
260 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
261 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
262
263 /* We provide macros for accessing buffer states in case in the
264  * future we want to put the buffer states in a more general
265  * "scanner state".
266  *
267  * Returns the top of the stack, or NULL.
268  */
269 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
270                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
271                           : NULL)
272
273 /* Same as previous macro, but useful when we know that the buffer stack is not
274  * NULL or when we need an lvalue. For internal use only.
275  */
276 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
277
278 /* yy_hold_char holds the character lost when yytext is formed. */
279 static char yy_hold_char;
280 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
281 int yyleng;
282
283 /* Points to current character in buffer. */
284 static char *yy_c_buf_p = (char *) 0;
285 static int yy_init = 0;         /* whether we need to initialize */
286 static int yy_start = 0;        /* start state number */
287
288 /* Flag which is used to allow yywrap()'s to do buffer switches
289  * instead of setting up a fresh yyin.  A bit of a hack ...
290  */
291 static int yy_did_buffer_switch_on_eof;
292
293 void yyrestart (FILE *input_file  );
294 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
295 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
296 void yy_delete_buffer (YY_BUFFER_STATE b  );
297 void yy_flush_buffer (YY_BUFFER_STATE b  );
298 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
299 void yypop_buffer_state (void );
300
301 static void yyensure_buffer_stack (void );
302 static void yy_load_buffer_state (void );
303 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
304
305 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
306
307 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
308 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
309 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
310
311 void *yyalloc (yy_size_t  );
312 void *yyrealloc (void *,yy_size_t  );
313 void yyfree (void *  );
314
315 #define yy_new_buffer yy_create_buffer
316
317 #define yy_set_interactive(is_interactive) \
318         { \
319         if ( ! YY_CURRENT_BUFFER ){ \
320         yyensure_buffer_stack (); \
321                 YY_CURRENT_BUFFER_LVALUE =    \
322             yy_create_buffer(yyin,YY_BUF_SIZE ); \
323         } \
324         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
325         }
326
327 #define yy_set_bol(at_bol) \
328         { \
329         if ( ! YY_CURRENT_BUFFER ){\
330         yyensure_buffer_stack (); \
331                 YY_CURRENT_BUFFER_LVALUE =    \
332             yy_create_buffer(yyin,YY_BUF_SIZE ); \
333         } \
334         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
335         }
336
337 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
338
339 /* Begin user sect3 */
340
341 typedef unsigned char YY_CHAR;
342
343 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
344
345 typedef int yy_state_type;
346
347 extern int yylineno;
348
349 int yylineno = 1;
350
351 extern char *yytext;
352 #define yytext_ptr yytext
353
354 static yy_state_type yy_get_previous_state (void );
355 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
356 static int yy_get_next_buffer (void );
357 static void yy_fatal_error (yyconst char msg[]  );
358
359 /* Done after the current pattern has been matched and before the
360  * corresponding action - sets up yytext.
361  */
362 #define YY_DO_BEFORE_ACTION \
363         (yytext_ptr) = yy_bp; \
364         yyleng = (size_t) (yy_cp - yy_bp); \
365         (yy_hold_char) = *yy_cp; \
366         *yy_cp = '\0'; \
367         (yy_c_buf_p) = yy_cp;
368
369 #define YY_NUM_RULES 42
370 #define YY_END_OF_BUFFER 43
371 /* This struct is not used in this scanner,
372    but its presence is necessary. */
373 struct yy_trans_info
374         {
375         flex_int32_t yy_verify;
376         flex_int32_t yy_nxt;
377         };
378 static yyconst flex_int16_t yy_acclist[606] =
379     {   0,
380        43,   41,   42,   41,   42,   41,   42,   40,   41,   42,
381        41,   42,   25,   41,   42,   41,   42,   40,   41,   42,
382        40,   41,   42,16410,   40,   41,   42,16410,   41,   42,
383        40,   41,   42,   40,   41,   42,   40,   41,   42,   40,
384        41,   42,   40,   41,   42,   40,   41,   42,   40,   41,
385        42,   40,   41,   42,   40,   41,   42,   40,   41,   42,
386        41,   42,   40,   41,   42,   40,   41,   42,   40,   41,
387        42,   40,   41,   42,   40,   41,   42,   40,   41,   42,
388        40,   41,   42,   40,   41,   42,   40,   41,   42,   40,
389        41,   42,   40,   41,   42,   40,   41,   42,   40,   41,
390
391        42,   40,   41,   42,   40,   41,   42,   40,   41,   42,
392        40,   41,   42,   41,   42,   41,   42,   40,   41,   42,
393        40,   41,   42,   40,   41,   42,16410,   40,   41,   42,
394     16410,   41,   42,   40,   41,   42,   40,   41,   42,   40,
395        41,   42,   40,   41,   42,   40,   41,   42,   40,   41,
396        42,   40,   41,   42,   40,   41,   42,   40,   41,   42,
397        40,   41,   42,   40,   41,   42,   40,   41,   42,   40,
398        41,   42,   40,   41,   42,   40,   41,   42,   40,   41,
399        42,   40,   41,   42,   40,   41,   42,   40,   41,   42,
400        40,   41,   42,   40,   41,   42,   40,   41,   42,   40,
401
402        41,   42,   40,   41,   42,   40,   41,   42,   40,   41,
403        42,   40,   41,   42,   41,   42,   33,   40,   17,   40,
404         9,   40,   40,   40,16410, 8218,   40,   35,   40,   40,
405        40,   40,   40,   40,   40,   40,   40,   40,    9,   40,
406        40,   40,   40,   36,   40,    3,   40,   40,    4,   40,
407        40,   40,   40,   40,   40,    9,   40,   40,   40,   34,
408        40,   40,    9,   40,   40,   40,16410, 8218,   40,   40,
409        40,   40,   40,   40,   40,   40,   40,   40,   40,    9,
410        40,   40,   40,   40,   40,    3,   40,   40,    4,   40,
411        40,   40,   40,   40,   40,    9,   40,   40,   40,   15,
412
413         9,   40,   23,   40,   23,    8,   40, 8218,   22,   40,
414        22,   24,   40,   40,   40,    6,   40,   40,   40,   40,
415        40,   40,    9,   40,   40,   40,   40,    4,   40,   40,
416         3,    3,   40,    3,   40,    3,   40,    4,    5,   40,
417         4,    4,   40,   40,   40,   40,    9,   40,   40,   34,
418        39,    9,   40,   23,   40,    8,   40,   22,   40,   35,
419        40,   40,   40,    6,   40,   40,   40,   40,   40,   40,
420         9,   40,   40,   40,   40,    4,   40,   40,    3,   40,
421         3,   40,    3,   40,    5,   40,    4,   40,   40,   40,
422        40,    9,   40,   40,   38,   38,   38,   37,   25,   25,
423
424         6,   40,   10,    6,   40,    7,   40,    6,   40,    6,
425        40,   40,   40,   19,   40,   40,   16,   40,   40,   40,
426        40,   40,   36,    3,   40,    3,    2,   40,    5,    4,
427         5,    5,   40,   40,    4,    4,   40,   40,   25,   39,
428        40,    6,   40,    7,   40,   40,   40,   40,   40,   19,
429        40,   40,   16,   40,   40,   40,   40,   40,   40,    2,
430        40,    5,   40,   40,    4,   40,   40,   38,    7,    7,
431         1,   40,   20,   40,   40,   19,   40,   40,   40,   40,
432        40,   40,   30,   36,    2,    2,    2,   40,    5,    5,
433         5,   40,   39,    1,   40,   40,   40,   19,   40,   40,
434
435        40,   40,   40,   40,    2,   40,    5,   40,   27,   38,
436         1,   23,   23,   22,   22,   24,   24,    1,    1,   40,
437        21,   20,   40,   40,   40,   11,   40,   40,   28,   36,
438        30,    2,    2,   27,   34,   39,   39,    1,   40,   40,
439        40,   40,   11,   40,   40,   18,    1,   24,    1,   21,
440        19,   40,   40,   40,   11,   40,   40,   40,   40,   40,
441        11,   40,   40,   12,   40,   40,   40,   40,   12,   40,
442        40,   14,   40,   40,   40,   14,   40,   40,   40,   39,
443        40,   40,   40,   40,   39,   39,   40,   40,   31,   40,
444        39,   39,   31,   40,   13,   31,   32,   32,   35,   39,
445
446        39,   31,   39,   34,   29
447     } ;
448
449 static yyconst flex_int16_t yy_accept[691] =
450     {   0,
451         1,    1,    1,    2,    4,    6,    8,   11,   13,   16,
452        18,   21,   25,   29,   31,   34,   37,   40,   43,   46,
453        49,   52,   55,   58,   61,   63,   66,   69,   72,   75,
454        78,   81,   84,   87,   90,   93,   96,   99,  102,  105,
455       108,  111,  114,  116,  118,  121,  124,  128,  132,  134,
456       137,  140,  143,  146,  149,  152,  155,  158,  161,  164,
457       167,  170,  173,  176,  179,  182,  185,  188,  191,  194,
458       197,  200,  203,  206,  209,  212,  215,  217,  217,  218,
459       219,  219,  219,  219,  219,  220,  220,  220,  220,  221,
460       221,  223,  223,  223,  223,  224,  224,  224,  226,  226,
461
462       228,  228,  229,  229,  230,  230,  231,  231,  232,  232,
463       233,  234,  235,  236,  237,  238,  239,  241,  242,  243,
464       244,  244,  244,  244,  244,  245,  246,  248,  248,  249,
465       251,  252,  253,  254,  255,  256,  258,  259,  260,  260,
466       260,  260,  261,  261,  262,  262,  263,  265,  265,  266,
467       268,  268,  270,  270,  271,  272,  272,  273,  274,  275,
468       276,  277,  278,  279,  280,  282,  283,  284,  285,  286,
469       288,  288,  289,  291,  292,  293,  294,  295,  296,  298,
470       299,  300,  300,  300,  300,  300,  300,  300,  300,  300,
471       300,  300,  300,  301,  301,  301,  301,  301,  301,  303,
472
473       305,  306,  308,  309,  309,  309,  309,  311,  312,  313,
474       313,  314,  314,  315,  315,  316,  316,  318,  318,  318,
475       318,  318,  318,  318,  319,  320,  321,  322,  323,  325,
476       326,  327,  328,  328,  328,  328,  328,  330,  330,  331,
477       331,  332,  334,  336,  338,  339,  339,  341,  342,  344,
478       345,  346,  347,  349,  350,  351,  351,  351,  351,  351,
479       352,  354,  356,  358,  360,  360,  361,  361,  362,  363,
480       363,  364,  366,  367,  368,  369,  370,  371,  373,  374,
481       375,  376,  378,  379,  379,  381,  383,  385,  387,  389,
482       390,  391,  392,  394,  395,  395,  395,  396,  397,  397,
483
484       397,  398,  398,  398,  399,  399,  399,  400,  400,  401,
485       401,  402,  402,  402,  402,  403,  403,  403,  403,  403,
486       403,  403,  403,  404,  406,  406,  408,  409,  410,  410,
487       411,  412,  412,  412,  412,  412,  412,  412,  413,  414,
488       416,  416,  417,  419,  420,  421,  422,  423,  423,  423,
489       423,  423,  424,  425,  426,  426,  427,  429,  430,  431,
490       431,  431,  432,  434,  435,  436,  436,  438,  439,  439,
491       440,  440,  440,  440,  440,  441,  441,  442,  442,  442,
492       444,  446,  447,  447,  448,  449,  450,  452,  453,  455,
493       456,  457,  458,  459,  460,  462,  464,  465,  467,  468,
494
495       468,  468,  468,  468,  469,  469,  469,  469,  469,  470,
496       470,  470,  470,  470,  470,  470,  470,  470,  470,  471,
497       473,  473,  473,  473,  473,  473,  474,  475,  476,  476,
498       478,  478,  479,  480,  481,  482,  483,  483,  483,  485,
499       485,  485,  486,  486,  487,  489,  490,  490,  491,  491,
500       493,  493,  493,  493,  493,  493,  493,  493,  494,  494,
501       494,  496,  497,  498,  500,  501,  502,  503,  504,  505,
502       507,  509,  509,  509,  509,  509,  509,  509,  511,  511,
503       512,  512,  513,  513,  514,  514,  515,  515,  516,  516,
504       517,  517,  518,  518,  518,  518,  519,  521,  521,  521,
505
506       522,  522,  522,  523,  524,  524,  524,  524,  524,  524,
507       525,  526,  528,  529,  531,  531,  532,  533,  534,  534,
508       534,  536,  536,  536,  537,  538,  538,  538,  540,  541,
509       542,  543,  545,  546,  546,  547,  547,  547,  547,  547,
510       548,  548,  549,  550,  550,  550,  551,  551,  551,  552,
511       552,  552,  552,  552,  553,  554,  555,  557,  558,  558,
512       558,  558,  558,  558,  559,  560,  561,  563,  564,  564,
513       564,  564,  564,  564,  564,  565,  565,  565,  565,  565,
514       566,  567,  567,  567,  567,  567,  568,  569,  569,  569,
515       569,  569,  570,  570,  570,  570,  571,  572,  574,  574,
516
517       574,  574,  574,  575,  575,  576,  578,  578,  578,  578,
518       578,  579,  580,  580,  580,  580,  580,  581,  582,  583,
519       583,  583,  583,  583,  583,  584,  585,  585,  585,  585,
520       585,  586,  587,  588,  589,  589,  589,  589,  589,  589,
521       591,  591,  591,  591,  591,  592,  593,  595,  595,  595,
522       596,  596,  597,  597,  598,  598,  598,  600,  600,  601,
523       602,  602,  602,  602,  602,  604,  604,  604,  604,  604,
524       604,  604,  604,  604,  604,  604,  604,  604,  604,  604,
525       604,  604,  604,  604,  604,  604,  604,  605,  606,  606
526     } ;
527
528 static yyconst flex_int32_t yy_ec[256] =
529     {   0,
530         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
531         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
532         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
533         1,    4,    1,    5,    6,    7,    8,    1,    9,   10,
534        11,   12,   13,    1,   14,   15,   16,   17,   18,   19,
535        20,   20,   20,   20,   20,   20,   20,   21,   22,    1,
536        23,    1,    1,   24,   25,   26,   27,   28,   29,   30,
537        31,   32,   33,   33,   34,   35,   36,   37,   38,   34,
538        34,   39,   40,   33,   41,   33,   42,   43,   33,   33,
539        44,    1,   45,    1,   46,    1,   47,   48,   49,   50,
540
541        51,   52,   53,   54,   55,   56,   57,   58,   59,   60,
542        61,   62,   63,   64,   65,   66,   67,   68,   69,   70,
543        71,   68,   72,    1,   73,    1,    1,    1,    1,    1,
544         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
545         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
546         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
547         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
548         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
549         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
550         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
551
552         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
553         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
554         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
555         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
556         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
557         1,    1,    1,    1,    1
558     } ;
559
560 static yyconst flex_int32_t yy_meta[74] =
561     {   0,
562         1,    2,    3,    2,    1,    1,    1,    1,    4,    5,
563         6,    1,    7,    8,    1,    1,    9,    9,    9,    9,
564        10,    1,   11,    1,   12,   12,   12,   12,   12,   12,
565        12,   12,   13,   12,   13,   13,   12,   12,   12,   13,
566        13,   12,   14,    1,    1,    1,   15,   15,   15,   15,
567        16,   15,   15,   15,   15,   15,   15,   15,   17,   18,
568        18,   18,   18,   18,   17,   17,   17,   17,   17,   19,
569        17,    1,    1
570     } ;
571
572 static yyconst flex_int16_t yy_base[769] =
573     {   0,
574         0,   73, 3831, 3832,  122,  131,    0,  142, 3826,  140,
575       151,  171,  162, 3826,  231,  159, 3774, 3763,  119, 3779,
576       143, 3774, 3758,  190,  301,  361,  211,  207,  279,  215,
577       224,  284,  243,  286,  301,  303,  305, 3776,  232, 3771,
578      3755,  264,  351, 3816,  149,  379,  430,  351,  255,  493,
579       212, 3765, 3754,  327, 3770,  157, 3765, 3749,  331,  555,
580       372,  245,  378,  351,  468,  530,  475,  477,  505,  523,
581       508,  576,  578,  385,  579,  610,  615, 3761,  372,    0,
582      3803,  309,  630,  431, 3832, 3707,  675,  575,  405, 3683,
583      3665, 3645,  450,  639, 3639,  472,  165,  640, 3638,    0,
584
585      3651, 3832,    0,  699,    0,  744,    0,  648,  787,  652,
586       656, 3606, 3611, 3569,  693, 3565, 3564,  697, 3554,  664,
587      3555,  856,  352,  929, 3832,  956, 1006,    0, 1031, 1080,
588       660,  717,  721, 3533, 3463, 3444, 3421, 3412,  435, 3375,
589       757, 3425, 3353,  497, 3352,  517,  607,  550,  681, 1130,
590       160,  518,  554, 1193, 1238, 3310,  686,  762,  787,  764,
591       617,  676,  750, 3271,  803,  816,  864,  835, 1262, 1312,
592      3304, 1337, 1387,  874,  888,  895,  700,  823,  865,  762,
593       866,  885, 3243,  583,  610,  626,  652,  676,  944,  949,
594      3295, 3232, 3832,  882, 1190, 3290, 3287, 3286, 3196, 3205,
595
596      3201,    0, 3832, 3200, 3197, 3179, 3160, 2966,  799,  830,
597       900,  958, 1412,  928,  962,  966, 1457, 2910, 2902, 2901,
598      2914, 2823,  382,  970, 1075, 2804,  759, 2818, 2854, 2812,
599      2807, 1108,  572, 1213,  739, 1527, 1591,    0, 1596,    0,
600      2837, 2817, 2642, 1118, 1202, 1246, 1645, 2640, 2638,  238,
601      2598, 2597, 2631, 2578, 3832, 1210,  979, 2639,  211, 2639,
602      1132, 1253,  606, 1263,  697, 2637,  895, 1217, 1688, 2636,
603      1259, 1733, 1467, 1472,  901, 1536, 1252, 1261, 1121, 1532,
604      1541, 1795, 1800, 2601,  810, 2580, 1556, 1849, 1535, 1573,
605      1473, 1474, 1570, 1543, 1566, 2536, 3832,  778,  832,  913,
606
607       982,  984,  989, 3832, 1585, 2575, 2574, 2450, 2449, 1281,
608      1646, 2503, 2487, 2473, 2473,  585, 2470,  367, 2469,  636,
609      1680, 1136, 3832, 2462, 1679, 2458, 2457, 1854, 1594, 3832,
610      1287, 2414, 2414, 2412, 2410, 2410, 2414, 2416, 2415,  968,
611       510,  598,    0, 2433, 2417, 2418, 2417, 1007, 1161, 1046,
612      1354, 2462, 2455, 1455, 1479, 3832, 1694, 1560, 2454, 1081,
613      1587, 1682, 2453, 1209, 3832, 2400,    0, 2400, 1789, 2456,
614      1711, 1744, 2412, 2397, 2454,  403, 1572, 1430,  374, 1545,
615      1697, 1866, 2449, 1750,  819, 1698, 1753, 1916, 1009, 1757,
616      1789, 1742, 1790, 1921, 1935, 1791, 1942, 1315, 1689, 1584,
617
618      2401, 1091, 2440, 1221, 1244, 1317, 1392, 1509, 2427, 1711,
619      2438, 2375, 2436, 2373, 2434, 2371, 2425, 1757, 3832, 1995,
620      2393, 2388, 1452, 2388, 2383, 2372, 2432, 1266, 1921, 2431,
621       688, 2401, 2378, 2368, 2368, 2420, 1386, 1891, 3832, 2408,
622      1930,  933, 1388, 1711, 2397, 2396, 1417, 3832, 2344,    0,
623      2390, 1944, 2386, 1642, 2386, 2343, 2336, 1841, 1603, 1575,
624      2030, 1957, 1941, 1963, 1959, 1955, 1981, 1986, 1970, 1852,
625      1962, 1979, 1810, 1491, 2389, 1515, 1602, 3832, 2064, 1754,
626      2388, 2387, 2324, 2323, 2384, 2383, 2320, 2316, 2376, 2375,
627      2307, 2306, 2362, 2358, 1791, 1963, 2365, 2314, 2323, 1943,
628
629       760, 2320, 3832, 2324, 2359, 2318, 2296, 2336, 2306, 2316,
630      2290, 1482, 2307, 3832, 2009, 3832, 2340, 3832, 2331, 2073,
631      2336, 2284, 2279, 2328, 1862, 1101, 1720, 1978, 2068, 2076,
632      2077, 2078, 2079, 2091, 3832, 2279, 2317, 1655, 2091, 2316,
633      2320, 2319, 3832, 2260, 2251, 3832, 2241, 2289, 2288, 2236,
634      2293, 2250, 2218, 2227, 2193, 2201,    0, 2181, 2100, 2241,
635      2177, 1793, 1633, 2104, 2086, 1994, 1989, 2103, 2118, 2179,
636      2219, 1681, 2165, 2158, 1878, 2169, 1755, 2146, 2117, 2191,
637      2112, 2052, 2041, 1589, 1812, 2264, 2114, 2127, 2014, 2027,
638      1999, 3832, 1950, 1786, 1961, 2337, 1972,    0, 1910, 1874,
639
640      1993,  598, 2410, 2075, 2089, 2113, 2135, 1850, 1813, 2106,
641      1804, 1713, 1668, 1635, 1721,  758, 2124, 1625, 1600, 2136,
642      1520, 1489, 2109, 2117, 1380, 1283, 1272, 1235, 1895, 1867,
643      2130, 2163, 1194, 1154, 2144, 2103, 1148, 2158, 2121,    0,
644      1047,  970,  924, 1998, 2187, 2202,    0, 2153,  839, 3832,
645       821, 2126,  787, 3832,  567,  501, 3832, 2172, 2225, 2231,
646      2157,  380,  362, 1923, 2228, 2218,  288, 2178,  944, 2175,
647      2177, 2238, 2239, 2243, 2246, 2289, 2290, 2291, 2293, 2299,
648      2311, 2312, 2315, 2318, 2319, 2216,  190, 3832, 3832, 2480,
649      2499, 2512, 2526, 2545, 2564, 2580, 2599, 2618, 2636, 1881,
650
651      1912, 2027, 2654, 2673, 2031, 2692, 2711, 2730, 2749, 2768,
652      2787, 2806, 2825, 2844, 2856, 2875, 2894, 2913, 2932, 2940,
653      2169, 2955, 2971, 2990, 3009, 3028, 3047, 3066, 3085, 3104,
654      3123, 3142, 3161, 3180, 3192, 3211, 3230, 3249, 3268, 3284,
655      3299, 3315, 3334, 3350, 3369, 3388, 3407, 3426, 3445, 3464,
656      3483, 3502, 3521, 3540, 3559, 3578, 3593, 3612, 3631, 3646,
657      3660, 3679, 3698, 3717, 3736, 3755, 3774, 3793
658     } ;
659
660 static yyconst flex_int16_t yy_def[769] =
661     {   0,
662       689,  689,  689,  689,  689,  689,  690,  691,  689,  692,
663       690,  689,   12,  693,  690,   15,   15,   15,   15,   15,
664        15,   15,   15,   15,  694,  690,   26,   26,   26,   26,
665        26,   26,   26,   26,   26,   26,   26,  690,  690,  690,
666       690,  690,  695,  689,  696,  696,  689,   47,  693,  696,
667        50,   50,   50,   50,   50,   50,   50,   50,   50,  696,
668        60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
669        60,  696,  696,  696,  696,  696,  695,  689,  689,  690,
670       697,  698,  697,  689,  689,  689,  689,  689,  690,  689,
671       690,  689,  699,  699,  690,  699,  689,   12,  689,  690,
672
673       693,  689,  700,  690,  701,  690,  702,  106,  689,  106,
674       106,  690,  690,  690,  106,  104,  690,  106,  690,  106,
675       703,  694,  703,  704,  689,  690,  689,  705,  690,  690,
676       690,  690,  690,  690,  690,  690,  690,  690,  695,  706,
677       695,  689,  707,  696,  689,  696,  696,  689,  696,  689,
678       689,  696,  708,  696,  154,  702,  155,  155,  155,  696,
679       696,  696,  155,  154,  696,  155,  696,  155,  154,  689,
680       705,  154,  689,  696,  696,  696,  696,  696,  696,  696,
681       696,  695,  689,  709,  710,  710,  711,  712,  709,  709,
682       713,  714,  689,  715,  715,  689,  689,  689,  690,  690,
683
684       689,  690,  689,  689,  689,  689,  690,  689,  689,  689,
685       690,  689,  690,  715,  690,  689,  690,  689,  689,  689,
686       689,  689,  689,  690,  690,  690,  690,  690,  690,  690,
687       690,  690,  716,  717,  718,  719,  690,  720,  690,  721,
688       720,  690,  239,  690,  722,  722,  690,  246,  690,  690,
689       690,  690,  690,  690,  689,  695,  689,  723,  689,  724,
690       696,  696,  696,  696,  725,  723,  726,  696,  696,  214,
691       696,  269,  696,  696,  696,  696,  696,  696,  696,  696,
692       696,  696,  269,  721,  696,  283,  696,  282,  696,  696,
693       696,  696,  696,  696,  695,  689,  689,  727,  728,  729,
694
695       730,  727,  731,  689,  732,  733,  733,  734,  734,  689,
696       735,  689,  689,  689,  690,  689,  689,  689,  689,  689,
697       689,  689,  689,  690,  735,  690,  689,  690,  325,  689,
698       690,  689,  689,  689,  689,  689,  689,  690,  690,  690,
699       689,  690,  690,  690,  690,  690,  690,  736,  736,  737,
700       738,  739,  689,  690,  689,  689,  740,  741,  689,  689,
701       741,  741,  690,  690,  689,  689,  690,  690,  695,  689,
702       689,  689,  689,  689,  742,  689,  696,  743,  743,  696,
703       696,  283,  329,  696,  696,  696,  696,  696,  696,  696,
704       696,  696,  696,  696,  744,  696,  696,  696,  696,  695,
705
706       689,  729,  745,  746,  730,  747,  731,  732,  689,  689,
707       748,  749,  750,  751,  752,  753,  689,  689,  689,  690,
708       689,  689,  689,  689,  689,  689,  690,  690,  689,  690,
709       689,  690,  690,  690,  690,  690,  754,  755,  689,  756,
710       689,  757,  757,  757,  690,  689,  689,  689,  689,  690,
711       689,  695,  689,  689,  689,  689,  689,  758,  743,  743,
712       696,  696,  696,  696,  696,  696,  696,  696,  696,  696,
713       696,  695,  689,  746,  759,  730,  747,  689,  732,  760,
714       748,  748,  749,  749,  750,  750,  751,  751,  752,  752,
715       753,  753,  689,  689,  760,  760,  690,  689,  689,  689,
716
717       689,  689,  689,  690,  761,  689,  689,  689,  689,  690,
718       690,  690,  690,  689,  689,  689,  689,  689,  689,  695,
719       689,  689,  689,  758,  758,  743,  743,  696,  696,  696,
720       696,  696,  696,  695,  689,  689,  759,  746,  732,  689,
721       689,  689,  689,  689,  689,  689,  689,  761,  761,  689,
722       689,  689,  689,  690,  690,  690,  690,  690,  695,  689,
723       689,  743,  743,  696,  696,  696,  696,  696,  695,  689,
724       689,  689,  689,  689,  689,  689,  689,  689,  689,  762,
725       690,  689,  689,  743,  743,  763,  696,  695,  689,  689,
726       689,  689,  689,  764,  764,  762,  596,  690,  689,  689,
727
728       743,  743,  763,  764,  603,  696,  695,  689,  689,  764,
729       596,  596,  689,  689,  743,  743,  765,  603,  603,  695,
730       689,  689,  764,  764,  596,  596,  689,  689,  743,  743,
731       765,  765,  603,  603,  695,  689,  689,  764,  764,  596,
732       766,  689,  767,  743,  765,  765,  603,  695,  689,  689,
733       689,  764,  766,  689,  689,  767,  689,  743,  765,  765,
734       695,  689,  689,  743,  765,  695,  689,  743,  695,  768,
735       768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
736       768,  768,  768,  768,  768,  768,  689,  689,    0,  689,
737       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
738
739       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
740       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
741       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
742       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
743       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
744       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
745       689,  689,  689,  689,  689,  689,  689,  689
746     } ;
747
748 static yyconst flex_int16_t yy_nxt[3906] =
749     {   0,
750         4,    4,    4,    5,    4,    4,    6,    4,    7,    8,
751         4,    9,   10,    7,    4,    4,   11,   12,   13,   13,
752         4,   14,    4,    4,   15,   16,   17,   18,   15,   15,
753        19,   15,   15,   15,   15,   20,   15,   21,   22,   23,
754        15,   24,   15,   25,    4,    4,   26,   27,   28,   29,
755        30,   31,   32,   33,   34,   35,   36,   37,   38,    7,
756        39,    7,    7,   40,   41,    7,    7,    7,   42,    7,
757         7,   43,    4,    4,    4,    4,    5,    4,   44,    6,
758        44,    7,    8,    4,    9,   10,   45,    4,    4,   46,
759        47,   48,   48,    4,   49,    4,    4,   50,   51,   52,
760
761        53,   50,   50,   54,   50,   50,   50,   50,   55,   50,
762        56,   57,   58,   50,   59,   50,   25,    4,    4,   60,
763        61,   62,   63,   64,   65,   66,   67,   68,   69,   70,
764        71,   72,   45,   73,   45,   45,   74,   75,   45,   45,
765        45,   76,   45,   45,   77,    4,   78,   79,   79,   79,
766        79,   82,   85,   86,   88,  113,  116,   80,   83,   83,
767        83,   83,  109,  260,   89,   93,   90,   91,   78,  145,
768       164,   92,   93,   93,   94,   80,  208,  689,  114,   80,
769       117,  208,  689,  209,   95,   96,   97,   98,   98,   98,
770        98,   99,  688,  109,  165,  100,  100,  100,  100,  100,
771
772       100,  100,  100,   80,  100,   80,   80,  100,  100,  100,
773        80,   80,  100,   80,  109,  109,  110,  100,  100,  100,
774       100,  100,  100,  100,  100,  100,  100,  100,  100,   80,
775       100,  100,  100,  100,  100,   80,   80,   80,   80,   80,
776        80,   80,  103,  120,  104,  135,  105,  106,  106,  106,
777       106,  107,  366,  131,  103,  130,  130,  102,  153,  130,
778       133,  131,  131,  373,  130,  130,  130,  109,  132,  158,
779       131,  131,  374,  104,  130,  130,  130,  108,  108,  108,
780       108,  108,  108,  108,  108,  108,  108,  108,  108,  131,
781       131,  174,  136,  173,  173,  130,  130,  130,  176,  367,
782
783       104,  121,  122,  122,  122,  121,  121,  121,  121,  121,
784       121,  121,  121,  121,  123,  121,  121,  138,  187,  188,
785       113,  121,  121,  121,  121,  131,  131,  130,  130,  130,
786       131,  131,  131,  131,  109,  130,  130,  130,  641,  130,
787       130,  130,  112,  114,  121,  125,  121,  131,  131,  131,
788       131,  131,  131,  140,   93,  130,  130,  130,  130,  130,
789       130,  130,  130,  161,  144,  233,  689,  141,  141,  141,
790       141,  145,  121,  121,  126,  109,  102,  127,  127,  127,
791       127,  128,   88,  208,  168,  209,  162,   80,   79,   79,
792        79,   79,  146,   80,   90,  147,  125,  174,  174,  148,
793
794       173,  173,  173,  129,  458,  145,  458,  130,  130,  131,
795       131,  131,  131,  131,  131,  131,  131,  131,  131,  667,
796       173,  199,  200,  142,  174,  174,  173,  173,  173,  175,
797       129,   93,   93,   94,  460,  180,  337,  140,   80,  535,
798       191,  160,  337,  149,   96,   97,  150,  150,  150,  150,
799       151,   93,   93,   93,  152,  152,  152,  152,  152,  152,
800       152,  152,  144,  152,  144,  144,  152,  152,  152,  144,
801       144,  152,  144,   93,   93,   93,  152,  152,  152,  152,
802       152,  152,  152,  152,  152,  152,  152,  152,  144,  152,
803       152,  152,  152,  152,  144,  144,  144,  144,  144,  144,
804
805       144,   80,  192,  657,  103,   80,  154,  142,  105,  155,
806       155,  155,  155,  156,  174,  174,  103,  145,  173,  173,
807       173,  174,  174,  174,  174,   80,   80,  173,  173,  173,
808       173,  173,  173,  261,  262,  154,  431,  145,  145,  157,
809       157,  157,  157,  157,  157,  157,  157,  157,  157,  157,
810       157,  174,  174,  260,  174,  174,  266,  267,  431,  173,
811       173,  173,  154,   80,  173,  173,  161,  201,  169,  174,
812       174,  170,  170,  170,  170,  171,  174,  174,  173,  173,
813       173,  173,  173,  173,   80,  349,   80,   80,  196,  162,
814       197,  178,  185,  297,  411,  198,  145,  172,  145,  145,
815
816       102,  173,  173,  174,  174,  174,  174,  174,  174,  174,
817       174,  174,  174,  109,   80,   80,  125,  140,   80,  187,
818       298,  663,  177,  263,  172,   80,  145,  145,  182,  432,
819       145,  141,  141,  141,  141,  187,  298,  145,  179,  185,
820        93,   93,   93,   93,  167,  413,  189,  189,  189,  189,
821       190,  433,  204,   80,  205,  689,  412,  276,  616,  206,
822       689,  300,  301,  181,  217,  217,  217,  217,  217,  217,
823       217,  217,  217,  217,  217,  217,  247,  247,  247,  247,
824       217,  217,  217,  217,   80,  303,  304,  142,  107,   80,
825       105,  194,  194,  194,  194,  107,  145,  264,  224,  266,
826
827       267,  145,  272,  272,  272,  272,  225,  414,   80,  217,
828       217,  217,  217,  217,  217,  217,  217,  107,  232,  508,
829       145,  195,  195,  195,  195,  195,  195,  195,  195,  195,
830       195,  195,  195,  247,  247,  247,  247,  247,  247,  247,
831       247,  509,  276,  351,  107,  211,  211,  211,  211,  211,
832       211,  211,  211,  211,  211,  211,  211,  213,  228,  140,
833       102,  230,  341,  251,  214,  277,  272,  272,  272,  272,
834        80,  252,   80,  141,  141,  141,  141,  256,  272,  272,
835       272,  272,  145,  352,  145,  342,  213,  303,  304,  654,
836       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
837
838       215,  215,  321,  272,  272,  272,  272,  342,  273,  546,
839       275,   80,  322,  213,  218,  277,  219,  630,   80,  322,
840       356,  220,  221,  145,  503,  222,  279,   80,  223,  142,
841       145,   80,  272,  272,  272,  272,  218,  274,  219,  145,
842       263,  300,  301,  145,  220,  221,  323,  323,  323,  323,
843       222,  272,  272,  272,  272,  223,  121,  122,  122,  122,
844       121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
845       121,  121,   80,   80,   80,  462,  121,  121,  121,  121,
846       279,  662,   80,  293,  145,  145,  145,  140,  650,  281,
847       288,  288,  288,  288,  145,  214,   80,  102,  295,  121,
848
849       125,  121,  214,   80,  288,  288,  288,  288,  145,   80,
850       280,  288,  288,  288,  288,  145,  324,  324,  324,  324,
851       294,  145,  403,  404,  214,  263,  657,  121,  121,  121,
852       234,  234,  234,  235,  291,  121,  121,  121,  121,  121,
853       121,  689,  443,  121,  121,  292,  670,  378,  689,  121,
854       121,  214,  121,  185,  297,  444,  379,  142,  185,  297,
855       189,  189,  189,  189,  190,  305,  305,  305,  305,  387,
856       689,  429,  121,  125,  325,  325,  325,  325,  326,  326,
857       326,  326,  327,  327,  327,  327,  326,  326,  326,  326,
858       370,  406,  188,  303,  304,  371,  372,  689,  406,  188,
859
860       121,  121,  237,  237,  237,  237,  237,  237,  237,  237,
861       237,  237,  237,  237,   80,  238,  142,   80,  338,  239,
862       349,  655,   80,   80,   80,   80,  240,  430,  241,  145,
863       242,  242,  242,  242,  242,  242,  242,  242,  242,  242,
864       242,  242,  242,  242,  242,  242,  242,  242,  243,  654,
865       351,  125,  244,  244,  244,  244,  244,  244,  244,  244,
866       244,  244,  244,  244,  242,  242,  242,  242,  242,  242,
867       242,  242,  242,  242,  242,  243,  242,  130,  130,  130,
868       130,  130,  130,  130,  130,  130,  130,  130,  130,  246,
869       352,  326,  326,  326,  326,  366,  247,  247,  247,  247,
870
871       403,  404,  248,  102,  249,  249,  249,  249,  249,  249,
872       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
873       249,  249,  249,  339,  326,  326,  326,  326,  356,   80,
874       250,   93,   93,   93,  357,  357,  357,  357,   80,  417,
875        80,  145,  365,  144,   96,  377,  150,  150,  150,  150,
876       145,  562,  145,  418,  152,  152,  152,  152,  152,  152,
877       152,  152,  144,  152,  144,  144,  152,  152,  152,  144,
878       144,  152,  144,  347,  437,  391,  152,  152,  152,  152,
879       152,  152,  152,  152,  152,  152,  152,  152,  144,  152,
880       152,  152,  152,  152,  144,  144,  144,  144,  144,  144,
881
882       144,   80,  651,  214,  647,  125,  311,  311,  311,  311,
883       214,  246,  140,  145,  234,  234,  234,  235,  358,  358,
884       358,  358,  647,  449,  248,   80,  369,  369,  369,  369,
885       475,  476,  214,  380,  380,  380,  380,  145,  642,  268,
886       268,  268,  268,  268,  268,  268,  268,  268,  268,  268,
887       268,  269,  360,  406,  188,  689,  316,  125,  270,  214,
888        80,   80,  689,  689,  689,  689,  320,   80,  689,   80,
889       450,   80,  145,  145,  390,  381,  381,  381,  381,  145,
890       269,  145,  142,  145,  271,  271,  271,  271,  271,  271,
891       271,  271,  271,  271,  271,  271,  689,  409,  409,  409,
892
893       409,  504,  389,  420,  420,  420,  420,  269,  282,  282,
894       282,  282,  282,  282,  282,  282,  282,  282,  282,  282,
895        80,  238,  641,   80,  504,  283,  475,  476,  144,  144,
896       144,  144,  284,  640,  241,  145,  285,  285,  285,  285,
897       285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
898       285,  285,  285,  285,  286,  438,  438,  438,  287,  287,
899       287,  287,  287,  287,  287,  287,  287,  287,  287,  287,
900       285,  285,  285,  285,  285,  285,  285,  285,  285,  285,
901       285,  286,  285,  173,  173,  173,  173,  173,  173,  173,
902       173,  173,  173,  173,  173,   80,  246,  689,  439,  437,
903
904       144,  406,  188,  288,  288,  288,  288,  145,  640,  248,
905       689,  289,  289,  289,  289,  289,  289,  289,  289,  289,
906       289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
907       514,  449,  102,  144,  144,  144,  144,  290,  144,  144,
908       144,  144,  144,  144,  144,  144,  144,  144,  144,  144,
909       144,  144,  144,  144,  144,  144,  144,  144,  215,  215,
910       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
911       328,  357,  357,  357,  357,   80,  459,  329,  448,  330,
912        80,   80,   80,  381,  381,  381,  381,  145,  381,  381,
913       381,  381,  145,  145,  145,  442,  442,  442,  442,  328,
914
915       475,  476,  500,  331,  331,  331,  331,  331,  331,  331,
916       331,  331,  331,  331,  331,  385,  500,  500,  185,  478,
917       386,  385,  386,  479,  406,  188,  328,  121,  234,  234,
918       234,  235,  556,  121,  121,  121,  121,  121,  121,  341,
919        80,  121,  121,   80,   80,  365,  557,  121,  121,   80,
920       121,   80,  145,   80,  637,  145,  145,  381,  381,  381,
921       381,  145,  388,  145,   80,  145,  356,  330,  140,  361,
922       121,  125,  395,  395,  395,  395,  145,  102,   80,  400,
923        80,   80,  362,  399,  388,  636,  140,  366,  263,  392,
924       145,  102,  145,  145,  185,  297,  689,  472,  121,  121,
925
926       246,  408,  408,  408,  408,  102,  393,  689,  393,  689,
927       447,  475,  476,  248,  689,  249,  249,  249,  249,  249,
928       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
929       249,  249,  249,  249,  398,  102,  689,  689,  142,  527,
930       601,  250,  354,  354,  354,  354,  354,  354,  354,  354,
931       354,  354,  354,  354,  361,  204,  142,  205,  634,  329,
932       633,  526,  206,  689,  475,  476,  329,  362,  330,  363,
933       363,  363,  363,  363,  363,  363,  363,  363,  363,  363,
934       363,  363,  363,  363,  363,  363,  363,  363,  329,  415,
935       415,  361,  329,  322,  628,  364,   80,   80,  585,  329,
936
937       322,  689,   80,  443,  689,   80,   80,   80,  145,  145,
938        80,   80,   80,   80,   88,  329,  444,  145,  145,  419,
939       443,  329,  102,  102,  453,  627,   90,  480,  480,  480,
940       480,   92,  689,  689,  271,  271,  271,  271,  271,  271,
941       271,  271,  271,  271,  271,  271,  382,  454,  329,  263,
942        80,  416,  416,  383,  463,  330,  429,  455,   80,   97,
943       493,   80,  145,  495,   99,   80,  461,  461,  461,  461,
944       145,  626,  494,  145,  563,  382,  496,  145,  629,  384,
945       384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
946       384,  140,  468,  506,  263,  102,  584,   80,   80,   80,
947
948       689,  448,  382,   80,  246,  452,  452,  452,  452,  145,
949       145,  145,  464,  689,  102,  145,  610,  248,  506,  289,
950       289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
951       289,  289,  289,  289,  289,  289,  289,  289,  610,  625,
952       469,  467,  525,  376,  525,  290,  394,  394,  394,  394,
953       394,  394,  394,  394,  394,  394,  394,  394,  361,  535,
954        80,  142,  518,  525,  376,  525,  602,  622,  536,  102,
955       644,  362,  145,  396,  396,  396,  396,  396,  396,  396,
956       396,  396,  396,  396,  396,  396,  396,  396,  396,  396,
957       396,  396,  438,  438,  438,  210,  210,  102,  621,  397,
958
959       331,  331,  331,  331,  331,  331,  331,  331,  331,  331,
960       331,  331,  384,  384,  384,  384,  384,  384,  384,  384,
961       384,  384,  384,  384,   80,  102,  212,  212,  591,   80,
962       505,  515,  515,  515,  614,  439,  145,  395,  395,  395,
963       395,  145,  592,   80,  443,  643,  140,  465,  144,   80,
964        80,  144,  144,  144,  144,  145,  449,  444,  520,  506,
965       109,  145,  145,   80,  613,   80,  429,   80,  507,  466,
966        80,   80,  495,  109,  516,  145,  529,  145,   80,  145,
967       668,  140,  145,  145,  506,  689,   80,  530,  543,   80,
968       145,  610,  534,  500,   80,  102,  611,   80,  145,  529,
969
970       102,  145,   80,  471,  495,  531,  145,  500,  500,  145,
971       515,  515,  515,  610,  145,  609,  521,  496,  612,  497,
972       497,  497,  497,  497,  497,  497,  497,  497,  497,  497,
973       497,  497,  497,  497,  497,  497,  497,  497,   80,  495,
974       532,  216,  216,  567,  533,  245,  245,  615,  592,  658,
975       145,  142,  496,  516,  528,  528,  528,  528,  528,  528,
976       528,  528,  528,  528,  528,  528,  528,  528,  528,  528,
977       528,  528,  528,  185,  297,  140,   80,  608,  617,  535,
978       539,  539,  539,  539,   80,   80,   80,   80,  145,  559,
979       559,  559,  559,  140,   80,  600,  145,  145,  145,  145,
980
981       185,  478,  140,  599,  569,  610,  145,  539,  539,  539,
982       539,   80,   80,  618,  177,  564,  559,  559,  559,  559,
983       140,   80,   80,  145,  145,  568,  376,  610,  566,  140,
984       623,  588,  376,  145,  145,  619,  610,  140,  140,  610,
985       607,  565,  567,  586,  638,  142,  140,  610,  620,  635,
986       586,  610,  624,  649,  632,  140,  610,  648,  610,  140,
987       632,  610,  598,  142,  606,  376,  661,  650,  587,  610,
988       666,  652,  521,  610,  102,  639,  632,  672,  610,  672,
989       102,  594,  632,  355,  355,  594,  652,  645,  610,  376,
990       142,  595,  595,  632,  595,  595,  595,  595,  595,  142,
991
992       595,  595,  595,  595,  376,  595,  595,  142,  142,  646,
993       610,  595,  595,  595,  595,  632,  142,  632,  672,  593,
994       140,  597,  659,  575,  590,  142,  664,  376,  643,  142,
995       376,  669,  632,  376,  595,  595,  595,  542,  589,  632,
996       672,  672,  583,  597,  582,  672,  581,  255,  672,  255,
997       557,  673,  674,  665,  632,  632,  675,  580,  632,  676,
998       660,  632,  595,  595,  595,  595,  580,  595,  595,  595,
999       595,  595,  596,  595,  595,  595,  595,  632,  595,  595,
1000       632,  665,  579,  632,  604,  595,  595,  595,  687,  578,
1001       142,  672,  672,  672,  605,  672,  577,  576,  549,  549,
1002
1003       575,  672,  677,  678,  679,  574,  680,  595,  595,  595,
1004       255,  255,  681,  672,  672,  255,  605,  672,  255,  573,
1005       672,  672,  572,  571,  682,  683,  543,  538,  684,  570,
1006       376,  685,  686,  561,  560,  595,  595,  595,  595,  257,
1007       595,  595,  595,  595,  595,  448,  595,  595,  595,  595,
1008       518,  595,  595,  558,  555,  554,  553,  595,  595,  595,
1009       595,  255,  255,  255,  552,  255,  551,  597,  550,  549,
1010       134,  255,  547,  545,  544,  543,  542,  541,  492,  492,
1011       595,  595,  595,  255,  255,  490,  490,  255,  488,  597,
1012       255,  255,  488,  486,  486,  484,  484,  482,  482,  538,
1013
1014       523,  522,  208,  201,  365,  519,  448,  518,  595,  595,
1015       595,  595,  441,  595,  595,  595,  595,  595,  596,  595,
1016       595,  595,  595,  109,  595,  595,  513,  512,  511,  510,
1017       604,  595,  595,  595,  429,  109,  503,  502,  501,  499,
1018       605,  498,  418,  492,  490,  488,  486,  484,  482,  419,
1019       297,  473,  260,  595,  595,  595,  376,  457,  456,   84,
1020       202,  451,  605,  448,  365,  356,  441,  436,  435,  434,
1021       202,  428,  427,  426,  425,  424,  423,  422,  421,  330,
1022       419,  595,  595,   80,  330,  208,  208,   80,   80,  202,
1023       201,   80,   80,   80,   80,   80,   80,   80,   80,   81,
1024
1025        81,   81,   81,   81,  201,   81,   81,   81,   81,   81,
1026        81,   81,   81,   81,   81,   81,   81,   81,   87,   87,
1027       201,  309,  309,   87,   87,   87,  101,  101,  101,  101,
1028       101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
1029       101,  101,  101,  101,  101,  124,  124,  124,  124,  124,
1030       124,  124,  124,  124,  124,  124,  124,  124,  124,  124,
1031       124,  124,  124,  124,  139,  139,  139,  139,  139,  139,
1032       139,  139,  139,  139,  139,  139,  139,  139,  139,  139,
1033       139,  139,  139,  144,  307,  307,  401,  144,  144,  144,
1034       356,  144,  144,  144,  144,  144,  144,  144,  144,  184,
1035
1036       184,  184,  184,  184,  260,  184,  184,  184,  184,  184,
1037       184,  184,  184,  184,  184,  184,  184,  184,  186,  186,
1038       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
1039       186,  186,  186,  186,  186,  186,  186,  203,  203,  260,
1040       259,  376,  259,  347,  368,  339,  338,  203,  365,  246,
1041       203,  203,  356,  203,  121,  121,  121,  121,  121,  121,
1042       121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
1043       121,  121,  121,  236,  236,  236,  236,  236,  236,  236,
1044       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
1045       236,  236,  140,  140,  140,  140,  140,  140,  140,  140,
1046
1047       140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
1048       140,  258,  258,  258,  258,  258,  258,  258,  258,  258,
1049       258,  258,  258,  258,  258,  258,  258,  258,  258,  258,
1050       265,  265,  265,  265,  265,  265,  265,  265,  265,  265,
1051       265,  265,  265,  265,  265,  265,  265,  265,  265,  184,
1052       184,  184,  184,  184,  184,  184,  184,  184,  184,  184,
1053       184,  184,  184,  184,  184,  184,  184,  184,  186,  186,
1054       186,  186,  186,  186,  186,  186,  186,  186,  186,  186,
1055       186,  186,  186,  186,  186,  186,  186,  299,  299,  299,
1056       299,  299,  299,  299,  299,  299,  299,  299,  299,  299,
1057
1058       299,  299,  299,  299,  299,  299,  302,  302,  302,  302,
1059       302,  302,  302,  302,  302,  302,  302,  302,  302,  302,
1060       302,  302,  302,  302,  302,  306,  306,  356,  306,  306,
1061       306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
1062       306,  306,  306,  306,  308,  308,  238,  308,  308,  308,
1063       308,  308,  308,  308,  308,  308,  308,  308,  308,  308,
1064       308,  308,  308,  310,  346,  310,  345,  344,  343,  310,
1065       310,  310,  340,  336,  310,  348,  348,  348,  348,  348,
1066       348,  348,  348,  348,  348,  348,  348,  348,  348,  348,
1067       348,  348,  348,  348,  121,  121,  121,  121,  121,  121,
1068
1069       121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
1070       121,  121,  121,  350,  350,  350,  350,  350,  350,  350,
1071       350,  350,  350,  350,  350,  350,  350,  350,  350,  350,
1072       350,  350,  236,  236,  236,  236,  236,  236,  236,  236,
1073       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
1074       236,  353,  353,  353,  353,  353,  353,  353,  353,  359,
1075       335,  334,  333,  359,  332,  359,  359,  359,  359,  320,
1076       359,  258,  258,  258,  258,  258,  258,  258,  258,  258,
1077       258,  258,  258,  258,  258,  258,  258,  258,  258,  258,
1078       375,  375,  375,  375,  375,  375,  375,  375,  375,  375,
1079
1080       375,  375,  375,  375,  375,  375,  375,  375,  375,  265,
1081       265,  265,  265,  265,  265,  265,  265,  265,  265,  265,
1082       265,  265,  265,  265,  265,  265,  265,  265,  101,  101,
1083       101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
1084       101,  101,  101,  101,  101,  101,  101,  302,  302,  302,
1085       302,  302,  302,  302,  302,  302,  302,  302,  302,  302,
1086       302,  302,  302,  302,  302,  302,  299,  299,  299,  299,
1087       299,  299,  299,  299,  299,  299,  299,  299,  299,  299,
1088       299,  299,  299,  299,  299,  402,  402,  402,  402,  402,
1089       402,  402,  402,  402,  402,  402,  402,  402,  402,  402,
1090
1091       402,  402,  402,  402,  405,  405,  405,  405,  405,  405,
1092       405,  405,  405,  405,  405,  405,  405,  405,  405,  405,
1093       405,  405,  405,  407,  407,  407,  407,  407,  407,  407,
1094       407,  407,  407,  407,  407,  407,  407,  407,  407,  407,
1095       407,  407,  184,  184,  184,  184,  184,  184,  184,  184,
1096       184,  184,  184,  184,  184,  184,  184,  184,  184,  184,
1097       184,  306,  306,  320,  306,  306,  306,  306,  306,  306,
1098       306,  306,  306,  306,  306,  306,  306,  306,  306,  306,
1099       308,  308,  319,  308,  308,  308,  308,  308,  308,  308,
1100       308,  308,  308,  308,  308,  308,  308,  308,  308,  410,
1101
1102       318,  410,  410,  317,  316,  410,  410,  410,  316,  315,
1103       410,  348,  348,  348,  348,  348,  348,  348,  348,  348,
1104       348,  348,  348,  348,  348,  348,  348,  348,  348,  348,
1105       350,  350,  350,  350,  350,  350,  350,  350,  350,  350,
1106       350,  350,  350,  350,  350,  350,  350,  350,  350,  121,
1107       121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
1108       121,  121,  121,  121,  121,  121,  121,  121,  440,  440,
1109       440,  440,  440,  440,  440,  440,  440,  440,  440,  440,
1110       440,  440,  440,  440,  440,  440,  440,  445,  445,  314,
1111       313,  445,  445,  312,  445,  445,  445,  445,  445,  445,
1112
1113       445,  445,  445,  446,  309,  307,  296,  260,  278,  446,
1114       446,  446,  446,  260,  446,  375,  375,  375,  375,  375,
1115       375,  375,  375,  375,  375,  375,  375,  375,  375,  375,
1116       375,  375,  375,  375,  101,  101,  101,  101,  101,  101,
1117       101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
1118       101,  101,  101,  470,  470,  260,  259,  470,  470,  470,
1119       470,  470,  470,  470,  470,  470,  470,  470,  470,  403,
1120       403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
1121       403,  403,  403,  403,  403,  403,  403,  403,  474,  474,
1122       474,  474,  474,  474,  474,  474,  474,  474,  474,  474,
1123
1124       474,  474,  474,  474,  474,  474,  474,  477,  477,  477,
1125       477,  477,  477,  477,  477,  477,  477,  477,  477,  477,
1126       477,  477,  477,  477,  477,  477,  481,  481,  257,  481,
1127       481,  481,  481,  481,  481,  481,  481,  481,  481,  481,
1128       481,  481,  481,  481,  481,  483,  483,  255,  483,  483,
1129       483,  483,  483,  483,  483,  483,  483,  483,  483,  483,
1130       483,  483,  483,  483,  485,  485,  254,  485,  485,  485,
1131       485,  485,  485,  485,  485,  485,  485,  485,  485,  485,
1132       485,  485,  485,  487,  487,  230,  487,  487,  487,  487,
1133       487,  487,  487,  487,  487,  487,  487,  487,  487,  487,
1134
1135       487,  487,  489,  489,  202,  489,  489,  489,  489,  489,
1136       489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
1137       489,  491,  491,  253,  491,  491,  491,  491,  491,  491,
1138       491,  491,  491,  491,  491,  491,  491,  491,  491,  491,
1139       348,  348,  348,  348,  348,  348,  348,  348,  348,  348,
1140       348,  348,  348,  348,  348,  348,  348,  348,  348,  121,
1141       121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
1142       121,  121,  121,  121,  121,  121,  121,  121,  440,  440,
1143       440,  440,  440,  440,  440,  440,  440,  440,  440,  440,
1144       440,  440,  440,  440,  440,  440,  440,  517,  228,  125,
1145
1146       231,  202,  229,  517,  517,  517,  517,  517,  517,  517,
1147       517,  517,  524,  524,  524,  524,  524,  524,  524,  524,
1148       524,  524,  524,  524,  524,  524,  524,  524,  524,  524,
1149       524,  537,  537,  537,  537,  227,  537,  537,  537,  537,
1150       537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
1151       540,  227,  226,  102,  208,  207,  540,  540,  540,  540,
1152       548,  548,  201,  548,  548,  548,  548,  548,  548,  548,
1153       548,  548,  548,  548,  548,  548,  548,  548,  548,  596,
1154       596,  202,  596,  596,  596,  596,  596,  596,  596,  596,
1155       596,  596,  596,  596,  596,  596,  596,  596,  603,  603,
1156
1157       201,  603,  603,  603,  603,  603,  603,  603,  603,  603,
1158       603,  603,  603,  603,  603,  603,  603,  595,  595,  193,
1159       595,  595,  595,  595,  595,  595,  595,  595,  595,  595,
1160       595,  595,  595,  595,  595,  595,  631,  631,  631,  631,
1161       631,  631,  631,  631,  631,  631,  631,  631,  631,  631,
1162       631,  631,  631,  631,  631,  653,  653,  653,  653,  653,
1163       653,  653,  653,  653,  653,  653,  653,  653,  653,  653,
1164       653,  653,  653,  653,  656,  656,  656,  656,  656,  656,
1165       656,  656,  656,  656,  656,  656,  656,  656,  656,  656,
1166       656,  656,  656,  671,  671,  671,  671,  671,  671,  671,
1167
1168       671,  671,  671,  671,  671,  671,  671,  671,  671,  671,
1169       671,  671,  185,  183,  167,  166,  163,  160,  159,  143,
1170       119,  137,  134,  119,  118,  115,  112,  111,  102,   84,
1171       689,    3,  689,  689,  689,  689,  689,  689,  689,  689,
1172       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1173       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1174       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1175       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1176       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1177       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1178
1179       689,  689,  689,  689,  689
1180     } ;
1181
1182 static yyconst flex_int16_t yy_chk[3906] =
1183     {   0,
1184         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1185         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1186         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1187         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1188         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1189         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1190         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1191         1,    1,    1,    2,    2,    2,    2,    2,    2,    2,
1192         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1193         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1194
1195         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1196         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1197         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1198         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1199         2,    2,    2,    2,    2,    2,    5,    6,    6,    6,
1200         6,    8,   10,   10,   11,   19,   21,   45,    8,    8,
1201         8,    8,   16,  151,   11,   13,   11,   11,    5,   45,
1202        56,   11,   12,   12,   12,   13,  151,   13,   19,   12,
1203        21,   97,   13,   97,   12,   12,   12,   12,   12,   12,
1204        12,   12,  687,   24,   56,   12,   12,   12,   12,   12,
1205
1206        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
1207        12,   12,   12,   12,   27,   51,   16,   12,   12,   12,
1208        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
1209        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
1210        12,   12,   15,   24,   15,   39,   15,   15,   15,   15,
1211        15,   15,  250,   28,   15,   28,   28,   49,   49,   27,
1212        28,   30,   30,  259,   30,   30,   30,   42,   27,   51,
1213        31,   31,  259,   15,   31,   31,   31,   15,   15,   15,
1214        15,   15,   15,   15,   15,   15,   15,   15,   15,   33,
1215        33,   62,   39,   62,   62,   33,   33,   33,   62,  250,
1216
1217        15,   25,   25,   25,   25,   25,   25,   25,   25,   25,
1218        25,   25,   25,   25,   25,   25,   25,   42,   82,   82,
1219        32,   25,   25,   25,   25,   29,   29,   29,   29,   29,
1220        32,   32,   34,   34,   59,   32,   32,   32,  667,   34,
1221        34,   34,   29,   32,   25,   25,   25,   35,   35,   36,
1222        36,   37,   37,   43,   48,   35,   35,   35,   36,   36,
1223        36,   37,   37,   54,   48,  123,   48,   43,   43,   43,
1224        43,   48,   25,   25,   26,   61,  379,   26,   26,   26,
1225        26,   26,   46,  318,   59,  318,   54,   46,   79,   79,
1226        79,   79,   46,   74,   46,   46,  123,   64,   64,   46,
1227
1228        64,   64,   64,   26,  376,   74,  376,   26,   26,   26,
1229        26,   26,   26,   26,   26,   26,   26,   26,   26,  663,
1230        61,   89,   89,   43,   63,   63,   63,   63,   63,   61,
1231        26,   47,   47,   47,  379,   74,  223,  139,   47,  662,
1232        84,   63,  223,   47,   47,   47,   47,   47,   47,   47,
1233        47,   93,   93,   93,   47,   47,   47,   47,   47,   47,
1234        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
1235        47,   47,   47,   96,   96,   96,   47,   47,   47,   47,
1236        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
1237        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
1238
1239        47,   50,   84,  656,   50,  144,   50,  139,   50,   50,
1240        50,   50,   50,   50,   65,   65,   50,  144,   65,   65,
1241        65,   67,   67,   68,   68,  146,  152,   67,   67,   67,
1242        68,   68,   68,  146,  146,   50,  341,  146,  152,   50,
1243        50,   50,   50,   50,   50,   50,   50,   50,   50,   50,
1244        50,   69,   69,  148,   71,   71,  153,  153,  341,   69,
1245        69,   69,   50,   60,   71,   71,   66,  148,   60,   70,
1246        70,   60,   60,   60,   60,   60,   66,   66,   70,   70,
1247        70,   66,   66,   66,   72,  233,   73,   75,   88,   66,
1248        88,   73,  184,  184,  316,   88,   72,   60,   73,   75,
1249
1250       602,   60,   60,   60,   60,   60,   60,   60,   60,   60,
1251        60,   60,   60,   76,  263,  147,  233,   77,   76,  185,
1252       185,  655,   72,  147,   60,  161,  263,  147,   77,  342,
1253        76,   77,   77,   77,   77,  186,  186,  161,   73,   83,
1254        94,   94,   94,   98,   75,  320,   83,   83,   83,   83,
1255        83,  342,   94,   98,   94,   98,  316,  161,  602,   94,
1256        98,  187,  187,   76,  108,  108,  108,  108,  110,  110,
1257       110,  110,  111,  111,  111,  111,  131,  131,  131,  131,
1258       120,  120,  120,  120,  162,  188,  188,   77,   87,  149,
1259        87,   87,   87,   87,   87,   87,  162,  149,  110,  265,
1260
1261       265,  149,  157,  157,  157,  157,  111,  320,  177,  115,
1262       115,  115,  115,  118,  118,  118,  118,   87,  120,  431,
1263       177,   87,   87,   87,   87,   87,   87,   87,   87,   87,
1264        87,   87,   87,  132,  132,  132,  132,  133,  133,  133,
1265       133,  431,  162,  235,   87,  104,  104,  104,  104,  104,
1266       104,  104,  104,  104,  104,  104,  104,  106,  115,  141,
1267       616,  118,  227,  132,  106,  177,  163,  163,  163,  163,
1268       180,  133,  160,  141,  141,  141,  141,  141,  158,  158,
1269       158,  158,  180,  235,  160,  227,  106,  298,  298,  653,
1270       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
1271
1272       106,  106,  209,  159,  159,  159,  159,  227,  158,  501,
1273       160,  165,  209,  106,  109,  163,  109,  616,  285,  209,
1274       285,  109,  109,  165,  501,  109,  180,  385,  109,  141,
1275       285,  178,  166,  166,  166,  166,  109,  159,  109,  385,
1276       165,  299,  299,  178,  109,  109,  210,  210,  210,  210,
1277       109,  168,  168,  168,  168,  109,  122,  122,  122,  122,
1278       122,  122,  122,  122,  122,  122,  122,  122,  122,  122,
1279       122,  122,  167,  179,  181,  385,  122,  122,  122,  122,
1280       166,  651,  174,  178,  167,  179,  181,  182,  649,  168,
1281       174,  174,  174,  174,  174,  194,  175,  267,  182,  122,
1282
1283       122,  122,  194,  176,  175,  175,  175,  175,  175,  275,
1284       167,  176,  176,  176,  176,  176,  211,  211,  211,  211,
1285       181,  275,  300,  300,  194,  179,  643,  122,  122,  124,
1286       124,  124,  124,  124,  175,  124,  124,  124,  124,  124,
1287       124,  214,  442,  124,  124,  176,  669,  267,  214,  124,
1288       124,  194,  124,  189,  189,  442,  267,  182,  190,  190,
1289       189,  189,  189,  189,  189,  190,  190,  190,  190,  275,
1290       214,  340,  124,  124,  212,  212,  212,  212,  215,  215,
1291       215,  215,  216,  216,  216,  216,  224,  224,  224,  224,
1292       257,  301,  301,  302,  302,  257,  257,  214,  303,  303,
1293
1294       124,  124,  126,  126,  126,  126,  126,  126,  126,  126,
1295       126,  126,  126,  126,  127,  127,  669,  389,  224,  127,
1296       348,  642,  127,  127,  127,  127,  127,  340,  127,  389,
1297       127,  127,  127,  127,  127,  127,  127,  127,  127,  127,
1298       127,  127,  127,  127,  127,  127,  127,  127,  127,  641,
1299       350,  348,  127,  127,  127,  127,  127,  127,  127,  127,
1300       127,  127,  127,  127,  127,  127,  127,  127,  127,  127,
1301       127,  127,  127,  127,  127,  127,  127,  129,  129,  129,
1302       129,  129,  129,  129,  129,  129,  129,  129,  129,  130,
1303       350,  225,  225,  225,  225,  360,  130,  130,  130,  130,
1304
1305       402,  402,  130,  526,  130,  130,  130,  130,  130,  130,
1306       130,  130,  130,  130,  130,  130,  130,  130,  130,  130,
1307       130,  130,  130,  225,  232,  232,  232,  232,  244,  279,
1308       130,  150,  150,  150,  244,  244,  244,  244,  150,  322,
1309       261,  279,  360,  150,  150,  261,  150,  150,  150,  150,
1310       150,  526,  261,  322,  150,  150,  150,  150,  150,  150,
1311       150,  150,  150,  150,  150,  150,  150,  150,  150,  150,
1312       150,  150,  150,  232,  349,  279,  150,  150,  150,  150,
1313       150,  150,  150,  150,  150,  150,  150,  150,  150,  150,
1314       150,  150,  150,  150,  150,  150,  150,  150,  150,  150,
1315
1316       150,  154,  637,  195,  634,  349,  195,  195,  195,  195,
1317       195,  245,  256,  154,  234,  234,  234,  234,  245,  245,
1318       245,  245,  633,  364,  245,  268,  256,  256,  256,  256,
1319       404,  404,  195,  268,  268,  268,  268,  268,  628,  154,
1320       154,  154,  154,  154,  154,  154,  154,  154,  154,  154,
1321       154,  155,  245,  405,  405,  246,  262,  234,  155,  195,
1322       277,  262,  246,  246,  246,  246,  264,  271,  246,  278,
1323       364,  264,  277,  262,  278,  271,  271,  271,  271,  271,
1324       155,  278,  256,  264,  155,  155,  155,  155,  155,  155,
1325       155,  155,  155,  155,  155,  155,  246,  310,  310,  310,
1326
1327       310,  428,  277,  331,  331,  331,  331,  155,  169,  169,
1328       169,  169,  169,  169,  169,  169,  169,  169,  169,  169,
1329       170,  170,  627,  398,  428,  170,  406,  406,  170,  170,
1330       170,  170,  170,  626,  170,  398,  170,  170,  170,  170,
1331       170,  170,  170,  170,  170,  170,  170,  170,  170,  170,
1332       170,  170,  170,  170,  170,  351,  351,  351,  170,  170,
1333       170,  170,  170,  170,  170,  170,  170,  170,  170,  170,
1334       170,  170,  170,  170,  170,  170,  170,  170,  170,  170,
1335       170,  170,  170,  172,  172,  172,  172,  172,  172,  172,
1336       172,  172,  172,  172,  172,  173,  173,  443,  351,  437,
1337
1338       173,  407,  407,  173,  173,  173,  173,  173,  625,  173,
1339       443,  173,  173,  173,  173,  173,  173,  173,  173,  173,
1340       173,  173,  173,  173,  173,  173,  173,  173,  173,  173,
1341       437,  447,  378,  173,  173,  173,  173,  173,  173,  173,
1342       173,  173,  173,  173,  173,  173,  173,  173,  173,  173,
1343       173,  173,  173,  173,  173,  173,  173,  173,  213,  213,
1344       213,  213,  213,  213,  213,  213,  213,  213,  213,  213,
1345       217,  354,  354,  354,  354,  273,  378,  217,  447,  217,
1346       274,  291,  292,  273,  273,  273,  273,  273,  274,  274,
1347       274,  274,  274,  291,  292,  355,  355,  355,  355,  217,
1348
1349       474,  474,  423,  217,  217,  217,  217,  217,  217,  217,
1350       217,  217,  217,  217,  217,  273,  423,  423,  408,  408,
1351       274,  291,  292,  408,  476,  476,  217,  236,  236,  236,
1352       236,  236,  512,  236,  236,  236,  236,  236,  236,  276,
1353       280,  236,  236,  289,  276,  289,  512,  236,  236,  281,
1354       236,  294,  280,  380,  622,  289,  276,  281,  281,  281,
1355       281,  281,  276,  294,  287,  380,  287,  380,  295,  358,
1356       236,  236,  287,  287,  287,  287,  287,  460,  293,  295,
1357       377,  290,  358,  293,  276,  621,  400,  290,  377,  280,
1358       293,  584,  377,  290,  305,  305,  361,  400,  236,  236,
1359
1360       237,  305,  305,  305,  305,  459,  281,  329,  294,  361,
1361       358,  477,  477,  237,  329,  237,  237,  237,  237,  237,
1362       237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
1363       237,  237,  237,  237,  290,  563,  329,  361,  295,  460,
1364       584,  237,  239,  239,  239,  239,  239,  239,  239,  239,
1365       239,  239,  239,  239,  247,  454,  400,  454,  619,  311,
1366       618,  459,  454,  329,  538,  538,  311,  247,  311,  247,
1367       247,  247,  247,  247,  247,  247,  247,  247,  247,  247,
1368       247,  247,  247,  247,  247,  247,  247,  247,  311,  321,
1369       572,  362,  325,  321,  614,  247,  269,  399,  563,  325,
1370
1371       321,  325,  357,  357,  362,  381,  386,  357,  269,  399,
1372       357,  357,  357,  357,  371,  311,  357,  381,  386,  381,
1373       444,  325,  527,  615,  371,  613,  371,  410,  410,  410,
1374       410,  371,  362,  444,  269,  269,  269,  269,  269,  269,
1375       269,  269,  269,  269,  269,  269,  272,  372,  325,  399,
1376       392,  321,  572,  272,  386,  272,  387,  372,  384,  372,
1377       418,  387,  392,  480,  372,  390,  384,  384,  384,  384,
1378       384,  612,  418,  387,  527,  272,  480,  390,  615,  272,
1379       272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
1380       272,  369,  392,  577,  390,  562,  562,  391,  393,  396,
1381
1382       495,  396,  272,  282,  282,  369,  369,  369,  369,  391,
1383       393,  396,  387,  495,  585,  282,  594,  282,  577,  282,
1384       282,  282,  282,  282,  282,  282,  282,  282,  282,  282,
1385       282,  282,  282,  282,  282,  282,  282,  282,  594,  611,
1386       393,  391,  458,  458,  458,  282,  283,  283,  283,  283,
1387       283,  283,  283,  283,  283,  283,  283,  283,  288,  473,
1388       470,  369,  470,  525,  525,  525,  585,  609,  473,  630,
1389       630,  288,  470,  288,  288,  288,  288,  288,  288,  288,
1390       288,  288,  288,  288,  288,  288,  288,  288,  288,  288,
1391       288,  288,  438,  438,  438,  700,  700,  629,  608,  288,
1392
1393       328,  328,  328,  328,  328,  328,  328,  328,  328,  328,
1394       328,  328,  382,  382,  382,  382,  382,  382,  382,  382,
1395       382,  382,  382,  382,  388,  664,  701,  701,  575,  394,
1396       429,  441,  441,  441,  600,  438,  388,  394,  394,  394,
1397       394,  394,  575,  395,  395,  629,  452,  388,  395,  463,
1398       397,  395,  395,  395,  395,  395,  397,  395,  452,  429,
1399       462,  463,  397,  466,  599,  462,  464,  465,  429,  388,
1400       471,  464,  496,  469,  441,  466,  463,  462,  469,  465,
1401       664,  472,  471,  464,  429,  496,  528,  465,  528,  467,
1402       469,  595,  472,  500,  468,  601,  597,  567,  528,  463,
1403
1404       644,  467,  566,  397,  420,  466,  468,  500,  500,  567,
1405       515,  515,  515,  595,  566,  593,  452,  420,  597,  420,
1406       420,  420,  420,  420,  420,  420,  420,  420,  420,  420,
1407       420,  420,  420,  420,  420,  420,  420,  420,  461,  461,
1408       467,  702,  702,  566,  468,  705,  705,  601,  591,  644,
1409       461,  472,  461,  515,  461,  461,  461,  461,  461,  461,
1410       461,  461,  461,  461,  461,  461,  461,  461,  461,  461,
1411       461,  461,  461,  479,  479,  520,  529,  590,  604,  589,
1412       479,  479,  479,  479,  530,  531,  532,  533,  529,  520,
1413       520,  520,  520,  534,  565,  583,  530,  531,  532,  533,
1414
1415       539,  539,  559,  582,  534,  604,  565,  539,  539,  539,
1416       539,  568,  564,  605,  529,  530,  559,  559,  559,  559,
1417       569,  606,  587,  568,  564,  533,  617,  604,  532,  588,
1418       610,  569,  631,  606,  587,  605,  610,  607,  620,  623,
1419       588,  531,  532,  564,  623,  520,  635,  624,  607,  620,
1420       565,  639,  610,  636,  617,  648,  652,  635,  610,  661,
1421       631,  623,  581,  534,  587,  632,  648,  636,  568,  624,
1422       661,  639,  559,  639,  658,  624,  617,  670,  652,  671,
1423       668,  579,  631,  721,  721,  578,  638,  632,  638,  645,
1424       569,  580,  580,  632,  580,  580,  580,  580,  580,  588,
1425
1426       580,  580,  580,  580,  646,  580,  580,  607,  620,  632,
1427       638,  580,  580,  580,  580,  632,  635,  645,  686,  576,
1428       666,  580,  645,  574,  573,  648,  658,  659,  668,  661,
1429       665,  666,  646,  660,  580,  580,  580,  571,  570,  645,
1430       672,  673,  561,  580,  560,  674,  558,  670,  675,  671,
1431       556,  672,  673,  659,  646,  659,  674,  555,  665,  675,
1432       646,  660,  580,  580,  586,  586,  554,  586,  586,  586,
1433       586,  586,  586,  586,  586,  586,  586,  659,  586,  586,
1434       665,  660,  553,  660,  586,  586,  586,  586,  686,  552,
1435       666,  676,  677,  678,  586,  679,  551,  550,  549,  548,
1436
1437       547,  680,  676,  677,  678,  545,  679,  586,  586,  586,
1438       672,  673,  680,  681,  682,  674,  586,  683,  675,  544,
1439       684,  685,  542,  541,  681,  682,  540,  537,  683,  536,
1440       524,  684,  685,  523,  522,  586,  586,  596,  596,  521,
1441       596,  596,  596,  596,  596,  519,  596,  596,  596,  596,
1442       517,  596,  596,  513,  511,  510,  509,  596,  596,  596,
1443       596,  676,  677,  678,  508,  679,  507,  596,  506,  505,
1444       504,  680,  502,  499,  498,  497,  494,  493,  492,  491,
1445       596,  596,  596,  681,  682,  490,  489,  683,  488,  596,
1446       684,  685,  487,  486,  485,  484,  483,  482,  481,  475,
1447
1448       457,  456,  455,  453,  451,  449,  446,  445,  596,  596,
1449       603,  603,  440,  603,  603,  603,  603,  603,  603,  603,
1450       603,  603,  603,  436,  603,  603,  435,  434,  433,  432,
1451       603,  603,  603,  603,  430,  427,  426,  425,  424,  422,
1452       603,  421,  417,  416,  415,  414,  413,  412,  411,  409,
1453       403,  401,  383,  603,  603,  603,  375,  374,  373,  370,
1454       368,  366,  603,  363,  359,  353,  352,  347,  346,  345,
1455       344,  339,  338,  337,  336,  335,  334,  333,  332,  327,
1456       326,  603,  603,  690,  324,  319,  317,  690,  690,  315,
1457       314,  690,  690,  690,  690,  690,  690,  690,  690,  691,
1458
1459       691,  691,  691,  691,  313,  691,  691,  691,  691,  691,
1460       691,  691,  691,  691,  691,  691,  691,  691,  692,  692,
1461       312,  309,  308,  692,  692,  692,  693,  693,  693,  693,
1462       693,  693,  693,  693,  693,  693,  693,  693,  693,  693,
1463       693,  693,  693,  693,  693,  694,  694,  694,  694,  694,
1464       694,  694,  694,  694,  694,  694,  694,  694,  694,  694,
1465       694,  694,  694,  694,  695,  695,  695,  695,  695,  695,
1466       695,  695,  695,  695,  695,  695,  695,  695,  695,  695,
1467       695,  695,  695,  696,  307,  306,  296,  696,  696,  696,
1468       286,  696,  696,  696,  696,  696,  696,  696,  696,  697,
1469
1470       697,  697,  697,  697,  284,  697,  697,  697,  697,  697,
1471       697,  697,  697,  697,  697,  697,  697,  697,  698,  698,
1472       698,  698,  698,  698,  698,  698,  698,  698,  698,  698,
1473       698,  698,  698,  698,  698,  698,  698,  699,  699,  270,
1474       266,  260,  258,  254,  253,  252,  251,  699,  249,  248,
1475       699,  699,  243,  699,  703,  703,  703,  703,  703,  703,
1476       703,  703,  703,  703,  703,  703,  703,  703,  703,  703,
1477       703,  703,  703,  704,  704,  704,  704,  704,  704,  704,
1478       704,  704,  704,  704,  704,  704,  704,  704,  704,  704,
1479       704,  704,  706,  706,  706,  706,  706,  706,  706,  706,
1480
1481       706,  706,  706,  706,  706,  706,  706,  706,  706,  706,
1482       706,  707,  707,  707,  707,  707,  707,  707,  707,  707,
1483       707,  707,  707,  707,  707,  707,  707,  707,  707,  707,
1484       708,  708,  708,  708,  708,  708,  708,  708,  708,  708,
1485       708,  708,  708,  708,  708,  708,  708,  708,  708,  709,
1486       709,  709,  709,  709,  709,  709,  709,  709,  709,  709,
1487       709,  709,  709,  709,  709,  709,  709,  709,  710,  710,
1488       710,  710,  710,  710,  710,  710,  710,  710,  710,  710,
1489       710,  710,  710,  710,  710,  710,  710,  711,  711,  711,
1490       711,  711,  711,  711,  711,  711,  711,  711,  711,  711,
1491
1492       711,  711,  711,  711,  711,  711,  712,  712,  712,  712,
1493       712,  712,  712,  712,  712,  712,  712,  712,  712,  712,
1494       712,  712,  712,  712,  712,  713,  713,  242,  713,  713,
1495       713,  713,  713,  713,  713,  713,  713,  713,  713,  713,
1496       713,  713,  713,  713,  714,  714,  241,  714,  714,  714,
1497       714,  714,  714,  714,  714,  714,  714,  714,  714,  714,
1498       714,  714,  714,  715,  231,  715,  230,  229,  228,  715,
1499       715,  715,  226,  222,  715,  716,  716,  716,  716,  716,
1500       716,  716,  716,  716,  716,  716,  716,  716,  716,  716,
1501       716,  716,  716,  716,  717,  717,  717,  717,  717,  717,
1502
1503       717,  717,  717,  717,  717,  717,  717,  717,  717,  717,
1504       717,  717,  717,  718,  718,  718,  718,  718,  718,  718,
1505       718,  718,  718,  718,  718,  718,  718,  718,  718,  718,
1506       718,  718,  719,  719,  719,  719,  719,  719,  719,  719,
1507       719,  719,  719,  719,  719,  719,  719,  719,  719,  719,
1508       719,  720,  720,  720,  720,  720,  720,  720,  720,  722,
1509       221,  220,  219,  722,  218,  722,  722,  722,  722,  208,
1510       722,  723,  723,  723,  723,  723,  723,  723,  723,  723,
1511       723,  723,  723,  723,  723,  723,  723,  723,  723,  723,
1512       724,  724,  724,  724,  724,  724,  724,  724,  724,  724,
1513
1514       724,  724,  724,  724,  724,  724,  724,  724,  724,  725,
1515       725,  725,  725,  725,  725,  725,  725,  725,  725,  725,
1516       725,  725,  725,  725,  725,  725,  725,  725,  726,  726,
1517       726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
1518       726,  726,  726,  726,  726,  726,  726,  727,  727,  727,
1519       727,  727,  727,  727,  727,  727,  727,  727,  727,  727,
1520       727,  727,  727,  727,  727,  727,  728,  728,  728,  728,
1521       728,  728,  728,  728,  728,  728,  728,  728,  728,  728,
1522       728,  728,  728,  728,  728,  729,  729,  729,  729,  729,
1523       729,  729,  729,  729,  729,  729,  729,  729,  729,  729,
1524
1525       729,  729,  729,  729,  730,  730,  730,  730,  730,  730,
1526       730,  730,  730,  730,  730,  730,  730,  730,  730,  730,
1527       730,  730,  730,  731,  731,  731,  731,  731,  731,  731,
1528       731,  731,  731,  731,  731,  731,  731,  731,  731,  731,
1529       731,  731,  732,  732,  732,  732,  732,  732,  732,  732,
1530       732,  732,  732,  732,  732,  732,  732,  732,  732,  732,
1531       732,  733,  733,  207,  733,  733,  733,  733,  733,  733,
1532       733,  733,  733,  733,  733,  733,  733,  733,  733,  733,
1533       734,  734,  206,  734,  734,  734,  734,  734,  734,  734,
1534       734,  734,  734,  734,  734,  734,  734,  734,  734,  735,
1535
1536       205,  735,  735,  204,  201,  735,  735,  735,  200,  199,
1537       735,  736,  736,  736,  736,  736,  736,  736,  736,  736,
1538       736,  736,  736,  736,  736,  736,  736,  736,  736,  736,
1539       737,  737,  737,  737,  737,  737,  737,  737,  737,  737,
1540       737,  737,  737,  737,  737,  737,  737,  737,  737,  738,
1541       738,  738,  738,  738,  738,  738,  738,  738,  738,  738,
1542       738,  738,  738,  738,  738,  738,  738,  738,  739,  739,
1543       739,  739,  739,  739,  739,  739,  739,  739,  739,  739,
1544       739,  739,  739,  739,  739,  739,  739,  740,  740,  198,
1545       197,  740,  740,  196,  740,  740,  740,  740,  740,  740,
1546
1547       740,  740,  740,  741,  192,  191,  183,  171,  164,  741,
1548       741,  741,  741,  156,  741,  742,  742,  742,  742,  742,
1549       742,  742,  742,  742,  742,  742,  742,  742,  742,  742,
1550       742,  742,  742,  742,  743,  743,  743,  743,  743,  743,
1551       743,  743,  743,  743,  743,  743,  743,  743,  743,  743,
1552       743,  743,  743,  744,  744,  145,  143,  744,  744,  744,
1553       744,  744,  744,  744,  744,  744,  744,  744,  744,  745,
1554       745,  745,  745,  745,  745,  745,  745,  745,  745,  745,
1555       745,  745,  745,  745,  745,  745,  745,  745,  746,  746,
1556       746,  746,  746,  746,  746,  746,  746,  746,  746,  746,
1557
1558       746,  746,  746,  746,  746,  746,  746,  747,  747,  747,
1559       747,  747,  747,  747,  747,  747,  747,  747,  747,  747,
1560       747,  747,  747,  747,  747,  747,  748,  748,  142,  748,
1561       748,  748,  748,  748,  748,  748,  748,  748,  748,  748,
1562       748,  748,  748,  748,  748,  749,  749,  140,  749,  749,
1563       749,  749,  749,  749,  749,  749,  749,  749,  749,  749,
1564       749,  749,  749,  749,  750,  750,  138,  750,  750,  750,
1565       750,  750,  750,  750,  750,  750,  750,  750,  750,  750,
1566       750,  750,  750,  751,  751,  137,  751,  751,  751,  751,
1567       751,  751,  751,  751,  751,  751,  751,  751,  751,  751,
1568
1569       751,  751,  752,  752,  136,  752,  752,  752,  752,  752,
1570       752,  752,  752,  752,  752,  752,  752,  752,  752,  752,
1571       752,  753,  753,  135,  753,  753,  753,  753,  753,  753,
1572       753,  753,  753,  753,  753,  753,  753,  753,  753,  753,
1573       754,  754,  754,  754,  754,  754,  754,  754,  754,  754,
1574       754,  754,  754,  754,  754,  754,  754,  754,  754,  755,
1575       755,  755,  755,  755,  755,  755,  755,  755,  755,  755,
1576       755,  755,  755,  755,  755,  755,  755,  755,  756,  756,
1577       756,  756,  756,  756,  756,  756,  756,  756,  756,  756,
1578       756,  756,  756,  756,  756,  756,  756,  757,  134,  121,
1579
1580       119,  117,  116,  757,  757,  757,  757,  757,  757,  757,
1581       757,  757,  758,  758,  758,  758,  758,  758,  758,  758,
1582       758,  758,  758,  758,  758,  758,  758,  758,  758,  758,
1583       758,  759,  759,  759,  759,  114,  759,  759,  759,  759,
1584       759,  759,  759,  759,  759,  759,  759,  759,  759,  759,
1585       760,  113,  112,  101,   99,   95,  760,  760,  760,  760,
1586       761,  761,   92,  761,  761,  761,  761,  761,  761,  761,
1587       761,  761,  761,  761,  761,  761,  761,  761,  761,  762,
1588       762,   91,  762,  762,  762,  762,  762,  762,  762,  762,
1589       762,  762,  762,  762,  762,  762,  762,  762,  763,  763,
1590
1591        90,  763,  763,  763,  763,  763,  763,  763,  763,  763,
1592       763,  763,  763,  763,  763,  763,  763,  764,  764,   86,
1593       764,  764,  764,  764,  764,  764,  764,  764,  764,  764,
1594       764,  764,  764,  764,  764,  764,  765,  765,  765,  765,
1595       765,  765,  765,  765,  765,  765,  765,  765,  765,  765,
1596       765,  765,  765,  765,  765,  766,  766,  766,  766,  766,
1597       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
1598       766,  766,  766,  766,  767,  767,  767,  767,  767,  767,
1599       767,  767,  767,  767,  767,  767,  767,  767,  767,  767,
1600       767,  767,  767,  768,  768,  768,  768,  768,  768,  768,
1601
1602       768,  768,  768,  768,  768,  768,  768,  768,  768,  768,
1603       768,  768,   81,   78,   58,   57,   55,   53,   52,   44,
1604        41,   40,   38,   23,   22,   20,   18,   17,   14,    9,
1605         3,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1606       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1607       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1608       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1609       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1610       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1611       689,  689,  689,  689,  689,  689,  689,  689,  689,  689,
1612
1613       689,  689,  689,  689,  689
1614     } ;
1615
1616 extern int yy_flex_debug;
1617 int yy_flex_debug = 0;
1618
1619 static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;
1620 static char *yy_full_match;
1621 static int yy_lp;
1622 static int yy_looking_for_trail_begin = 0;
1623 static int yy_full_lp;
1624 static int *yy_full_state;
1625 #define YY_TRAILING_MASK 0x2000
1626 #define YY_TRAILING_HEAD_MASK 0x4000
1627 #define REJECT \
1628 { \
1629 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \
1630 yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
1631 (yy_lp) = (yy_full_lp); /* restore orig. accepting pos. */ \
1632 (yy_state_ptr) = (yy_full_state); /* restore orig. state */ \
1633 yy_current_state = *(yy_state_ptr); /* restore curr. state */ \
1634 ++(yy_lp); \
1635 goto find_rule; \
1636 }
1637
1638 #define yymore() yymore_used_but_not_detected
1639 #define YY_MORE_ADJ 0
1640 #define YY_RESTORE_YY_MORE_OFFSET
1641 char *yytext;
1642 #line 1 "parser.l"
1643 #line 8 "parser.l"
1644 /*\r
1645  * parser.l -- lex parser of algebraic chess moves for XBoard\r
1646  *\r
1647  * Copyright 1991 by Digital Equipment Corporation, Maynard,\r
1648  * Massachusetts.\r
1649  *\r
1650  * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005,\r
1651  * 2006, 2007, 2008, 2009 Free Software Foundation, Inc.\r
1652  *\r
1653  * The following terms apply to Digital Equipment Corporation's copyright\r
1654  * interest in XBoard:\r
1655  * ------------------------------------------------------------------------\r
1656  * All Rights Reserved\r
1657  *\r
1658  * Permission to use, copy, modify, and distribute this software and its\r
1659  * documentation for any purpose and without fee is hereby granted,\r
1660  * provided that the above copyright notice appear in all copies and that\r
1661  * both that copyright notice and this permission notice appear in\r
1662  * supporting documentation, and that the name of Digital not be\r
1663  * used in advertising or publicity pertaining to distribution of the\r
1664  * software without specific, written prior permission.\r
1665  *\r
1666  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING\r
1667  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL\r
1668  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR\r
1669  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,\r
1670  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,\r
1671  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS\r
1672  * SOFTWARE.\r
1673  * ------------------------------------------------------------------------\r
1674  *\r
1675  * The following terms apply to the enhanced version of XBoard\r
1676  * distributed by the Free Software Foundation:\r
1677  * ------------------------------------------------------------------------\r
1678  *\r
1679  * GNU XBoard is free software: you can redistribute it and/or modify\r
1680  * it under the terms of the GNU General Public License as published by\r
1681  * the Free Software Foundation, either version 3 of the License, or (at\r
1682  * your option) any later version.\r
1683  *\r
1684  * GNU XBoard is distributed in the hope that it will be useful, but\r
1685  * WITHOUT ANY WARRANTY; without even the implied warranty of\r
1686  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
1687  * General Public License for more details.\r
1688  *\r
1689  * You should have received a copy of the GNU General Public License\r
1690  * along with this program. If not, see http://www.gnu.org/licenses/.  \r
1691  *\r
1692  *------------------------------------------------------------------------\r
1693  ** See the file ChangeLog for a revision history.  */\r
1694 \r
1695 /* This parser handles all forms of promotion.\r
1696  * The parser resolves ambiguous moves by searching and check-testing.\r
1697  * It also parses comments of the form [anything] or (anything).\r
1698  *\r
1699  * [HGM] Parser extensively modified for bigger boards, Shogi-like syntax,\r
1700  * and unknow pieces. All pieces are now mandatory upper case, but can be\r
1701  * any letter A-Z. Files must be lower case (as before), but can run upto 'l'.\r
1702  * Ranks can be 0-9. The parser returns 0 for off-board files and ranks.\r
1703  * For an unknown piece (as mover or promotion piece) it returns\r
1704  * IllegalMove, like it does when the piece doesn't match.\r
1705  * Promotions can now also be appended Shogi-style, a bare '=' or '+',\r
1706  * and this is then returned as promotion character. The piece indicator\r
1707  * can be prefixed by a '+' to indicate it is a promoted piece.\r
1708  */\r
1709 \r
1710 #include "config.h"\r
1711 \r
1712 #define NO_CONSTRAINT   -1\r
1713 #undef YYLMAX\r
1714 #define YYLMAX                  4096\r
1715 #define UNPUT_BUF_SIZE          YYLMAX\r
1716 \r
1717 #ifdef FLEX_SCANNER\r
1718 /* yytext is probably a char*, but could be a char[].  yy_text is set\r
1719    in YY_DECL below, because if yytext is a char*, its value is not\r
1720    constant. */\r
1721 char *yy_text;\r
1722 #else /*!FLEX_SCANNER*/\r
1723 /* yytext is definitely a char[], so yy_text can be set here, statically. */\r
1724 char *yy_text = (char *) yytext;\r
1725 #endif\r
1726 \r
1727 #ifdef FLEX_SCANNER\r
1728 /* This is flex */\r
1729 /* [AP] use prototypes in function declarations */\r
1730 #define YY_USE_PROTOS\r
1731 \r
1732 #ifdef YY_USE_PROTOS\r
1733 #define YY_PROTO(proto) proto\r
1734 #else\r
1735 #define YY_PROTO(proto) ()\r
1736 #endif\r
1737 /* end of [AP] fix */\r
1738 \r
1739 #undef YY_INPUT\r
1740 #define YY_INPUT(buf, result, max_size) my_yy_input(buf, &result, max_size)\r
1741 #undef YY_DECL\r
1742 #define YY_DECL                     \\r
1743     int _yylex YY_PROTO((void));    \\r
1744     int yylex YY_PROTO((void))      \\r
1745     {                               \\r
1746         int result = _yylex();      \\r
1747         yy_text = (char *) yytext;  \\r
1748         return(result);             \\r
1749     }                               \\r
1750     int _yylex YY_PROTO((void))\r
1751 #else\r
1752 /* This is lex */\r
1753 #undef input\r
1754 #undef output\r
1755 #undef unput\r
1756 #endif\r
1757 \r
1758 /* The includes must be here, below the #undef input */\r
1759 \r
1760 #include <ctype.h>\r
1761 \r
1762 #if STDC_HEADERS\r
1763 # include <stdlib.h>\r
1764 # include <string.h>\r
1765 #else /* not STDC_HEADERS */\r
1766 # if HAVE_STRING_H\r
1767 #  include <string.h>\r
1768 # else /* not HAVE_STRING_H */\r
1769 #  include <strings.h>\r
1770 # endif /* not HAVE_STRING_H */\r
1771 #endif /* not STDC_HEADERS */\r
1772 \r
1773 #if HAVE_UNISTD_H\r
1774 # include <unistd.h>\r
1775 #endif\r
1776 \r
1777 #if defined(_amigados)\r
1778 # include <errno.h>\r
1779 # if HAVE_FCNTL_H\r
1780 #  include <fcntl.h>    /*  isatty() prototype  */\r
1781 # endif /*  HAVE_FCNTL_H        */\r
1782 #endif  /*  defined(_amigados)  */\r
1783 \r
1784 #include "common.h"\r
1785 #include "backend.h"\r
1786 #include "frontend.h"\r
1787 #include "parser.h"\r
1788 #include "moves.h"\r
1789 \r
1790 extern int PosFlags P((int));\r
1791 \r
1792 extern Board    boards[MAX_MOVES];\r
1793 int             yyboardindex;\r
1794 int             yyskipmoves = FALSE;\r
1795 char            currentMoveString[YYLMAX];\r
1796 #ifndef FLEX_SCANNER\r
1797 char            unputBuffer[UNPUT_BUF_SIZE];\r
1798 int             unputCount = 0;\r
1799 #endif\r
1800 \r
1801 #ifdef FLEX_SCANNER\r
1802 void my_yy_input P((char *buf, int *result, int max_size));\r
1803 #else /*!FLEX_SCANNER*/\r
1804 static int input P((void));\r
1805 static void output P((int ch));\r
1806 static void unput P((int ch));\r
1807 int yylook P((void));\r
1808 int yyback P((int *, int));\r
1809 #endif\r
1810 #undef yywrap\r
1811 int yywrap P((void));\r
1812 extern void CopyBoard P((Board to, Board from));\r
1813 \r
1814 #line 1815 "parser.c"
1815
1816 #define INITIAL 0
1817
1818 #ifndef YY_NO_UNISTD_H
1819 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1820  * down here because we want the user's section 1 to have been scanned first.
1821  * The user has a chance to override it with an option.
1822  */
1823 #include <unistd.h>
1824 #endif
1825
1826 #ifndef YY_EXTRA_TYPE
1827 #define YY_EXTRA_TYPE void *
1828 #endif
1829
1830 static int yy_init_globals (void );
1831
1832 /* Macros after this point can all be overridden by user definitions in
1833  * section 1.
1834  */
1835
1836 #ifndef YY_SKIP_YYWRAP
1837 #ifdef __cplusplus
1838 extern "C" int yywrap (void );
1839 #else
1840 extern int yywrap (void );
1841 #endif
1842 #endif
1843
1844     static void yyunput (int c,char *buf_ptr  );
1845     
1846 #ifndef yytext_ptr
1847 static void yy_flex_strncpy (char *,yyconst char *,int );
1848 #endif
1849
1850 #ifdef YY_NEED_STRLEN
1851 static int yy_flex_strlen (yyconst char * );
1852 #endif
1853
1854 #ifndef YY_NO_INPUT
1855
1856 #ifdef __cplusplus
1857 static int yyinput (void );
1858 #else
1859 static int input (void );
1860 #endif
1861
1862 #endif
1863
1864 /* Amount of stuff to slurp up with each read. */
1865 #ifndef YY_READ_BUF_SIZE
1866 #define YY_READ_BUF_SIZE 8192
1867 #endif
1868
1869 /* Copy whatever the last rule matched to the standard output. */
1870 #ifndef ECHO
1871 /* This used to be an fputs(), but since the string might contain NUL's,
1872  * we now use fwrite().
1873  */
1874 #define ECHO fwrite( yytext, yyleng, 1, yyout )
1875 #endif
1876
1877 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1878  * is returned in "result".
1879  */
1880 #ifndef YY_INPUT
1881 #define YY_INPUT(buf,result,max_size) \
1882         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1883                 { \
1884                 int c = '*'; \
1885                 int n; \
1886                 for ( n = 0; n < max_size && \
1887                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1888                         buf[n] = (char) c; \
1889                 if ( c == '\n' ) \
1890                         buf[n++] = (char) c; \
1891                 if ( c == EOF && ferror( yyin ) ) \
1892                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1893                 result = n; \
1894                 } \
1895         else \
1896                 { \
1897                 errno=0; \
1898                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1899                         { \
1900                         if( errno != EINTR) \
1901                                 { \
1902                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1903                                 break; \
1904                                 } \
1905                         errno=0; \
1906                         clearerr(yyin); \
1907                         } \
1908                 }\
1909 \
1910
1911 #endif
1912
1913 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1914  * we don't want an extra ';' after the "return" because that will cause
1915  * some compilers to complain about unreachable statements.
1916  */
1917 #ifndef yyterminate
1918 #define yyterminate() return YY_NULL
1919 #endif
1920
1921 /* Number of entries by which start-condition stack grows. */
1922 #ifndef YY_START_STACK_INCR
1923 #define YY_START_STACK_INCR 25
1924 #endif
1925
1926 /* Report a fatal error. */
1927 #ifndef YY_FATAL_ERROR
1928 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1929 #endif
1930
1931 /* end tables serialization structures and prototypes */
1932
1933 /* Default declaration of generated scanner - a define so the user can
1934  * easily add parameters.
1935  */
1936 #ifndef YY_DECL
1937 #define YY_DECL_IS_OURS 1
1938
1939 extern int yylex (void);
1940
1941 #define YY_DECL int yylex (void)
1942 #endif /* !YY_DECL */
1943
1944 /* Code executed at the beginning of each rule, after yytext and yyleng
1945  * have been set up.
1946  */
1947 #ifndef YY_USER_ACTION
1948 #define YY_USER_ACTION
1949 #endif
1950
1951 /* Code executed at the end of each rule. */
1952 #ifndef YY_BREAK
1953 #define YY_BREAK break;
1954 #endif
1955
1956 #define YY_RULE_SETUP \
1957         if ( yyleng > 0 ) \
1958                 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1959                                 (yytext[yyleng - 1] == '\n'); \
1960         YY_USER_ACTION
1961
1962 /** The main scanner function which does all the work.
1963  */
1964 YY_DECL
1965 {
1966         register yy_state_type yy_current_state;
1967         register char *yy_cp, *yy_bp;
1968         register int yy_act;
1969     
1970 #line 179 "parser.l"
1971
1972 \r
1973 #line 1974 "parser.c"
1974
1975         if ( !(yy_init) )
1976                 {
1977                 (yy_init) = 1;
1978
1979 #ifdef YY_USER_INIT
1980                 YY_USER_INIT;
1981 #endif
1982
1983         /* Create the reject buffer large enough to save one state per allowed character. */
1984         if ( ! (yy_state_buf) )
1985             (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
1986             if ( ! (yy_state_buf) )
1987                 YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
1988
1989                 if ( ! (yy_start) )
1990                         (yy_start) = 1; /* first start state */
1991
1992                 if ( ! yyin )
1993                         yyin = stdin;
1994
1995                 if ( ! yyout )
1996                         yyout = stdout;
1997
1998                 if ( ! YY_CURRENT_BUFFER ) {
1999                         yyensure_buffer_stack ();
2000                         YY_CURRENT_BUFFER_LVALUE =
2001                                 yy_create_buffer(yyin,YY_BUF_SIZE );
2002                 }
2003
2004                 yy_load_buffer_state( );
2005                 }
2006
2007         while ( 1 )             /* loops until end-of-file is reached */
2008                 {
2009                 yy_cp = (yy_c_buf_p);
2010
2011                 /* Support of yytext. */
2012                 *yy_cp = (yy_hold_char);
2013
2014                 /* yy_bp points to the position in yy_ch_buf of the start of
2015                  * the current run.
2016                  */
2017                 yy_bp = yy_cp;
2018
2019                 yy_current_state = (yy_start);
2020                 yy_current_state += YY_AT_BOL();
2021
2022                 (yy_state_ptr) = (yy_state_buf);
2023                 *(yy_state_ptr)++ = yy_current_state;
2024
2025 yy_match:
2026                 do
2027                         {
2028                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
2029                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2030                                 {
2031                                 yy_current_state = (int) yy_def[yy_current_state];
2032                                 if ( yy_current_state >= 690 )
2033                                         yy_c = yy_meta[(unsigned int) yy_c];
2034                                 }
2035                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2036                         *(yy_state_ptr)++ = yy_current_state;
2037                         ++yy_cp;
2038                         }
2039                 while ( yy_base[yy_current_state] != 3832 );
2040
2041 yy_find_action:
2042                 yy_current_state = *--(yy_state_ptr);
2043                 (yy_lp) = yy_accept[yy_current_state];
2044 find_rule: /* we branch to this label when backing up */
2045                 for ( ; ; ) /* until we find what rule we matched */
2046                         {
2047                         if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
2048                                 {
2049                                 yy_act = yy_acclist[(yy_lp)];
2050                                 if ( yy_act & YY_TRAILING_HEAD_MASK ||
2051                                      (yy_looking_for_trail_begin) )
2052                                         {
2053                                         if ( yy_act == (yy_looking_for_trail_begin) )
2054                                                 {
2055                                                 (yy_looking_for_trail_begin) = 0;
2056                                                 yy_act &= ~YY_TRAILING_HEAD_MASK;
2057                                                 break;
2058                                                 }
2059                                         }
2060                                 else if ( yy_act & YY_TRAILING_MASK )
2061                                         {
2062                                         (yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;
2063                                         (yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;
2064                                         }
2065                                 else
2066                                         {
2067                                         (yy_full_match) = yy_cp;
2068                                         (yy_full_state) = (yy_state_ptr);
2069                                         (yy_full_lp) = (yy_lp);
2070                                         break;
2071                                         }
2072                                 ++(yy_lp);
2073                                 goto find_rule;
2074                                 }
2075                         --yy_cp;
2076                         yy_current_state = *--(yy_state_ptr);
2077                         (yy_lp) = yy_accept[yy_current_state];
2078                         }
2079
2080                 YY_DO_BEFORE_ACTION;
2081
2082 do_action:      /* This label is used only to access EOF actions. */
2083
2084                 switch ( yy_act )
2085         { /* beginning of action switch */
2086 case 1:
2087 YY_RULE_SETUP
2088 #line 181 "parser.l"
2089 {\r
2090     /*\r
2091      * Fully-qualified algebraic move, possibly with promotion\r
2092      */\r
2093     int skip1 = 0, skip2 = 0, skip3 = 0, promoted = 0;\r
2094     ChessSquare piece;\r
2095     ChessMove result;\r
2096     char c;\r
2097     \r
2098     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
2099 \r
2100     if (yytext[0] == '+') skip1 = skip3 = promoted = 1; /* [HGM] Shogi promoted */\r
2101 \r
2102     /* remove the / */\r
2103     if (yytext[1+skip1] == '/')  skip1++; \r
2104     \r
2105     /* remove the [xX:-] */\r
2106     if ((yytext[3+skip1] == 'x') || (yytext[3+skip1] == 'X') ||\r
2107         (yytext[3+skip1] == '-') || (yytext[3+skip1] == ':')) skip2 = 1;\r
2108     \r
2109     currentMoveString[0] = yytext[1+skip1];\r
2110     currentMoveString[1] = yytext[2+skip1];\r
2111     currentMoveString[2] = yytext[3+skip1+skip2];\r
2112     currentMoveString[3] = yytext[4+skip1+skip2];\r
2113     currentMoveString[4] = NULLCHAR;\r
2114     \r
2115     if (appData.debugMode) {\r
2116         fprintf(debugFP, "Parser Qa1b2: yyleng=%d\n",\r
2117         yyleng);\r
2118     }\r
2119 \r
2120     if (yyleng-skip1-skip2 > 5) { char c;\r
2121         if (yytext[yyleng-1] == ')') {\r
2122             c = currentMoveString[4] = ToLower(yytext[yyleng-2]);\r
2123         } else {\r
2124             c = currentMoveString[4] = ToLower(yytext[yyleng-1]);\r
2125         }\r
2126         currentMoveString[5] = NULLCHAR;\r
2127         if(c != '=' && c != '+' && CharToPiece(c) == EmptySquare)\r
2128             return IllegalMove; /* [HGM] promotion to invalid piece */\r
2129     }\r
2130 \r
2131     if (appData.debugMode) {\r
2132         fprintf(debugFP, "parser: %s\n", currentMoveString);\r
2133     }\r
2134     /* [HGM] do not allow values beyond board size */\r
2135     if(currentMoveString[1] - ONE >= BOARD_HEIGHT ||\r
2136        currentMoveString[1] - ONE <  0            ||\r
2137        currentMoveString[0] - AAA >= BOARD_RGHT   ||\r
2138        currentMoveString[3] - ONE >= BOARD_HEIGHT ||\r
2139        currentMoveString[3] - ONE <  0            ||\r
2140        currentMoveString[2] - AAA >= BOARD_RGHT   ||\r
2141        currentMoveString[0] - AAA <  BOARD_LEFT   ||\r
2142        currentMoveString[2] - AAA <  BOARD_LEFT     )\r
2143       return ImpossibleMove;\r
2144 \r
2145     piece = boards[yyboardindex]\r
2146       [currentMoveString[1] - ONE][currentMoveString[0] - AAA];\r
2147     if(promoted) piece = (ChessSquare) (DEMOTED piece);\r
2148     c = PieceToChar(piece);\r
2149     if(c == '~') c = PieceToChar((ChessSquare) (DEMOTED piece));\r
2150     if (ToLower(yytext[skip3]) != ToLower(c))\r
2151       return (int) IllegalMove;\r
2152 \r
2153     result = LegalityTest(boards[yyboardindex],\r
2154                           PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: might think we can e.p.!\r
2155                           currentMoveString[1] - ONE,\r
2156                           currentMoveString[0] - AAA,\r
2157                           currentMoveString[3] - ONE,\r
2158                           currentMoveString[2] - AAA,\r
2159                           currentMoveString[4]);\r
2160 \r
2161     if (currentMoveString[4] == NULLCHAR &&\r
2162         (result == WhitePromotionKnight || result == BlackPromotionKnight ||\r
2163          result == WhitePromotionQueen  || result == BlackPromotionQueen)) {\r
2164         currentMoveString[4] = PieceToChar(BlackQueen);\r
2165         currentMoveString[5] = NULLCHAR;\r
2166     }\r
2167 \r
2168     return (int) result;\r
2169 }\r
2170         YY_BREAK
2171 case 2:
2172 YY_RULE_SETUP
2173 #line 263 "parser.l"
2174 {\r
2175     /*\r
2176      * Simple algebraic move, possibly with promotion\r
2177      * [HGM] Engine moves are received in this format, with lower-case promoChar!\r
2178      */\r
2179     int skip = 0;\r
2180     ChessMove result;\r
2181 \r
2182     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
2183 \r
2184     /* remove the [xX:-] */\r
2185     if ((yytext[2] == 'x') || (yytext[2] == 'X') ||\r
2186         (yytext[2] == '-') || (yytext[2] == ':')) skip = 1;\r
2187 \r
2188     currentMoveString[0] = yytext[0];\r
2189     currentMoveString[1] = yytext[1];\r
2190     currentMoveString[2] = yytext[2+skip];\r
2191     currentMoveString[3] = yytext[3+skip];\r
2192     currentMoveString[4] = NULLCHAR;\r
2193 \r
2194     if (yyleng-skip > 4) { char c;\r
2195         if (yytext[yyleng-1] == ')') {\r
2196             c = currentMoveString[4] = ToLower(yytext[yyleng-2]);\r
2197         } else {\r
2198             c = currentMoveString[4] = ToLower(yytext[yyleng-1]);\r
2199         }\r
2200         currentMoveString[5] = NULLCHAR;\r
2201         if(c != '=' && c != '+' && CharToPiece(c) == EmptySquare)\r
2202             return IllegalMove;\r
2203     }\r
2204 \r
2205     /* [HGM] do not allow values beyond board size */\r
2206     if(currentMoveString[1] - ONE >= BOARD_HEIGHT ||\r
2207        currentMoveString[1] - ONE <  0            ||\r
2208        currentMoveString[0] - AAA >= BOARD_RGHT   ||\r
2209        currentMoveString[3] - ONE >= BOARD_HEIGHT ||\r
2210        currentMoveString[3] - ONE <  0            ||\r
2211        currentMoveString[2] - AAA >= BOARD_RGHT   ||\r
2212        currentMoveString[0] - AAA <  BOARD_LEFT   ||\r
2213        currentMoveString[2] - AAA <  BOARD_LEFT     )\r
2214       return ImpossibleMove;\r
2215 \r
2216     result = LegalityTest(boards[yyboardindex],\r
2217                           PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: might think we can e.p.!\r
2218                           currentMoveString[1] - ONE,\r
2219                           currentMoveString[0] - AAA,\r
2220                           currentMoveString[3] - ONE,\r
2221                           currentMoveString[2] - AAA,\r
2222                           currentMoveString[4]);\r
2223 \r
2224     if (currentMoveString[4] == NULLCHAR) {
2225       if(result == WhitePromotionKnight || result == BlackPromotionKnight ||
2226          result == WhitePromotionQueen  || result == BlackPromotionQueen) {
2227         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk)
2228             currentMoveString[4] = PieceToChar(BlackFerz);
2229         else if(gameInfo.variant == VariantGreat)
2230             currentMoveString[4] = PieceToChar(BlackMan);
2231         else
2232             currentMoveString[4] = PieceToChar(BlackQueen);
2233         currentMoveString[5] = NULLCHAR;
2234       }
2235     } else if(appData.testLegality && // strip off unnecessary and false promo characters
2236        !(result == WhitePromotionQueen  || result == BlackPromotionQueen ||
2237          result == WhiteNonPromotion    || result == BlackNonPromotion)) currentMoveString[4] = NULLCHAR;
2238
2239     return (int) result;
2240 }
2241         YY_BREAK
2242 case 3:
2243 YY_RULE_SETUP
2244 #line 331 "parser.l"
2245 {\r
2246     /*\r
2247      * Pawn move, possibly with promotion\r
2248      */\r
2249     DisambiguateClosure cl;\r
2250     int skip = 0; char c;\r
2251 \r
2252     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
2253 \r
2254     /* remove the =() */\r
2255     if (yytext[2] == '=' && yytext[3] != NULLCHAR) skip++;\r
2256     if (yytext[2+skip] == '(') skip++;\r
2257 \r
2258     cl.pieceIn = WhiteOnMove(yyboardindex) ? WhitePawn : BlackPawn;\r
2259     cl.rfIn = -1;\r
2260     cl.ffIn = yytext[0] - AAA;\r
2261     cl.rtIn = yytext[1] - ONE;\r
2262     cl.ftIn = yytext[0] - AAA;\r
2263     c = cl.promoCharIn = ToLower(yytext[2+skip]);\r
2264 \r
2265     /* [HGM] do not allow values beyond board size */\r
2266     if(cl.rtIn >= BOARD_HEIGHT ||\r
2267        cl.rtIn <  0            ||\r
2268        cl.ffIn >= BOARD_RGHT   ||\r
2269        cl.ftIn <  BOARD_LEFT     )\r
2270       return ImpossibleMove;\r
2271 \r
2272     if(c != '=' && c != '+' && c != NULLCHAR && CharToPiece(c) == EmptySquare)\r
2273       return IllegalMove;\r
2274 \r
2275 \r
2276     Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);\r
2277 \r
2278     currentMoveString[0] = cl.ff + AAA;\r
2279     currentMoveString[1] = cl.rf + ONE;\r
2280     currentMoveString[2] = cl.ft + AAA;\r
2281     currentMoveString[3] = cl.rt + ONE;\r
2282     currentMoveString[4] = cl.promoChar;\r
2283     currentMoveString[5] = NULLCHAR;\r
2284 \r
2285     return (int) cl.kind;\r
2286 }\r
2287         YY_BREAK
2288 case 4:
2289 YY_RULE_SETUP
2290 #line 375 "parser.l"
2291 {\r
2292     /*\r
2293      * Pawn capture, possibly with promotion, possibly ambiguous\r
2294      */\r
2295     DisambiguateClosure cl;\r
2296     int skip1 = 0, skip2 = 0; char c;\r
2297 \r
2298     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
2299 \r
2300     /* remove trailing ep or e.p. (nonstandard PGN) */\r
2301     if (yytext[yyleng-1] == 'p') {\r
2302       yyleng -= 2;\r
2303       yytext[yyleng] = NULLCHAR;\r
2304     } else if (yytext[yyleng-1] == '.') {\r
2305       yyleng -= 4;\r
2306       yytext[yyleng] = NULLCHAR;\r
2307     }\r
2308 \r
2309     /* remove the [xX:-] and =() */\r
2310     if ((yytext[1] == 'x') || (yytext[1] == 'X')\r
2311         || (yytext[1] == ':') || (yytext[1] == '-')) skip1 = 1;\r
2312     if (yytext[2+skip1] == '=' && yytext[3+skip1] != NULLCHAR) skip2++;\r
2313     if (yytext[2+skip1+skip2] == '(') skip2++;\r
2314 \r
2315     cl.pieceIn = WhiteOnMove(yyboardindex) ? WhitePawn : BlackPawn;\r
2316     cl.rfIn = -1;\r
2317     cl.ffIn = yytext[0] - AAA;\r
2318     cl.rtIn = -1;\r
2319     cl.ftIn = yytext[1+skip1] - AAA;\r
2320     c = cl.promoCharIn = yytext[2+skip1+skip2];\r
2321 \r
2322     /* [HGM] do not allow values beyond board size */\r
2323     if(cl.ffIn >= BOARD_RGHT  ||\r
2324        cl.ffIn <  BOARD_LEFT  ||\r
2325        cl.ftIn >= BOARD_RGHT  ||\r
2326        cl.ftIn <  BOARD_LEFT     )\r
2327       return ImpossibleMove;\r
2328 \r
2329     if(c != '=' && c != '+' && c != NULLCHAR && CharToPiece(c) == EmptySquare)\r
2330       return IllegalMove;\r
2331 \r
2332     Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);\r
2333 \r
2334     currentMoveString[0] = cl.ff + AAA;\r
2335     currentMoveString[1] = cl.rf + ONE;\r
2336     currentMoveString[2] = cl.ft + AAA;\r
2337     currentMoveString[3] = cl.rt + ONE;\r
2338     currentMoveString[4] = cl.promoChar;\r
2339     currentMoveString[5] = NULLCHAR;\r
2340 \r
2341     return (int) cl.kind;\r
2342 }\r
2343         YY_BREAK
2344 case 5:
2345 YY_RULE_SETUP
2346 #line 428 "parser.l"
2347 {\r
2348     /*\r
2349      * unambiguously abbreviated Pawn capture, possibly with promotion\r
2350      */\r
2351     int skip = 0;\r
2352     ChessMove result; char c;\r
2353 \r
2354     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
2355 \r
2356     /* remove trailing ep or e.p. (nonstandard PGN) */\r
2357     if (yytext[yyleng-1] == 'p') {\r
2358       yyleng -= 2;\r
2359       yytext[yyleng] = NULLCHAR;\r
2360     } else if (yytext[yyleng-1] == '.') {\r
2361       yyleng -= 4;\r
2362       yytext[yyleng] = NULLCHAR;\r
2363     }\r
2364 \r
2365     /* remove the [xX:-] */\r
2366     if ((yytext[1] == 'x') || (yytext[1] == 'X')\r
2367         || (yytext[1] == ':') || (yytext[1] == '-')) skip = 1;\r
2368 \r
2369     currentMoveString[0] = yytext[0];\r
2370     currentMoveString[2] = yytext[1+skip];\r
2371     currentMoveString[3] = yytext[2+skip];\r
2372 \r
2373     /* [HGM] do not allow values beyond board size */\r
2374     if(currentMoveString[0] - AAA >= BOARD_RGHT   ||\r
2375        currentMoveString[3] - ONE >= BOARD_HEIGHT ||\r
2376        currentMoveString[3] - ONE <  0            ||\r
2377        currentMoveString[2] - AAA >= BOARD_RGHT   ||\r
2378        currentMoveString[0] - AAA <  BOARD_LEFT   ||\r
2379        currentMoveString[2] - AAA <  BOARD_LEFT     )\r
2380       return ImpossibleMove;\r
2381 \r
2382     if (gameInfo.variant == VariantXiangqi && /* [HGM] In Xiangqi rank stays same */\r
2383          currentMoveString[0] != currentMoveString[2] ) {\r
2384         currentMoveString[1] = yytext[2+skip];\r
2385     } else \r
2386     if (WhiteOnMove(yyboardindex)) {\r
2387         if (yytext[2+skip] == ONE) return (int) ImpossibleMove;\r
2388         currentMoveString[1] = yytext[2+skip] - 1;\r
2389         if(boards[yyboardindex][currentMoveString[1]-ONE][currentMoveString[0]-AAA] != WhitePawn) \r
2390                 return ImpossibleMove;\r
2391     } else {\r
2392         currentMoveString[1] = currentMoveString[3] + 1;\r
2393         if (currentMoveString[3] == ONE+BOARD_HEIGHT-1) return (int) ImpossibleMove;\r
2394         if(boards[yyboardindex][currentMoveString[1]-ONE][currentMoveString[0]-AAA] != BlackPawn) \r
2395                 return ImpossibleMove;\r
2396     }\r
2397     if (yyleng-skip > 3) {\r
2398         if (yytext[yyleng-1] == ')')\r
2399           c = currentMoveString[4] = ToLower(yytext[yyleng-2]);\r
2400         else\r
2401           c = currentMoveString[4] = ToLower(yytext[yyleng-1]);\r
2402         currentMoveString[5] = NULLCHAR;\r
2403         if(c != '=' && c != '+' && CharToPiece(c) == EmptySquare)\r
2404             return IllegalMove;\r
2405     } else {\r
2406         currentMoveString[4] = NULLCHAR;\r
2407     }\r
2408 \r
2409     result = LegalityTest(boards[yyboardindex],\r
2410                           PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: might think we can e.p.!\r
2411                           currentMoveString[1] - ONE,\r
2412                           currentMoveString[0] - AAA,\r
2413                           currentMoveString[3] - ONE,\r
2414                           currentMoveString[2] - AAA,\r
2415                           currentMoveString[4]);\r
2416 \r
2417     if (currentMoveString[4] == NULLCHAR &&\r
2418         (result == WhitePromotionQueen  || result == BlackPromotionQueen ||\r
2419          result == WhitePromotionKnight || result == BlackPromotionKnight)) {\r
2420         currentMoveString[4] = PieceToChar(BlackQueen);\r
2421         // [HGM] shatranj: take care of variants without Queen\r
2422         if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk)\r
2423             currentMoveString[4] = PieceToChar(BlackFerz);\r
2424         if(gameInfo.variant == VariantGreat)\r
2425             currentMoveString[4] = PieceToChar(BlackMan);\r
2426         currentMoveString[5] = NULLCHAR;\r
2427     }\r
2428 \r
2429     if (result != IllegalMove) return (int) result;\r
2430 \r
2431     /* Special case: improperly written en passant capture */\r
2432     if (WhiteOnMove(yyboardindex)) {\r
2433         if (currentMoveString[3] == '5') {\r
2434             currentMoveString[1] = '5';\r
2435             currentMoveString[3] = '6';\r
2436         } else {\r
2437             return (int) IllegalMove;\r
2438         }\r
2439     } else {\r
2440         if (currentMoveString[3] == '4') {\r
2441             currentMoveString[1] = '4';\r
2442             currentMoveString[3] = '3';\r
2443         } else {\r
2444             return (int) IllegalMove;\r
2445         }\r
2446     }\r
2447 \r
2448     result = LegalityTest(boards[yyboardindex],\r
2449                           PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: might think we can e.p.!\r
2450                           currentMoveString[1] - ONE,\r
2451                           currentMoveString[0] - AAA,\r
2452                           currentMoveString[3] - ONE,\r
2453                           currentMoveString[2] - AAA,\r
2454                           currentMoveString[4]);\r
2455 \r
2456     if (result == WhiteCapturesEnPassant || result == BlackCapturesEnPassant)\r
2457       return (int) result;\r
2458     else\r
2459       return (int) IllegalMove;\r
2460 }\r
2461         YY_BREAK
2462 case 6:
2463 YY_RULE_SETUP
2464 #line 543 "parser.l"
2465 {\r
2466     /*\r
2467      * piece move, possibly ambiguous\r
2468      */\r
2469     DisambiguateClosure cl;\r
2470     int skip = 0, skip2 = 0, promoted = 0;\r
2471 \r
2472     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
2473 \r
2474     if(yytext[0] == '+') promoted = skip = skip2 = 1;\r
2475 \r
2476     /* remove the [xX:-] */\r
2477     if ((yytext[1+skip] == 'x') || (yytext[1+skip] == 'X')\r
2478         || (yytext[1+skip] == ':') || (yytext[1+skip] == '-')) skip++;\r
2479 \r
2480     if (WhiteOnMove(yyboardindex)) {\r
2481         cl.pieceIn = CharToPiece(ToUpper(yytext[skip2]));\r
2482     } else {\r
2483         cl.pieceIn = CharToPiece(ToLower(yytext[skip2]));\r
2484     }\r
2485     if(promoted) cl.pieceIn = (ChessSquare) (PROMOTED cl.pieceIn);\r
2486 \r
2487     cl.rfIn = -1;\r
2488     cl.ffIn = -1;\r
2489     cl.rtIn = yytext[2+skip] - ONE;\r
2490     cl.ftIn = yytext[1+skip] - AAA;\r
2491     cl.promoCharIn = NULLCHAR;\r
2492 \r
2493     if(yyleng-skip > 3) /* [HGM] can have Shogi-style promotion */\r
2494         cl.promoCharIn = yytext[yyleng-1];\r
2495 \r
2496     if (appData.debugMode) {\r
2497         fprintf(debugFP, "Parser Qa1: yyleng=%d,  %d(%d,%d)-(%d,%d) = %d (%c)\n",\r
2498         yyleng,\r
2499         cl.pieceIn,cl.ffIn,cl.rfIn,cl.ftIn,cl.rtIn,cl.promoCharIn,cl.promoCharIn?cl.promoCharIn:' ');\r
2500     }\r
2501 \r
2502     /* [HGM] but do not allow values beyond board size */\r
2503     if(cl.rtIn >= BOARD_HEIGHT ||\r
2504        cl.rtIn <  0            ||\r
2505        cl.ftIn >= BOARD_RGHT   ||\r
2506        cl.ftIn <  BOARD_LEFT     )\r
2507       return ImpossibleMove;\r
2508 \r
2509     Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);\r
2510 \r
2511     currentMoveString[0] = cl.ff + AAA;\r
2512     currentMoveString[1] = cl.rf + ONE;\r
2513     currentMoveString[2] = cl.ft + AAA;\r
2514     currentMoveString[3] = cl.rt + ONE;\r
2515     currentMoveString[4] = cl.promoChar;\r
2516     currentMoveString[5] = NULLCHAR;\r
2517 \r
2518     return (int) cl.kind;\r
2519 }\r
2520         YY_BREAK
2521 case 7:
2522 YY_RULE_SETUP
2523 #line 599 "parser.l"
2524 {\r
2525     /*\r
2526      * piece move with rank or file disambiguator\r
2527      */\r
2528     DisambiguateClosure cl;\r
2529     int skip = 0, skip2 = 0; int promoted=0;\r
2530 \r
2531     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
2532 \r
2533     if(yytext[0]=='+') promoted = skip = skip2 = 1;\r
2534 \r
2535     /* remove the [xX:-] */\r
2536     if ((yytext[2+skip] == 'x') || (yytext[2+skip] == 'X')\r
2537         || (yytext[2+skip] == ':') || (yytext[2+skip] == '-')) skip++;\r
2538 \r
2539     if (WhiteOnMove(yyboardindex)) {\r
2540         cl.pieceIn = CharToPiece(ToUpper(yytext[skip2]));\r
2541     } else {\r
2542         cl.pieceIn = CharToPiece(ToLower(yytext[skip2]));\r
2543     }\r
2544     if(promoted) cl.pieceIn = (ChessSquare) (PROMOTED cl.pieceIn);\r
2545 \r
2546     if (isalpha(yytext[1+skip2])) {\r
2547         cl.rfIn = -1;\r
2548         cl.ffIn = yytext[1+skip2] - AAA;\r
2549        \r
2550         if(cl.ffIn >= BOARD_RGHT ||\r
2551            cl.ffIn <  BOARD_LEFT   ) return 0;\r
2552     } else {\r
2553         cl.rfIn = yytext[1+skip2] - ONE;\r
2554         cl.ffIn = -1;\r
2555         if(cl.rfIn >= BOARD_HEIGHT ||\r
2556            cl.rfIn <  0) return 0;\r
2557     }\r
2558     cl.rtIn = yytext[3+skip] - ONE;\r
2559     cl.ftIn = yytext[2+skip] - AAA;\r
2560     cl.promoCharIn = NULLCHAR;\r
2561 \r
2562     if(yyleng-skip > 4) /* [HGM] can have Shogi-style promotion */\r
2563         cl.promoCharIn = yytext[yyleng-1];\r
2564 \r
2565     /* [HGM] do not allow values beyond board size */\r
2566     if(cl.rtIn >= BOARD_HEIGHT ||\r
2567        cl.rtIn <  0            ||\r
2568        cl.ftIn >= BOARD_RGHT   ||\r
2569        cl.ftIn <  BOARD_LEFT     )\r
2570       return ImpossibleMove;\r
2571 \r
2572     Disambiguate(boards[yyboardindex], PosFlags(yyboardindex), &cl);\r
2573 \r
2574     currentMoveString[0] = cl.ff + AAA;\r
2575     currentMoveString[1] = cl.rf + ONE;\r
2576     currentMoveString[2] = cl.ft + AAA;\r
2577     currentMoveString[3] = cl.rt + ONE;\r
2578     currentMoveString[4] = cl.promoChar;\r
2579     currentMoveString[5] = NULLCHAR;\r
2580 \r
2581     return (int) cl.kind;\r
2582 }\r
2583         YY_BREAK
2584 case 8:
2585 YY_RULE_SETUP
2586 #line 659 "parser.l"
2587 {\r
2588     int rf, ff, rt, ft;\r
2589 \r
2590     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
2591 \r
2592     /* [HGM] all squares referenced to board edges in stead of absolute */\r
2593     if (WhiteOnMove(yyboardindex)) {\r
2594         if (boards[yyboardindex][0][(BOARD_WIDTH-1)>>1] == WhiteKing) {\r
2595             /* ICS wild castling */\r
2596             rf = 0;\r
2597             ff = (BOARD_WIDTH-1)>>1;\r
2598             rt = 0;\r
2599             ft = BOARD_RGHT-3;\r
2600         } else {\r
2601             rf = 0;\r
2602             ff = BOARD_WIDTH>>1;\r
2603             rt = 0;\r
2604             ft = BOARD_LEFT+2;\r
2605         }\r
2606     } else{ \r
2607         if (boards[yyboardindex][BOARD_HEIGHT-1][(BOARD_WIDTH-1)>>1] == BlackKing) {\r
2608             /* ICS wild castling */\r
2609             rf = BOARD_HEIGHT-1;\r
2610             ff = (BOARD_WIDTH-1)>>1;\r
2611             rt = BOARD_HEIGHT-1;\r
2612             ft = BOARD_RGHT-3;\r
2613         } else {\r
2614             rf = BOARD_HEIGHT-1;\r
2615             ff = BOARD_WIDTH>>1;\r
2616             rt = BOARD_HEIGHT-1;\r
2617             ft = BOARD_LEFT+2;\r
2618         }\r
2619     }\r
2620     if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
2621         if (WhiteOnMove(yyboardindex)) {\r
2622             ff = initialRights[2];\r
2623             ft = initialRights[1];\r
2624         } else {\r
2625             ff = initialRights[5];\r
2626             ft = initialRights[4];\r
2627         }\r
2628         if (appData.debugMode) \r
2629         {\r
2630           fprintf(debugFP, "Parser FRC long %d %d\n", ff, ft);\r
2631         };\r
2632         if(ff < 0 || ft < 0) return 0;\r
2633     }\r
2634     sprintf(currentMoveString, "%c%c%c%c",ff+AAA,rf+ONE,ft+AAA,rt+ONE);\r
2635     if (appData.debugMode) {\r
2636         fprintf(debugFP, "long castling %d %d\n", ff, ft);\r
2637     }\r
2638     return (int) LegalityTest(boards[yyboardindex],\r
2639                               PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: e.p.!\r
2640                               rf, ff, rt, ft, NULLCHAR);\r
2641 }\r
2642         YY_BREAK
2643 case 9:
2644 YY_RULE_SETUP
2645 #line 715 "parser.l"
2646 {\r
2647     int rf, ff, rt, ft;\r
2648 \r
2649     if (yyskipmoves) return (int) AmbiguousMove; /* not disambiguated */\r
2650 \r
2651     if (WhiteOnMove(yyboardindex)) {\r
2652         if (boards[yyboardindex][0][(BOARD_WIDTH-1)>>1] == WhiteKing) {\r
2653             /* ICS wild castling */\r
2654             rf = 0;\r
2655             ff = (BOARD_WIDTH-1)>>1;\r
2656             rt = 0;\r
2657             ft = BOARD_LEFT+1;\r
2658         } else {\r
2659             rf = 0;\r
2660             ff = BOARD_WIDTH>>1;\r
2661             rt = 0;\r
2662             ft = BOARD_RGHT-2;\r
2663         }\r
2664     } else {\r
2665         if (boards[yyboardindex][BOARD_HEIGHT-1][(BOARD_WIDTH-1)>>1] == BlackKing) {\r
2666             /* ICS wild castling */\r
2667             rf = BOARD_HEIGHT-1;\r
2668             ff = (BOARD_WIDTH-1)>>1;\r
2669             rt = BOARD_HEIGHT-1;\r
2670             ft = BOARD_LEFT+1;\r
2671         } else {\r
2672             rf = BOARD_HEIGHT-1;\r
2673             ff = BOARD_WIDTH>>1;\r
2674             rt = BOARD_HEIGHT-1;\r
2675             ft = BOARD_RGHT-2;\r
2676         }\r
2677     }\r
2678     if(PosFlags(0) & F_FRC_TYPE_CASTLING) {
2679         if (WhiteOnMove(yyboardindex)) {\r
2680             ff = initialRights[2];\r
2681             ft = initialRights[0];\r
2682         } else {\r
2683             ff = initialRights[5];\r
2684             ft = initialRights[3];\r
2685         }\r
2686     if (appData.debugMode) {\r
2687         fprintf(debugFP, "Parser FRC short %d %d\n", ff, ft);\r
2688     }\r
2689         if(ff < 0 || ft < 0) return 0;\r
2690     }\r
2691     sprintf(currentMoveString, "%c%c%c%c",ff+AAA,rf+ONE,ft+AAA,rt+ONE);\r
2692     if (appData.debugMode) {\r
2693         fprintf(debugFP, "short castling %d %d\n", ff, ft);\r
2694     }\r
2695 \r
2696     return (int) LegalityTest(boards[yyboardindex],\r
2697                               PosFlags(yyboardindex)&~F_MANDATORY_CAPTURE, // [HGM] losers: e.p.!\r
2698                               rf, ff, rt, ft, NULLCHAR);\r
2699 }\r
2700         YY_BREAK
2701 case 10:
2702 YY_RULE_SETUP
2703 #line 770 "parser.l"
2704 {\r
2705     /* Bughouse piece drop.  No legality checking for now. */\r
2706     currentMoveString[1] = '@';\r
2707     currentMoveString[2] = yytext[2];\r
2708     currentMoveString[3] = yytext[3];\r
2709     currentMoveString[4] = NULLCHAR;\r
2710 \r
2711     if (appData.debugMode) {\r
2712         fprintf(debugFP, "Drop: %s\n", currentMoveString);\r
2713     }\r
2714     /* [HGM] do not allow values beyond board size */\r
2715     if(currentMoveString[3] - ONE >= BOARD_HEIGHT ||\r
2716        currentMoveString[2] - AAA >= BOARD_WIDTH     )\r
2717       return ImpossibleMove;\r
2718 \r
2719     if (WhiteOnMove(yyboardindex)) {\r
2720         currentMoveString[0] = ToUpper(yytext[0]);\r
2721         return (int) WhiteDrop;\r
2722     } else {\r
2723         currentMoveString[0] = ToLower(yytext[0]);\r
2724         return (int) BlackDrop;\r
2725     }\r
2726 }\r
2727         YY_BREAK
2728 case 11:
2729 YY_RULE_SETUP
2730 #line 794 "parser.l"
2731 {\r
2732     if (WhiteOnMove(yyboardindex))\r
2733       return (int) BlackWins;\r
2734     else\r
2735       return (int) WhiteWins;\r
2736 }\r
2737         YY_BREAK
2738 case 12:
2739 YY_RULE_SETUP
2740 #line 801 "parser.l"
2741 {\r
2742     return (int) (ToUpper(yytext[0]) == 'W' ? BlackWins : WhiteWins);\r
2743 }\r
2744         YY_BREAK
2745 case 13:
2746 YY_RULE_SETUP
2747 #line 805 "parser.l"
2748 {\r
2749     return (int) GameUnfinished;\r
2750 }\r
2751         YY_BREAK
2752 case 14:
2753 YY_RULE_SETUP
2754 #line 809 "parser.l"
2755 {\r
2756     return (int) GameIsDrawn;\r
2757 }\r
2758         YY_BREAK
2759 case 15:
2760 YY_RULE_SETUP
2761 #line 813 "parser.l"
2762 {\r
2763     return (int) GameIsDrawn;\r
2764 }\r
2765         YY_BREAK
2766 case 16:
2767 YY_RULE_SETUP
2768 #line 817 "parser.l"
2769 {\r
2770     if (WhiteOnMove(yyboardindex))\r
2771       return (int) BlackWins;\r
2772     else\r
2773       return (int) WhiteWins;\r
2774 }\r
2775         YY_BREAK
2776 case 17:
2777 YY_RULE_SETUP
2778 #line 824 "parser.l"
2779 {\r
2780     if (WhiteOnMove(yyboardindex))\r
2781       return (int) BlackWins;\r
2782     else\r
2783       return (int) WhiteWins;\r
2784 }\r
2785         YY_BREAK
2786 case 18:
2787 YY_RULE_SETUP
2788 #line 831 "parser.l"
2789 {\r
2790     return (int) GameIsDrawn;\r
2791 }\r
2792         YY_BREAK
2793 case 19:
2794 YY_RULE_SETUP
2795 #line 835 "parser.l"
2796 {\r
2797     return (int) GameIsDrawn;\r
2798 }\r
2799         YY_BREAK
2800 case 20:
2801 YY_RULE_SETUP
2802 #line 839 "parser.l"
2803\r
2804     return (int) (ToUpper(yytext[0]) == 'W' ? WhiteWins : BlackWins);\r
2805 }\r
2806         YY_BREAK
2807 case 21:
2808 YY_RULE_SETUP
2809 #line 843 "parser.l"
2810\r
2811     return (int) (ToUpper(yytext[0]) == 'W' ? BlackWins : WhiteWins);\r
2812 }\r
2813         YY_BREAK
2814 case 22:
2815 YY_RULE_SETUP
2816 #line 847 "parser.l"
2817\r
2818     return (int) WhiteWins;\r
2819 }\r
2820         YY_BREAK
2821 case 23:
2822 YY_RULE_SETUP
2823 #line 851 "parser.l"
2824\r
2825     return (int) BlackWins;\r
2826 }\r
2827         YY_BREAK
2828 case 24:
2829 YY_RULE_SETUP
2830 #line 855 "parser.l"
2831 {\r
2832     return (int) GameIsDrawn;\r
2833 }\r
2834         YY_BREAK
2835 case 25:
2836 YY_RULE_SETUP
2837 #line 859 "parser.l"
2838 {\r
2839     return (int) GameUnfinished;\r
2840 }\r
2841         YY_BREAK
2842 case 26:
2843 /* rule 26 can match eol */
2844 YY_RULE_SETUP
2845 #line 863 "parser.l"
2846 {\r
2847     /* move numbers */\r
2848     if ((yyleng == 1) && (yytext[0] == '1'))\r
2849       return (int) MoveNumberOne;\r
2850 }\r
2851         YY_BREAK
2852 case 27:
2853 YY_RULE_SETUP
2854 #line 869 "parser.l"
2855 {\r
2856     /* elapsed time indication, e.g. (0:12) or {10:21.071} */ \r
2857     return (int) ElapsedTime;\r
2858 }\r
2859         YY_BREAK
2860 case 28:
2861 /* rule 28 can match eol */
2862 YY_RULE_SETUP
2863 #line 874 "parser.l"
2864 {\r
2865     /* position diagram enclosed in [-- --] */\r
2866     return (int) PositionDiagram;\r
2867 }\r
2868         YY_BREAK
2869 case 29:
2870 /* rule 29 can match eol */
2871 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2872 (yy_c_buf_p) = yy_cp -= 1;
2873 YY_DO_BEFORE_ACTION; /* set up yytext again */
2874 YY_RULE_SETUP
2875 #line 879 "parser.l"
2876 {\r
2877     /* position diagram enclosed in {-- --} */\r
2878     return (int) PositionDiagram;\r
2879 }\r
2880         YY_BREAK
2881 case 30:
2882 /* rule 30 can match eol */
2883 YY_RULE_SETUP
2884 #line 884 "parser.l"
2885 {\r
2886     return (int) PGNTag;\r
2887 }    \r
2888         YY_BREAK
2889 case 31:
2890 YY_RULE_SETUP
2891 #line 888 "parser.l"
2892 {\r
2893     return (int) GNUChessGame;\r
2894 }\r
2895         YY_BREAK
2896 case 32:
2897 /* rule 32 can match eol */
2898 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2899 (yy_c_buf_p) = yy_cp -= 1;
2900 YY_DO_BEFORE_ACTION; /* set up yytext again */
2901 YY_RULE_SETUP
2902 #line 892 "parser.l"
2903 {\r
2904     return (int) XBoardGame;\r
2905 }\r
2906         YY_BREAK
2907 case 33:
2908 YY_RULE_SETUP
2909 #line 896 "parser.l"
2910 {                               /* numeric annotation glyph */\r
2911     return (int) NAG;\r
2912 }\r
2913         YY_BREAK
2914 case 34:
2915 /* rule 34 can match eol */
2916 YY_RULE_SETUP
2917 #line 900 "parser.l"
2918 {                               /* anything in {} */\r
2919     return (int) Comment; \r
2920 }\r
2921         YY_BREAK
2922 case 35:
2923 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2924 (yy_c_buf_p) = yy_cp -= 1;
2925 YY_DO_BEFORE_ACTION; /* set up yytext again */
2926 YY_RULE_SETUP
2927 #line 904 "parser.l"
2928 {                                          /* ; to end of line */\r
2929     return (int) Comment;\r
2930 }\r
2931         YY_BREAK
2932 case 36:
2933 /* rule 36 can match eol */
2934 YY_RULE_SETUP
2935 #line 908 "parser.l"
2936 {                               /* anything in [] */\r
2937     return (int) Comment; \r
2938 }\r
2939         YY_BREAK
2940 case 37:
2941 /* rule 37 can match eol */
2942 YY_RULE_SETUP
2943 #line 912 "parser.l"
2944 { /* very nested () */\r
2945     return (int) Comment; \r
2946 }\r
2947         YY_BREAK
2948 case 38:
2949 /* rule 38 can match eol */
2950 YY_RULE_SETUP
2951 #line 916 "parser.l"
2952 {                               /* >=2 chars in () */\r
2953     return (int) Comment; \r
2954 }       \r
2955         YY_BREAK
2956 case 39:
2957 /* rule 39 can match eol */
2958 YY_RULE_SETUP
2959 #line 920 "parser.l"
2960 {\r
2961         /* Skip mail headers */\r
2962 }\r
2963         YY_BREAK
2964 case 40:
2965 YY_RULE_SETUP
2966 #line 924 "parser.l"
2967 {\r
2968         /* Skip random words */\r
2969 }\r
2970         YY_BREAK
2971 case 41:
2972 /* rule 41 can match eol */
2973 YY_RULE_SETUP
2974 #line 928 "parser.l"
2975 {\r
2976         /* Skip everything else */\r
2977 }\r
2978         YY_BREAK
2979 case 42:
2980 YY_RULE_SETUP
2981 #line 932 "parser.l"
2982 ECHO;
2983         YY_BREAK
2984 #line 2985 "parser.c"
2985                         case YY_STATE_EOF(INITIAL):
2986                                 yyterminate();
2987
2988         case YY_END_OF_BUFFER:
2989                 {
2990                 /* Amount of text matched not including the EOB char. */
2991                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2992
2993                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2994                 *yy_cp = (yy_hold_char);
2995                 YY_RESTORE_YY_MORE_OFFSET
2996
2997                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2998                         {
2999                         /* We're scanning a new file or input source.  It's
3000                          * possible that this happened because the user
3001                          * just pointed yyin at a new source and called
3002                          * yylex().  If so, then we have to assure
3003                          * consistency between YY_CURRENT_BUFFER and our
3004                          * globals.  Here is the right place to do so, because
3005                          * this is the first action (other than possibly a
3006                          * back-up) that will match for the new input source.
3007                          */
3008                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
3009                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
3010                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
3011                         }
3012
3013                 /* Note that here we test for yy_c_buf_p "<=" to the position
3014                  * of the first EOB in the buffer, since yy_c_buf_p will
3015                  * already have been incremented past the NUL character
3016                  * (since all states make transitions on EOB to the
3017                  * end-of-buffer state).  Contrast this with the test
3018                  * in input().
3019                  */
3020                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3021                         { /* This was really a NUL. */
3022                         yy_state_type yy_next_state;
3023
3024                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
3025
3026                         yy_current_state = yy_get_previous_state(  );
3027
3028                         /* Okay, we're now positioned to make the NUL
3029                          * transition.  We couldn't have
3030                          * yy_get_previous_state() go ahead and do it
3031                          * for us because it doesn't know how to deal
3032                          * with the possibility of jamming (and we don't
3033                          * want to build jamming into it because then it
3034                          * will run more slowly).
3035                          */
3036
3037                         yy_next_state = yy_try_NUL_trans( yy_current_state );
3038
3039                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3040
3041                         if ( yy_next_state )
3042                                 {
3043                                 /* Consume the NUL. */
3044                                 yy_cp = ++(yy_c_buf_p);
3045                                 yy_current_state = yy_next_state;
3046                                 goto yy_match;
3047                                 }
3048
3049                         else
3050                                 {
3051                                 yy_cp = (yy_c_buf_p);
3052                                 goto yy_find_action;
3053                                 }
3054                         }
3055
3056                 else switch ( yy_get_next_buffer(  ) )
3057                         {
3058                         case EOB_ACT_END_OF_FILE:
3059                                 {
3060                                 (yy_did_buffer_switch_on_eof) = 0;
3061
3062                                 if ( yywrap( ) )
3063                                         {
3064                                         /* Note: because we've taken care in
3065                                          * yy_get_next_buffer() to have set up
3066                                          * yytext, we can now set up
3067                                          * yy_c_buf_p so that if some total
3068                                          * hoser (like flex itself) wants to
3069                                          * call the scanner after we return the
3070                                          * YY_NULL, it'll still work - another
3071                                          * YY_NULL will get returned.
3072                                          */
3073                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
3074
3075                                         yy_act = YY_STATE_EOF(YY_START);
3076                                         goto do_action;
3077                                         }
3078
3079                                 else
3080                                         {
3081                                         if ( ! (yy_did_buffer_switch_on_eof) )
3082                                                 YY_NEW_FILE;
3083                                         }
3084                                 break;
3085                                 }
3086
3087                         case EOB_ACT_CONTINUE_SCAN:
3088                                 (yy_c_buf_p) =
3089                                         (yytext_ptr) + yy_amount_of_matched_text;
3090
3091                                 yy_current_state = yy_get_previous_state(  );
3092
3093                                 yy_cp = (yy_c_buf_p);
3094                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3095                                 goto yy_match;
3096
3097                         case EOB_ACT_LAST_MATCH:
3098                                 (yy_c_buf_p) =
3099                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
3100
3101                                 yy_current_state = yy_get_previous_state(  );
3102
3103                                 yy_cp = (yy_c_buf_p);
3104                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3105                                 goto yy_find_action;
3106                         }
3107                 break;
3108                 }
3109
3110         default:
3111                 YY_FATAL_ERROR(
3112                         "fatal flex scanner internal error--no action found" );
3113         } /* end of action switch */
3114                 } /* end of scanning one token */
3115 } /* end of yylex */
3116
3117 /* yy_get_next_buffer - try to read in a new buffer
3118  *
3119  * Returns a code representing an action:
3120  *      EOB_ACT_LAST_MATCH -
3121  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
3122  *      EOB_ACT_END_OF_FILE - end of file
3123  */
3124 static int yy_get_next_buffer (void)
3125 {
3126         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
3127         register char *source = (yytext_ptr);
3128         register int number_to_move, i;
3129         int ret_val;
3130
3131         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
3132                 YY_FATAL_ERROR(
3133                 "fatal flex scanner internal error--end of buffer missed" );
3134
3135         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
3136                 { /* Don't try to fill the buffer, so this is an EOF. */
3137                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
3138                         {
3139                         /* We matched a single character, the EOB, so
3140                          * treat this as a final EOF.
3141                          */
3142                         return EOB_ACT_END_OF_FILE;
3143                         }
3144
3145                 else
3146                         {
3147                         /* We matched some text prior to the EOB, first
3148                          * process it.
3149                          */
3150                         return EOB_ACT_LAST_MATCH;
3151                         }
3152                 }
3153
3154         /* Try to read more data. */
3155
3156         /* First move last chars to start of buffer. */
3157         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
3158
3159         for ( i = 0; i < number_to_move; ++i )
3160                 *(dest++) = *(source++);
3161
3162         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
3163                 /* don't do the read, it's not guaranteed to return an EOF,
3164                  * just force an EOF
3165                  */
3166                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
3167
3168         else
3169                 {
3170                         int num_to_read =
3171                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
3172
3173                 while ( num_to_read <= 0 )
3174                         { /* Not enough room in the buffer - grow it. */
3175
3176                         YY_FATAL_ERROR(
3177 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
3178
3179                         }
3180
3181                 if ( num_to_read > YY_READ_BUF_SIZE )
3182                         num_to_read = YY_READ_BUF_SIZE;
3183
3184                 /* Read in more data. */
3185                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
3186                         (yy_n_chars), (size_t) num_to_read );
3187
3188                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3189                 }
3190
3191         if ( (yy_n_chars) == 0 )
3192                 {
3193                 if ( number_to_move == YY_MORE_ADJ )
3194                         {
3195                         ret_val = EOB_ACT_END_OF_FILE;
3196                         yyrestart(yyin  );
3197                         }
3198
3199                 else
3200                         {
3201                         ret_val = EOB_ACT_LAST_MATCH;
3202                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
3203                                 YY_BUFFER_EOF_PENDING;
3204                         }
3205                 }
3206
3207         else
3208                 ret_val = EOB_ACT_CONTINUE_SCAN;
3209
3210         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
3211                 /* Extend the array by 50%, plus the number we really need. */
3212                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
3213                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
3214                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
3215                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
3216         }
3217
3218         (yy_n_chars) += number_to_move;
3219         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
3220         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
3221
3222         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
3223
3224         return ret_val;
3225 }
3226
3227 /* yy_get_previous_state - get the state just before the EOB char was reached */
3228
3229     static yy_state_type yy_get_previous_state (void)
3230 {
3231         register yy_state_type yy_current_state;
3232         register char *yy_cp;
3233     
3234         yy_current_state = (yy_start);
3235         yy_current_state += YY_AT_BOL();
3236
3237         (yy_state_ptr) = (yy_state_buf);
3238         *(yy_state_ptr)++ = yy_current_state;
3239
3240         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
3241                 {
3242                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
3243                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3244                         {
3245                         yy_current_state = (int) yy_def[yy_current_state];
3246                         if ( yy_current_state >= 690 )
3247                                 yy_c = yy_meta[(unsigned int) yy_c];
3248                         }
3249                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
3250                 *(yy_state_ptr)++ = yy_current_state;
3251                 }
3252
3253         return yy_current_state;
3254 }
3255
3256 /* yy_try_NUL_trans - try to make a transition on the NUL character
3257  *
3258  * synopsis
3259  *      next_state = yy_try_NUL_trans( current_state );
3260  */
3261     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
3262 {
3263         register int yy_is_jam;
3264     
3265         register YY_CHAR yy_c = 1;
3266         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3267                 {
3268                 yy_current_state = (int) yy_def[yy_current_state];
3269                 if ( yy_current_state >= 690 )
3270                         yy_c = yy_meta[(unsigned int) yy_c];
3271                 }
3272         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
3273         yy_is_jam = (yy_current_state == 689);
3274         if ( ! yy_is_jam )
3275                 *(yy_state_ptr)++ = yy_current_state;
3276
3277         return yy_is_jam ? 0 : yy_current_state;
3278 }
3279
3280     static void yyunput (int c, register char * yy_bp )
3281 {
3282         register char *yy_cp;
3283     
3284     yy_cp = (yy_c_buf_p);
3285
3286         /* undo effects of setting up yytext */
3287         *yy_cp = (yy_hold_char);
3288
3289         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
3290                 { /* need to shift things up to make room */
3291                 /* +2 for EOB chars. */
3292                 register int number_to_move = (yy_n_chars) + 2;
3293                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
3294                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
3295                 register char *source =
3296                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
3297
3298                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
3299                         *--dest = *--source;
3300
3301                 yy_cp += (int) (dest - source);
3302                 yy_bp += (int) (dest - source);
3303                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
3304                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
3305
3306                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
3307                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
3308                 }
3309
3310         *--yy_cp = (char) c;
3311
3312         (yytext_ptr) = yy_bp;
3313         (yy_hold_char) = *yy_cp;
3314         (yy_c_buf_p) = yy_cp;
3315 }
3316
3317 #ifndef YY_NO_INPUT
3318 #ifdef __cplusplus
3319     static int yyinput (void)
3320 #else
3321     static int input  (void)
3322 #endif
3323
3324 {
3325         int c;
3326     
3327         *(yy_c_buf_p) = (yy_hold_char);
3328
3329         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
3330                 {
3331                 /* yy_c_buf_p now points to the character we want to return.
3332                  * If this occurs *before* the EOB characters, then it's a
3333                  * valid NUL; if not, then we've hit the end of the buffer.
3334                  */
3335                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3336                         /* This was really a NUL. */
3337                         *(yy_c_buf_p) = '\0';
3338
3339                 else
3340                         { /* need more input */
3341                         int offset = (yy_c_buf_p) - (yytext_ptr);
3342                         ++(yy_c_buf_p);
3343
3344                         switch ( yy_get_next_buffer(  ) )
3345                                 {
3346                                 case EOB_ACT_LAST_MATCH:
3347                                         /* This happens because yy_g_n_b()
3348                                          * sees that we've accumulated a
3349                                          * token and flags that we need to
3350                                          * try matching the token before
3351                                          * proceeding.  But for input(),
3352                                          * there's no matching to consider.
3353                                          * So convert the EOB_ACT_LAST_MATCH
3354                                          * to EOB_ACT_END_OF_FILE.
3355                                          */
3356
3357                                         /* Reset buffer status. */
3358                                         yyrestart(yyin );
3359
3360                                         /*FALLTHROUGH*/
3361
3362                                 case EOB_ACT_END_OF_FILE:
3363                                         {
3364                                         if ( yywrap( ) )
3365                                                 return EOF;
3366
3367                                         if ( ! (yy_did_buffer_switch_on_eof) )
3368                                                 YY_NEW_FILE;
3369 #ifdef __cplusplus
3370                                         return yyinput();
3371 #else
3372                                         return input();
3373 #endif
3374                                         }
3375
3376                                 case EOB_ACT_CONTINUE_SCAN:
3377                                         (yy_c_buf_p) = (yytext_ptr) + offset;
3378                                         break;
3379                                 }
3380                         }
3381                 }
3382
3383         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
3384         *(yy_c_buf_p) = '\0';   /* preserve yytext */
3385         (yy_hold_char) = *++(yy_c_buf_p);
3386
3387         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
3388
3389         return c;
3390 }
3391 #endif  /* ifndef YY_NO_INPUT */
3392
3393 /** Immediately switch to a different input stream.
3394  * @param input_file A readable stream.
3395  * 
3396  * @note This function does not reset the start condition to @c INITIAL .
3397  */
3398     void yyrestart  (FILE * input_file )
3399 {
3400     
3401         if ( ! YY_CURRENT_BUFFER ){
3402         yyensure_buffer_stack ();
3403                 YY_CURRENT_BUFFER_LVALUE =
3404             yy_create_buffer(yyin,YY_BUF_SIZE );
3405         }
3406
3407         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
3408         yy_load_buffer_state( );
3409 }
3410
3411 /** Switch to a different input buffer.
3412  * @param new_buffer The new input buffer.
3413  * 
3414  */
3415     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
3416 {
3417     
3418         /* TODO. We should be able to replace this entire function body
3419          * with
3420          *              yypop_buffer_state();
3421          *              yypush_buffer_state(new_buffer);
3422      */
3423         yyensure_buffer_stack ();
3424         if ( YY_CURRENT_BUFFER == new_buffer )
3425                 return;
3426
3427         if ( YY_CURRENT_BUFFER )
3428                 {
3429                 /* Flush out information for old buffer. */
3430                 *(yy_c_buf_p) = (yy_hold_char);
3431                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3432                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3433                 }
3434
3435         YY_CURRENT_BUFFER_LVALUE = new_buffer;
3436         yy_load_buffer_state( );
3437
3438         /* We don't actually know whether we did this switch during
3439          * EOF (yywrap()) processing, but the only time this flag
3440          * is looked at is after yywrap() is called, so it's safe
3441          * to go ahead and always set it.
3442          */
3443         (yy_did_buffer_switch_on_eof) = 1;
3444 }
3445
3446 static void yy_load_buffer_state  (void)
3447 {
3448         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
3449         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
3450         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
3451         (yy_hold_char) = *(yy_c_buf_p);
3452 }
3453
3454 /** Allocate and initialize an input buffer state.
3455  * @param file A readable stream.
3456  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
3457  * 
3458  * @return the allocated buffer state.
3459  */
3460     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
3461 {
3462         YY_BUFFER_STATE b;
3463     
3464         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
3465         if ( ! b )
3466                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3467
3468         b->yy_buf_size = size;
3469
3470         /* yy_ch_buf has to be 2 characters longer than the size given because
3471          * we need to put in 2 end-of-buffer characters.
3472          */
3473         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
3474         if ( ! b->yy_ch_buf )
3475                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3476
3477         b->yy_is_our_buffer = 1;
3478
3479         yy_init_buffer(b,file );
3480
3481         return b;
3482 }
3483
3484 /** Destroy the buffer.
3485  * @param b a buffer created with yy_create_buffer()
3486  * 
3487  */
3488     void yy_delete_buffer (YY_BUFFER_STATE  b )
3489 {
3490     
3491         if ( ! b )
3492                 return;
3493
3494         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
3495                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
3496
3497         if ( b->yy_is_our_buffer )
3498                 yyfree((void *) b->yy_ch_buf  );
3499
3500         yyfree((void *) b  );
3501 }
3502
3503 #ifndef __cplusplus
3504 extern int isatty (int );
3505 #endif /* __cplusplus */
3506     
3507 /* Initializes or reinitializes a buffer.
3508  * This function is sometimes called more than once on the same buffer,
3509  * such as during a yyrestart() or at EOF.
3510  */
3511     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
3512
3513 {
3514         int oerrno = errno;
3515     
3516         yy_flush_buffer(b );
3517
3518         b->yy_input_file = file;
3519         b->yy_fill_buffer = 1;
3520
3521     /* If b is the current buffer, then yy_init_buffer was _probably_
3522      * called from yyrestart() or through yy_get_next_buffer.
3523      * In that case, we don't want to reset the lineno or column.
3524      */
3525     if (b != YY_CURRENT_BUFFER){
3526         b->yy_bs_lineno = 1;
3527         b->yy_bs_column = 0;
3528     }
3529
3530         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
3531     
3532         errno = oerrno;
3533 }
3534
3535 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
3536  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
3537  * 
3538  */
3539     void yy_flush_buffer (YY_BUFFER_STATE  b )
3540 {
3541         if ( ! b )
3542                 return;
3543
3544         b->yy_n_chars = 0;
3545
3546         /* We always need two end-of-buffer characters.  The first causes
3547          * a transition to the end-of-buffer state.  The second causes
3548          * a jam in that state.
3549          */
3550         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3551         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3552
3553         b->yy_buf_pos = &b->yy_ch_buf[0];
3554
3555         b->yy_at_bol = 1;
3556         b->yy_buffer_status = YY_BUFFER_NEW;
3557
3558         if ( b == YY_CURRENT_BUFFER )
3559                 yy_load_buffer_state( );
3560 }
3561
3562 /** Pushes the new state onto the stack. The new state becomes
3563  *  the current state. This function will allocate the stack
3564  *  if necessary.
3565  *  @param new_buffer The new state.
3566  *  
3567  */
3568 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
3569 {
3570         if (new_buffer == NULL)
3571                 return;
3572
3573         yyensure_buffer_stack();
3574
3575         /* This block is copied from yy_switch_to_buffer. */
3576         if ( YY_CURRENT_BUFFER )
3577                 {
3578                 /* Flush out information for old buffer. */
3579                 *(yy_c_buf_p) = (yy_hold_char);
3580                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3581                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3582                 }
3583
3584         /* Only push if top exists. Otherwise, replace top. */
3585         if (YY_CURRENT_BUFFER)
3586                 (yy_buffer_stack_top)++;
3587         YY_CURRENT_BUFFER_LVALUE = new_buffer;
3588
3589         /* copied from yy_switch_to_buffer. */
3590         yy_load_buffer_state( );
3591         (yy_did_buffer_switch_on_eof) = 1;
3592 }
3593
3594 /** Removes and deletes the top of the stack, if present.
3595  *  The next element becomes the new top.
3596  *  
3597  */
3598 void yypop_buffer_state (void)
3599 {
3600         if (!YY_CURRENT_BUFFER)
3601                 return;
3602
3603         yy_delete_buffer(YY_CURRENT_BUFFER );
3604         YY_CURRENT_BUFFER_LVALUE = NULL;
3605         if ((yy_buffer_stack_top) > 0)
3606                 --(yy_buffer_stack_top);
3607
3608         if (YY_CURRENT_BUFFER) {
3609                 yy_load_buffer_state( );
3610                 (yy_did_buffer_switch_on_eof) = 1;
3611         }
3612 }
3613
3614 /* Allocates the stack if it does not exist.
3615  *  Guarantees space for at least one push.
3616  */
3617 static void yyensure_buffer_stack (void)
3618 {
3619         int num_to_alloc;
3620     
3621         if (!(yy_buffer_stack)) {
3622
3623                 /* First allocation is just for 2 elements, since we don't know if this
3624                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
3625                  * immediate realloc on the next call.