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