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