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