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