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