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