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