* Bug #14313 fixed - Parser did not create a column separator after spaces and '...
[scilab.git] / scilab / modules / ast / src / cpp / parse / scanscilab.cpp
1
2 #line 3 "src/cpp/parse/scanscilab.cpp"
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 35
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
57 /* Limits of integral types. */
58 #ifndef INT8_MIN
59 #define INT8_MIN               (-128)
60 #endif
61 #ifndef INT16_MIN
62 #define INT16_MIN              (-32767-1)
63 #endif
64 #ifndef INT32_MIN
65 #define INT32_MIN              (-2147483647-1)
66 #endif
67 #ifndef INT8_MAX
68 #define INT8_MAX               (127)
69 #endif
70 #ifndef INT16_MAX
71 #define INT16_MAX              (32767)
72 #endif
73 #ifndef INT32_MAX
74 #define INT32_MAX              (2147483647)
75 #endif
76 #ifndef UINT8_MAX
77 #define UINT8_MAX              (255U)
78 #endif
79 #ifndef UINT16_MAX
80 #define UINT16_MAX             (65535U)
81 #endif
82 #ifndef UINT32_MAX
83 #define UINT32_MAX             (4294967295U)
84 #endif
85
86 #endif /* ! C99 */
87
88 #endif /* ! FLEXINT_H */
89
90 #ifdef __cplusplus
91
92 /* The "const" storage-class-modifier is valid. */
93 #define YY_USE_CONST
94
95 #else   /* ! __cplusplus */
96
97 /* C99 requires __STDC__ to be defined as 1. */
98 #if defined (__STDC__)
99
100 #define YY_USE_CONST
101
102 #endif  /* defined (__STDC__) */
103 #endif  /* ! __cplusplus */
104
105 #ifdef YY_USE_CONST
106 #define yyconst const
107 #else
108 #define yyconst
109 #endif
110
111 /* Returned upon end-of-file. */
112 #define YY_NULL 0
113
114 /* Promotes a possibly negative, possibly signed char to an unsigned
115  * integer for use as an array index.  If the signed char is negative,
116  * we want to instead treat it as an 8-bit unsigned char, hence the
117  * double cast.
118  */
119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
120
121 /* Enter a start condition.  This macro really ought to take a parameter,
122  * but we do it the disgusting crufty way forced on us by the ()-less
123  * definition of BEGIN.
124  */
125 #define BEGIN (yy_start) = 1 + 2 *
126
127 /* Translate the current start state into a value that can be later handed
128  * to BEGIN to return to the state.  The YYSTATE alias is for lex
129  * compatibility.
130  */
131 #define YY_START (((yy_start) - 1) / 2)
132 #define YYSTATE YY_START
133
134 /* Action number for EOF rule of a given start state. */
135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
136
137 /* Special action meaning "start processing a new file". */
138 #define YY_NEW_FILE yyrestart(yyin  )
139
140 #define YY_END_OF_BUFFER_CHAR 0
141
142 /* Size of default input buffer. */
143 #ifndef YY_BUF_SIZE
144 #ifdef __ia64__
145 /* On IA-64, the buffer size is 16k, not 8k.
146  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
147  * Ditto for the __ia64__ case accordingly.
148  */
149 #define YY_BUF_SIZE 32768
150 #else
151 #define YY_BUF_SIZE 16384
152 #endif /* __ia64__ */
153 #endif
154
155 /* The state buf must be large enough to hold one state per character in the main buffer.
156  */
157 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
158
159 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
160 #define YY_TYPEDEF_YY_BUFFER_STATE
161 typedef struct yy_buffer_state *YY_BUFFER_STATE;
162 #endif
163
164 extern int yyleng;
165
166 extern FILE *yyin, *yyout;
167
168 #define EOB_ACT_CONTINUE_SCAN 0
169 #define EOB_ACT_END_OF_FILE 1
170 #define EOB_ACT_LAST_MATCH 2
171
172 #define YY_LESS_LINENO(n)
173
174 /* Return all but the first "n" matched characters back to the input stream. */
175 #define yyless(n) \
176         do \
177                 { \
178                 /* Undo effects of setting up yytext. */ \
179         int yyless_macro_arg = (n); \
180         YY_LESS_LINENO(yyless_macro_arg);\
181                 *yy_cp = (yy_hold_char); \
182                 YY_RESTORE_YY_MORE_OFFSET \
183                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
184                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
185                 } \
186         while ( 0 )
187
188 #define unput(c) yyunput( c, (yytext_ptr)  )
189
190 #ifndef YY_TYPEDEF_YY_SIZE_T
191 #define YY_TYPEDEF_YY_SIZE_T
192 typedef size_t yy_size_t;
193 #endif
194
195 #ifndef YY_STRUCT_YY_BUFFER_STATE
196 #define YY_STRUCT_YY_BUFFER_STATE
197 struct yy_buffer_state
198 {
199 FILE *yy_input_file;
200
201 char *yy_ch_buf;                /* input buffer */
202 char *yy_buf_pos;               /* current position in input buffer */
203
204 /* Size of input buffer in bytes, not including room for EOB
205  * characters.
206  */
207 yy_size_t yy_buf_size;
208
209 /* Number of characters read into yy_ch_buf, not including EOB
210  * characters.
211  */
212 int yy_n_chars;
213
214 /* Whether we "own" the buffer - i.e., we know we created it,
215  * and can realloc() it to grow it, and should free() it to
216  * delete it.
217  */
218 int yy_is_our_buffer;
219
220 /* Whether this is an "interactive" input source; if so, and
221  * if we're using stdio for input, then we want to use getc()
222  * instead of fread(), to make sure we stop fetching input after
223  * each newline.
224  */
225 int yy_is_interactive;
226
227 /* Whether we're considered to be at the beginning of a line.
228  * If so, '^' rules will be active on the next match, otherwise
229  * not.
230  */
231 int yy_at_bol;
232
233 int yy_bs_lineno; /**< The line count. */
234 int yy_bs_column; /**< The column count. */
235
236 /* Whether to try to fill the input buffer when we reach the
237  * end of it.
238  */
239 int yy_fill_buffer;
240
241 int yy_buffer_status;
242
243 #define YY_BUFFER_NEW 0
244 #define YY_BUFFER_NORMAL 1
245 /* When an EOF's been seen but there's still some text to process
246  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
247  * shouldn't try reading from the input source any more.  We might
248  * still have a bunch of tokens to match, though, because of
249  * possible backing-up.
250  *
251  * When we actually see the EOF, we change the status to "new"
252  * (via yyrestart()), so that the user can continue scanning by
253  * just pointing yyin at a new input file.
254  */
255 #define YY_BUFFER_EOF_PENDING 2
256
257 };
258 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
259
260 /* Stack of input buffers. */
261 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
262 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
263 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
264
265 /* We provide macros for accessing buffer states in case in the
266  * future we want to put the buffer states in a more general
267  * "scanner state".
268  *
269  * Returns the top of the stack, or NULL.
270  */
271 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
272                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
273                           : NULL)
274
275 /* Same as previous macro, but useful when we know that the buffer stack is not
276  * NULL or when we need an lvalue. For internal use only.
277  */
278 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
279
280 /* yy_hold_char holds the character lost when yytext is formed. */
281 static char yy_hold_char;
282 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
283 int yyleng;
284
285 /* Points to current character in buffer. */
286 static char *yy_c_buf_p = (char *) 0;
287 static int yy_init = 0;         /* whether we need to initialize */
288 static int yy_start = 0;        /* start state number */
289
290 /* Flag which is used to allow yywrap()'s to do buffer switches
291  * instead of setting up a fresh yyin.  A bit of a hack ...
292  */
293 static int yy_did_buffer_switch_on_eof;
294
295 void yyrestart (FILE *input_file  );
296 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
297 YY_BUFFER_STATE yy_create_buffer (FILE *file, int size  );
298 void yy_delete_buffer (YY_BUFFER_STATE b  );
299 void yy_flush_buffer (YY_BUFFER_STATE b  );
300 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
301 void yypop_buffer_state (void );
302
303 static void yyensure_buffer_stack (void );
304 static void yy_load_buffer_state (void );
305 static void yy_init_buffer (YY_BUFFER_STATE b, FILE *file  );
306
307 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
308
309 YY_BUFFER_STATE yy_scan_buffer (char *base, yy_size_t size  );
310 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
311 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes, int len  );
312
313 void *yyalloc (yy_size_t  );
314 void *yyrealloc (void *, yy_size_t  );
315 void yyfree (void *  );
316
317 #define yy_new_buffer yy_create_buffer
318
319 #define yy_set_interactive(is_interactive) \
320         { \
321         if ( ! YY_CURRENT_BUFFER ){ \
322         yyensure_buffer_stack (); \
323                 YY_CURRENT_BUFFER_LVALUE =    \
324             yy_create_buffer(yyin,YY_BUF_SIZE ); \
325         } \
326         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
327         }
328
329 #define yy_set_bol(at_bol) \
330         { \
331         if ( ! YY_CURRENT_BUFFER ){\
332         yyensure_buffer_stack (); \
333                 YY_CURRENT_BUFFER_LVALUE =    \
334             yy_create_buffer(yyin,YY_BUF_SIZE ); \
335         } \
336         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
337         }
338
339 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
340
341 /* Begin user sect3 */
342
343 #define yywrap(n) 1
344 #define YY_SKIP_YYWRAP
345
346 typedef unsigned char YY_CHAR;
347
348 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
349
350 typedef int yy_state_type;
351
352 extern int yylineno;
353
354 int yylineno = 1;
355
356 extern char *yytext;
357 #define yytext_ptr yytext
358
359 static yy_state_type yy_get_previous_state (void );
360 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
361 static int yy_get_next_buffer (void );
362 static void yy_fatal_error (yyconst char msg[]  );
363
364 /* Done after the current pattern has been matched and before the
365  * corresponding action - sets up yytext.
366  */
367 #define YY_DO_BEFORE_ACTION \
368         (yytext_ptr) = yy_bp; \
369         yyleng = (size_t) (yy_cp - yy_bp); \
370         (yy_hold_char) = *yy_cp; \
371         *yy_cp = '\0'; \
372         (yy_c_buf_p) = yy_cp;
373
374 #define YY_NUM_RULES 142
375 #define YY_END_OF_BUFFER 143
376 /* This struct is not used in this scanner,
377    but its presence is necessary. */
378 struct yy_trans_info
379 {
380 flex_int32_t yy_verify;
381 flex_int32_t yy_nxt;
382 };
383 static yyconst flex_int16_t yy_acclist[937] =
384 {
385 0,
386 16408,  120,  120,  130,  130,  110,  110,  106,  106,  143,
387 83,  142,   79,   83,  142,   80,  142,   80,   83,  142,
388 77,   83,  142,   74,   83,  142,   27,   83,  142,   74,
389 83,  142,   30,   83,  142,   78,   83,  142,   34,   83,
390 142,   35,   83,  142,   48,   83,  142,   47,   83,  142,
391 37,   83,  142,   46,   83,  142,   67,   83,  142,   49,
392 83,  142,   69,   83,  142,   38,   83,  142,   36,   83,
393 142,   60,   83,  142,   64,   83,  142,   61,   83,  142,
394 26,   83,  142,   65,   83,  142,   50,   83,  142,   66,
395 83,  142,   51,   83,  142,   74,   83,  142,   74,   83,
396
397 142,   74,   83,  142,   74,   83,  142,   74,   83,  142,
398 74,   83,  142,   74,   83,  142,   74,   83,  142,   74,
399 83,  142,   74,   83,  142,   74,   83,  142,   39,   83,
400 142,   32,   83,  142,   40,   83,  142,   26,   83,  142,
401 83,  142,   83,  142,   83,  142,   83,  142,   83,  142,
402 83,  142,   83,  142,   83,  142,   83,  142,   79,   83,
403 142, 16408,   74,   83,  142,   27,   83,  142,   74,   83,
404 142,   74,   83,  142,   74,   83,  142,   74,   83,  142,
405 74,   83,  142,   74,   83,  142,   74,   83,  142,   74,
406 83,  142,   74,   83,  142,   74,   83,  142,   74,   83,
407
408 142,   74,   83,  142,   83,  142,   83,  142,   83,  142,
409 83,  142,   83,  142,   83,  142,   83,  142,   83,  142,
410 83,  142,  120,  121,  142,  119,  142,  119,  121,  142,
411 117,  121,  142,  116,  121,  142,  121,  142,  130,  131,
412 142,  129,  142,  129,  131,  142,  126,  131,  142,  127,
413 131,  142,  131,  142,  110,  111,  142,  109,  142,  109,
414 111,  142,  111,  142,  111,  142,  106,  142,  105,  142,
415 105,  142,  104,  142,  103,  104,  142,  100,  142,  100,
416 104,  142,  104,  142,   97,  142,   79,   97,  142,   88,
417 142,   88,   97,  142,   77,   97,  142,   74,   97,  142,
418
419 27,   97,  142,   74,   97,  142,   30,   97,  142,   78,
420 97,  142,   84,   86,   97,  142,   85,   97,  142,   48,
421 97,  142,   91,   97,  142,   37,   97,  142,   93,   97,
422 142,   67,   97,  142,   49,   97,  142,   69,   97,  142,
423 38,   87,   97,  142,   36,   97,  142,   60,   97,  142,
424 64,   97,  142,   61,   97,  142,   26,   97,  142,   65,
425 97,  142,   50,   97,  142,   89,   97,  142,   51,   97,
426 142,   39,   97,  142,   32,   97,  142,   90,   97,  142,
427 26,   97,  142,   97,  142,   97,  142,   97,  142,   97,
428 142,   97,  142,   97,  142,   97,  142,   97,  142,  141,
429
430 142,  132,  142,  135,  142,  135,  142,   77,  142,   78,
431 142,  137,  141,  142,  134,  142,  133,  142,  138,  141,
432 142,  136,  141,  142,  139,  141,  142,  140,  141,  142,
433 142,   25,  142,  142,   25,  142,   25,  142,   25,  142,
434 25,  142,   25,  142,   25,  142,   25,  142,   25,  142,
435 25,  142,   25,  142,   25,  142,   25,  142,  142,  142,
436 142,  142,  142,  142,  142,  142,   79,   81,   81,   80,
437 74,   74,    3,   29,   74,    2,   28,   74,   31,   51,
438 41,   42,   68,   43,   73,   44,   45,   75,   76,   72,
439 69,   62,   59,   58,   63,   74,   74,   74,   17,   74,
440
441 74,   74,   74,   74,    4,   74,   74,   74,   74,   74,
442 74,   74,   74,   33,   74,   79, 16408,   74,   74,    3,
443 29,   74,    2,   28,   74,   74,   74,   74,   17,   74,
444 74,   74,   74,   74,    4,   74,   74,   74,   74,   74,
445 74,   74,   74,   74,  120,  119,  112,  113,  114,  115,
446 130,  129,  122,  123,  124,  125,  110,  109,  107,  108,
447 106,  105,  103,  100,  101,  102,   79,   86,   95,   96,
448 87,   88,   29,   74,   28,   74,   87,  141,  132,  135,
449 25,   25,    3,   25,    2,   25,   25,   25,   25,   17,
450 25,   25,   25,   25,   25,    4,   25,   25,   25,   25,
451
452 25,   25,   25,   25,   25,   82,   82,   55,   52,   53,
453 54,   56,   72,   70,   71,   57,   74,   74,   74,   74,
454 74,    8,   74,   15,   74,   74,   74,   74,   74,   74,
455 74,   74,   20,   74,   74,    1,   74, 8216, 8216,   74,
456 74,   74,   74,   74,    8,   74,   15,   74,   74,   74,
457 74,   74,   74,   74,   74,   20,   74,   74,    1,   74,
458 118,  118,  128,  128,   92,   94,   98,   98,   25,   25,
459 25,   25,   25,    8,   25,   15,   25,   25,   25,   25,
460 25,   25,   25,   25,   20,   25,   25,   74,   12,   74,
461 74,   74,    6,   74,   74,   74,   74,   74,   74,   74,
462
463 74,    5,   74,   74,    1,    1,   74,    1,    1,    1,
464 1,    1,    1,    1,    1,   74, 8216,   74,   12,   74,
465 74,   74,    6,   74,   74,   74,   74,   74,   74,   74,
466 74,    5,   74,   74,    1,    1,   74,    1,    1,    1,
467 1,    1,    1,    1,    1,   74,   99,   25,   12,   25,
468 25,   25,    6,   25,   25,   25,   25,   25,   25,   25,
469 25,    5,   25,   25,   25,   74,   74,   18,   74,   21,
470 74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
471 16,   74,    1,    1,    1,    1,    1,    1,    1,   74,
472 74,   18,   74,   21,   74,   74,   74,   74,   74,   74,
473
474 74,   74,   74,   74,   16,   74,    1, 8216,    1, 8216,
475 1,    1,    1,    1,    1,    1,    1,   25,   25,   18,
476 25,   21,   25,   25,   25,   25,   25,   25,   25,   25,
477 25,   25,   16,   25,   74,    7,   74,   74,   74,   74,
478 23,   74,   22,   74,    9,   74,   10,   74,    1,    1,
479 1,   74,    7,   74,   74,   74,   74,   23,   74,   22,
480 74,    9,   74,   10,   74,    1, 8216,    1,    1,    1,
481 25,    7,   25,   25,   25,   25,   23,   25,   22,   25,
482 9,   25,   10,   25,   74,   74,   74,   74,    1,   74,
483 74,   74,   74,   74,    1,   74,   25,   25,   25,   25,
484
485 19,   74,   74,   13,   74,   74,   19,   74,   74,   13,
486 74,   74,   19,   25,   25,   13,   25,   25,   74,   11,
487 74,   74,   11,   74,   25,   11,   25,   74,   74,   25,
488 14,   74,   14,   74,   14,   25
489 } ;
490
491 static yyconst flex_int16_t yy_accept[810] =
492 {
493 0,
494 1,    1,    2,    3,    4,    5,    6,    7,    8,    9,
495 10,   10,   10,   10,   10,   10,   10,   10,   10,   11,
496 13,   16,   18,   21,   24,   27,   30,   33,   36,   39,
497 42,   45,   48,   51,   54,   57,   60,   63,   66,   69,
498 72,   75,   78,   81,   84,   87,   90,   93,   96,   99,
499 102,  105,  108,  111,  114,  117,  120,  123,  126,  129,
500 132,  135,  138,  141,  143,  145,  147,  149,  151,  153,
501 155,  157,  159,  163,  166,  169,  172,  175,  178,  181,
502 184,  187,  190,  193,  196,  199,  202,  205,  207,  209,
503 211,  213,  215,  217,  219,  221,  223,  226,  228,  231,
504
505 234,  237,  239,  242,  244,  247,  250,  253,  255,  258,
506 260,  263,  265,  267,  269,  271,  273,  275,  278,  280,
507 283,  285,  287,  290,  292,  295,  298,  301,  304,  307,
508 310,  313,  317,  320,  323,  326,  329,  332,  335,  338,
509 341,  345,  348,  351,  354,  357,  360,  363,  366,  369,
510 372,  375,  378,  381,  384,  386,  388,  390,  392,  394,
511 396,  398,  400,  402,  404,  406,  408,  410,  412,  415,
512 417,  419,  422,  425,  428,  431,  432,  434,  435,  437,
513 439,  441,  443,  445,  447,  449,  451,  453,  455,  457,
514 459,  460,  461,  462,  463,  464,  465,  466,  467,  468,
515
516 469,  470,  470,  470,  471,  472,  472,  472,  472,  472,
517 472,  472,  472,  472,  473,  473,  473,  473,  473,  473,
518 473,  473,  473,  476,  479,  480,  481,  481,  482,  483,
519 484,  485,  486,  487,  488,  489,  489,  490,  491,  492,
520 492,  492,  492,  493,  494,  494,  495,  495,  496,  496,
521 496,  497,  498,  499,  501,  502,  503,  504,  505,  507,
522 508,  509,  510,  511,  512,  513,  514,  515,  515,  516,
523 516,  516,  516,  516,  516,  516,  516,  516,  518,  518,
524 518,  518,  518,  518,  518,  518,  518,  518,  518,  518,
525 519,  519,  519,  519,  519,  519,  519,  519,  519,  520,
526
527 520,  520,  520,  520,  520,  520,  520,  520,  523,  526,
528 527,  528,  529,  531,  532,  533,  534,  535,  537,  538,
529 539,  540,  541,  542,  543,  544,  545,  545,  545,  545,
530 545,  545,  545,  545,  545,  546,  547,  548,  549,  550,
531 551,  551,  552,  553,  554,  555,  556,  557,  557,  558,
532 559,  560,  561,  562,  563,  564,  565,  566,  567,  568,
533 569,  570,  571,  572,  573,  575,  577,  577,  578,  579,
534 580,  581,  582,  582,  582,  582,  582,  582,  582,  582,
535 582,  583,  583,  583,  583,  583,  583,  583,  583,  583,
536 585,  587,  588,  589,  590,  592,  593,  594,  595,  596,
537
538 598,  599,  600,  601,  602,  603,  604,  605,  606,  606,
539 606,  606,  606,  606,  606,  606,  607,  608,  608,  608,
540 608,  608,  608,  608,  608,  608,  608,  608,  608,  608,
541 608,  608,  609,  610,  611,  612,  613,  614,  614,  615,
542 615,  616,  617,  618,  619,  620,  621,  622,  624,  626,
543 627,  628,  629,  630,  631,  632,  633,  635,  636,  638,
544 638,  638,  638,  638,  638,  638,  638,  638,  638,  638,
545 638,  638,  638,  638,  638,  638,  638,  638,  638,  638,
546 638,  638,  638,  638,  638,  638,  638,  638,  639,  640,
547 640,  640,  640,  640,  640,  640,  640,  640,  640,  640,
548
549 640,  640,  640,  640,  641,  642,  643,  644,  645,  647,
550 649,  650,  651,  652,  653,  654,  655,  656,  658,  659,
551 661,  661,  661,  661,  662,  663,  664,  665,  666,  667,
552 667,  668,  669,  669,  669,  669,  669,  669,  669,  669,
553 669,  669,  669,  669,  669,  669,  669,  669,  670,  671,
554 672,  673,  674,  676,  678,  679,  680,  681,  682,  683,
555 684,  685,  687,  688,  688,  688,  688,  688,  688,  688,
556 688,  688,  688,  689,  691,  692,  693,  695,  696,  697,
557 698,  699,  700,  701,  702,  704,  705,  706,  708,  709,
558 710,  711,  712,  713,  714,  715,  716,  717,  717,  717,
559
560 717,  717,  717,  717,  717,  717,  717,  717,  717,  717,
561 717,  717,  717,  717,  717,  718,  718,  718,  718,  718,
562 718,  718,  719,  721,  722,  723,  725,  726,  727,  728,
563 729,  730,  731,  732,  734,  735,  736,  738,  739,  740,
564 741,  742,  743,  744,  745,  746,  747,  748,  748,  748,
565 748,  748,  748,  748,  749,  751,  752,  753,  755,  756,
566 757,  758,  759,  760,  761,  762,  764,  765,  766,  767,
567 768,  770,  772,  773,  774,  775,  776,  777,  778,  779,
568 780,  781,  783,  784,  785,  786,  787,  788,  789,  790,
569 790,  790,  790,  790,  790,  790,  790,  791,  792,  794,
570
571 796,  797,  798,  799,  800,  801,  802,  803,  804,  805,
572 807,  809,  811,  812,  813,  814,  815,  816,  817,  818,
573 819,  820,  822,  824,  825,  826,  827,  828,  829,  830,
574 831,  832,  833,  835,  836,  838,  839,  840,  841,  843,
575 845,  847,  849,  850,  851,  852,  852,  852,  853,  855,
576 856,  857,  858,  860,  862,  864,  866,  868,  869,  870,
577 871,  872,  874,  875,  876,  877,  879,  881,  883,  885,
578 886,  887,  888,  889,  891,  892,  893,  894,  895,  897,
579 898,  899,  900,  901,  903,  904,  906,  907,  909,  910,
580 912,  913,  915,  916,  918,  919,  920,  922,  923,  925,
581
582 926,  928,  929,  930,  931,  933,  935,  937,  937
583 } ;
584
585 static yyconst flex_int32_t yy_ec[256] =
586 {
587 0,
588 1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
589 2,    2,    4,    1,    1,    1,    1,    1,    1,    1,
590 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
591 1,    2,    1,    5,    6,    7,    8,    9,   10,   11,
592 12,   13,   14,   15,   16,   17,   18,   19,   19,   19,
593 19,   19,   19,   19,   19,   19,   19,   20,   21,   22,
594 23,   24,    6,   25,    6,    6,    6,   26,   27,   28,
595 6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
596 6,    6,    6,   29,    6,    6,    6,    6,    6,    6,
597 30,   31,   32,   33,    6,    1,   34,   35,   36,   37,
598
599 38,   39,    6,   40,   41,    6,   42,   43,   44,   45,
600 46,    6,    6,   47,   48,   49,   50,    6,   51,    6,
601 52,    6,   53,   54,   55,   56,    1,   57,   57,   57,
602 57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
603 57,   57,   57,   58,   58,   58,   58,   58,   58,   58,
604 58,   58,   58,   58,   58,   58,   58,   58,   58,   59,
605 59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
606 59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
607 59,   59,   59,   59,   59,   59,   60,   59,   59,   59,
608 61,    1,    1,   62,   62,   62,   62,   62,   62,   62,
609
610 62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
611 62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
612 62,   62,   62,   63,   64,   64,   64,   64,   64,   64,
613 64,   64,   64,   64,   64,   64,   65,   66,   67,   68,
614 69,   69,   69,   70,    1,    1,    1,    1,    1,    1,
615 1,    1,    1,    1,    1
616 } ;
617
618 static yyconst flex_int32_t yy_meta[71] =
619 {
620 0,
621 1,    2,    3,    4,    5,    6,    6,    7,    1,    5,
622 8,    1,    9,    1,   10,    1,   11,    9,   12,    1,
623 10,    8,    8,    8,    1,    6,    6,    6,    6,    1,
624 1,    1,    1,    6,    6,    6,    6,    6,    6,    6,
625 6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
626 6,    6,    1,    1,    1,    1,    1,    1,    1,    1,
627 1,    6,    6,    6,    6,    6,    6,    6,    6,    6
628 } ;
629
630 static yyconst flex_int16_t yy_base[835] =
631 {
632 0,
633 0,   70,  138,  141,  149,  157,  160,  166,  146,  153,
634 173,  178,  196,    0,  265,  320,  376,    0,  904, 4153,
635 183,  270,  279, 4153,  239,  248,  419,  893, 4153, 4153,
636 4153,  155, 4153, 4153, 4153,  319,  175,  329, 4153, 4153,
637 269,  272,  275,  276, 4153,  877, 4153, 4153,  325,  421,
638 423,  451,  425,  463,  469,  475,  477,  482,  504, 4153,
639 838, 4153,  317,  300,  267,  477,  132,  488,  497,  310,
640 502,  829,  562,  515,  524,  631,  567,  569,  571,  606,
641 573,  491,  608,  614,  633,  636,  638,  513,  417,  631,
642 137,  645,  650,  580,  655,  823,    0, 4153,  875,  274,
643
644 329,  844,    0, 4153,  848,  451,  599,  832,    0, 4153,
645 844,  826,  821,    0, 4153,  789, 4153,  783, 4153,  764,
646 655, 4153,  715,  718,  719, 4153,  699,  687,  730,  733,
647 4153, 4153, 4153,  334, 4153, 4153, 4153,  753,  719,  756,
648 728, 4153,  721,  646,  656,  723, 4153,  707, 4153, 4153,
649 4153,  632, 4153,  739,  730,  491,  738,  239,  743,  747,
650 752,  624,    0,  672, 4153,  653, 4153, 4153,    0, 4153,
651 4153,    0,    0,    0,    0, 4153,  752,  761,  804,  807,
652 811,  809,  836,  813,  848,  854,  860,  862,  867,  889,
653 862,  717,  873,  305,  882,  866,  887,  597,  933, 4153,
654
655 647,  947,  950,  759,  927,  900,  913,  920,  408,  925,
656 929,  934,  589,    0,  939,  942,  947,  484,  952,  956,
657 961,  587,  995,  997, 4153, 4153,    0, 4153,  446,  604,
658 596, 1011,  594, 4153, 4153,    0, 4153, 1013, 1016,  896,
659 1041,  741, 4153, 4153,  745, 4153,  758, 4153,  882,    0,
660 1030, 1033, 1035, 1037, 1049, 1062, 1065, 1074, 1067, 1081,
661 1079, 1096, 1103, 1108, 1112, 1121, 4153, 1029, 1126, 1119,
662 1124, 1129, 1134, 1139, 1144, 1149, 1154, 1214, 1161, 1170,
663 1184,  968, 1189,  510, 1194, 1108, 1199,  550, 1260, 1258,
664 1206, 1112, 1211,  518, 1231, 1235, 1241,  548, 1259, 1251,
665
666 1214, 1273,  906, 1278, 1245, 1283,  482, 1317, 1319, 1321,
667 1323, 1335, 1326, 1348, 1353, 1360, 1365, 1372, 1377, 1384,
668 1391, 1396, 1400, 1413, 1415, 1418, 1411, 1416, 1421, 1426,
669 1431, 1436, 1441, 1446,    0, 4153, 4153, 4153, 4153, 4153,
670 1505,    0, 4153, 4153, 4153, 4153, 4153, 1507,    0, 4153,
671 4153, 4153,    0, 4153,  525, 4153, 4153, 4153, 1512, 4153,
672 523,  521,  507, 1068, 1490, 1492, 1531,  505,    0,  499,
673 4153, 1508, 1485, 1254, 1493,  912, 1501, 1259, 1506,  442,
674 1506, 1520, 1399, 1525, 1076, 1530, 1534, 1539,  438, 1573,
675 1575, 1577, 1579, 1591, 1582, 1604, 1609, 1616, 1621, 1628,
676
677 1633, 1640, 1647, 1652, 1656, 1669, 1671, 1674, 1667, 1672,
678 1677, 1682, 1687, 1692, 1697, 4153,  490, 1702, 1707, 1712,
679 1717, 1722, 1727, 1732, 1737, 1742, 1747, 1752, 1757, 1762,
680 1767, 4153, 4153, 4153, 4153, 4153, 1810,  454,  438,  356,
681 354, 4153, 1804, 1802, 1806, 1821, 1828, 1830, 1833, 1835,
682 1847, 1852, 1859, 1861, 1864, 1866, 1878, 1890, 1939, 1863,
683 1877, 1953, 2013, 1959, 1655, 1964, 1101, 1969, 1973, 1978,
684 308, 2038, 1984, 1871, 1989, 1162, 1994, 1998, 2003,  292,
685 2008, 2013, 2027, 2032, 2037, 2052, 2057, 4153, 2117, 2063,
686 2072, 2077, 2085, 2090, 2095, 2100, 2105, 2110, 2115, 2120,
687
688 2125, 2130, 2135, 2169, 2171, 2176, 2178, 2185, 2193, 2200,
689 2202, 2207, 2215, 2219, 2224, 2231, 2238, 2243, 2246, 2295,
690 2309, 2314, 2319, 4153,  330, 4153,  317,  281,  271, 2379,
691 4153,  180,  153, 2327, 2332, 2341, 2346, 2351, 2356, 2361,
692 2366, 2371, 2376, 2381, 2386, 2391, 2396, 2430, 2432, 2437,
693 2439, 2446, 2454, 2461, 2463, 2468, 2476, 2480, 2485, 2492,
694 2499, 2504, 2507, 2500, 2505, 2510, 2515, 2520, 2525, 2530,
695 2535, 2540, 2574, 2576, 2578, 2580, 2583, 2602, 2605, 2608,
696 2614, 2617, 2631, 2633, 2645, 2647,    0,    0, 2630, 2066,
697 2640, 1321, 2645, 2649, 2654,  108, 2688, 2661, 2671, 2681,
698
699 2686, 2691, 2696, 2701, 2706, 2711, 2716, 2721, 2726, 2731,
700 2736, 2741, 2746, 2751, 2811, 2757, 2766, 2771, 2779, 2784,
701 2789, 2823, 2825, 2827, 2829, 2832, 2851, 2854, 2857, 2863,
702 2866, 2880, 2882, 2894, 2896, 2925,    0, 2880, 2335, 2894,
703 1328, 2899, 2665, 2904,   90, 2938, 4153, 2911, 2925, 2931,
704 2936, 2941, 2946, 2980, 2982, 2984, 2986, 2989, 3008, 3011,
705 3014, 3020, 3023, 3037, 3039, 3051, 3053, 3055, 3067,    0,
706 3069, 3081, 3083, 3085, 3097, 3109, 3112, 3115, 3127, 3131,
707 3139, 3145, 3132, 3138, 3143, 3148, 3153, 3158, 3163, 3168,
708 3173, 3178, 3183, 3188, 3193,    0, 3227,    0, 3229, 3231,
709
710 3234, 3236, 3243, 3258, 3261, 3265, 3277, 3280, 3292, 3289,
711 0, 3321, 3276, 3288, 3293, 3298, 3303, 3308, 3313, 3347,
712 0, 3349, 3351, 3354, 3356, 3363, 3378, 3381, 3385, 3397,
713 3400, 3412, 3409, 3415, 3427, 3431, 3440, 3434, 3443, 3449,
714 3456, 3462, 3449, 3455, 3460,    0,    0, 3494, 3496, 3498,
715 3500, 3512, 3503, 3526, 3528, 3530, 3560, 3513, 3527, 3532,
716 3566, 3568, 3570, 3572, 3584, 3575, 3598, 3600, 3602, 3606,
717 3614, 3628, 3630,    0, 3632, 3636, 3654, 3658,    0, 3662,
718 3666, 3680, 3684, 3688, 3702, 3706, 3710, 3718, 3724, 3732,
719 3740, 3746, 3755, 3748, 3762, 3764, 3770, 3777, 3779, 3786,
720
721 3792, 3801, 3808, 3810, 3805, 3823, 3832, 4153, 3881, 3893,
722 3905, 3917, 3929, 3941, 3948, 3955, 3966, 3972, 3979, 3991,
723 4003, 4015, 4027, 4039, 4046, 4053, 4065, 4076, 4087, 4097,
724 4104, 4116, 4128, 4140
725 } ;
726
727 static yyconst flex_int16_t yy_def[835] =
728 {
729 0,
730 808,  808,  809,  809,  810,  810,  811,  811,  812,  812,
731 813,  813,  808,   13,  814,  814,  808,   17,  808,  808,
732 808,  808,  808,  808,  815,  816,  815,  808,  808,  808,
733 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
734 808,  808,  808,  808,  808,  808,  808,  808,   27,   27,
735 27,   27,   27,   27,   27,   27,   27,   27,   27,  808,
736 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
737 808,  808,  817,  818,  819,  818,   76,   76,   76,   76,
738 76,   76,   76,   76,   76,   76,   76,  808,  808,  808,
739 808,  808,  808,  808,  808,  808,  820,  808,  808,  808,
740
741 808,  808,  821,  808,  808,  808,  808,  808,  822,  808,
742 808,  808,  808,  823,  808,  808,  808,  808,  808,  808,
743 808,  808,  808,  808,  808,  808,   27,  816,   27,  808,
744 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
745 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
746 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
747 808,  808,  824,  808,  808,  808,  808,  808,  824,  808,
748 808,  824,  824,  824,  824,  808,  825,  826,  825,  179,
749 179,  179,  179,  179,  179,  179,  179,  179,  179,  179,
750 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
751
752 808,  808,  808,  808,   27,  808,  808,  808,  808,  808,
753 808,  808,  808,  128,  808,  808,  808,  808,  808,  808,
754 808,  808,   27,   27,  808,  808,  827,  808,  808,  808,
755 808,  808,  808,  808,  808,  828,  808,  808,  808,  808,
756 808,  808,  808,  808,  808,  808,  808,  808,  808,  829,
757 27,   27,   27,   27,   27,   27,   27,   27,   27,   27,
758 27,   27,   27,   27,   27,   27,  808,  808,   27,  808,
759 808,  808,  808,  808,  808,  808,  808,  817,  830,  831,
760 808,  808,  808,  808,  808,  808,  808,  808,  832,   76,
761 808,  808,  808,  808,  808,  808,  808,  808,  819,  808,
762
763 808,  808,  808,  808,  808,  808,  808,   76,   76,   76,
764 76,   76,   76,   76,   76,   76,   76,   76,   76,   76,
765 76,   76,   76,   76,   76,   76,  808,  808,  808,  808,
766 808,  808,  808,  808,  820,  808,  808,  808,  808,  808,
767 808,  821,  808,  808,  808,  808,  808,  808,  822,  808,
768 808,  808,  823,  808,  808,  808,  808,  808,  808,  808,
769 808,  808,  808,  808,   27,   27,  808,  808,  824,  808,
770 808,  179,  808,  808,  808,  808,  808,  808,  808,  808,
771 826,  808,  808,  808,  808,  808,  808,  808,  808,  179,
772 179,  179,  179,  179,  179,  179,  179,  179,  179,  179,
773
774 179,  179,  179,  179,  179,  179,  179,  179,  808,  808,
775 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
776 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
777 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
778 808,  808,   27,   27,   27,   27,   27,   27,   27,   27,
779 27,   27,   27,   27,   27,   27,   27,   27,  808,  808,
780 808,  808,  830,  808,  808,  808,  808,  808,  808,  808,
781 808,  831,  808,  808,  808,  808,  808,  808,  808,  808,
782 808,  808,  808,  808,  808,  808,  808,  808,  832,  808,
783 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
784
785 808,  808,  808,   76,   76,   76,   76,   76,   76,   76,
786 76,   76,   76,   76,   76,   76,   76,   76,   76,  808,
787 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
788 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
789 808,  808,  808,  808,  808,  808,  808,  179,  179,  179,
790 179,  179,  179,  179,  179,  179,  179,  179,  179,  179,
791 179,  179,  179,  808,  808,  808,  808,  808,  808,  808,
792 808,  808,   27,   27,   27,   27,   27,   27,   27,   27,
793 27,   27,   27,   27,   27,   27,  833,  459,  833,  833,
794 833,  833,  833,  833,  833,  833,   27,  808,  808,  808,
795
796 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
797 808,  808,  808,  808,  832,  808,  808,  808,  808,  808,
798 808,   76,   76,   76,   76,   76,   76,   76,   76,   76,
799 76,   76,   76,   76,   76,  834,  520,  833,  833,  833,
800 833,  833,  833,  833,  833,   76,  808,  808,  808,  808,
801 808,  808,  808,  179,  179,  179,  179,  179,  179,  179,
802 179,  179,  179,  179,  179,  179,  179,  179,   27,  128,
803 27,   27,   27,   27,   27,   27,   27,   27,   27,   27,
804 27,   27,  833,  833,  833,  833,  833,  833,  833,  808,
805 808,  808,  808,  808,  808,  463,   76,  299,   76,   76,
806
807 76,   76,   76,   76,   76,   76,   76,   76,   76,   76,
808 833,  834,  833,  833,  833,  833,  833,  833,  833,  179,
809 381,  179,  179,  179,  179,  179,  179,  179,  179,  179,
810 179,  179,  179,   27,   27,   27,   27,   27,   27,   27,
811 27,   27,  833,  833,  833,  463,  472,   76,   76,   76,
812 76,   76,   76,   76,   76,   76,  834,  833,  833,  833,
813 179,  179,  179,  179,  179,  179,  179,  179,  179,   27,
814 27,   27,   27,  459,   76,   76,   76,   76,  520,  179,
815 179,  179,  179,   27,   27,   27,   27,   76,   76,   76,
816 76,  179,  179,  179,  179,   27,   27,   76,   76,  179,
817
818 179,   27,   76,  179,   27,   76,  179,    0,  808,  808,
819 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
820 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
821 808,  808,  808,  808
822 } ;
823
824 static yyconst flex_int16_t yy_nxt[4224] =
825 {
826 0,
827 20,   21,   22,   23,   24,   25,   26,   27,   28,   29,
828 30,   31,   32,   33,   34,   35,   36,   37,   38,   39,
829 40,   41,   42,   43,   44,   25,   25,   25,   25,   45,
830 46,   47,   48,   25,   49,   50,   51,   52,   53,   25,
831 54,   25,   25,   25,   25,   55,   56,   57,   58,   25,
832 59,   25,   60,   61,   62,   63,   20,   20,   20,   20,
833 20,   64,   65,   66,   67,   68,   69,   70,   71,   72,
834 20,   73,   22,   23,   24,   74,   75,   76,   28,   29,
835 30,   31,   32,   33,   34,   35,   36,   37,   38,   39,
836 40,   41,   42,   43,   44,   74,   74,   74,   74,   45,
837
838 46,   47,   48,   74,   77,   78,   79,   80,   81,   74,
839 82,   74,   74,   74,   74,   83,   84,   85,   86,   74,
840 87,   74,   60,   61,   62,   63,   20,   20,   20,   20,
841 20,   88,   89,   90,   91,   92,   93,   94,   95,   96,
842 98,   99,  100,   98,   99,  100,  719,  101,  115,  116,
843 101,  104,  105,  106,  102,  115,  116,  102,  107,  104,
844 105,  106,  110,  111,  689,  108,  107,  226,  110,  111,
845 647,  227,  112,  108,  118,  119,  120,  113,  112,  118,
846 119,  120,  531,  113,  199,  200,  201,  235,  272,  272,
847 121,  236,  237,  329,  329,  121,  122,  123,  124,  125,
848
849 126,  127,  128,  129,  130,  131,  132,  133,  134,  135,
850 136,  137,  138,  139,  140,  141,  142,  143,  144,  145,
851 146,  127,  127,  127,  127,  147,  148,  149,  150,  127,
852 127,  127,  127,  127,  127,  127,  127,  127,  127,  127,
853 127,  127,  127,  127,  127,  127,  127,  127,  151,  152,
854 153,  154,  122,  122,  122,  122,  122,  155,  156,  157,
855 158,  159,  159,  160,  161,  162,  164,  165,  166,  167,
856 242,  202,  529,  245,  168,  169,  247,  249,  337,  170,
857 202,  204,  528,  338,  203,  171,  172,  173,  174,  175,
858 203,  243,  244,  203,  246,  272,  272,  248,  244,  203,
859
860 206,  207,  208,  209,  210,  210,  211,  212,  213,  215,
861 216,  217,  218,  219,  219,  220,  221,  222,  268,  526,
862 175,  164,  165,  166,  167,  270,  270,  270,  228,  168,
863 169,  229,  524,  339,  170,  230,  231,  232,  340,  244,
864 171,  172,  173,  174,  175,  238,  226,  239,  611,  233,
865 227,  234,  205,  205,  240,  241,  269,  269,  269,  269,
866 269,  411,  411,  205,  604,  240,  241,  275,  275,  275,
867 275,  251,  441,  205,  441,  175,  176,  176,  176,  176,
868 176,  177,  178,  179,  176,  176,  176,  176,  176,  176,
869 176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
870
871 176,  177,  177,  177,  177,  176,  176,  176,  176,  177,
872 180,  181,  182,  183,  184,  177,  185,  177,  177,  177,
873 177,  186,  187,  188,  189,  177,  190,  177,  176,  176,
874 176,  176,  176,  176,  176,  176,  176,  191,  192,  193,
875 194,  195,  195,  196,  197,  198,  223,  224,  205,  205,
876 205,  205,  205,  205,  252,  344,  439,  223,  234,  205,
877 345,  205,  433,  205,  420,  420,  253,  224,  254,  205,
878 257,  205,  439,  205,  258,  327,  327,  327,  205,  205,
879 206,  207,  208,  209,  210,  210,  211,  212,  213,  205,
880 205,  205,  416,  255,  547,  256,  205,  205,  540,  205,
881
882 370,  259,  205,  205,  205,  205,  368,  205,  368,  205,
883 205,  205,  261,  205,  262,  205,  289,  260,  290,  290,
884 205,  264,  529,  205,  528,  205,  355,  263,  265,  318,
885 205,  205,  205,  271,  271,  271,  271,  271,  503,  290,
886 427,  427,  205,  266,  273,  273,  273,  273,  273,  270,
887 270,  270,  205,  273,  273,  273,  274,  273,  276,  276,
888 276,  276,  276,  278,  200,  201,  483,  483,  280,  326,
889 326,  326,  326,  326,  492,  492,  291,  292,  293,  294,
890 295,  295,  296,  297,  298,  300,  301,  302,  303,  304,
891 304,  305,  306,  307,  290,  290,  290,  290,  290,  290,
892
893 290,  290,  311,  346,  496,  290,  487,  290,  347,  290,
894 435,  290,  434,  310,  312,  290,  313,  290,  316,  290,
895 230,  290,  317,  281,  282,  283,  284,  285,  285,  286,
896 287,  288,  289,  290,  290,  290,  290,  332,  332,  332,
897 332,  290,  290,  431,  290,  424,  290,  245,  314,  200,
898 315,  320,  290,  415,  290,  371,  319,  247,  308,  309,
899 290,  290,  290,  290,  290,  290,  290,  357,  246,  308,
900 321,  290,  358,  370,  290,  323,  290,  325,  248,  309,
901 277,  290,  324,  322,  290,  267,  290,  328,  328,  328,
902 328,  328,  291,  292,  293,  294,  295,  295,  296,  297,
903
904 298,  330,  330,  330,  330,  330,  330,  330,  330,  331,
905 330,  333,  333,  333,  333,  333,  359,  200,  201,  202,
906 202,  364,  242,  250,  249,  360,  205,  205,  361,  368,
907 362,  235,  203,  203,  363,  236,  237,  205,  203,  203,
908 268,  225,  242,  243,  244,  244,  245,  205,  215,  216,
909 217,  218,  219,  219,  220,  221,  222,  365,  366,  247,
910 202,  244,  228,  243,  244,  229,  356,  246,  365,  367,
911 231,  232,  238,  203,  239,  409,  409,  409,  366,  203,
912 248,  240,  241,  233,  355,  234,  269,  269,  269,  269,
913 269,  354,  240,  241,  271,  271,  271,  271,  271,  273,
914
915 273,  273,  273,  273,  275,  275,  275,  275,  276,  276,
916 276,  276,  276,  373,  374,  375,  376,  377,  377,  378,
917 379,  380,  382,  383,  384,  385,  386,  386,  387,  388,
918 389,  390,  391,  352,  372,  372,  372,  372,  372,  372,
919 372,  372,  390,  351,  393,  372,  350,  372,  348,  372,
920 343,  372,  391,  392,  395,  372,  394,  372,  398,  372,
921 341,  372,  399,  372,  372,  373,  374,  375,  376,  377,
922 377,  378,  379,  380,  372,  372,  372,  336,  396,  334,
923 397,  372,  372,  249,  372,  277,  400,  372,  372,  372,
924 372,  267,  372,  250,  372,  372,  372,  402,  372,  403,
925
926 372,  225,  401,  808,  244,  372,  405,  808,  372,  438,
927 372,  438,  404,  406,  439,  372,  372,  372,  408,  408,
928 408,  408,  408,  413,  413,  413,  413,  372,  407,  410,
929 410,  410,  410,  410,  199,  200,  201,  372,  412,  412,
930 412,  412,  412,  414,  414,  414,  414,  414,  202,  416,
931 417,  202,  416,  417,  205,  205,  205,  205,  205,  205,
932 205,  203,  499,  499,  203,  205,  808,  203,  536,  536,
933 203,  418,  418,  418,  808,  205,  419,  419,  419,  419,
934 419,  421,  421,  421,  421,  421,  422,  422,  422,  422,
935 423,  423,  423,  423,  423,  214,  214,  214,  214,  214,
936
937 425,  425,  425,  426,  426,  426,  426,  426,  428,  428,
938 428,  428,  428,  429,  429,  429,  429,  430,  430,  430,
939 430,  430,  205,  205,  205,  205,  481,  481,  481,  232,
940 268,  437,  238,  205,  239,  205,  240,  241,  240,  241,
941 808,  240,  241,  205,  808,  205,  808,  240,  241,  240,
942 241,  244,  240,  241,  440,  808,  440,  205,  205,  441,
943 205,  205,  205,  205,  205,  205,  808,  443,  205,  202,
944 808,  205,  808,  205,  808,  205,  205,  205,  205,  446,
945 444,  445,  203,  205,  808,  205,  808,  205,  203,  205,
946 205,  808,  205,  205,  205,  205,  447,  205,  448,  808,
947
948 205,  205,  205,  205,  808,  205,  205,  205,  205,  205,
949 205,  449,  205,  205,  808,  205,  808,  205,  450,  205,
950 451,  808,  205,  205,  205,  808,  452,  453,  808,  205,
951 205,  205,  543,  543,  205,  205,  205,  808,  454,  205,
952 205,  205,  808,  455,  205,  456,  205,  808,  205,  205,
953 205,  205,  808,  205,  205,  808,  205,  600,  600,  205,
954 205,  458,  289,  457,  205,  485,  485,  485,  485,  205,
955 490,  490,  490,  808,  205,  269,  269,  269,  269,  269,
956 269,  269,  269,  269,  269,  269,  269,  269,  269,  269,
957 269,  269,  269,  269,  269,  269,  269,  269,  269,  459,
958
959 460,  460,  460,  460,  460,  461,  461,  461,  461,  461,
960 462,  462,  462,  462,  462,  278,  200,  201,  607,  607,
961 280,  808,  464,  465,  466,  467,  468,  468,  469,  470,
962 471,  473,  474,  475,  476,  477,  477,  478,  479,  480,
963 279,  279,  279,  279,  279,  482,  482,  482,  482,  482,
964 484,  484,  484,  484,  484,  486,  486,  486,  486,  486,
965 289,  289,  290,  290,  290,  290,  290,  491,  491,  491,
966 491,  491,  497,  497,  497,  281,  282,  283,  284,  285,
967 285,  286,  287,  288,  489,  290,  290,  493,  493,  493,
968 493,  493,  494,  494,  494,  494,  290,  495,  495,  495,
969
970 495,  495,  501,  501,  501,  501,  290,  299,  299,  299,
971 299,  299,  534,  534,  534,  489,  538,  538,  538,  538,
972 300,  301,  302,  303,  304,  304,  305,  306,  307,  498,
973 498,  498,  498,  498,  500,  500,  500,  500,  500,  502,
974 502,  502,  502,  502,  290,  290,  290,  290,  290,  290,
975 290,  290,  808,  290,  290,  290,  808,  290,  504,  290,
976 808,  290,  290,  290,  290,  290,  808,  290,  808,  290,
977 505,  506,  808,  290,  290,  290,  290,  685,  685,  507,
978 290,  290,  808,  290,  715,  715,  290,  290,  290,  509,
979 808,  290,  290,  290,  808,  508,  290,  808,  290,  290,
980
981 290,  290,  808,  290,  290,  290,  510,  808,  290,  511,
982 290,  290,  290,  290,  808,  290,  512,  808,  290,  290,
983 290,  808,  290,  290,  290,  290,  808,  290,  290,  290,
984 808,  513,  514,  515,  290,  808,  516,  517,  290,  290,
985 290,  290,  290,  290,  290,  290,  290,  808,  290,  808,
986 808,  290,  808,  290,  808,  519,  290,  541,  541,  541,
987 808,  290,  808,  290,  518,  808,  290,  326,  326,  326,
988 326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
989 326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
990 326,  520,  521,  521,  521,  521,  521,  522,  522,  522,
991
992 522,  522,  523,  523,  523,  523,  523,  524,  525,  526,
993 527,  808,  808,  359,  200,  201,  808,  205,  205,  205,
994 205,  341,  360,  348,  808,  361,  808,  362,  205,  808,
995 205,  363,  530,  531,  532,  372,  372,  808,  205,  808,
996 205,  372,  372,  372,  372,  372,  372,  367,  533,  535,
997 535,  535,  535,  535,  808,  808,  372,  537,  537,  537,
998 537,  537,  539,  539,  539,  539,  539,  382,  383,  384,
999 385,  386,  386,  387,  388,  389,  381,  381,  381,  381,
1000 381,  542,  542,  542,  542,  542,  544,  544,  544,  544,
1001 544,  545,  545,  545,  545,  546,  546,  546,  546,  546,
1002
1003 372,  372,  372,  372,  372,  372,  372,  372,  808,  372,
1004 372,  372,  808,  372,  548,  372,  808,  372,  372,  372,
1005 372,  372,  808,  372,  808,  372,  549,  550,  808,  372,
1006 372,  372,  372,  808,  808,  551,  372,  372,  808,  372,
1007 808,  808,  372,  372,  372,  553,  808,  372,  372,  372,
1008 808,  552,  372,  808,  372,  372,  372,  372,  808,  372,
1009 372,  372,  554,  808,  372,  555,  372,  372,  372,  372,
1010 808,  372,  556,  808,  372,  372,  372,  808,  372,  372,
1011 372,  372,  808,  372,  372,  372,  808,  557,  558,  559,
1012 372,  808,  560,  561,  372,  372,  372,  372,  372,  372,
1013
1014 372,  372,  372,  808,  372,  808,  808,  372,  808,  372,
1015 808,  563,  372,  598,  598,  598,  808,  372,  808,  372,
1016 562,  808,  372,  408,  408,  408,  408,  408,  408,  408,
1017 408,  408,  408,  408,  408,  408,  408,  408,  408,  408,
1018 408,  408,  408,  564,  564,  564,  564,  564,  565,  565,
1019 565,  565,  565,  566,  566,  566,  566,  566,  205,  205,
1020 205,  205,  205,  205,  205,  205,  205,  205,  205,  205,
1021 205,  205,  205,  205,  205,  205,  205,  205,  567,  567,
1022 567,  567,  567,  568,  568,  568,  568,  568,  569,  569,
1023 569,  569,  569,  214,  214,  214,  214,  214,  214,  214,
1024
1025 214,  214,  214,  214,  214,  214,  214,  214,  214,  214,
1026 214,  214,  214,  570,  570,  570,  570,  570,  571,  571,
1027 571,  571,  571,  572,  572,  572,  572,  572,  437,  205,
1028 205,  205,  205,  205,  205,  240,  241,  573,  808,  574,
1029 205,  575,  205,  808,  205,  808,  240,  241,  205,  205,
1030 205,  808,  205,  808,  205,  205,  205,  205,  205,  205,
1031 205,  205,  205,  205,  808,  577,  205,  808,  578,  576,
1032 579,  205,  808,  205,  205,  205,  205,  808,  205,  205,
1033 205,  205,  808,  205,  580,  205,  205,  205,  205,  205,
1034 205,  205,  205,  205,  205,  205,  808,  205,  583,  205,
1035
1036 205,  581,  205,  808,  205,  205,  205,  205,  582,  205,
1037 585,  808,  584,  808,  205,  808,  205,  205,  205,  597,
1038 597,  597,  597,  597,  808,  808,  205,  808,  205,  605,
1039 605,  605,  586,  597,  597,  597,  597,  597,  205,  587,
1040 587,  808,  587,  587,  588,  588,  587,  587,  587,  587,
1041 587,  587,  587,  587,  587,  587,  587,  588,  587,  587,
1042 587,  587,  587,  587,  588,  588,  588,  588,  587,  587,
1043 587,  587,  588,  588,  588,  588,  588,  588,  588,  588,
1044 588,  588,  588,  588,  588,  588,  588,  588,  588,  588,
1045 588,  587,  587,  587,  587,  587,  587,  587,  587,  587,
1046
1047 589,  590,  591,  592,  593,  593,  594,  595,  596,  597,
1048 597,  597,  597,  597,  289,  463,  463,  463,  463,  463,
1049 599,  599,  599,  599,  599,  601,  601,  601,  601,  601,
1050 602,  602,  602,  602,  603,  603,  603,  603,  603,  289,
1051 472,  472,  472,  472,  472,  606,  606,  606,  606,  606,
1052 608,  608,  608,  608,  608,  609,  609,  609,  609,  610,
1053 610,  610,  610,  610,  279,  279,  279,  279,  279,  279,
1054 279,  279,  279,  279,  464,  465,  466,  467,  468,  468,
1055 469,  470,  471,  279,  279,  279,  279,  279,  279,  279,
1056 279,  279,  279,  612,  612,  612,  612,  612,  808,  473,
1057
1058 474,  475,  476,  477,  477,  478,  479,  480,  613,  613,
1059 613,  613,  613,  614,  614,  614,  614,  614,  615,  290,
1060 290,  290,  290,  290,  683,  683,  683,  488,  290,  290,
1061 290,  290,  290,  290,  290,  290,  290,  290,  488,  808,
1062 488,  290,  290,  290,  290,  290,  616,  616,  616,  616,
1063 616,  617,  617,  617,  617,  617,  618,  618,  618,  618,
1064 618,  299,  299,  299,  299,  299,  299,  299,  299,  299,
1065 299,  299,  299,  299,  299,  299,  299,  299,  299,  299,
1066 299,  619,  619,  619,  619,  619,  620,  620,  620,  620,
1067 620,  621,  621,  621,  621,  621,  290,  290,  290,  290,
1068
1069 808,  808,  622,  290,  290,  290,  290,  290,  623,  290,
1070 808,  624,  290,  290,  290,  808,  290,  290,  808,  290,
1071 290,  290,  626,  290,  290,  808,  625,  290,  290,  290,
1072 290,  627,  808,  290,  290,  290,  808,  628,  290,  808,
1073 290,  290,  290,  290,  629,  290,  290,  290,  290,  808,
1074 290,  290,  290,  290,  808,  290,  808,  290,  290,  290,
1075 808,  632,  290,  290,  630,  290,  290,  290,  631,  290,
1076 290,  290,  290,  290,  290,  808,  290,  808,  808,  633,
1077 808,  290,  634,  808,  290,  808,  290,  808,  635,  808,
1078 808,  290,  808,  808,  290,  587,  636,  808,  587,  587,
1079
1080 637,  637,  587,  587,  587,  587,  587,  587,  587,  587,
1081 587,  587,  587,  637,  587,  587,  587,  587,  587,  587,
1082 637,  637,  637,  637,  587,  587,  587,  587,  637,  637,
1083 637,  637,  637,  637,  637,  637,  637,  637,  637,  637,
1084 637,  637,  637,  637,  637,  637,  637,  587,  587,  587,
1085 587,  587,  587,  587,  587,  587,  638,  639,  640,  641,
1086 642,  642,  643,  644,  645,  646,  646,  646,  646,  646,
1087 646,  646,  646,  646,  646,  646,  646,  646,  646,  646,
1088 530,  531,  532,  372,  372,  372,  372,  372,  372,  372,
1089 372,  372,  372,  713,  713,  713,  533,  372,  372,  372,
1090
1091 372,  372,  372,  372,  372,  372,  372,  648,  648,  648,
1092 648,  648,  649,  649,  649,  649,  649,  650,  650,  650,
1093 650,  650,  381,  381,  381,  381,  381,  381,  381,  381,
1094 381,  381,  381,  381,  381,  381,  381,  381,  381,  381,
1095 381,  381,  651,  651,  651,  651,  651,  652,  652,  652,
1096 652,  652,  653,  653,  653,  653,  653,  372,  372,  372,
1097 372,  808,  808,  654,  372,  372,  372,  372,  372,  655,
1098 372,  808,  656,  372,  372,  372,  808,  372,  372,  808,
1099 372,  372,  372,  658,  372,  372,  808,  657,  372,  372,
1100 372,  372,  659,  808,  372,  372,  372,  808,  660,  372,
1101
1102 808,  372,  372,  372,  372,  661,  372,  372,  372,  372,
1103 808,  372,  372,  372,  372,  808,  372,  808,  372,  372,
1104 372,  808,  664,  372,  372,  662,  372,  372,  372,  663,
1105 372,  372,  372,  372,  372,  372,  808,  372,  808,  808,
1106 665,  808,  372,  666,  808,  372,  808,  372,  808,  667,
1107 808,  808,  372,  808,  808,  372,  668,  668,  668,  668,
1108 668,  668,  668,  668,  668,  668,  668,  668,  668,  668,
1109 668,  669,  669,  669,  669,  669,  669,  669,  669,  669,
1110 669,  669,  669,  669,  669,  669,  670,  670,  670,  670,
1111 670,  670,  670,  670,  670,  670,  670,  670,  670,  670,
1112
1113 670,  205,  205,  205,  205,  205,  205,  205,  205,  808,
1114 205,  205,  205,  808,  205,  671,  205,  672,  205,  808,
1115 673,  205,  205,  674,  205,  808,  205,  808,  205,  205,
1116 205,  205,  205,  205,  808,  205,  205,  808,  808,  808,
1117 205,  205,  205,  205,  205,  205,  205,  808,  808,  808,
1118 205,  675,  205,  676,  677,  205,  205,  678,  205,  205,
1119 205,  205,  205,  679,  808,  205,  680,  808,  681,  205,
1120 808,  205,  205,  205,  205,  205,  808,  808,  808,  205,
1121 808,  205,  808,  205,  682,  205,  588,  588,  588,  588,
1122 588,  808,  808,  205,  808,  205,  684,  684,  684,  684,
1123
1124 684,  686,  686,  686,  686,  686,  687,  687,  687,  687,
1125 688,  688,  688,  688,  688,  205,  205,  463,  463,  463,
1126 463,  463,  717,  717,  717,  717,  205,  463,  463,  463,
1127 463,  463,  808,  808,  808,  808,  205,  463,  463,  463,
1128 463,  463,  463,  463,  463,  463,  463,  690,  690,  690,
1129 690,  690,  691,  691,  691,  691,  691,  692,  692,  692,
1130 692,  692,  472,  472,  472,  472,  472,  472,  472,  472,
1131 472,  472,  472,  472,  472,  472,  472,  472,  472,  472,
1132 472,  472,  693,  693,  693,  693,  693,  694,  694,  694,
1133 694,  694,  695,  695,  695,  695,  695,  696,  696,  696,
1134
1135 696,  696,  696,  696,  696,  696,  696,  696,  696,  696,
1136 696,  696,  615,  697,  697,  697,  697,  697,  808,  808,
1137 808,  488,  697,  697,  697,  697,  697,  697,  697,  697,
1138 697,  697,  488,  808,  488,  698,  698,  698,  698,  698,
1139 698,  698,  698,  698,  698,  698,  698,  698,  698,  698,
1140 290,  290,  290,  290,  290,  290,  290,  290,  808,  290,
1141 290,  290,  808,  290,  699,  290,  700,  290,  808,  701,
1142 290,  290,  702,  290,  808,  290,  808,  290,  290,  290,
1143 290,  290,  290,  808,  290,  290,  808,  808,  808,  290,
1144 290,  290,  290,  290,  290,  290,  808,  808,  808,  290,
1145
1146 703,  290,  704,  705,  290,  290,  706,  290,  290,  290,
1147 290,  290,  707,  808,  290,  708,  808,  709,  290,  808,
1148 290,  290,  290,  290,  290,  808,  636,  488,  290,  808,
1149 290,  808,  290,  710,  290,  587,  637,  637,  637,  637,
1150 637,  808,  290,  808,  290,  808,  587,  587,  587,  712,
1151 714,  714,  714,  714,  714,  716,  716,  716,  716,  716,
1152 718,  718,  718,  718,  718,  290,  290,  720,  720,  720,
1153 720,  720,  808,  808,  808,  808,  290,  808,  808,  808,
1154 712,  720,  720,  720,  720,  720,  290,  720,  720,  720,
1155 720,  720,  721,  721,  721,  721,  721,  721,  721,  721,
1156
1157 721,  721,  721,  721,  721,  721,  721,  372,  372,  372,
1158 372,  372,  372,  372,  372,  808,  372,  372,  372,  808,
1159 372,  722,  372,  723,  372,  808,  724,  372,  372,  725,
1160 372,  808,  372,  808,  372,  372,  372,  372,  372,  372,
1161 808,  372,  372,  808,  808,  808,  372,  372,  372,  372,
1162 372,  372,  372,  808,  808,  808,  372,  726,  372,  727,
1163 728,  372,  372,  729,  372,  372,  372,  372,  372,  730,
1164 808,  372,  731,  808,  732,  372,  808,  372,  372,  372,
1165 372,  372,  372,  372,  808,  372,  808,  372,  808,  372,
1166 733,  372,  808,  372,  205,  205,  205,  205,  808,  372,
1167
1168 808,  372,  808,  372,  808,  205,  808,  205,  205,  205,
1169 205,  205,  205,  205,  808,  205,  808,  205,  808,  205,
1170 808,  205,  808,  735,  205,  205,  808,  734,  808,  205,
1171 808,  205,  808,  205,  808,  205,  205,  205,  808,  205,
1172 205,  736,  205,  205,  808,  205,  808,  205,  808,  737,
1173 205,  808,  739,  205,  205,  205,  808,  205,  205,  205,
1174 205,  808,  738,  205,  808,  205,  205,  205,  808,  205,
1175 808,  740,  205,  205,  808,  205,  808,  205,  742,  741,
1176 808,  808,  808,  205,  808,  808,  808,  205,  588,  588,
1177 588,  588,  588,  205,  588,  588,  588,  588,  588,  588,
1178
1179 588,  588,  588,  588,  588,  588,  588,  588,  588,  743,
1180 743,  743,  743,  743,  744,  744,  744,  744,  744,  745,
1181 745,  745,  745,  745,  746,  746,  746,  746,  746,  746,
1182 746,  746,  746,  746,  746,  746,  746,  746,  746,  747,
1183 747,  747,  747,  747,  747,  747,  747,  747,  747,  747,
1184 747,  747,  747,  747,  290,  290,  290,  290,  290,  290,
1185 808,  290,  290,  290,  290,  290,  808,  290,  808,  290,
1186 290,  290,  290,  808,  749,  290,  808,  290,  748,  290,
1187 808,  290,  290,  808,  290,  290,  290,  750,  290,  290,
1188 808,  290,  290,  290,  808,  808,  290,  808,  751,  290,
1189
1190 808,  808,  753,  290,  290,  290,  290,  290,  290,  290,
1191 808,  752,  808,  290,  808,  290,  290,  290,  290,  290,
1192 290,  754,  757,  488,  808,  290,  808,  290,  755,  808,
1193 290,  756,  637,  637,  637,  637,  637,  290,  808,  808,
1194 290,  808,  808,  587,  637,  637,  637,  637,  637,  637,
1195 637,  637,  637,  637,  637,  637,  637,  637,  637,  758,
1196 758,  758,  758,  758,  759,  759,  759,  759,  759,  760,
1197 760,  760,  760,  760,  372,  372,  372,  372,  372,  372,
1198 808,  372,  372,  372,  372,  372,  808,  372,  808,  372,
1199 372,  372,  372,  808,  762,  372,  808,  372,  761,  372,
1200
1201 808,  372,  372,  808,  372,  372,  372,  763,  372,  372,
1202 808,  372,  372,  372,  808,  808,  372,  808,  764,  372,
1203 808,  808,  766,  372,  372,  372,  372,  372,  372,  372,
1204 808,  765,  808,  372,  808,  372,  372,  372,  372,  372,
1205 372,  767,  205,  205,  808,  372,  808,  372,  768,  808,
1206 372,  769,  808,  205,  205,  205,  808,  372,  205,  205,
1207 372,  205,  205,  205,  770,  205,  771,  205,  205,  205,
1208 205,  205,  205,  808,  773,  205,  205,  205,  205,  205,
1209 808,  205,  205,  205,  205,  772,  808,  205,  205,  205,
1210 205,  205,  808,  808,  205,  808,  808,  205,  808,  808,
1211
1212 205,  808,  808,  808,  205,  774,  774,  774,  774,  774,
1213 205,  774,  774,  774,  774,  774,  774,  774,  774,  774,
1214 774,  290,  290,  290,  290,  290,  290,  290,  290,  808,
1215 290,  290,  290,  776,  290,  808,  290,  808,  290,  290,
1216 290,  290,  290,  775,  290,  777,  290,  808,  290,  808,
1217 290,  290,  778,  290,  290,  290,  290,  290,  290,  808,
1218 290,  757,  488,  808,  290,  808,  290,  808,  290,  779,
1219 779,  779,  779,  779,  290,  808,  290,  808,  290,  808,
1220 808,  808,  587,  779,  779,  779,  779,  779,  779,  779,
1221 779,  779,  779,  372,  372,  372,  372,  372,  372,  372,
1222
1223 372,  808,  372,  372,  372,  781,  372,  808,  372,  808,
1224 372,  372,  372,  372,  372,  780,  372,  782,  372,  808,
1225 372,  808,  372,  372,  783,  372,  372,  372,  372,  372,
1226 372,  808,  372,  205,  205,  808,  372,  808,  372,  808,
1227 372,  205,  205,  784,  205,  808,  372,  808,  372,  808,
1228 372,  808,  205,  808,  205,  205,  205,  205,  205,  290,
1229 290,  808,  785,  290,  290,  808,  205,  808,  205,  788,
1230 290,  808,  786,  808,  290,  808,  205,  787,  205,  808,
1231 290,  290,  290,  808,  789,  290,  290,  808,  808,  372,
1232 372,  808,  290,  372,  372,  808,  290,  808,  790,  792,
1233
1234 372,  808,  290,  808,  372,  791,  290,  372,  372,  808,
1235 372,  372,  372,  808,  793,  205,  205,  808,  372,  808,
1236 808,  808,  372,  808,  794,  808,  205,  808,  372,  205,
1237 205,  795,  372,  205,  205,  808,  205,  205,  205,  808,
1238 205,  808,  796,  808,  205,  290,  290,  797,  205,  808,
1239 205,  290,  290,  808,  205,  808,  290,  808,  205,  290,
1240 290,  808,  290,  808,  798,  808,  290,  290,  290,  808,
1241 290,  808,  290,  372,  372,  372,  372,  799,  290,  808,
1242 290,  808,  372,  372,  372,  808,  372,  808,  290,  372,
1243 372,  205,  205,  372,  372,  800,  372,  205,  205,  801,
1244
1245 372,  808,  205,  372,  290,  290,  290,  290,  205,  802,
1246 372,  808,  205,  372,  372,  290,  808,  290,  205,  372,
1247 372,  808,  803,  808,  372,  290,  808,  290,  205,  205,
1248 372,  804,  205,  205,  372,  290,  290,  372,  372,  205,
1249 372,  808,  808,  205,  808,  805,  290,  808,  372,  205,
1250 290,  290,  806,  205,  807,  808,  290,  808,  372,  372,
1251 372,  290,  808,  808,  808,  808,  808,  808,  808,  808,
1252 372,  290,  808,  808,  808,  808,  808,  808,  808,  808,
1253 372,   97,   97,   97,   97,   97,   97,   97,   97,   97,
1254 97,   97,   97,  103,  103,  103,  103,  103,  103,  103,
1255
1256 103,  103,  103,  103,  103,  109,  109,  109,  109,  109,
1257 109,  109,  109,  109,  109,  109,  109,  114,  114,  114,
1258 114,  114,  114,  114,  114,  114,  114,  114,  114,  117,
1259 117,  117,  117,  117,  117,  117,  117,  117,  117,  117,
1260 117,  163,  163,  163,  163,  163,  163,  163,  163,  163,
1261 163,  163,  163,  205,  808,  808,  808,  808,  808,  205,
1262 214,  808,  808,  808,  808,  808,  214,  279,  279,  279,
1263 808,  279,  279,  290,  808,  808,  808,  290,  808,  808,
1264 808,  808,  808,  290,  299,  808,  808,  808,  808,  808,
1265 299,  335,  335,  808,  808,  808,  335,  335,  335,  335,
1266
1267 335,  808,  335,  342,  342,  808,  808,  808,  342,  342,
1268 342,  342,  342,  808,  342,  349,  349,  808,  808,  349,
1269 349,  349,  349,  808,  349,  349,  349,  353,  353,  808,
1270 808,  353,  353,  353,  353,  353,  353,  353,  353,  369,
1271 808,  808,  808,  808,  369,  369,  369,  369,  808,  369,
1272 369,  372,  808,  808,  808,  808,  808,  372,  381,  808,
1273 808,  808,  808,  808,  381,  432,  432,  432,  432,  432,
1274 432,  432,  432,  432,  432,  432,  436,  436,  436,  436,
1275 436,  436,  436,  436,  436,  436,  436,  442,  442,  442,
1276 442,  442,  442,  442,  442,  442,  442,  442,  463,  808,
1277
1278 808,  808,  463,  808,  808,  808,  808,  808,  463,  472,
1279 808,  808,  808,  808,  808,  472,  488,  488,  488,  488,
1280 488,  488,  488,  808,  488,  488,  488,  488,  587,  587,
1281 808,  587,  587,  587,  587,  587,  587,  587,  587,  587,
1282 711,  711,  711,  711,  711,  711,  711,  711,  711,  711,
1283 711,  711,   19,  808,  808,  808,  808,  808,  808,  808,
1284 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1285 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1286 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1287 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1288
1289 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1290 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1291 808,  808,  808
1292 } ;
1293
1294 static yyconst flex_int16_t yy_chk[4224] =
1295 {
1296 0,
1297 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1298 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1299 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1300 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1301 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1302 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1303 1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
1304 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1305 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1306 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1307
1308 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1309 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1310 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1311 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
1312 3,    3,    3,    4,    4,    4,  645,    3,    9,    9,
1313 4,    5,    5,    5,    3,   10,   10,    4,    5,    6,
1314 6,    6,    7,    7,  596,    5,    6,   32,    8,    8,
1315 533,   32,    7,    6,   11,   11,   11,    7,    8,   12,
1316 12,   12,  532,    8,   21,   21,   21,   37,   67,   67,
1317 11,   37,   37,   91,   91,   12,   13,   13,   13,   13,
1318
1319 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1320 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1321 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1322 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1323 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1324 13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
1325 13,   13,   13,   13,   13,   13,   15,   15,   15,   15,
1326 41,   22,  529,   42,   15,   15,   43,   44,  100,   15,
1327 23,   23,  528,  100,   22,   15,   15,   15,   15,   15,
1328 22,   41,   41,   23,   42,  158,  158,   43,   44,   23,
1329
1330 25,   25,   25,   25,   25,   25,   25,   25,   25,   26,
1331 26,   26,   26,   26,   26,   26,   26,   26,   63,  527,
1332 15,   16,   16,   16,   16,   65,   65,   65,   36,   16,
1333 16,   36,  525,  101,   16,   36,   36,   36,  101,   63,
1334 16,   16,   16,   16,   16,   38,  134,   38,  480,   36,
1335 134,   36,   49,   49,   38,   38,   64,   64,   64,   64,
1336 64,  194,  194,   49,  471,   38,   38,   70,   70,   70,
1337 70,   49,  441,   49,  440,   16,   17,   17,   17,   17,
1338 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1339 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1340
1341 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1342 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1343 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1344 17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
1345 17,   17,   17,   17,   17,   17,   27,   27,   50,   50,
1346 51,   51,   53,   53,   50,  106,  439,   27,  229,   50,
1347 106,   51,  229,   53,  209,  209,   50,   27,   51,   50,
1348 53,   51,  438,   53,   53,   89,   89,   89,   52,   52,
1349 27,   27,   27,   27,   27,   27,   27,   27,   27,   52,
1350 54,   54,  417,   52,  389,   52,   55,   55,  380,   52,
1351
1352 370,   54,   56,   56,   57,   57,  368,   55,  363,   58,
1353 58,   54,   56,   56,   57,   57,   74,   55,   82,   82,
1354 58,   58,  362,   56,  361,   57,  355,   57,   58,   82,
1355 58,   59,   59,   66,   66,   66,   66,   66,  307,   82,
1356 218,  218,   59,   59,   68,   68,   68,   68,   68,  156,
1357 156,  156,   59,   69,   69,   69,   69,   69,   71,   71,
1358 71,   71,   71,   73,   73,   73,  284,  284,   73,   88,
1359 88,   88,   88,   88,  294,  294,   74,   74,   74,   74,
1360 74,   74,   74,   74,   74,   75,   75,   75,   75,   75,
1361 75,   75,   75,   75,   77,   77,   78,   78,   79,   79,
1362
1363 81,   81,   78,  107,  298,   77,  288,   78,  107,   79,
1364 233,   81,  231,   77,   78,   77,   79,   78,   81,   79,
1365 230,   81,   81,   73,   73,   73,   73,   73,   73,   73,
1366 73,   73,   76,   80,   80,   83,   83,   94,   94,   94,
1367 94,   84,   84,  222,   80,  213,   83,  144,   80,  201,
1368 80,   84,   84,  198,   80,  166,   83,  145,   76,   76,
1369 85,   85,   84,   86,   86,   87,   87,  121,  144,   76,
1370 85,   85,  121,  164,   86,   86,   87,   87,  145,   76,
1371 162,   85,   86,   85,   86,  152,   87,   90,   90,   90,
1372 90,   90,   76,   76,   76,   76,   76,   76,   76,   76,
1373
1374 76,   92,   92,   92,   92,   92,   93,   93,   93,   93,
1375 93,   95,   95,   95,   95,   95,  123,  123,  123,  124,
1376 125,  125,  143,  148,  146,  123,  127,  127,  123,  141,
1377 123,  139,  124,  125,  123,  139,  139,  127,  124,  125,
1378 154,  130,  242,  143,  143,  146,  245,  127,  128,  128,
1379 128,  128,  128,  128,  128,  128,  128,  129,  129,  247,
1380 204,  154,  138,  242,  242,  138,  120,  245,  129,  138,
1381 138,  138,  140,  204,  140,  192,  192,  192,  129,  204,
1382 247,  140,  140,  138,  118,  138,  155,  155,  155,  155,
1383 155,  116,  140,  140,  157,  157,  157,  157,  157,  159,
1384
1385 159,  159,  159,  159,  160,  160,  160,  160,  161,  161,
1386 161,  161,  161,  177,  177,  177,  177,  177,  177,  177,
1387 177,  177,  178,  178,  178,  178,  178,  178,  178,  178,
1388 178,  179,  179,  113,  180,  180,  182,  182,  181,  181,
1389 184,  184,  179,  112,  181,  180,  111,  182,  108,  181,
1390 105,  184,  179,  180,  182,  180,  181,  182,  184,  181,
1391 102,  184,  184,  183,  183,  179,  179,  179,  179,  179,
1392 179,  179,  179,  179,  183,  185,  185,   99,  183,   96,
1393 183,  186,  186,  249,  183,   72,  185,  187,  187,  188,
1394 188,   61,  186,   46,  189,  189,  185,  187,  187,  188,
1395
1396 188,   28,  186,   19,  249,  189,  189,    0,  187,  240,
1397 188,  240,  188,  189,  240,  189,  190,  190,  191,  191,
1398 191,  191,  191,  196,  196,  196,  196,  190,  190,  193,
1399 193,  193,  193,  193,  199,  199,  199,  190,  195,  195,
1400 195,  195,  195,  197,  197,  197,  197,  197,  202,  202,
1401 202,  203,  203,  203,  205,  205,  206,  206,  206,  206,
1402 206,  202,  303,  303,  203,  205,    0,  202,  376,  376,
1403 203,  207,  207,  207,    0,  205,  208,  208,  208,  208,
1404 208,  210,  210,  210,  210,  210,  211,  211,  211,  211,
1405 212,  212,  212,  212,  212,  215,  215,  215,  215,  215,
1406
1407 216,  216,  216,  217,  217,  217,  217,  217,  219,  219,
1408 219,  219,  219,  220,  220,  220,  220,  221,  221,  221,
1409 221,  221,  223,  223,  224,  224,  282,  282,  282,  232,
1410 268,  238,  239,  223,  239,  224,  232,  232,  238,  238,
1411 0,  239,  239,  223,    0,  224,    0,  232,  232,  238,
1412 238,  268,  239,  239,  241,    0,  241,  251,  251,  241,
1413 252,  252,  253,  253,  254,  254,    0,  251,  251,  364,
1414 0,  252,    0,  253,    0,  254,  255,  255,  251,  253,
1415 252,  252,  364,  253,    0,  254,    0,  255,  364,  256,
1416 256,    0,  257,  257,  259,  259,  255,  255,  256,    0,
1417
1418 256,  258,  258,  257,    0,  259,  261,  261,  260,  260,
1419 256,  257,  258,  257,    0,  259,    0,  261,  258,  260,
1420 260,    0,  258,  262,  262,    0,  261,  261,    0,  260,
1421 263,  263,  385,  385,  262,  264,  264,    0,  262,  265,
1422 265,  263,    0,  263,  262,  264,  264,    0,  266,  266,
1423 265,  263,    0,  269,  269,    0,  264,  467,  467,  266,
1424 265,  266,  279,  265,  269,  286,  286,  286,  286,  266,
1425 292,  292,  292,    0,  269,  270,  270,  270,  270,  270,
1426 271,  271,  271,  271,  271,  272,  272,  272,  272,  272,
1427 273,  273,  273,  273,  273,  274,  274,  274,  274,  274,
1428
1429 275,  275,  275,  275,  275,  276,  276,  276,  276,  276,
1430 277,  277,  277,  277,  277,  278,  278,  278,  476,  476,
1431 278,    0,  279,  279,  279,  279,  279,  279,  279,  279,
1432 279,  280,  280,  280,  280,  280,  280,  280,  280,  280,
1433 281,  281,  281,  281,  281,  283,  283,  283,  283,  283,
1434 285,  285,  285,  285,  285,  287,  287,  287,  287,  287,
1435 299,  289,  291,  291,  291,  291,  291,  293,  293,  293,
1436 293,  293,  301,  301,  301,  278,  278,  278,  278,  278,
1437 278,  278,  278,  278,  289,  290,  290,  295,  295,  295,
1438 295,  295,  296,  296,  296,  296,  290,  297,  297,  297,
1439
1440 297,  297,  305,  305,  305,  305,  290,  300,  300,  300,
1441 300,  300,  374,  374,  374,  289,  378,  378,  378,  378,
1442 299,  299,  299,  299,  299,  299,  299,  299,  299,  302,
1443 302,  302,  302,  302,  304,  304,  304,  304,  304,  306,
1444 306,  306,  306,  306,  308,  308,  309,  309,  310,  310,
1445 311,  311,    0,  313,  313,  308,    0,  309,  310,  310,
1446 0,  311,  312,  312,  313,  308,    0,  309,    0,  310,
1447 311,  311,    0,  312,  313,  314,  314,  592,  592,  312,
1448 315,  315,    0,  312,  641,  641,  314,  316,  316,  315,
1449 0,  315,  317,  317,    0,  314,  314,    0,  316,  318,
1450
1451 318,  315,    0,  317,  319,  319,  316,    0,  316,  317,
1452 318,  320,  320,  317,    0,  319,  319,    0,  321,  321,
1453 318,    0,  320,  322,  322,  319,    0,  323,  323,  321,
1454 0,  320,  320,  321,  322,    0,  322,  323,  323,  321,
1455 324,  324,  325,  325,  322,  326,  326,    0,  323,    0,
1456 0,  324,    0,  325,    0,  325,  326,  383,  383,  383,
1457 0,  324,    0,  325,  324,    0,  326,  327,  327,  327,
1458 327,  327,  328,  328,  328,  328,  328,  329,  329,  329,
1459 329,  329,  330,  330,  330,  330,  330,  331,  331,  331,
1460 331,  331,  332,  332,  332,  332,  332,  333,  333,  333,
1461
1462 333,  333,  334,  334,  334,  334,  334,  341,  341,  348,
1463 348,    0,    0,  359,  359,  359,    0,  365,  365,  366,
1464 366,  341,  359,  348,    0,  359,    0,  359,  365,    0,
1465 366,  359,  367,  367,  367,  372,  372,    0,  365,    0,
1466 366,  373,  373,  373,  373,  373,  372,  367,  367,  375,
1467 375,  375,  375,  375,    0,    0,  372,  377,  377,  377,
1468 377,  377,  379,  379,  379,  379,  379,  381,  381,  381,
1469 381,  381,  381,  381,  381,  381,  382,  382,  382,  382,
1470 382,  384,  384,  384,  384,  384,  386,  386,  386,  386,
1471 386,  387,  387,  387,  387,  388,  388,  388,  388,  388,
1472
1473 390,  390,  391,  391,  392,  392,  393,  393,    0,  395,
1474 395,  390,    0,  391,  392,  392,    0,  393,  394,  394,
1475 395,  390,    0,  391,    0,  392,  393,  393,    0,  394,
1476 395,  396,  396,    0,    0,  394,  397,  397,    0,  394,
1477 0,    0,  396,  398,  398,  397,    0,  397,  399,  399,
1478 0,  396,  396,    0,  398,  400,  400,  397,    0,  399,
1479 401,  401,  398,    0,  398,  399,  400,  402,  402,  399,
1480 0,  401,  401,    0,  403,  403,  400,    0,  402,  404,
1481 404,  401,    0,  405,  405,  403,    0,  402,  402,  403,
1482 404,    0,  404,  405,  405,  403,  406,  406,  407,  407,
1483
1484 404,  408,  408,    0,  405,    0,    0,  406,    0,  407,
1485 0,  407,  408,  465,  465,  465,    0,  406,    0,  407,
1486 406,    0,  408,  409,  409,  409,  409,  409,  410,  410,
1487 410,  410,  410,  411,  411,  411,  411,  411,  412,  412,
1488 412,  412,  412,  413,  413,  413,  413,  413,  414,  414,
1489 414,  414,  414,  415,  415,  415,  415,  415,  418,  418,
1490 418,  418,  418,  419,  419,  419,  419,  419,  420,  420,
1491 420,  420,  420,  421,  421,  421,  421,  421,  422,  422,
1492 422,  422,  422,  423,  423,  423,  423,  423,  424,  424,
1493 424,  424,  424,  425,  425,  425,  425,  425,  426,  426,
1494
1495 426,  426,  426,  427,  427,  427,  427,  427,  428,  428,
1496 428,  428,  428,  429,  429,  429,  429,  429,  430,  430,
1497 430,  430,  430,  431,  431,  431,  431,  431,  437,  444,
1498 444,  443,  443,  445,  445,  437,  437,  443,    0,  444,
1499 444,  445,  443,    0,  445,    0,  437,  437,  446,  446,
1500 444,    0,  443,    0,  445,  447,  447,  448,  448,  446,
1501 449,  449,  450,  450,    0,  447,  447,    0,  448,  446,
1502 450,  449,    0,  450,  451,  451,  447,    0,  448,  452,
1503 452,  449,    0,  450,  451,  451,  453,  453,  454,  454,
1504 452,  455,  455,  456,  456,  451,    0,  453,  454,  454,
1505
1506 452,  452,  455,    0,  456,  457,  457,  453,  453,  454,
1507 456,    0,  455,    0,  456,    0,  457,  458,  458,  460,
1508 460,  460,  460,  460,    0,    0,  457,    0,  458,  474,
1509 474,  474,  458,  461,  461,  461,  461,  461,  458,  459,
1510 459,    0,  459,  459,  459,  459,  459,  459,  459,  459,
1511 459,  459,  459,  459,  459,  459,  459,  459,  459,  459,
1512 459,  459,  459,  459,  459,  459,  459,  459,  459,  459,
1513 459,  459,  459,  459,  459,  459,  459,  459,  459,  459,
1514 459,  459,  459,  459,  459,  459,  459,  459,  459,  459,
1515 459,  459,  459,  459,  459,  459,  459,  459,  459,  459,
1516
1517 459,  459,  459,  459,  459,  459,  459,  459,  459,  462,
1518 462,  462,  462,  462,  463,  464,  464,  464,  464,  464,
1519 466,  466,  466,  466,  466,  468,  468,  468,  468,  468,
1520 469,  469,  469,  469,  470,  470,  470,  470,  470,  472,
1521 473,  473,  473,  473,  473,  475,  475,  475,  475,  475,
1522 477,  477,  477,  477,  477,  478,  478,  478,  478,  479,
1523 479,  479,  479,  479,  481,  481,  481,  481,  481,  482,
1524 482,  482,  482,  482,  463,  463,  463,  463,  463,  463,
1525 463,  463,  463,  483,  483,  483,  483,  483,  484,  484,
1526 484,  484,  484,  485,  485,  485,  485,  485,    0,  472,
1527
1528 472,  472,  472,  472,  472,  472,  472,  472,  486,  486,
1529 486,  486,  486,  487,  487,  487,  487,  487,  489,  490,
1530 490,  490,  490,  490,  590,  590,  590,  489,  491,  491,
1531 491,  491,  491,  492,  492,  492,  492,  492,  489,    0,
1532 489,  493,  493,  493,  493,  493,  494,  494,  494,  494,
1533 494,  495,  495,  495,  495,  495,  496,  496,  496,  496,
1534 496,  497,  497,  497,  497,  497,  498,  498,  498,  498,
1535 498,  499,  499,  499,  499,  499,  500,  500,  500,  500,
1536 500,  501,  501,  501,  501,  501,  502,  502,  502,  502,
1537 502,  503,  503,  503,  503,  503,  504,  504,  505,  505,
1538
1539 0,    0,  504,  506,  506,  507,  507,  504,  505,  505,
1540 0,  506,  508,  508,  506,    0,  507,  504,    0,  505,
1541 509,  509,  508,  508,  506,    0,  507,  510,  510,  511,
1542 511,  509,    0,  508,  512,  512,    0,  511,  510,    0,
1543 511,  509,  513,  513,  512,  512,  514,  514,  510,    0,
1544 511,  515,  515,  513,    0,  512,    0,  514,  516,  516,
1545 0,  515,  515,  513,  513,  517,  517,  514,  514,  516,
1546 518,  518,  515,  519,  519,    0,  517,    0,    0,  516,
1547 0,  518,  517,    0,  519,    0,  517,    0,  519,    0,
1548 0,  518,    0,    0,  519,  520,  520,    0,  520,  520,
1549
1550 520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
1551 520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
1552 520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
1553 520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
1554 520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
1555 520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
1556 520,  520,  520,  520,  520,  521,  521,  521,  521,  521,
1557 522,  522,  522,  522,  522,  523,  523,  523,  523,  523,
1558 530,  530,  530,  534,  534,  534,  534,  534,  535,  535,
1559 535,  535,  535,  639,  639,  639,  530,  536,  536,  536,
1560
1561 536,  536,  537,  537,  537,  537,  537,  538,  538,  538,
1562 538,  538,  539,  539,  539,  539,  539,  540,  540,  540,
1563 540,  540,  541,  541,  541,  541,  541,  542,  542,  542,
1564 542,  542,  543,  543,  543,  543,  543,  544,  544,  544,
1565 544,  544,  545,  545,  545,  545,  545,  546,  546,  546,
1566 546,  546,  547,  547,  547,  547,  547,  548,  548,  549,
1567 549,    0,    0,  548,  550,  550,  551,  551,  548,  549,
1568 549,    0,  550,  552,  552,  550,    0,  551,  548,    0,
1569 549,  553,  553,  552,  552,  550,    0,  551,  554,  554,
1570 555,  555,  553,    0,  552,  556,  556,    0,  555,  554,
1571
1572 0,  555,  553,  557,  557,  556,  556,  558,  558,  554,
1573 0,  555,  559,  559,  557,    0,  556,    0,  558,  560,
1574 560,    0,  559,  559,  557,  557,  561,  561,  558,  558,
1575 560,  562,  562,  559,  563,  563,    0,  561,    0,    0,
1576 560,    0,  562,  561,    0,  563,    0,  561,    0,  563,
1577 0,    0,  562,    0,    0,  563,  564,  564,  564,  564,
1578 564,  565,  565,  565,  565,  565,  566,  566,  566,  566,
1579 566,  567,  567,  567,  567,  567,  568,  568,  568,  568,
1580 568,  569,  569,  569,  569,  569,  570,  570,  570,  570,
1581 570,  571,  571,  571,  571,  571,  572,  572,  572,  572,
1582
1583 572,  573,  573,  574,  574,  575,  575,  576,  576,    0,
1584 577,  577,  573,    0,  574,  573,  575,  575,  576,    0,
1585 576,  577,  573,  577,  574,    0,  575,    0,  576,  578,
1586 578,  577,  579,  579,    0,  580,  580,    0,    0,    0,
1587 578,  581,  581,  579,  582,  582,  580,    0,    0,    0,
1588 578,  578,  581,  579,  580,  582,  580,  581,  583,  583,
1589 584,  584,  581,  582,    0,  582,  583,    0,  584,  583,
1590 0,  584,  585,  585,  586,  586,    0,    0,    0,  583,
1591 0,  584,    0,  585,  586,  586,  589,  589,  589,  589,
1592 589,    0,    0,  585,    0,  586,  591,  591,  591,  591,
1593
1594 591,  593,  593,  593,  593,  593,  594,  594,  594,  594,
1595 595,  595,  595,  595,  595,  597,  597,  598,  598,  598,
1596 598,  598,  643,  643,  643,  643,  597,  599,  599,  599,
1597 599,  599,    0,    0,    0,    0,  597,  600,  600,  600,
1598 600,  600,  601,  601,  601,  601,  601,  602,  602,  602,
1599 602,  602,  603,  603,  603,  603,  603,  604,  604,  604,
1600 604,  604,  605,  605,  605,  605,  605,  606,  606,  606,
1601 606,  606,  607,  607,  607,  607,  607,  608,  608,  608,
1602 608,  608,  609,  609,  609,  609,  609,  610,  610,  610,
1603 610,  610,  611,  611,  611,  611,  611,  612,  612,  612,
1604
1605 612,  612,  613,  613,  613,  613,  613,  614,  614,  614,
1606 614,  614,  615,  616,  616,  616,  616,  616,    0,    0,
1607 0,  615,  617,  617,  617,  617,  617,  618,  618,  618,
1608 618,  618,  615,    0,  615,  619,  619,  619,  619,  619,
1609 620,  620,  620,  620,  620,  621,  621,  621,  621,  621,
1610 622,  622,  623,  623,  624,  624,  625,  625,    0,  626,
1611 626,  622,    0,  623,  622,  624,  624,  625,    0,  625,
1612 626,  622,  626,  623,    0,  624,    0,  625,  627,  627,
1613 626,  628,  628,    0,  629,  629,    0,    0,    0,  627,
1614 630,  630,  628,  631,  631,  629,    0,    0,    0,  627,
1615
1616 627,  630,  628,  629,  631,  629,  630,  632,  632,  633,
1617 633,  630,  631,    0,  631,  632,    0,  633,  632,    0,
1618 633,  634,  634,  635,  635,    0,  636,  636,  632,    0,
1619 633,    0,  634,  635,  635,  636,  638,  638,  638,  638,
1620 638,    0,  634,    0,  635,    0,  636,  636,  636,  636,
1621 640,  640,  640,  640,  640,  642,  642,  642,  642,  642,
1622 644,  644,  644,  644,  644,  646,  646,  648,  648,  648,
1623 648,  648,    0,    0,    0,    0,  646,    0,    0,    0,
1624 636,  649,  649,  649,  649,  649,  646,  650,  650,  650,
1625 650,  650,  651,  651,  651,  651,  651,  652,  652,  652,
1626
1627 652,  652,  653,  653,  653,  653,  653,  654,  654,  655,
1628 655,  656,  656,  657,  657,    0,  658,  658,  654,    0,
1629 655,  654,  656,  656,  657,    0,  657,  658,  654,  658,
1630 655,    0,  656,    0,  657,  659,  659,  658,  660,  660,
1631 0,  661,  661,    0,    0,    0,  659,  662,  662,  660,
1632 663,  663,  661,    0,    0,    0,  659,  659,  662,  660,
1633 661,  663,  661,  662,  664,  664,  665,  665,  662,  663,
1634 0,  663,  664,    0,  665,  664,    0,  665,  666,  666,
1635 667,  667,  668,  668,    0,  664,    0,  665,    0,  666,
1636 667,  667,    0,  668,  669,  669,  671,  671,    0,  666,
1637
1638 0,  667,    0,  668,    0,  669,    0,  671,  672,  672,
1639 673,  673,  674,  674,    0,  669,    0,  671,    0,  672,
1640 0,  673,    0,  674,  675,  675,    0,  673,    0,  672,
1641 0,  673,    0,  674,    0,  675,  676,  676,    0,  677,
1642 677,  675,  678,  678,    0,  675,    0,  676,    0,  676,
1643 677,    0,  678,  678,  679,  679,    0,  676,  680,  680,
1644 677,    0,  677,  678,    0,  679,  681,  681,    0,  680,
1645 0,  679,  682,  682,    0,  679,    0,  681,  681,  680,
1646 0,    0,    0,  682,    0,    0,    0,  681,  683,  683,
1647 683,  683,  683,  682,  684,  684,  684,  684,  684,  685,
1648
1649 685,  685,  685,  685,  686,  686,  686,  686,  686,  687,
1650 687,  687,  687,  687,  688,  688,  688,  688,  688,  689,
1651 689,  689,  689,  689,  690,  690,  690,  690,  690,  691,
1652 691,  691,  691,  691,  692,  692,  692,  692,  692,  693,
1653 693,  693,  693,  693,  694,  694,  694,  694,  694,  695,
1654 695,  695,  695,  695,  697,  697,  699,  699,  700,  700,
1655 0,  701,  701,  702,  702,  697,    0,  699,    0,  700,
1656 703,  703,  701,    0,  702,  697,    0,  699,  701,  700,
1657 0,  703,  701,    0,  702,  704,  704,  703,  705,  705,
1658 0,  703,  706,  706,    0,    0,  704,    0,  704,  705,
1659
1660 0,    0,  706,  706,  707,  707,  704,  708,  708,  705,
1661 0,  705,    0,  706,    0,  707,  710,  710,  708,  709,
1662 709,  707,  712,  712,    0,  707,    0,  710,  708,    0,
1663 709,  709,  713,  713,  713,  713,  713,  710,    0,    0,
1664 709,    0,    0,  712,  714,  714,  714,  714,  714,  715,
1665 715,  715,  715,  715,  716,  716,  716,  716,  716,  717,
1666 717,  717,  717,  717,  718,  718,  718,  718,  718,  719,
1667 719,  719,  719,  719,  720,  720,  722,  722,  723,  723,
1668 0,  724,  724,  725,  725,  720,    0,  722,    0,  723,
1669 726,  726,  724,    0,  725,  720,    0,  722,  724,  723,
1670
1671 0,  726,  724,    0,  725,  727,  727,  726,  728,  728,
1672 0,  726,  729,  729,    0,    0,  727,    0,  727,  728,
1673 0,    0,  729,  729,  730,  730,  727,  731,  731,  728,
1674 0,  728,    0,  729,    0,  730,  733,  733,  731,  732,
1675 732,  730,  734,  734,    0,  730,    0,  733,  731,    0,
1676 732,  732,    0,  734,  735,  735,    0,  733,  736,  736,
1677 732,  738,  738,  734,  734,  735,  736,  737,  737,  736,
1678 739,  739,  738,    0,  738,  735,  740,  740,  737,  736,
1679 0,  739,  738,  741,  741,  737,    0,  740,  737,  742,
1680 742,  739,    0,    0,  741,    0,    0,  740,    0,    0,
1681
1682 742,    0,    0,    0,  741,  743,  743,  743,  743,  743,
1683 742,  744,  744,  744,  744,  744,  745,  745,  745,  745,
1684 745,  748,  748,  749,  749,  750,  750,  751,  751,    0,
1685 753,  753,  748,  750,  749,    0,  750,    0,  751,  752,
1686 752,  753,  748,  748,  749,  751,  750,    0,  751,    0,
1687 752,  753,  752,  754,  754,  755,  755,  756,  756,    0,
1688 752,  757,  757,    0,  754,    0,  755,    0,  756,  758,
1689 758,  758,  758,  758,  754,    0,  755,    0,  756,    0,
1690 0,    0,  757,  759,  759,  759,  759,  759,  760,  760,
1691 760,  760,  760,  761,  761,  762,  762,  763,  763,  764,
1692
1693 764,    0,  766,  766,  761,  763,  762,    0,  763,    0,
1694 764,  765,  765,  766,  761,  761,  762,  764,  763,    0,
1695 764,    0,  765,  766,  765,  767,  767,  768,  768,  769,
1696 769,    0,  765,  770,  770,    0,  767,    0,  768,    0,
1697 769,  771,  771,  770,  770,    0,  767,    0,  768,    0,
1698 769,    0,  771,    0,  770,  772,  772,  773,  773,  775,
1699 775,    0,  771,  776,  776,    0,  772,    0,  773,  775,
1700 775,    0,  772,    0,  776,    0,  772,  773,  773,    0,
1701 775,  777,  777,    0,  776,  778,  778,    0,    0,  780,
1702 780,    0,  777,  781,  781,    0,  778,    0,  777,  780,
1703
1704 780,    0,  777,    0,  781,  778,  778,  782,  782,    0,
1705 780,  783,  783,    0,  781,  784,  784,    0,  782,    0,
1706 0,    0,  783,    0,  782,    0,  784,    0,  782,  785,
1707 785,  783,  783,  786,  786,    0,  784,  787,  787,    0,
1708 785,    0,  785,    0,  786,  788,  788,  787,  787,    0,
1709 785,  789,  789,    0,  786,    0,  788,    0,  787,  790,
1710 790,    0,  789,    0,  789,    0,  788,  791,  791,    0,
1711 790,    0,  789,  792,  792,  794,  794,  791,  791,    0,
1712 790,    0,  793,  793,  792,    0,  794,    0,  791,  795,
1713 795,  796,  796,  793,  792,  793,  794,  797,  797,  795,
1714
1715 795,    0,  796,  793,  798,  798,  799,  799,  797,  796,
1716 795,    0,  796,  800,  800,  798,    0,  799,  797,  801,
1717 801,    0,  798,    0,  800,  798,    0,  799,  802,  802,
1718 801,  800,  805,  805,  800,  803,  803,  804,  804,  802,
1719 801,    0,    0,  805,    0,  802,  803,    0,  804,  802,
1720 806,  806,  803,  805,  804,    0,  803,    0,  804,  807,
1721 807,  806,    0,    0,    0,    0,    0,    0,    0,    0,
1722 807,  806,    0,    0,    0,    0,    0,    0,    0,    0,
1723 807,  809,  809,  809,  809,  809,  809,  809,  809,  809,
1724 809,  809,  809,  810,  810,  810,  810,  810,  810,  810,
1725
1726 810,  810,  810,  810,  810,  811,  811,  811,  811,  811,
1727 811,  811,  811,  811,  811,  811,  811,  812,  812,  812,
1728 812,  812,  812,  812,  812,  812,  812,  812,  812,  813,
1729 813,  813,  813,  813,  813,  813,  813,  813,  813,  813,
1730 813,  814,  814,  814,  814,  814,  814,  814,  814,  814,
1731 814,  814,  814,  815,    0,    0,    0,    0,    0,  815,
1732 816,    0,    0,    0,    0,    0,  816,  817,  817,  817,
1733 0,  817,  817,  818,    0,    0,    0,  818,    0,    0,
1734 0,    0,    0,  818,  819,    0,    0,    0,    0,    0,
1735 819,  820,  820,    0,    0,    0,  820,  820,  820,  820,
1736
1737 820,    0,  820,  821,  821,    0,    0,    0,  821,  821,
1738 821,  821,  821,    0,  821,  822,  822,    0,    0,  822,
1739 822,  822,  822,    0,  822,  822,  822,  823,  823,    0,
1740 0,  823,  823,  823,  823,  823,  823,  823,  823,  824,
1741 0,    0,    0,    0,  824,  824,  824,  824,    0,  824,
1742 824,  825,    0,    0,    0,    0,    0,  825,  826,    0,
1743 0,    0,    0,    0,  826,  827,  827,  827,  827,  827,
1744 827,  827,  827,  827,  827,  827,  828,  828,  828,  828,
1745 828,  828,  828,  828,  828,  828,  828,  829,  829,  829,
1746 829,  829,  829,  829,  829,  829,  829,  829,  830,    0,
1747
1748 0,    0,  830,    0,    0,    0,    0,    0,  830,  831,
1749 0,    0,    0,    0,    0,  831,  832,  832,  832,  832,
1750 832,  832,  832,    0,  832,  832,  832,  832,  833,  833,
1751 0,  833,  833,  833,  833,  833,  833,  833,  833,  833,
1752 834,  834,  834,  834,  834,  834,  834,  834,  834,  834,
1753 834,  834,  808,  808,  808,  808,  808,  808,  808,  808,
1754 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1755 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1756 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1757 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1758
1759 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1760 808,  808,  808,  808,  808,  808,  808,  808,  808,  808,
1761 808,  808,  808
1762 } ;
1763
1764 extern int yy_flex_debug;
1765 int yy_flex_debug = 0;
1766
1767 static yy_state_type *yy_state_buf = 0, *yy_state_ptr = 0;
1768 static char *yy_full_match;
1769 static int yy_lp;
1770 static int yy_looking_for_trail_begin = 0;
1771 static int yy_full_lp;
1772 static int *yy_full_state;
1773 #define YY_TRAILING_MASK 0x2000
1774 #define YY_TRAILING_HEAD_MASK 0x4000
1775 #define REJECT \
1776 { \
1777 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \
1778 yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
1779 (yy_lp) = (yy_full_lp); /* restore orig. accepting pos. */ \
1780 (yy_state_ptr) = (yy_full_state); /* restore orig. state */ \
1781 yy_current_state = *(yy_state_ptr); /* restore curr. state */ \
1782 ++(yy_lp); \
1783 goto find_rule; \
1784 }
1785
1786 #define yymore() yymore_used_but_not_detected
1787 #define YY_MORE_ADJ 0
1788 #define YY_RESTORE_YY_MORE_OFFSET
1789 char *yytext;
1790 /*
1791  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
1792  *  Copyright (C) 2008-2012 - Scilab Enterprises - Bruno JOFRET
1793  *
1794  *  This file must be used under the terms of the CeCILL.
1795  *  This source file is licensed as described in the file COPYING, which
1796  *  you should have received as part of this distribution.  The terms
1797  *  are also available at
1798  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
1799  *
1800  */
1801
1802 #include <stack>
1803
1804 #include "isatty.hxx"
1805 #include "parse.hxx"
1806 #include "parser_private.hxx"
1807
1808 #include "context.hxx"
1809
1810 extern "C"
1811 {
1812 #include "charEncoding.h"
1813 #include "sci_malloc.h"
1814 }
1815
1816 static std::stack<int> paren_levels;
1817
1818 static int comment_level = 0;
1819 static int last_token = 0;
1820 static int exit_status = PARSE_ERROR;
1821 static int str_opener_column = 0;
1822 static std::string current_file;
1823 static std::string program_name;
1824
1825 static std::string pstBuffer;
1826
1827 extern void yyerror(std::string);
1828
1829 #define YY_USER_ACTION                          \
1830     yylloc.first_column = yylloc.last_column; yylloc.last_column += yyleng;
1831 //yylloc.last_column += yyleng;
1832
1833 /* -*- Verbose Special Debug -*- */
1834 //#define DEV
1835 //#define TOKENDEV
1836
1837 #ifdef DEV
1838 #define DEBUG(x) std::cout << "[DEBUG] " << x << std::endl;
1839 #else
1840 #define DEBUG(x) /* Nothing */
1841 #endif
1842
1843 #define INITIAL 0
1844 #define SIMPLESTRING 1
1845 #define DOUBLESTRING 2
1846 #define REGIONCOMMENT 3
1847 #define LINECOMMENT 4
1848 #define LINEBREAK 5
1849 #define MATRIX 6
1850 #define SHELLMODE 7
1851 #define BEGINID 8
1852
1853 #ifndef YY_EXTRA_TYPE
1854 #define YY_EXTRA_TYPE void *
1855 #endif
1856
1857 static int yy_init_globals (void );
1858
1859 /* Accessor methods to globals.
1860    These are made visible to non-reentrant scanners for convenience. */
1861
1862 int yylex_destroy (void );
1863
1864 int yyget_debug (void );
1865
1866 void yyset_debug (int debug_flag  );
1867
1868 YY_EXTRA_TYPE yyget_extra (void );
1869
1870 void yyset_extra (YY_EXTRA_TYPE user_defined  );
1871
1872 FILE *yyget_in (void );
1873
1874 void yyset_in  (FILE * in_str  );
1875
1876 FILE *yyget_out (void );
1877
1878 void yyset_out  (FILE * out_str  );
1879
1880 int yyget_leng (void );
1881
1882 char *yyget_text (void );
1883
1884 int yyget_lineno (void );
1885
1886 void yyset_lineno (int line_number  );
1887
1888 /* Macros after this point can all be overridden by user definitions in
1889  * section 1.
1890  */
1891
1892 #ifndef YY_SKIP_YYWRAP
1893 #ifdef __cplusplus
1894 extern "C" int yywrap (void );
1895 #else
1896 extern int yywrap (void );
1897 #endif
1898 #endif
1899
1900 static void yyunput (int c, char *buf_ptr  );
1901
1902 #ifndef yytext_ptr
1903 static void yy_flex_strncpy (char *, yyconst char *, int );
1904 #endif
1905
1906 #ifdef YY_NEED_STRLEN
1907 static int yy_flex_strlen (yyconst char * );
1908 #endif
1909
1910 #ifndef YY_NO_INPUT
1911
1912 #ifdef __cplusplus
1913 static int yyinput (void );
1914 #else
1915 static int input (void );
1916 #endif
1917
1918 #endif
1919
1920 static int yy_start_stack_ptr = 0;
1921 static int yy_start_stack_depth = 0;
1922 static int *yy_start_stack = NULL;
1923
1924 static void yy_push_state (int new_state );
1925
1926 static void yy_pop_state (void );
1927
1928 static int yy_top_state (void );
1929
1930 /* Amount of stuff to slurp up with each read. */
1931 #ifndef YY_READ_BUF_SIZE
1932 #ifdef __ia64__
1933 /* On IA-64, the buffer size is 16k, not 8k */
1934 #define YY_READ_BUF_SIZE 16384
1935 #else
1936 #define YY_READ_BUF_SIZE 8192
1937 #endif /* __ia64__ */
1938 #endif
1939
1940 /* Copy whatever the last rule matched to the standard output. */
1941 #ifndef ECHO
1942 /* This used to be an fputs(), but since the string might contain NUL's,
1943  * we now use fwrite().
1944  */
1945 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
1946 #endif
1947
1948 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1949  * is returned in "result".
1950  */
1951 #ifndef YY_INPUT
1952 #define YY_INPUT(buf,result,max_size) \
1953         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1954                 { \
1955                 int c = '*'; \
1956                 size_t n; \
1957                 for ( n = 0; n < max_size && \
1958                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1959                         buf[n] = (char) c; \
1960                 if ( c == '\n' ) \
1961                         buf[n++] = (char) c; \
1962                 if ( c == EOF && ferror( yyin ) ) \
1963                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1964                 result = n; \
1965                 } \
1966         else \
1967                 { \
1968                 errno=0; \
1969                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1970                         { \
1971                         if( errno != EINTR) \
1972                                 { \
1973                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1974                                 break; \
1975                                 } \
1976                         errno=0; \
1977                         clearerr(yyin); \
1978                         } \
1979                 }\
1980 \
1981  
1982 #endif
1983
1984 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1985  * we don't want an extra ';' after the "return" because that will cause
1986  * some compilers to complain about unreachable statements.
1987  */
1988 #ifndef yyterminate
1989 #define yyterminate() return YY_NULL
1990 #endif
1991
1992 /* Number of entries by which start-condition stack grows. */
1993 #ifndef YY_START_STACK_INCR
1994 #define YY_START_STACK_INCR 25
1995 #endif
1996
1997 /* Report a fatal error. */
1998 #ifndef YY_FATAL_ERROR
1999 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
2000 #endif
2001
2002 /* end tables serialization structures and prototypes */
2003
2004 /* Default declaration of generated scanner - a define so the user can
2005  * easily add parameters.
2006  */
2007 #ifndef YY_DECL
2008 #define YY_DECL_IS_OURS 1
2009
2010 extern int yylex (void);
2011
2012 #define YY_DECL int yylex (void)
2013 #endif /* !YY_DECL */
2014
2015 /* Code executed at the beginning of each rule, after yytext and yyleng
2016  * have been set up.
2017  */
2018 #ifndef YY_USER_ACTION
2019 #define YY_USER_ACTION
2020 #endif
2021
2022 /* Code executed at the end of each rule. */
2023 #ifndef YY_BREAK
2024 #define YY_BREAK break;
2025 #endif
2026
2027 #define YY_RULE_SETUP \
2028         if ( yyleng > 0 ) \
2029                 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
2030                                 (yytext[yyleng - 1] == '\n'); \
2031         YY_USER_ACTION
2032
2033 /** The main scanner function which does all the work.
2034  */
2035 YY_DECL
2036 {
2037 register yy_state_type yy_current_state;
2038 register char * yy_cp, *yy_bp;
2039 register int yy_act;
2040
2041 if ( !(yy_init) )
2042 {
2043     (yy_init) = 1;
2044
2045 #ifdef YY_USER_INIT
2046     YY_USER_INIT;
2047 #endif
2048
2049     /* Create the reject buffer large enough to save one state per allowed character. */
2050     if ( ! (yy_state_buf) )
2051     {
2052         (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
2053     }
2054     if ( ! (yy_state_buf) )
2055     {
2056         YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
2057     }
2058
2059     if ( ! (yy_start) )
2060     {
2061         (yy_start) = 1;    /* first start state */
2062     }
2063
2064     if ( ! yyin )
2065     {
2066         yyin = stdin;
2067     }
2068
2069     if ( ! yyout )
2070     {
2071         yyout = stdout;
2072     }
2073
2074     if ( ! YY_CURRENT_BUFFER )
2075     {
2076         yyensure_buffer_stack ();
2077         YY_CURRENT_BUFFER_LVALUE =
2078             yy_create_buffer(yyin, YY_BUF_SIZE );
2079     }
2080
2081     yy_load_buffer_state( );
2082 }
2083
2084 while ( 1 )             /* loops until end-of-file is reached */
2085 {
2086     yy_cp = (yy_c_buf_p);
2087
2088     /* Support of yytext. */
2089     *yy_cp = (yy_hold_char);
2090
2091     /* yy_bp points to the position in yy_ch_buf of the start of
2092      * the current run.
2093      */
2094     yy_bp = yy_cp;
2095
2096     yy_current_state = (yy_start);
2097     yy_current_state += YY_AT_BOL();
2098
2099     (yy_state_ptr) = (yy_state_buf);
2100     *(yy_state_ptr)++ = yy_current_state;
2101
2102 yy_match:
2103     do
2104     {
2105         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
2106         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2107         {
2108             yy_current_state = (int) yy_def[yy_current_state];
2109             if ( yy_current_state >= 809 )
2110             {
2111                 yy_c = yy_meta[(unsigned int) yy_c];
2112             }
2113         }
2114         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2115         *(yy_state_ptr)++ = yy_current_state;
2116         ++yy_cp;
2117     }
2118     while ( yy_base[yy_current_state] != 4153 );
2119
2120 yy_find_action:
2121     yy_current_state = *--(yy_state_ptr);
2122     (yy_lp) = yy_accept[yy_current_state];
2123 find_rule: /* we branch to this label when backing up */
2124     for ( ; ; ) /* until we find what rule we matched */
2125     {
2126         if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
2127         {
2128             yy_act = yy_acclist[(yy_lp)];
2129             if ( yy_act & YY_TRAILING_HEAD_MASK ||
2130                     (yy_looking_for_trail_begin) )
2131             {
2132                 if ( yy_act == (yy_looking_for_trail_begin) )
2133                 {
2134                     (yy_looking_for_trail_begin) = 0;
2135                     yy_act &= ~YY_TRAILING_HEAD_MASK;
2136                     break;
2137                 }
2138             }
2139             else if ( yy_act & YY_TRAILING_MASK )
2140             {
2141                 (yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;
2142                 (yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;
2143             }
2144             else
2145             {
2146                 (yy_full_match) = yy_cp;
2147                 (yy_full_state) = (yy_state_ptr);
2148                 (yy_full_lp) = (yy_lp);
2149                 break;
2150             }
2151             ++(yy_lp);
2152             goto find_rule;
2153         }
2154         --yy_cp;
2155         yy_current_state = *--(yy_state_ptr);
2156         (yy_lp) = yy_accept[yy_current_state];
2157     }
2158
2159     YY_DO_BEFORE_ACTION;
2160
2161 do_action:      /* This label is used only to access EOF actions. */
2162
2163     switch ( yy_act )
2164     {
2165             /* beginning of action switch */
2166         case 1:
2167             *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2168             (yy_c_buf_p) = yy_cp = yy_bp + 3;
2169             YY_DO_BEFORE_ACTION; /* set up yytext again */
2170             YY_RULE_SETUP
2171             {
2172                 // BOM found ==> ignored
2173             }
2174             YY_BREAK
2175         case 2:
2176             YY_RULE_SETUP
2177             {
2178                 BEGIN(INITIAL);
2179                 return scan_throw(BOOLTRUE);
2180             }
2181             YY_BREAK
2182         case 3:
2183             YY_RULE_SETUP
2184             {
2185                 BEGIN(INITIAL);
2186                 return scan_throw(BOOLFALSE);
2187             }
2188             YY_BREAK
2189         case 4:
2190             YY_RULE_SETUP
2191             {
2192                 if (last_token != DOT)
2193                 {
2194                     ParserSingleInstance::pushControlStatus(Parser::WithinIf);
2195                 }
2196                 DEBUG("BEGIN(INITIAL)");
2197                 BEGIN(INITIAL);
2198                 return scan_throw(IF);
2199             }
2200             YY_BREAK
2201         case 5:
2202             YY_RULE_SETUP
2203             {
2204                 DEBUG("BEGIN(INITIAL)");
2205                 BEGIN(INITIAL);
2206                 return scan_throw(THEN);
2207             }
2208             YY_BREAK
2209         case 6:
2210             YY_RULE_SETUP
2211             {
2212                 if (last_token != DOT)
2213                 {
2214                     // Pop to step out IF
2215                     ParserSingleInstance::popControlStatus();
2216                     ParserSingleInstance::pushControlStatus(Parser::WithinElse);
2217                 }
2218                 DEBUG("BEGIN(INITIAL)");
2219                 BEGIN(INITIAL);
2220                 return scan_throw(ELSE);
2221             }
2222             YY_BREAK
2223         case 7:
2224             YY_RULE_SETUP
2225             {
2226                 if (last_token != DOT)
2227                 {
2228                     ParserSingleInstance::popControlStatus();
2229                     ParserSingleInstance::pushControlStatus(Parser::WithinElseIf);
2230                 }
2231                 DEBUG("BEGIN(INITIAL)");
2232                 BEGIN(INITIAL);
2233                 return scan_throw(ELSEIF);
2234             }
2235             YY_BREAK
2236         case 8:
2237             YY_RULE_SETUP
2238             {
2239                 if (last_token != DOT)
2240                 {
2241                     ParserSingleInstance::popControlStatus();
2242                 }
2243                 DEBUG("BEGIN(INITIAL)");
2244                 BEGIN(INITIAL);
2245                 return scan_throw(END);
2246             }
2247             YY_BREAK
2248         case 9:
2249             YY_RULE_SETUP
2250             {
2251                 if (last_token != DOT)
2252                 {
2253                     ParserSingleInstance::pushControlStatus(Parser::WithinSelect);
2254                 }
2255                 DEBUG("BEGIN(INITIAL)");
2256                 BEGIN(INITIAL);
2257                 return scan_throw(SELECT);
2258             }
2259             YY_BREAK
2260         case 10:
2261             YY_RULE_SETUP
2262             {
2263                 if (last_token != DOT)
2264                 {
2265                     ParserSingleInstance::pushControlStatus(Parser::WithinSwitch);
2266                 }
2267                 DEBUG("BEGIN(INITIAL)");
2268                 BEGIN(INITIAL);
2269                 return scan_throw(SWITCH);
2270             }
2271             YY_BREAK
2272         case 11:
2273             YY_RULE_SETUP
2274             {
2275                 if (last_token != DOT)
2276                 {
2277                     ParserSingleInstance::popControlStatus();
2278                     ParserSingleInstance::pushControlStatus(Parser::WithinOtherwise);
2279                 }
2280                 DEBUG("BEGIN(INITIAL)");
2281                 BEGIN(INITIAL);
2282                 return scan_throw(OTHERWISE);
2283             }
2284             YY_BREAK
2285         case 12:
2286             YY_RULE_SETUP
2287             {
2288                 if (last_token != DOT)
2289                 {
2290                     ParserSingleInstance::popControlStatus();
2291                     ParserSingleInstance::pushControlStatus(Parser::WithinCase);
2292                 }
2293                 DEBUG("BEGIN(INITIAL)");
2294                 BEGIN(INITIAL);
2295                 return scan_throw(CASE);
2296             }
2297             YY_BREAK
2298         case 13:
2299             YY_RULE_SETUP
2300             {
2301                 if (last_token != DOT)
2302                 {
2303                     ParserSingleInstance::pushControlStatus(Parser::WithinFunction);
2304                 }
2305                 DEBUG("BEGIN(INITIAL)");
2306                 BEGIN(INITIAL);
2307                 return scan_throw(FUNCTION);
2308             }
2309             YY_BREAK
2310         case 14:
2311             YY_RULE_SETUP
2312             {
2313                 if (last_token != DOT)
2314                 {
2315                     ParserSingleInstance::popControlStatus();
2316                 }
2317                 DEBUG("BEGIN(INITIAL)");
2318                 BEGIN(INITIAL);
2319                 return scan_throw(ENDFUNCTION);
2320             }
2321             YY_BREAK
2322         case 15:
2323             YY_RULE_SETUP
2324             {
2325                 if (last_token != DOT)
2326                 {
2327                     ParserSingleInstance::pushControlStatus(Parser::WithinFor);
2328                 }
2329                 BEGIN(INITIAL);
2330                 return scan_throw(FOR);
2331             }
2332             YY_BREAK
2333         case 16:
2334             YY_RULE_SETUP
2335             {
2336                 if (last_token != DOT)
2337                 {
2338                     ParserSingleInstance::pushControlStatus(Parser::WithinWhile);
2339                 }
2340                 BEGIN(INITIAL);
2341                 return scan_throw(WHILE);
2342             }
2343             YY_BREAK
2344         case 17:
2345             YY_RULE_SETUP
2346             {
2347                 BEGIN(INITIAL);
2348                 return scan_throw(DO);
2349             }
2350             YY_BREAK
2351         case 18:
2352             YY_RULE_SETUP
2353             {
2354                 BEGIN(INITIAL);
2355                 return scan_throw(BREAK);
2356             }
2357             YY_BREAK
2358         case 19:
2359             YY_RULE_SETUP
2360             {
2361                 BEGIN(INITIAL);
2362                 return scan_throw(CONTINUE);
2363             }
2364             YY_BREAK
2365         case 20:
2366             YY_RULE_SETUP
2367             {
2368                 ParserSingleInstance::pushControlStatus(Parser::WithinTry);
2369                 BEGIN(INITIAL);
2370                 return scan_throw(TRY);
2371             }
2372             YY_BREAK
2373         case 21:
2374             YY_RULE_SETUP
2375             {
2376                 // Pop to step out TRY
2377                 ParserSingleInstance::popControlStatus();
2378                 ParserSingleInstance::pushControlStatus(Parser::WithinCatch);
2379                 BEGIN(INITIAL);
2380                 return scan_throw(CATCH);
2381             }
2382             YY_BREAK
2383         case 22:
2384             YY_RULE_SETUP
2385             {
2386                 BEGIN(INITIAL);
2387                 return scan_throw(RETURN);
2388             }
2389             YY_BREAK
2390         case 23:
2391             YY_RULE_SETUP
2392             {
2393                 BEGIN(INITIAL);
2394                 return scan_throw(RETURN);
2395             }
2396             YY_BREAK
2397         case 24:
2398             /* rule 24 can match eol */
2399             YY_RULE_SETUP
2400             {
2401                 BEGIN(BEGINID);
2402             }
2403             YY_BREAK
2404
2405         case 25:
2406             YY_RULE_SETUP
2407             {
2408                 wchar_t *pwText = to_wide_string(yytext);
2409                 if (yytext != NULL && pwText == NULL)
2410                 {
2411                     std::string str = "Can\'t convert \'";
2412                     str += yytext;
2413                     str += "\' to UTF-8";
2414                     BEGIN(INITIAL);
2415                     yyerror(str);
2416                     return scan_throw(FLEX_ERROR);
2417                 }
2418                 yylval.str = new std::wstring(pwText);
2419                 FREE(pwText);
2420                 types::InternalType * pIT = symbol::Context::getInstance()->get(symbol::Symbol(*yylval.str));
2421                 if (pIT && pIT->isCallable())
2422                 {
2423                     scan_throw(ID);
2424                     BEGIN(SHELLMODE);
2425                 }
2426                 else
2427                 {
2428                     BEGIN(INITIAL);
2429                     return scan_throw(ID);
2430                 }
2431             }
2432             YY_BREAK
2433
2434         case 26:
2435             YY_RULE_SETUP
2436             {
2437                 return scan_throw(NOT);
2438             }
2439             YY_BREAK
2440         case 27:
2441             YY_RULE_SETUP
2442             {
2443                 return scan_throw(DOLLAR);
2444             }
2445             YY_BREAK
2446         case 28:
2447             YY_RULE_SETUP
2448             {
2449                 return scan_throw(BOOLTRUE);
2450             }
2451             YY_BREAK
2452         case 29:
2453             YY_RULE_SETUP
2454             {
2455                 return scan_throw(BOOLFALSE);
2456             }
2457             YY_BREAK
2458         case 30:
2459             YY_RULE_SETUP
2460             {
2461                 return scan_throw(AND);
2462             }
2463             YY_BREAK
2464         case 31:
2465             YY_RULE_SETUP
2466             {
2467                 return scan_throw(ANDAND);
2468             }
2469             YY_BREAK
2470         case 32:
2471             YY_RULE_SETUP
2472             {
2473                 return scan_throw(OR);
2474             }
2475             YY_BREAK
2476         case 33:
2477             YY_RULE_SETUP
2478             {
2479                 return scan_throw(OROR);
2480             }
2481             YY_BREAK
2482         case 34:
2483             YY_RULE_SETUP
2484             {
2485                 return scan_throw(LPAREN);
2486             }
2487             YY_BREAK
2488         case 35:
2489             YY_RULE_SETUP
2490             {
2491                 return scan_throw(RPAREN);
2492             }
2493             YY_BREAK
2494         case 36:
2495             YY_RULE_SETUP
2496             {
2497                 scan_step();
2498                 return scan_throw(SEMI);
2499             }
2500             YY_BREAK
2501         case 37:
2502             YY_RULE_SETUP
2503             {
2504                 scan_step();
2505                 return scan_throw(COMMA);
2506             }
2507             YY_BREAK
2508         case 38:
2509             YY_RULE_SETUP
2510             {
2511                 return scan_throw(COLON);
2512             }
2513             YY_BREAK
2514         case 39:
2515             YY_RULE_SETUP
2516             {
2517                 yy_push_state(MATRIX);
2518                 paren_levels.push(0);
2519                 ParserSingleInstance::pushControlStatus(Parser::WithinCell);
2520                 return scan_throw(LBRACE);
2521             }
2522             YY_BREAK
2523         case 40:
2524             YY_RULE_SETUP
2525             {
2526                 return scan_throw(RBRACE);
2527             }
2528             YY_BREAK
2529         case 41:
2530             YY_RULE_SETUP
2531             {
2532                 return scan_throw(DOTQUOTE);
2533             }
2534             YY_BREAK
2535         case 42:
2536             YY_RULE_SETUP
2537             {
2538                 return scan_throw(DOTTIMES);
2539             }
2540             YY_BREAK
2541         case 43:
2542             YY_RULE_SETUP
2543             {
2544                 return scan_throw(DOTRDIVIDE);
2545             }
2546             YY_BREAK
2547         case 44:
2548             YY_RULE_SETUP
2549             {
2550                 return scan_throw(DOTLDIVIDE);
2551             }
2552             YY_BREAK
2553         case 45:
2554             YY_RULE_SETUP
2555             {
2556                 return scan_throw(DOTPOWER);
2557             }
2558             YY_BREAK
2559         case 46:
2560             YY_RULE_SETUP
2561             {
2562                 return scan_throw(MINUS);
2563             }
2564             YY_BREAK
2565         case 47:
2566             YY_RULE_SETUP
2567             {
2568                 return scan_throw(PLUS);
2569             }
2570             YY_BREAK
2571         case 48:
2572             YY_RULE_SETUP
2573             {
2574                 return scan_throw(TIMES);
2575             }
2576             YY_BREAK
2577         case 49:
2578             YY_RULE_SETUP
2579             {
2580                 return scan_throw(RDIVIDE);
2581             }
2582             YY_BREAK
2583         case 50:
2584             YY_RULE_SETUP
2585             {
2586                 return scan_throw(LDIVIDE);
2587             }
2588             YY_BREAK
2589         case 51:
2590             YY_RULE_SETUP
2591             {
2592                 return scan_throw(POWER);
2593             }
2594             YY_BREAK
2595         case 52:
2596             YY_RULE_SETUP
2597             {
2598                 return scan_throw(KRONTIMES);
2599             }
2600             YY_BREAK
2601         case 53:
2602             YY_RULE_SETUP
2603             {
2604                 return scan_throw(KRONRDIVIDE);
2605             }
2606             YY_BREAK
2607         case 54:
2608             YY_RULE_SETUP
2609             {
2610                 return scan_throw(KRONLDIVIDE);
2611             }
2612             YY_BREAK
2613         case 55:
2614             /* rule 55 can match eol */
2615             YY_RULE_SETUP
2616             {
2617                 unput(yytext[yyleng - 1]);
2618                 return scan_throw(CONTROLTIMES);
2619             }
2620             YY_BREAK
2621         case 56:
2622             /* rule 56 can match eol */
2623             YY_RULE_SETUP
2624             {
2625                 unput(yytext[yyleng - 1]);
2626                 return scan_throw(CONTROLRDIVIDE);
2627             }
2628             YY_BREAK
2629         case 57:
2630             /* rule 57 can match eol */
2631             YY_RULE_SETUP
2632             {
2633                 unput(yytext[yyleng - 1]);
2634                 return scan_throw(CONTROLLDIVIDE);
2635             }
2636             YY_BREAK
2637         case 58:
2638             YY_RULE_SETUP
2639             {
2640                 return scan_throw(EQ);
2641             }
2642             YY_BREAK
2643         case 59:
2644             YY_RULE_SETUP
2645             {
2646                 return scan_throw(NE);
2647             }
2648             YY_BREAK
2649         case 60:
2650             YY_RULE_SETUP
2651             {
2652                 return scan_throw(LT);
2653             }
2654             YY_BREAK
2655         case 61:
2656             YY_RULE_SETUP
2657             {
2658                 return scan_throw(GT);
2659             }
2660             YY_BREAK
2661         case 62:
2662             YY_RULE_SETUP
2663             {
2664                 return scan_throw(LE);
2665             }
2666             YY_BREAK
2667         case 63:
2668             YY_RULE_SETUP
2669             {
2670                 return scan_throw(GE);
2671             }
2672             YY_BREAK
2673         case 64:
2674             YY_RULE_SETUP
2675             {
2676                 return scan_throw(ASSIGN);
2677             }
2678             YY_BREAK
2679         case 65:
2680             YY_RULE_SETUP
2681             {
2682                 DEBUG("yy_push_state(MATRIX)");
2683                 yy_push_state(MATRIX);
2684                 paren_levels.push(0);
2685                 ParserSingleInstance::pushControlStatus(Parser::WithinMatrix);
2686                 return scan_throw(LBRACK);
2687             }
2688             YY_BREAK
2689         case 66:
2690             YY_RULE_SETUP
2691             {
2692                 return scan_throw(RBRACK);
2693             }
2694             YY_BREAK
2695         case 67:
2696             YY_RULE_SETUP
2697             {
2698                 return scan_throw(DOT);
2699             }
2700             YY_BREAK
2701         case 68:
2702             YY_RULE_SETUP
2703             {
2704                 ParserSingleInstance::pushControlStatus(Parser::WithinDots);
2705                 yy_push_state(LINEBREAK);
2706             }
2707             YY_BREAK
2708         case 69:
2709             YY_RULE_SETUP
2710             {
2711                 yylval.number = atof(yytext);
2712 #ifdef TOKENDEV
2713                 std::cout << "--> [DEBUG] INTEGER : " << yytext << std::endl;
2714 #endif
2715                 //  scan_step();
2716                 return scan_throw(VARINT);
2717             }
2718             YY_BREAK
2719         case 70:
2720             YY_RULE_SETUP
2721             {
2722                 scan_exponent_convert(yytext);
2723                 yylval.number = atof(yytext);
2724 #ifdef TOKENDEV
2725                 std::cout << "--> [DEBUG] FLOATING : " << yytext << std::endl;
2726 #endif
2727                 //scan_step();
2728                 return scan_throw(VARFLOAT);
2729             }
2730             YY_BREAK
2731         case 71:
2732             YY_RULE_SETUP
2733             {
2734                 yylval.number = atof(yytext);
2735 #ifdef TOKENDEV
2736                 std::cout << "--> [DEBUG] FLOATING : " << yytext << std::endl;
2737 #endif
2738                 //scan_step();
2739                 return scan_throw(VARFLOAT);
2740             }
2741             YY_BREAK
2742         case 72:
2743             YY_RULE_SETUP
2744             {
2745                 yylval.number = atof(yytext);
2746 #ifdef TOKENDEV
2747                 std::cout << "--> [DEBUG] NUMBER : " << yytext << std::endl;
2748 #endif
2749                 //  scan_step();
2750                 return scan_throw(NUM);
2751             }
2752             YY_BREAK
2753         case 73:
2754             YY_RULE_SETUP
2755             {
2756                 yylval.number = atof(yytext);
2757 #ifdef TOKENDEV
2758                 std::cout << "--> [DEBUG] LITTLE : " << yytext << std::endl;
2759 #endif
2760                 //  scan_step();
2761                 return scan_throw(NUM);
2762             }
2763             YY_BREAK
2764         case 74:
2765             YY_RULE_SETUP
2766             {
2767                 wchar_t *pwText = to_wide_string(yytext);
2768                 if (yytext != NULL && pwText == NULL)
2769                 {
2770                     std::string str = "Can\'t convert \'";
2771                     str += yytext;
2772                     str += "\' to UTF-8";
2773                     BEGIN(INITIAL);
2774                     yyerror(str);
2775                     return scan_throw(FLEX_ERROR);
2776                 }
2777                 yylval.str = new std::wstring(pwText);
2778                 FREE(pwText);
2779 #ifdef TOKENDEV
2780                 std::cout << "--> [DEBUG] ID : " << yytext << std::endl;
2781 #endif
2782                 //  scan_step();
2783                 return scan_throw(ID);
2784             }
2785             YY_BREAK
2786         case 75:
2787             YY_RULE_SETUP
2788             {
2789                 yylval.comment = new std::wstring();
2790                 comment_level = 1;
2791                 ParserSingleInstance::pushControlStatus(Parser::WithinBlockComment);
2792                 yy_push_state(REGIONCOMMENT);
2793             }
2794             YY_BREAK
2795         case 76:
2796             YY_RULE_SETUP
2797             {
2798                 pstBuffer.clear();
2799                 yy_push_state(LINECOMMENT);
2800             }
2801             YY_BREAK
2802         case 77:
2803             YY_RULE_SETUP
2804             {
2805                 pstBuffer.clear();
2806                 str_opener_column = yylloc.first_column;
2807                 yy_push_state(DOUBLESTRING);
2808             }
2809             YY_BREAK
2810         case 78:
2811             YY_RULE_SETUP
2812             {
2813                 /*
2814                 ** Matrix Transposition special behaviour
2815                 ** ID' []' toto()' are transposition call
2816                 */
2817                 if (last_token == ID
2818                 || last_token == RBRACK
2819                 || last_token == RPAREN
2820                 || last_token == RBRACE
2821                 || last_token == VARINT
2822                 || last_token == VARFLOAT
2823                 || last_token == NUM
2824                 || last_token == BOOLTRUE
2825                 || last_token == BOOLFALSE)
2826                 {
2827                     return scan_throw(QUOTE);
2828                 }
2829                 else
2830                 {
2831                     pstBuffer.clear();
2832                     str_opener_column = yylloc.first_column;
2833                     yy_push_state(SIMPLESTRING);
2834                 }
2835             }
2836             YY_BREAK
2837         case 79:
2838             YY_RULE_SETUP
2839             {
2840                 scan_step();
2841                 scan_throw(SPACES);
2842             }
2843             YY_BREAK
2844         case 80:
2845             /* rule 80 can match eol */
2846             YY_RULE_SETUP
2847             {
2848                 yylloc.last_line += 1;
2849                 yylloc.last_column = 1;
2850                 scan_step();
2851                 if (last_token != EOL)
2852                 {
2853                     return scan_throw(EOL);
2854                 }
2855
2856             }
2857             YY_BREAK
2858         case 81:
2859             /* rule 81 can match eol */
2860             YY_RULE_SETUP
2861             {
2862                 yylloc.last_line += 1;
2863                 yylloc.last_column = 1;
2864                 scan_step();
2865                 if (last_token != EOL)
2866                 {
2867                     return scan_throw(EOL);
2868                 }
2869                 scan_throw(EOL);
2870             }
2871             YY_BREAK
2872         case 82:
2873             /* rule 82 can match eol */
2874             YY_RULE_SETUP
2875             {
2876                 yylloc.last_line += 2;
2877                 yylloc.last_column = 1;
2878                 scan_step();
2879                 if (last_token != EOL)
2880                 {
2881                     return scan_throw(EOL);
2882                 }
2883                 scan_throw(EOL);
2884             }
2885             YY_BREAK
2886         case 83:
2887             YY_RULE_SETUP
2888             {
2889                 std::string str = "Unexpected token \'";
2890                 str += yytext;
2891                 str += "\'";
2892                 BEGIN(INITIAL);
2893                 yyerror(str);
2894                 return scan_throw(FLEX_ERROR);
2895             }
2896             YY_BREAK
2897
2898         case 84:
2899             YY_RULE_SETUP
2900             {
2901                 ++paren_levels.top();
2902                 return scan_throw(LPAREN);
2903             }
2904             YY_BREAK
2905         case 85:
2906             YY_RULE_SETUP
2907             {
2908                 --paren_levels.top();
2909                 return scan_throw(RPAREN);
2910             }
2911             YY_BREAK
2912         case 86:
2913             YY_RULE_SETUP
2914             {
2915                 unput(yytext[yyleng - 1]);
2916                 if (last_token == ID
2917                 || last_token == RPAREN
2918                 || last_token == QUOTE
2919                 || last_token == VARINT
2920                 || last_token == VARFLOAT
2921                 || last_token == NUM)
2922                 {
2923                     return scan_throw(COMMA);
2924                 }
2925             }
2926             YY_BREAK
2927         case 87:
2928             YY_RULE_SETUP
2929             {
2930                 return scan_throw(COLON);
2931             }
2932             YY_BREAK
2933         case 88:
2934             /* rule 88 can match eol */
2935             YY_RULE_SETUP
2936             {
2937                 yylloc.last_line += 1;
2938                 yylloc.last_column = 1;
2939                 if (last_token != DOTS && last_token != EOL)
2940                 {
2941                     return scan_throw(EOL);
2942                 }
2943                 scan_throw(EOL);
2944             }
2945             YY_BREAK
2946         case 89:
2947             YY_RULE_SETUP
2948             {
2949                 DEBUG("yy_pop_state()");
2950                 yy_pop_state();
2951                 paren_levels.pop();
2952                 ParserSingleInstance::popControlStatus();
2953                 return scan_throw(RBRACK);
2954             }
2955             YY_BREAK
2956         case 90:
2957             YY_RULE_SETUP
2958             {
2959                 yy_pop_state();
2960                 paren_levels.pop();
2961                 ParserSingleInstance::popControlStatus();
2962                 return scan_throw(RBRACE);
2963             }
2964             YY_BREAK
2965         case 91:
2966         case 92:
2967             YY_RULE_SETUP
2968             {
2969                 return scan_throw(PLUS);
2970             }
2971             YY_BREAK
2972         case 93:
2973         case 94:
2974             YY_RULE_SETUP
2975             {
2976                 return scan_throw(MINUS);
2977             }
2978             YY_BREAK
2979         case 95:
2980             YY_RULE_SETUP
2981             {
2982                 // no need to unput the '+'
2983                 if (last_token != LBRACK
2984                 && last_token != EOL
2985                 && last_token != SEMI
2986                 && last_token != COMMA
2987                 && paren_levels.top() == 0)
2988                 {
2989                     return scan_throw(COMMA);
2990                 }
2991                 else
2992                 {
2993                     unput('+');
2994                 }
2995             }
2996             YY_BREAK
2997         case 96:
2998             YY_RULE_SETUP
2999             {
3000                 unput('-');
3001                 if (last_token != LBRACK
3002                 && last_token != EOL
3003                 && last_token != SEMI
3004                 && last_token != COMMA
3005                 && paren_levels.top() == 0)
3006                 {
3007                     return scan_throw(COMMA);
3008                 }
3009             }
3010             YY_BREAK
3011         case 97:
3012             YY_RULE_SETUP
3013             {
3014                 std::string str = "Unexpected token \'";
3015                 str += yytext;
3016                 str += "\' within a matrix.";
3017                 BEGIN(INITIAL);
3018                 yyerror(str);
3019                 return scan_throw(FLEX_ERROR);
3020             }
3021             YY_BREAK
3022         case 98:
3023             /* rule 98 can match eol */
3024             YY_RULE_SETUP
3025             {
3026                 /* Just do nothing */
3027                 yylloc.last_line += 1;
3028                 yylloc.last_column = 1;
3029                 if (last_token == SPACES)
3030                 {
3031                     unput(' ');
3032                 }
3033
3034                 scan_step();
3035             }
3036             YY_BREAK
3037         case 99:
3038             YY_RULE_SETUP
3039             {
3040                 /* Just do nothing */
3041                 pstBuffer.clear();
3042                 yy_push_state(LINECOMMENT);
3043                 scan_throw(DOTS);
3044             }
3045             YY_BREAK
3046         case YY_STATE_EOF(MATRIX):
3047         {
3048             yy_pop_state();
3049             paren_levels.pop();
3050         }
3051         YY_BREAK
3052
3053         case 100:
3054             /* rule 100 can match eol */
3055             YY_RULE_SETUP
3056             {
3057                 yylloc.last_line += 1;
3058                 yylloc.last_column = 1;
3059                 scan_step();
3060                 yy_pop_state();
3061                 ParserSingleInstance::popControlStatus();
3062             }
3063             YY_BREAK
3064         case 101:
3065             YY_RULE_SETUP
3066             {
3067                 ++comment_level;
3068                 yy_push_state(REGIONCOMMENT);
3069             }
3070             YY_BREAK
3071         case 102:
3072             YY_RULE_SETUP
3073             {
3074                 scan_throw(DOTS);
3075                 pstBuffer.clear();
3076                 yy_push_state(LINECOMMENT);
3077             }
3078             YY_BREAK
3079         case 103:
3080             YY_RULE_SETUP
3081             {
3082                 /* Do nothing... */
3083             }
3084             YY_BREAK
3085         case YY_STATE_EOF(LINEBREAK):
3086         {
3087             yy_pop_state();
3088         }
3089         YY_BREAK
3090         case 104:
3091             YY_RULE_SETUP
3092             {
3093                 std::string str = "Unexpected token \'";
3094                 str += yytext;
3095                 str += "\' after line break with .. or ...";
3096                 BEGIN(INITIAL);
3097                 yyerror(str);
3098                 return scan_throw(FLEX_ERROR);
3099             }
3100             YY_BREAK
3101
3102         case 105:
3103             /* rule 105 can match eol */
3104             YY_RULE_SETUP
3105             {
3106                 //yylloc.last_line += 1;
3107                 //yylloc.last_column = 1;
3108                 //scan_step();
3109                 yy_pop_state();
3110                 for (int i = yyleng - 1 ; i >= 0 ; --i)
3111                 {
3112                     //std::cerr << "Unputting i = {" << i << "}" << std::endl;
3113                     //std::cerr << "Unputting {" << yytext[i] << "}" << std::endl;
3114                     unput(yytext[i]);
3115                     yylloc.last_column--;
3116                 }
3117                 /*
3118                 ** To forgot comments after lines break
3119                 */
3120                 if (last_token != DOTS)
3121                 {
3122                     //std::cerr << "pstBuffer = {" << *pstBuffer << "}" << std::endl;
3123                     //std::cerr << "pstBuffer->c_str() = {" << pstBuffer->c_str() << "}" << std::endl;
3124                     wchar_t *pwstBuffer = to_wide_string(pstBuffer.c_str());
3125                     //std::wcerr << L"pwstBuffer = W{" << pwstBuffer << L"}" << std::endl;
3126                     if (pstBuffer.c_str() != NULL && pwstBuffer == NULL)
3127                     {
3128                         pstBuffer.clear();
3129                         std::string str = "Can\'t convert \'";
3130                         str += pstBuffer.c_str();
3131                         str += "\' to UTF-8";
3132                         BEGIN(INITIAL);
3133                         yyerror(str);
3134                         return scan_throw(FLEX_ERROR);
3135                     }
3136                     yylval.comment = new std::wstring(pwstBuffer);
3137                     pstBuffer.clear();
3138                     FREE (pwstBuffer);
3139                     return scan_throw(COMMENT);
3140                 }
3141                 else
3142                 {
3143                     pstBuffer.clear();
3144                 }
3145             }
3146             YY_BREAK
3147         case YY_STATE_EOF(LINECOMMENT):
3148         {
3149             yy_pop_state();
3150             wchar_t *pwstBuffer = to_wide_string(pstBuffer.c_str());
3151             if (pstBuffer.c_str() != NULL && pwstBuffer == NULL)
3152             {
3153                 pstBuffer.clear();
3154                 std::string str = "Can\'t convert \'";
3155                 str += pstBuffer.c_str();
3156                 str += "\' to UTF-8";
3157                 BEGIN(INITIAL);
3158                 yyerror(str);
3159                 return scan_throw(FLEX_ERROR);
3160             }
3161             yylval.comment = new std::wstring(pwstBuffer);
3162             pstBuffer.clear();
3163             FREE (pwstBuffer);
3164             return scan_throw(COMMENT);
3165         }
3166         YY_BREAK
3167         case 106:
3168             YY_RULE_SETUP
3169             {
3170                 // Put the char in a temporary CHAR buffer to go through UTF-8 trouble
3171                 // only translate to WCHAR_T when popping state.
3172                 pstBuffer += yytext;
3173             }
3174             YY_BREAK
3175
3176         case 107:
3177             YY_RULE_SETUP
3178             {
3179                 --comment_level;
3180                 if (comment_level == 0)
3181                 {
3182                     ParserSingleInstance::popControlStatus();
3183                     yy_pop_state();
3184                     //return scan_throw(BLOCKCOMMENT);
3185                 }
3186             }
3187             YY_BREAK
3188         case 108:
3189             YY_RULE_SETUP
3190             {
3191                 ++comment_level;
3192                 yy_push_state(REGIONCOMMENT);
3193             }
3194             YY_BREAK
3195         case 109:
3196             /* rule 109 can match eol */
3197             YY_RULE_SETUP
3198             {
3199                 yylloc.last_line += 1;
3200                 yylloc.last_column = 1;
3201                 scan_step();
3202                 *yylval.comment += L"\n//";
3203             }
3204             YY_BREAK
3205         case 110:
3206         case 111:
3207             YY_RULE_SETUP
3208             {
3209                 wchar_t *pwText = to_wide_string(yytext);
3210                 *yylval.comment += std::wstring(pwText);
3211                 FREE(pwText);
3212             }
3213             YY_BREAK
3214         case YY_STATE_EOF(REGIONCOMMENT):
3215         {
3216             yy_pop_state();
3217             //    std::string str = "unexpected end of file in a comment";
3218             //    scan_error(str);
3219         }
3220         YY_BREAK
3221
3222         case 112:
3223             YY_RULE_SETUP
3224             {
3225                 pstBuffer += "\"";
3226             }
3227             YY_BREAK
3228         case 113:
3229             YY_RULE_SETUP
3230             {
3231                 pstBuffer += "'";
3232             }
3233             YY_BREAK
3234         case 114:
3235             YY_RULE_SETUP
3236             {
3237                 pstBuffer += "\"";
3238             }
3239             YY_BREAK
3240         case 115:
3241             YY_RULE_SETUP
3242             {
3243                 pstBuffer += "'";
3244             }
3245             YY_BREAK
3246         case 116:
3247             YY_RULE_SETUP
3248             {
3249                 yy_pop_state();
3250                 //scan_step();
3251                 wchar_t *pwstBuffer = to_wide_string(pstBuffer.c_str());
3252                 if (pstBuffer.c_str() != NULL && pwstBuffer == NULL)
3253                 {
3254                     pstBuffer.clear();
3255                     std::string str = "Can\'t convert \'";
3256                     str += pstBuffer.c_str();
3257                     str += "\' to UTF-8";
3258                     BEGIN(INITIAL);
3259                     yyerror(str);
3260                     return scan_throw(FLEX_ERROR);
3261                 }
3262                 yylval.str = new std::wstring(pwstBuffer);
3263                 pstBuffer.clear();
3264                 FREE(pwstBuffer);
3265                 yylloc.first_column = str_opener_column;
3266                 return scan_throw(STR);
3267             }
3268             YY_BREAK
3269         case 117:
3270             YY_RULE_SETUP
3271             {
3272                 pstBuffer.clear();
3273                 BEGIN(INITIAL);
3274                 yyerror("Heterogeneous string detected, starting with \' and ending with \".");
3275                 return scan_throw(FLEX_ERROR);
3276             }
3277             YY_BREAK
3278         case 118:
3279             /* rule 118 can match eol */
3280             YY_RULE_SETUP
3281             {
3282                 yylloc.last_line += 1;
3283                 yylloc.last_column = 1;
3284                 /* Do nothing... Just skip */
3285             }
3286             YY_BREAK
3287         case 119:
3288             /* rule 119 can match eol */
3289             YY_RULE_SETUP
3290             {
3291                 pstBuffer.clear();
3292                 yylloc.last_line += 1;
3293                 yylloc.last_column = 1;
3294                 BEGIN(INITIAL);
3295                 yyerror("Unexpected end of line in a string.");
3296                 return scan_throw(FLEX_ERROR);
3297             }
3298             YY_BREAK
3299         case YY_STATE_EOF(SIMPLESTRING):
3300         {
3301             pstBuffer.clear();
3302             BEGIN(INITIAL);
3303             yyerror("Unexpected end of file in a string.");
3304             return scan_throw(FLEX_ERROR);
3305         }
3306         YY_BREAK
3307         case 120:
3308         case 121:
3309             YY_RULE_SETUP
3310             {
3311                 //scan_step();
3312                 pstBuffer += yytext;
3313             }
3314             YY_BREAK
3315
3316         case 122:
3317             YY_RULE_SETUP
3318             {
3319                 pstBuffer += "\"";
3320             }
3321             YY_BREAK
3322         case 123:
3323             YY_RULE_SETUP
3324             {
3325                 pstBuffer += "'";
3326             }
3327             YY_BREAK
3328         case 124:
3329             YY_RULE_SETUP
3330             {
3331                 pstBuffer += "\"";
3332             }
3333             YY_BREAK
3334         case 125:
3335             YY_RULE_SETUP
3336             {
3337                 pstBuffer += "'";
3338             }
3339             YY_BREAK
3340         case 126:
3341             YY_RULE_SETUP
3342             {
3343                 yy_pop_state();
3344                 //scan_step();
3345                 wchar_t *pwstBuffer = to_wide_string(pstBuffer.c_str());
3346                 if (pstBuffer.c_str() != NULL && pwstBuffer == NULL)
3347                 {
3348                     pstBuffer.clear();
3349                     std::string str = "Can\'t convert \'";
3350                     str += pstBuffer.c_str();
3351                     str += "\' to UTF-8";
3352                     BEGIN(INITIAL);
3353                     yyerror(str);
3354                     return scan_throw(FLEX_ERROR);
3355                 }
3356                 yylval.str = new std::wstring(pwstBuffer);
3357                 pstBuffer.clear();
3358                 FREE(pwstBuffer);
3359                 yylloc.first_column = str_opener_column;
3360                 return scan_throw(STR);
3361             }
3362             YY_BREAK
3363         case 127:
3364             YY_RULE_SETUP
3365             {
3366                 pstBuffer.clear();
3367                 BEGIN(INITIAL);
3368                 yyerror("Heterogeneous string detected, starting with \" and ending with \'.");
3369                 return scan_throw(FLEX_ERROR);
3370             }
3371             YY_BREAK
3372         case 128:
3373             /* rule 128 can match eol */
3374             YY_RULE_SETUP
3375             {
3376                 yylloc.last_line += 1;
3377                 yylloc.last_column = 1;
3378                 /* Do nothing... Just skip */
3379             }
3380             YY_BREAK
3381         case 129:
3382             /* rule 129 can match eol */
3383             YY_RULE_SETUP
3384             {
3385                 pstBuffer.clear();
3386                 yylloc.last_line += 1;
3387                 yylloc.last_column = 1;
3388                 BEGIN(INITIAL);
3389                 yyerror("Unexpected end of line in a string.");
3390                 return scan_throw(FLEX_ERROR);
3391             }
3392             YY_BREAK
3393         case YY_STATE_EOF(DOUBLESTRING):
3394         {
3395             pstBuffer.clear();
3396             BEGIN(INITIAL);
3397             yyerror("Unexpected end of file in a string.");
3398             return scan_throw(FLEX_ERROR);
3399         }
3400         YY_BREAK
3401         case 130:
3402         case 131:
3403             YY_RULE_SETUP
3404             {
3405                 //scan_step();
3406                 pstBuffer += yytext;
3407             }
3408             YY_BREAK
3409
3410         case 132:
3411             YY_RULE_SETUP
3412             {
3413                 if (last_token == ID)
3414                 {
3415                     scan_throw(SPACES);
3416                     return ID;
3417                 }
3418             }
3419             YY_BREAK
3420         case 133:
3421             YY_RULE_SETUP
3422             {
3423                 BEGIN(INITIAL);
3424                 scan_step();
3425                 return scan_throw(SEMI);
3426             }
3427             YY_BREAK
3428         case 134:
3429             YY_RULE_SETUP
3430             {
3431                 BEGIN(INITIAL);
3432                 scan_step();
3433                 return scan_throw(COMMA);
3434             }
3435             YY_BREAK
3436         case 135:
3437             /* rule 135 can match eol */
3438             YY_RULE_SETUP
3439             {
3440                 BEGIN(INITIAL);
3441                 yylloc.last_line += 1;
3442                 yylloc.last_column = 1;
3443                 scan_step();
3444                 return scan_throw(EOL);
3445             }
3446             YY_BREAK
3447         case 136:
3448             YY_RULE_SETUP
3449             {
3450                 if (last_token == STR || last_token == SPACES)
3451                 {
3452                     wchar_t *pwText = to_wide_string(yytext);
3453                     yylval.str = new std::wstring(pwText);
3454                     FREE(pwText);
3455                     return scan_throw(STR);
3456                 }
3457                 else
3458                 {
3459                     BEGIN(INITIAL);
3460                     return scan_throw(ASSIGN);
3461                 }
3462             }
3463             YY_BREAK
3464         case 137:
3465             YY_RULE_SETUP
3466             {
3467                 if (last_token == STR || last_token == SPACES)
3468                 {
3469                     wchar_t *pwText = to_wide_string(yytext);
3470                     yylval.str = new std::wstring(pwText);
3471                     FREE(pwText);
3472                     return scan_throw(STR);
3473                 }
3474                 else
3475                 {
3476                     BEGIN(INITIAL);
3477                     return scan_throw(LPAREN);
3478                 }
3479             }
3480             YY_BREAK
3481         case 138:
3482             YY_RULE_SETUP
3483             {
3484                 if (last_token == STR || last_token == SPACES)
3485                 {
3486                     wchar_t *pwText = to_wide_string(yytext);
3487                     yylval.str = new std::wstring(pwText);
3488                     FREE(pwText);
3489                     return scan_throw(STR);
3490                 }
3491                 else
3492                 {
3493                     BEGIN(INITIAL);
3494                     return scan_throw(LT);
3495                 }
3496             }
3497             YY_BREAK
3498         case 139:
3499             YY_RULE_SETUP
3500             {
3501                 if (last_token == STR || last_token == SPACES)
3502                 {
3503                     wchar_t *pwText = to_wide_string(yytext);
3504                     yylval.str = new std::wstring(pwText);
3505                     FREE(pwText);
3506                     return scan_throw(STR);
3507                 }
3508                 else
3509                 {
3510                     BEGIN(INITIAL);
3511                     return scan_throw(GT);
3512                 }
3513             }
3514             YY_BREAK
3515         case 140:
3516             YY_RULE_SETUP
3517             {
3518                 if (last_token == STR || last_token == SPACES)
3519                 {
3520                     wchar_t *pwText = to_wide_string(yytext);
3521                     yylval.str = new std::wstring(pwText);
3522                     FREE(pwText);
3523                     return scan_throw(STR);
3524                 }
3525                 else
3526                 {
3527                     BEGIN(INITIAL);
3528                     return scan_throw(NOT);
3529                 }
3530             }
3531             YY_BREAK
3532         case 141:
3533             YY_RULE_SETUP
3534             {
3535                 wchar_t *pwText = to_wide_string(yytext);
3536                 yylval.str = new std::wstring(pwText);
3537                 FREE(pwText);
3538                 return scan_throw(STR);
3539             }
3540             YY_BREAK
3541         case YY_STATE_EOF(SHELLMODE):
3542         {
3543             BEGIN(INITIAL);
3544         }
3545         YY_BREAK
3546
3547         case 142:
3548             YY_RULE_SETUP
3549             ECHO;
3550             YY_BREAK
3551         case YY_STATE_EOF(INITIAL):
3552         case YY_STATE_EOF(BEGINID):
3553             yyterminate();
3554
3555         case YY_END_OF_BUFFER:
3556         {
3557             /* Amount of text matched not including the EOB char. */
3558             int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
3559
3560             /* Undo the effects of YY_DO_BEFORE_ACTION. */
3561             *yy_cp = (yy_hold_char);
3562             YY_RESTORE_YY_MORE_OFFSET
3563
3564             if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
3565             {
3566                 /* We're scanning a new file or input source.  It's
3567                  * possible that this happened because the user
3568                  * just pointed yyin at a new source and called
3569                  * yylex().  If so, then we have to assure
3570                  * consistency between YY_CURRENT_BUFFER and our
3571                  * globals.  Here is the right place to do so, because
3572                  * this is the first action (other than possibly a
3573                  * back-up) that will match for the new input source.
3574                  */
3575                 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
3576                 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
3577                 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
3578             }
3579
3580             /* Note that here we test for yy_c_buf_p "<=" to the position
3581              * of the first EOB in the buffer, since yy_c_buf_p will
3582              * already have been incremented past the NUL character
3583              * (since all states make transitions on EOB to the
3584              * end-of-buffer state).  Contrast this with the test
3585              * in input().
3586              */
3587             if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3588             {
3589                 /* This was really a NUL. */
3590                 yy_state_type yy_next_state;
3591
3592                 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
3593
3594                 yy_current_state = yy_get_previous_state(  );
3595
3596                 /* Okay, we're now positioned to make the NUL
3597                  * transition.  We couldn't have
3598                  * yy_get_previous_state() go ahead and do it
3599                  * for us because it doesn't know how to deal
3600                  * with the possibility of jamming (and we don't
3601                  * want to build jamming into it because then it
3602                  * will run more slowly).
3603                  */
3604
3605                 yy_next_state = yy_try_NUL_trans( yy_current_state );
3606
3607                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3608
3609                 if ( yy_next_state )
3610                 {
3611                     /* Consume the NUL. */
3612                     yy_cp = ++(yy_c_buf_p);
3613                     yy_current_state = yy_next_state;
3614                     goto yy_match;
3615                 }
3616
3617                 else
3618                 {
3619                     yy_cp = (yy_c_buf_p);
3620                     goto yy_find_action;
3621                 }
3622             }
3623
3624             else switch ( yy_get_next_buffer(  ) )
3625                 {
3626                     case EOB_ACT_END_OF_FILE:
3627                     {
3628                         (yy_did_buffer_switch_on_eof) = 0;
3629
3630                         if ( yywrap( ) )
3631                         {
3632                             /* Note: because we've taken care in
3633                              * yy_get_next_buffer() to have set up
3634                              * yytext, we can now set up
3635                              * yy_c_buf_p so that if some total
3636                              * hoser (like flex itself) wants to
3637                              * call the scanner after we return the
3638                              * YY_NULL, it'll still work - another
3639                              * YY_NULL will get returned.
3640                              */
3641                             (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
3642
3643                             yy_act = YY_STATE_EOF(YY_START);
3644                             goto do_action;
3645                         }
3646
3647                         else
3648                         {
3649                             if ( ! (yy_did_buffer_switch_on_eof) )
3650                             {
3651                                 YY_NEW_FILE;
3652                             }
3653                         }
3654                         break;
3655                     }
3656
3657                     case EOB_ACT_CONTINUE_SCAN:
3658                         (yy_c_buf_p) =
3659                             (yytext_ptr) + yy_amount_of_matched_text;
3660
3661                         yy_current_state = yy_get_previous_state(  );
3662
3663                         yy_cp = (yy_c_buf_p);
3664                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3665                         goto yy_match;
3666
3667                     case EOB_ACT_LAST_MATCH:
3668                         (yy_c_buf_p) =
3669                             &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
3670
3671                         yy_current_state = yy_get_previous_state(  );
3672
3673                         yy_cp = (yy_c_buf_p);
3674                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3675                         goto yy_find_action;
3676                 }
3677             break;
3678         }
3679
3680         default:
3681             YY_FATAL_ERROR(
3682                 "fatal flex scanner internal error--no action found" );
3683     } /* end of action switch */
3684 } /* end of scanning one token */
3685 } /* end of yylex */
3686
3687 /* yy_get_next_buffer - try to read in a new buffer
3688  *
3689  * Returns a code representing an action:
3690  *      EOB_ACT_LAST_MATCH -
3691  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
3692  *      EOB_ACT_END_OF_FILE - end of file
3693  */
3694 static int yy_get_next_buffer (void)
3695 {
3696 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
3697 register char *source = (yytext_ptr);
3698 register int number_to_move, i;
3699 int ret_val;
3700
3701 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
3702     YY_FATAL_ERROR(
3703         "fatal flex scanner internal error--end of buffer missed" );
3704
3705 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
3706 {
3707     /* Don't try to fill the buffer, so this is an EOF. */
3708     if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
3709     {
3710         /* We matched a single character, the EOB, so
3711          * treat this as a final EOF.
3712          */
3713         return EOB_ACT_END_OF_FILE;
3714     }
3715
3716     else
3717     {
3718         /* We matched some text prior to the EOB, first
3719          * process it.
3720          */
3721         return EOB_ACT_LAST_MATCH;
3722     }
3723 }
3724
3725 /* Try to read more data. */
3726
3727 /* First move last chars to start of buffer. */
3728 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
3729
3730 for ( i = 0; i < number_to_move; ++i )
3731 {
3732     *(dest++) = *(source++);
3733 }
3734
3735 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
3736     /* don't do the read, it's not guaranteed to return an EOF,
3737      * just force an EOF
3738      */
3739 {
3740     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
3741 }
3742
3743 else
3744 {
3745     int num_to_read =
3746         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
3747
3748     while ( num_to_read <= 0 )
3749     {
3750         /* Not enough room in the buffer - grow it. */
3751
3752         YY_FATAL_ERROR(
3753             "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
3754
3755     }
3756
3757     if ( num_to_read > YY_READ_BUF_SIZE )
3758     {
3759         num_to_read = YY_READ_BUF_SIZE;
3760     }
3761
3762     /* Read in more data. */
3763     YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
3764               (yy_n_chars), (size_t) num_to_read );
3765
3766     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3767 }
3768
3769 if ( (yy_n_chars) == 0 )
3770 {
3771     if ( number_to_move == YY_MORE_ADJ )
3772     {
3773         ret_val = EOB_ACT_END_OF_FILE;
3774         yyrestart(yyin  );
3775     }
3776
3777     else
3778     {
3779         ret_val = EOB_ACT_LAST_MATCH;
3780         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
3781             YY_BUFFER_EOF_PENDING;
3782     }
3783 }
3784
3785 else
3786 {
3787     ret_val = EOB_ACT_CONTINUE_SCAN;
3788 }
3789
3790 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size)
3791 {
3792     /* Extend the array by 50%, plus the number we really need. */
3793     yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
3794     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, new_size  );
3795     if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
3796     {
3797         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
3798     }
3799 }
3800
3801 (yy_n_chars) += number_to_move;
3802 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
3803 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
3804
3805 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
3806
3807 return ret_val;
3808 }
3809
3810 /* yy_get_previous_state - get the state just before the EOB char was reached */
3811
3812 static yy_state_type yy_get_previous_state (void)
3813 {
3814 register yy_state_type yy_current_state;
3815 register char *yy_cp;
3816
3817 yy_current_state = (yy_start);
3818 yy_current_state += YY_AT_BOL();
3819
3820 (yy_state_ptr) = (yy_state_buf);
3821 *(yy_state_ptr)++ = yy_current_state;
3822
3823 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
3824 {
3825     register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
3826     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3827     {
3828         yy_current_state = (int) yy_def[yy_current_state];
3829         if ( yy_current_state >= 809 )
3830         {
3831             yy_c = yy_meta[(unsigned int) yy_c];
3832         }
3833     }
3834     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
3835     *(yy_state_ptr)++ = yy_current_state;
3836 }
3837
3838 return yy_current_state;
3839 }
3840
3841 /* yy_try_NUL_trans - try to make a transition on the NUL character
3842  *
3843  * synopsis
3844  *      next_state = yy_try_NUL_trans( current_state );
3845  */
3846 static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
3847 {
3848 register int yy_is_jam;
3849
3850 register YY_CHAR yy_c = 1;
3851 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3852 {
3853     yy_current_state = (int) yy_def[yy_current_state];
3854     if ( yy_current_state >= 809 )
3855     {
3856         yy_c = yy_meta[(unsigned int) yy_c];
3857     }
3858 }
3859 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
3860 yy_is_jam = (yy_current_state == 808);
3861 if ( ! yy_is_jam )
3862 {
3863     *(yy_state_ptr)++ = yy_current_state;
3864 }
3865
3866 return yy_is_jam ? 0 : yy_current_state;
3867 }
3868
3869 static void yyunput (int c, register char * yy_bp )
3870 {
3871 register char *yy_cp;
3872
3873 yy_cp = (yy_c_buf_p);
3874
3875 /* undo effects of setting up yytext */
3876 *yy_cp = (yy_hold_char);
3877
3878 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
3879 {
3880     /* need to shift things up to make room */
3881     /* +2 for EOB chars. */
3882     register int number_to_move = (yy_n_chars) + 2;
3883     register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
3884                               YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
3885     register char *source =
3886         &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
3887
3888     while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
3889     {
3890         *--dest = *--source;
3891     }
3892
3893     yy_cp += (int) (dest - source);
3894     yy_bp += (int) (dest - source);
3895     YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
3896         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
3897
3898     if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
3899     {
3900         YY_FATAL_ERROR( "flex scanner push-back overflow" );
3901     }
3902 }
3903
3904 *--yy_cp = (char) c;
3905
3906 (yytext_ptr) = yy_bp;
3907 (yy_hold_char) = *yy_cp;
3908 (yy_c_buf_p) = yy_cp;
3909 }
3910
3911 #ifndef YY_NO_INPUT
3912 #ifdef __cplusplus
3913 static int yyinput (void)
3914 #else
3915 static int input  (void)
3916 #endif
3917
3918 {
3919     int c;
3920
3921     *(yy_c_buf_p) = (yy_hold_char);
3922
3923     if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
3924     {
3925         /* yy_c_buf_p now points to the character we want to return.
3926          * If this occurs *before* the EOB characters, then it's a
3927          * valid NUL; if not, then we've hit the end of the buffer.
3928          */
3929         if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3930             /* This was really a NUL. */
3931         {
3932             *(yy_c_buf_p) = '\0';
3933         }
3934
3935         else
3936         {
3937             /* need more input */
3938             int offset = (yy_c_buf_p) - (yytext_ptr);
3939             ++(yy_c_buf_p);
3940
3941             switch ( yy_get_next_buffer(  ) )
3942             {
3943                 case EOB_ACT_LAST_MATCH:
3944                     /* This happens because yy_g_n_b()
3945                      * sees that we've accumulated a
3946                      * token and flags that we need to
3947                      * try matching the token before
3948                      * proceeding.  But for input(),
3949                      * there's no matching to consider.
3950                      * So convert the EOB_ACT_LAST_MATCH
3951                      * to EOB_ACT_END_OF_FILE.
3952                      */
3953
3954                     /* Reset buffer status. */
3955                     yyrestart(yyin );
3956
3957                     /*FALLTHROUGH*/
3958
3959                 case EOB_ACT_END_OF_FILE:
3960                 {
3961                     if ( yywrap( ) )
3962                     {
3963                         return EOF;
3964                     }
3965
3966                     if ( ! (yy_did_buffer_switch_on_eof) )
3967                     {
3968                         YY_NEW_FILE;
3969                     }
3970 #ifdef __cplusplus
3971                     return yyinput();
3972 #else
3973                     return input();
3974 #endif
3975                 }
3976
3977                 case EOB_ACT_CONTINUE_SCAN:
3978                     (yy_c_buf_p) = (yytext_ptr) + offset;
3979                     break;
3980             }
3981         }
3982     }
3983
3984     c = *(unsigned char *) (yy_c_buf_p);        /* cast for 8-bit char's */
3985     *(yy_c_buf_p) = '\0';       /* preserve yytext */
3986     (yy_hold_char) = *++(yy_c_buf_p);
3987
3988     YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
3989
3990     return c;
3991 }
3992 #endif  /* ifndef YY_NO_INPUT */
3993
3994 /** Immediately switch to a different input stream.
3995  * @param input_file A readable stream.
3996  *
3997  * @note This function does not reset the start condition to @c INITIAL .
3998  */
3999 void yyrestart  (FILE * input_file )
4000 {
4001
4002     if ( ! YY_CURRENT_BUFFER )
4003     {
4004         yyensure_buffer_stack ();
4005         YY_CURRENT_BUFFER_LVALUE =
4006             yy_create_buffer(yyin, YY_BUF_SIZE );
4007     }
4008
4009     yy_init_buffer(YY_CURRENT_BUFFER, input_file );
4010     yy_load_buffer_state( );
4011 }
4012
4013 /** Switch to a different input buffer.
4014  * @param new_buffer The new input buffer.
4015  *
4016  */
4017 void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
4018 {
4019
4020     /* TODO. We should be able to replace this entire function body
4021      * with
4022      *          yypop_buffer_state();
4023      *          yypush_buffer_state(new_buffer);
4024      */
4025     yyensure_buffer_stack ();
4026     if ( YY_CURRENT_BUFFER == new_buffer )
4027     {
4028         return;
4029     }
4030
4031     if ( YY_CURRENT_BUFFER )
4032     {
4033         /* Flush out information for old buffer. */
4034         *(yy_c_buf_p) = (yy_hold_char);
4035         YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
4036         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4037     }
4038
4039     YY_CURRENT_BUFFER_LVALUE = new_buffer;
4040     yy_load_buffer_state( );
4041
4042     /* We don't actually know whether we did this switch during
4043      * EOF (yywrap()) processing, but the only time this flag
4044      * is looked at is after yywrap() is called, so it's safe
4045      * to go ahead and always set it.
4046      */
4047     (yy_did_buffer_switch_on_eof) = 1;
4048 }
4049
4050 static void yy_load_buffer_state  (void)
4051 {
4052     (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
4053     (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
4054     yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
4055     (yy_hold_char) = *(yy_c_buf_p);
4056 }
4057
4058 /** Allocate and initialize an input buffer state.
4059  * @param file A readable stream.
4060  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
4061  *
4062  * @return the allocated buffer state.
4063  */
4064 YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
4065 {
4066     YY_BUFFER_STATE b;
4067
4068     b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
4069     if ( ! b )
4070     {
4071         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
4072     }
4073
4074     b->yy_buf_size = size;
4075
4076     /* yy_ch_buf has to be 2 characters longer than the size given because
4077      * we need to put in 2 end-of-buffer characters.
4078      */
4079     b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
4080     if ( ! b->yy_ch_buf )
4081     {
4082         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
4083     }
4084
4085     b->yy_is_our_buffer = 1;
4086
4087     yy_init_buffer(b, file );
4088
4089     return b;
4090 }
4091
4092 /** Destroy the buffer.
4093  * @param b a buffer created with yy_create_buffer()
4094  *
4095  */
4096 void yy_delete_buffer (YY_BUFFER_STATE  b )
4097 {
4098
4099     if ( ! b )
4100     {
4101         return;
4102     }
4103
4104     if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
4105     {
4106         YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
4107     }
4108
4109     if ( b->yy_is_our_buffer )
4110     {
4111         yyfree((void *) b->yy_ch_buf  );
4112     }
4113
4114     yyfree((void *) b  );
4115 }
4116
4117 #ifndef __cplusplus
4118 extern int isatty (int );
4119 #endif /* __cplusplus */
4120
4121 /* Initializes or reinitializes a buffer.
4122  * This function is sometimes called more than once on the same buffer,
4123  * such as during a yyrestart() or at EOF.
4124  */
4125 static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
4126
4127 {
4128 int oerrno = errno;
4129
4130 yy_flush_buffer(b );
4131
4132 b->yy_input_file = file;
4133 b->yy_fill_buffer = 1;
4134
4135 /* If b is the current buffer, then yy_init_buffer was _probably_
4136  * called from yyrestart() or through yy_get_next_buffer.
4137  * In that case, we don't want to reset the lineno or column.
4138  */
4139 if (b != YY_CURRENT_BUFFER)
4140 {
4141     b->yy_bs_lineno = 1;
4142     b->yy_bs_column = 0;
4143 }
4144
4145 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
4146
4147 errno = oerrno;
4148 }
4149
4150 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
4151  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
4152  *
4153  */
4154 void yy_flush_buffer (YY_BUFFER_STATE  b )
4155 {
4156 if ( ! b )
4157 {
4158     return;
4159 }
4160
4161 b->yy_n_chars = 0;
4162
4163 /* We always need two end-of-buffer characters.  The first causes
4164  * a transition to the end-of-buffer state.  The second causes
4165  * a jam in that state.
4166  */
4167 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
4168 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
4169
4170 b->yy_buf_pos = &b->yy_ch_buf[0];
4171
4172 b->yy_at_bol = 1;
4173 b->yy_buffer_status = YY_BUFFER_NEW;
4174
4175 if ( b == YY_CURRENT_BUFFER )
4176 {
4177     yy_load_buffer_state( );
4178 }
4179 }
4180
4181 /** Pushes the new state onto the stack. The new state becomes
4182  *  the current state. This function will allocate the stack
4183  *  if necessary.
4184  *  @param new_buffer The new state.
4185  *
4186  */
4187 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
4188 {
4189 if (new_buffer == NULL)
4190 {
4191     return;
4192 }
4193
4194 yyensure_buffer_stack();
4195
4196 /* This block is copied from yy_switch_to_buffer. */
4197 if ( YY_CURRENT_BUFFER )
4198 {
4199     /* Flush out information for old buffer. */
4200     *(yy_c_buf_p) = (yy_hold_char);
4201     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
4202     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4203 }
4204
4205 /* Only push if top exists. Otherwise, replace top. */
4206 if (YY_CURRENT_BUFFER)
4207 {
4208     (yy_buffer_stack_top)++;
4209 }
4210 YY_CURRENT_BUFFER_LVALUE = new_buffer;
4211
4212 /* copied from yy_switch_to_buffer. */
4213 yy_load_buffer_state( );
4214 (yy_did_buffer_switch_on_eof) = 1;
4215 }
4216
4217 /** Removes and deletes the top of the stack, if present.
4218  *  The next element becomes the new top.
4219  *
4220  */
4221 void yypop_buffer_state (void)
4222 {
4223 if (!YY_CURRENT_BUFFER)
4224 {
4225     return;
4226 }
4227
4228 yy_delete_buffer(YY_CURRENT_BUFFER );
4229 YY_CURRENT_BUFFER_LVALUE = NULL;
4230 if ((yy_buffer_stack_top) > 0)
4231 {
4232     --(yy_buffer_stack_top);
4233 }
4234
4235 if (YY_CURRENT_BUFFER)
4236 {
4237     yy_load_buffer_state( );
4238     (yy_did_buffer_switch_on_eof) = 1;
4239 }
4240 }
4241
4242 /* Allocates the stack if it does not exist.
4243  *  Guarantees space for at least one push.
4244  */
4245 static void yyensure_buffer_stack (void)
4246 {
4247 int num_to_alloc;
4248
4249 if (!(yy_buffer_stack))
4250 {
4251
4252     /* First allocation is just for 2 elements, since we don't know if this
4253      * scanner will even need a stack. We use 2 instead of 1 to avoid an
4254      * immediate realloc on the next call.
4255      */
4256     num_to_alloc = 1;
4257     (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
4258                         (num_to_alloc * sizeof(struct yy_buffer_state*)
4259                         );
4260     if ( ! (yy_buffer_stack) )
4261     {
4262         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
4263     }
4264
4265     memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
4266
4267     (yy_buffer_stack_max) = num_to_alloc;
4268     (yy_buffer_stack_top) = 0;
4269     return;
4270 }
4271
4272 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1)
4273 {
4274
4275     /* Increase the buffer to prepare for a possible push. */
4276     int grow_size = 8 /* arbitrary grow size */;
4277
4278     num_to_alloc = (yy_buffer_stack_max) + grow_size;
4279     (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
4280                         ((yy_buffer_stack),
4281                          num_to_alloc * sizeof(struct yy_buffer_state*)
4282                         );
4283     if ( ! (yy_buffer_stack) )
4284     {
4285         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
4286     }
4287
4288     /* zero only the new slots.*/
4289     memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
4290     (yy_buffer_stack_max) = num_to_alloc;
4291 }
4292 }
4293
4294 /** Setup the input buffer state to scan directly from a user-specified character buffer.
4295  * @param base the character buffer
4296  * @param size the size in bytes of the character buffer
4297  *
4298  * @return the newly allocated buffer state object.
4299  */
4300 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
4301 {
4302 YY_BUFFER_STATE b;
4303
4304 if ( size < 2 ||
4305         base[size - 2] != YY_END_OF_BUFFER_CHAR ||
4306         base[size - 1] != YY_END_OF_BUFFER_CHAR )
4307     /* They forgot to leave room for the EOB's. */
4308 {
4309     return 0;
4310 }
4311
4312 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
4313 if ( ! b )
4314 {
4315     YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
4316 }
4317
4318 b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
4319 b->yy_buf_pos = b->yy_ch_buf = base;
4320 b->yy_is_our_buffer = 0;
4321 b->yy_input_file = 0;
4322 b->yy_n_chars = b->yy_buf_size;
4323 b->yy_is_interactive = 0;
4324 b->yy_at_bol = 1;
4325 b->yy_fill_buffer = 0;
4326 b->yy_buffer_status = YY_BUFFER_NEW;
4327
4328 yy_switch_to_buffer(b  );
4329
4330 return b;
4331 }
4332
4333 /** Setup the input buffer state to scan a string. The next call to yylex() will
4334  * scan from a @e copy of @a str.
4335  * @param yystr a NUL-terminated string to scan
4336  *
4337  * @return the newly allocated buffer state object.
4338  * @note If you want to scan bytes that may contain NUL values, then use
4339  *       yy_scan_bytes() instead.
4340  */
4341 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
4342 {
4343
4344 return yy_scan_bytes(yystr, strlen(yystr) );
4345 }
4346
4347 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
4348  * scan from a @e copy of @a bytes.
4349  * @param yybytes the byte buffer to scan
4350  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
4351  *
4352  * @return the newly allocated buffer state object.
4353  */
4354 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
4355 {
4356 YY_BUFFER_STATE b;
4357 char *buf;
4358 yy_size_t n;
4359 int i;
4360
4361 /* Get memory for full buffer, including space for trailing EOB's. */
4362 n = _yybytes_len + 2;
4363 buf = (char *) yyalloc(n  );
4364 if ( ! buf )
4365 {
4366     YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
4367 }
4368
4369 for ( i = 0; i < _yybytes_len; ++i )
4370 {
4371     buf[i] = yybytes[i];
4372 }
4373
4374 buf[_yybytes_len] = buf[_yybytes_len + 1] = YY_END_OF_BUFFER_CHAR;
4375
4376 b = yy_scan_buffer(buf, n );
4377 if ( ! b )
4378 {
4379     YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
4380 }
4381
4382 /* It's okay to grow etc. this buffer, and we should throw it
4383  * away when we're done.
4384  */
4385 b->yy_is_our_buffer = 1;
4386
4387 return b;
4388 }
4389
4390 static void yy_push_state (int  new_state )
4391 {
4392 if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
4393 {
4394     yy_size_t new_size;
4395
4396     (yy_start_stack_depth) += YY_START_STACK_INCR;
4397     new_size = (yy_start_stack_depth) * sizeof( int );
4398
4399     if ( ! (yy_start_stack) )
4400     {
4401         (yy_start_stack) = (int *) yyalloc(new_size  );
4402     }
4403
4404     else
4405     {
4406         (yy_start_stack) = (int *) yyrealloc((void *) (yy_start_stack), new_size  );
4407     }
4408
4409     if ( ! (yy_start_stack) )
4410     {
4411         YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
4412     }
4413 }
4414
4415 (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
4416
4417 BEGIN(new_state);
4418 }
4419
4420 static void yy_pop_state  (void)
4421 {
4422 if ( --(yy_start_stack_ptr) < 0 )
4423 {
4424     YY_FATAL_ERROR( "start-condition stack underflow" );
4425 }
4426
4427 BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
4428 }
4429
4430 static int yy_top_state  (void)
4431 {
4432 return (yy_start_stack)[(yy_start_stack_ptr) - 1];
4433 }
4434
4435 #ifndef YY_EXIT_FAILURE
4436 #define YY_EXIT_FAILURE 2
4437 #endif
4438
4439 static void yy_fatal_error (yyconst char* msg )
4440 {
4441 (void) fprintf( stderr, "%s\n", msg );
4442 exit( YY_EXIT_FAILURE );
4443 }
4444
4445 /* Redefine yyless() so it works in section 3 code. */
4446
4447 #undef yyless
4448 #define yyless(n) \
4449         do \
4450                 { \
4451                 /* Undo effects of setting up yytext. */ \
4452         int yyless_macro_arg = (n); \
4453         YY_LESS_LINENO(yyless_macro_arg);\
4454                 yytext[yyleng] = (yy_hold_char); \
4455                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
4456                 (yy_hold_char) = *(yy_c_buf_p); \
4457                 *(yy_c_buf_p) = '\0'; \
4458                 yyleng = yyless_macro_arg; \
4459                 } \
4460         while ( 0 )
4461
4462 /* Accessor  methods (get/set functions) to struct members. */
4463
4464 /** Get the current line number.
4465  *
4466  */
4467 int yyget_lineno  (void)
4468 {
4469
4470 return yylineno;
4471 }
4472
4473 /** Get the input stream.
4474  *
4475  */
4476 FILE *yyget_in  (void)
4477 {
4478 return yyin;
4479 }
4480
4481 /** Get the output stream.
4482  *
4483  */
4484 FILE *yyget_out  (void)
4485 {
4486 return yyout;
4487 }
4488
4489 /** Get the length of the current token.
4490  *
4491  */
4492 int yyget_leng  (void)
4493 {
4494 return yyleng;
4495 }
4496
4497 /** Get the current token.
4498  *
4499  */
4500
4501 char *yyget_text  (void)
4502 {
4503 return yytext;
4504 }
4505
4506 /** Set the current line number.
4507  * @param line_number
4508  *
4509  */
4510 void yyset_lineno (int  line_number )
4511 {
4512
4513 yylineno = line_number;
4514 }
4515
4516 /** Set the input stream. This does not discard the current
4517  * input buffer.
4518  * @param in_str A readable stream.
4519  *
4520  * @see yy_switch_to_buffer
4521  */
4522 void yyset_in (FILE *  in_str )
4523 {
4524 yyin = in_str ;
4525 }
4526
4527 void yyset_out (FILE *  out_str )
4528 {
4529 yyout = out_str ;
4530 }
4531
4532 int yyget_debug  (void)
4533 {
4534 return yy_flex_debug;
4535 }
4536
4537 void yyset_debug (int  bdebug )
4538 {
4539 yy_flex_debug = bdebug ;
4540 }
4541
4542 static int yy_init_globals (void)
4543 {
4544 /* Initialization is the same as for the non-reentrant scanner.
4545 * This function is called from yylex_destroy(), so don't allocate here.
4546 */
4547
4548 (yy_buffer_stack) = 0;
4549 (yy_buffer_stack_top) = 0;
4550 (yy_buffer_stack_max) = 0;
4551 (yy_c_buf_p) = (char *) 0;
4552 (yy_init) = 0;
4553 (yy_start) = 0;
4554
4555 (yy_start_stack_ptr) = 0;
4556 (yy_start_stack_depth) = 0;
4557 (yy_start_stack) =  NULL;
4558
4559 (yy_state_buf) = 0;
4560 (yy_state_ptr) = 0;
4561 (yy_full_match) = 0;
4562 (yy_lp) = 0;
4563
4564 /* Defined in main.c */
4565 #ifdef YY_STDINIT
4566 yyin = stdin;
4567 yyout = stdout;
4568 #else
4569 yyin = (FILE *) 0;
4570 yyout = (FILE *) 0;
4571 #endif
4572
4573 /* For future reference: Set errno on error, since we are called by
4574  * yylex_init()
4575  */
4576 return 0;
4577 }
4578
4579 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
4580 int yylex_destroy  (void)
4581 {
4582
4583 /* Pop the buffer stack, destroying each element. */
4584 while (YY_CURRENT_BUFFER)
4585 {
4586     yy_delete_buffer(YY_CURRENT_BUFFER  );
4587     YY_CURRENT_BUFFER_LVALUE = NULL;
4588     yypop_buffer_state();
4589 }
4590
4591 /* Destroy the stack itself. */
4592 yyfree((yy_buffer_stack) );
4593 (yy_buffer_stack) = NULL;
4594
4595 /* Destroy the start condition stack. */
4596 yyfree((yy_start_stack)  );
4597 (yy_start_stack) = NULL;
4598
4599 yyfree ( (yy_state_buf) );
4600 (yy_state_buf)  = NULL;
4601
4602 /* Reset the globals. This is important in a non-reentrant scanner so the next time
4603  * yylex() is called, initialization will occur. */
4604 yy_init_globals( );
4605
4606 return 0;
4607 }
4608
4609 /*
4610  * Internal utility routines.
4611  */
4612
4613 #ifndef yytext_ptr
4614 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
4615 {
4616 register int i;
4617 for ( i = 0; i < n; ++i )
4618 {
4619     s1[i] = s2[i];
4620 }
4621 }
4622 #endif
4623
4624 #ifdef YY_NEED_STRLEN
4625 static int yy_flex_strlen (yyconst char * s )
4626 {
4627 register int n;
4628 for ( n = 0; s[n]; ++n )
4629     ;
4630
4631 return n;
4632 }
4633 #endif
4634
4635 void *yyalloc (yy_size_t  size )
4636 {
4637 return (void *) malloc( size );
4638 }
4639
4640 void *yyrealloc  (void * ptr, yy_size_t  size )
4641 {
4642 /* The cast to (char *) in the following accommodates both
4643  * implementations that use char* generic pointers, and those
4644  * that use void* generic pointers.  It works with the latter
4645  * because both ANSI C and C++ allow castless assignment from
4646  * any pointer type to void*, and deal with argument conversions
4647  * as though doing an assignment.
4648  */
4649 return (void *) realloc( (char *) ptr, size );
4650 }
4651
4652 void yyfree (void * ptr )
4653 {
4654 free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
4655 }
4656
4657 #define YYTABLES_NAME "yytables"
4658
4659 int scan_throw(int token)
4660 {
4661 last_token = token;
4662 #ifdef DEV
4663 std::cout << "--> [DEBUG] TOKEN : " << token << std::endl;
4664 #endif
4665 return token;
4666 }
4667
4668 int get_last_token()
4669 {
4670 return last_token;
4671 }
4672
4673 void scan_step()
4674 {
4675 yylloc.first_line = yylloc.last_line;
4676 yylloc.first_column = yylloc.last_column;
4677 }
4678
4679 /*
4680 ** convert floating numbers to C standard
4681 ** 1.2d-3 -> 1.2e-3
4682 ** 1.2D-3 -> 1.2e-3
4683 */
4684 void scan_exponent_convert(char *in)
4685 {
4686 for (; *in != 'd' && *in != 'D'; ++in);
4687 *in = 'e';
4688 }
4689
4690 #ifdef _MSC_VER
4691 int isatty (int desc)
4692 {
4693 return 0;
4694 }
4695 #endif
4696