1 #line 2 "sgf_l.c"
2
3 #line 4 "sgf_l.c"
4
5 #define YY_INT_ALIGNED short int
6
7 /* A lexical scanner generated by flex */
8
9 #define yy_create_buffer sgf_create_buffer
10 #define yy_delete_buffer sgf_delete_buffer
11 #define yy_flex_debug sgf_flex_debug
12 #define yy_init_buffer sgf_init_buffer
13 #define yy_flush_buffer sgf_flush_buffer
14 #define yy_load_buffer_state sgf_load_buffer_state
15 #define yy_switch_to_buffer sgf_switch_to_buffer
16 #define yyin sgfin
17 #define yyleng sgfleng
18 #define yylex sgflex
19 #define yylineno sgflineno
20 #define yyout sgfout
21 #define yyrestart sgfrestart
22 #define yytext sgftext
23 #define yywrap sgfwrap
24 #define yyalloc sgfalloc
25 #define yyrealloc sgfrealloc
26 #define yyfree sgffree
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 37
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 #if defined(__FreeBSD__)
39 #ifndef __STDC_LIMIT_MACROS
40 #define __STDC_LIMIT_MACROS
41 #endif
42 #include <sys/cdefs.h>
43 #include <stdint.h>
44 #else
45 #define __dead2
46 #endif
47
48 /* begin standard C headers. */
49 #include <stdio.h>
50 #include <string.h>
51 #include <errno.h>
52 #include <stdlib.h>
53
54 /* end standard C headers. */
55
56 /* flex integer type definitions */
57
58 #ifndef FLEXINT_H
59 #define FLEXINT_H
60
61 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
62
63 #if defined(__FreeBSD__) || \
64 (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
65
66 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
67 * if you want the limit (max/min) macros for int types.
68 */
69 #ifndef __STDC_LIMIT_MACROS
70 #define __STDC_LIMIT_MACROS 1
71 #endif
72
73 #include <inttypes.h>
74 typedef int8_t flex_int8_t;
75 typedef uint8_t flex_uint8_t;
76 typedef int16_t flex_int16_t;
77 typedef uint16_t flex_uint16_t;
78 typedef int32_t flex_int32_t;
79 typedef uint32_t flex_uint32_t;
80 #else
81 typedef signed char flex_int8_t;
82 typedef short int flex_int16_t;
83 typedef int flex_int32_t;
84 typedef unsigned char flex_uint8_t;
85 typedef unsigned short int flex_uint16_t;
86 typedef unsigned int flex_uint32_t;
87
88 /* Limits of integral types. */
89 #ifndef INT8_MIN
90 #define INT8_MIN (-128)
91 #endif
92 #ifndef INT16_MIN
93 #define INT16_MIN (-32767-1)
94 #endif
95 #ifndef INT32_MIN
96 #define INT32_MIN (-2147483647-1)
97 #endif
98 #ifndef INT8_MAX
99 #define INT8_MAX (127)
100 #endif
101 #ifndef INT16_MAX
102 #define INT16_MAX (32767)
103 #endif
104 #ifndef INT32_MAX
105 #define INT32_MAX (2147483647)
106 #endif
107 #ifndef UINT8_MAX
108 #define UINT8_MAX (255U)
109 #endif
110 #ifndef UINT16_MAX
111 #define UINT16_MAX (65535U)
112 #endif
113 #ifndef UINT32_MAX
114 #define UINT32_MAX (4294967295U)
115 #endif
116
117 #endif /* ! C99 */
118
119 #endif /* ! FLEXINT_H */
120
121 #ifdef __cplusplus
122
123 /* The "const" storage-class-modifier is valid. */
124 #define YY_USE_CONST
125
126 #else /* ! __cplusplus */
127
128 /* C99 requires __STDC__ to be defined as 1. */
129 #if defined (__STDC__)
130
131 #define YY_USE_CONST
132
133 #endif /* defined (__STDC__) */
134 #endif /* ! __cplusplus */
135
136 #ifdef YY_USE_CONST
137 #define yyconst const
138 #else
139 #define yyconst
140 #endif
141
142 /* Returned upon end-of-file. */
143 #define YY_NULL 0
144
145 /* Promotes a possibly negative, possibly signed char to an unsigned
146 * integer for use as an array index. If the signed char is negative,
147 * we want to instead treat it as an 8-bit unsigned char, hence the
148 * double cast.
149 */
150 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
151
152 /* Enter a start condition. This macro really ought to take a parameter,
153 * but we do it the disgusting crufty way forced on us by the ()-less
154 * definition of BEGIN.
155 */
156 #define BEGIN (yy_start) = 1 + 2 *
157
158 /* Translate the current start state into a value that can be later handed
159 * to BEGIN to return to the state. The YYSTATE alias is for lex
160 * compatibility.
161 */
162 #define YY_START (((yy_start) - 1) / 2)
163 #define YYSTATE YY_START
164
165 /* Action number for EOF rule of a given start state. */
166 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
167
168 /* Special action meaning "start processing a new file". */
169 #define YY_NEW_FILE sgfrestart(sgfin )
170
171 #define YY_END_OF_BUFFER_CHAR 0
172
173 /* Size of default input buffer. */
174 #ifndef YY_BUF_SIZE
175 #define YY_BUF_SIZE 16384
176 #endif
177
178 /* The state buf must be large enough to hold one state per character in the main buffer.
179 */
180 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
181
182 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
183 #define YY_TYPEDEF_YY_BUFFER_STATE
184 typedef struct yy_buffer_state *YY_BUFFER_STATE;
185 #endif
186
187 #ifndef YY_TYPEDEF_YY_SIZE_T
188 #define YY_TYPEDEF_YY_SIZE_T
189 typedef size_t yy_size_t;
190 #endif
191
192 extern yy_size_t sgfleng;
193
194 extern FILE *sgfin, *sgfout;
195
196 #define EOB_ACT_CONTINUE_SCAN 0
197 #define EOB_ACT_END_OF_FILE 1
198 #define EOB_ACT_LAST_MATCH 2
199
200 #define YY_LESS_LINENO(n)
201
202 /* Return all but the first "n" matched characters back to the input stream. */
203 #define yyless(n) \
204 do \
205 { \
206 /* Undo effects of setting up sgftext. */ \
207 int yyless_macro_arg = (n); \
208 YY_LESS_LINENO(yyless_macro_arg);\
209 *yy_cp = (yy_hold_char); \
210 YY_RESTORE_YY_MORE_OFFSET \
211 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
212 YY_DO_BEFORE_ACTION; /* set up sgftext again */ \
213 } \
214 while ( 0 )
215
216 #define unput(c) yyunput( c, (yytext_ptr) )
217
218 #ifndef YY_STRUCT_YY_BUFFER_STATE
219 #define YY_STRUCT_YY_BUFFER_STATE
220 struct yy_buffer_state
221 {
222 FILE *yy_input_file;
223
224 char *yy_ch_buf; /* input buffer */
225 char *yy_buf_pos; /* current position in input buffer */
226
227 /* Size of input buffer in bytes, not including room for EOB
228 * characters.
229 */
230 yy_size_t yy_buf_size;
231
232 /* Number of characters read into yy_ch_buf, not including EOB
233 * characters.
234 */
235 yy_size_t yy_n_chars;
236
237 /* Whether we "own" the buffer - i.e., we know we created it,
238 * and can realloc() it to grow it, and should free() it to
239 * delete it.
240 */
241 int yy_is_our_buffer;
242
243 /* Whether this is an "interactive" input source; if so, and
244 * if we're using stdio for input, then we want to use getc()
245 * instead of fread(), to make sure we stop fetching input after
246 * each newline.
247 */
248 int yy_is_interactive;
249
250 /* Whether we're considered to be at the beginning of a line.
251 * If so, '^' rules will be active on the next match, otherwise
252 * not.
253 */
254 int yy_at_bol;
255
256 int yy_bs_lineno; /**< The line count. */
257 int yy_bs_column; /**< The column count. */
258
259 /* Whether to try to fill the input buffer when we reach the
260 * end of it.
261 */
262 int yy_fill_buffer;
263
264 int yy_buffer_status;
265
266 #define YY_BUFFER_NEW 0
267 #define YY_BUFFER_NORMAL 1
268 /* When an EOF's been seen but there's still some text to process
269 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
270 * shouldn't try reading from the input source any more. We might
271 * still have a bunch of tokens to match, though, because of
272 * possible backing-up.
273 *
274 * When we actually see the EOF, we change the status to "new"
275 * (via sgfrestart()), so that the user can continue scanning by
276 * just pointing sgfin at a new input file.
277 */
278 #define YY_BUFFER_EOF_PENDING 2
279
280 };
281 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
282
283 /* Stack of input buffers. */
284 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
285 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
286 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
287
288 /* We provide macros for accessing buffer states in case in the
289 * future we want to put the buffer states in a more general
290 * "scanner state".
291 *
292 * Returns the top of the stack, or NULL.
293 */
294 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
295 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
296 : NULL)
297 #define yy_current_buffer YY_CURRENT_BUFFER
298
299 /* Same as previous macro, but useful when we know that the buffer stack is not
300 * NULL or when we need an lvalue. For internal use only.
301 */
302 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
303
304 /* yy_hold_char holds the character lost when sgftext is formed. */
305 static char yy_hold_char;
306 static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
307 yy_size_t sgfleng;
308
309 /* Points to current character in buffer. */
310 static char *yy_c_buf_p = (char *) 0;
311 static int yy_init = 0; /* whether we need to initialize */
312 static int yy_start = 0; /* start state number */
313
314 /* Flag which is used to allow sgfwrap()'s to do buffer switches
315 * instead of setting up a fresh sgfin. A bit of a hack ...
316 */
317 static int yy_did_buffer_switch_on_eof;
318
319 void sgfrestart (FILE *input_file );
320 void sgf_switch_to_buffer (YY_BUFFER_STATE new_buffer );
321 YY_BUFFER_STATE sgf_create_buffer (FILE *file,int size );
322 void sgf_delete_buffer (YY_BUFFER_STATE b );
323 void sgf_flush_buffer (YY_BUFFER_STATE b );
324 void sgfpush_buffer_state (YY_BUFFER_STATE new_buffer );
325 void sgfpop_buffer_state (void );
326
327 static void sgfensure_buffer_stack (void );
328 static void sgf_load_buffer_state (void );
329 static void sgf_init_buffer (YY_BUFFER_STATE b,FILE *file );
330
331 #define YY_FLUSH_BUFFER sgf_flush_buffer(YY_CURRENT_BUFFER )
332
333 YY_BUFFER_STATE sgf_scan_buffer (char *base,yy_size_t size );
334 YY_BUFFER_STATE sgf_scan_string (yyconst char *yy_str );
335 YY_BUFFER_STATE sgf_scan_bytes (yyconst char *bytes,yy_size_t len );
336
337 void *sgfalloc (yy_size_t );
338 void *sgfrealloc (void *,yy_size_t );
339 void sgffree (void * );
340
341 #define yy_new_buffer sgf_create_buffer
342
343 #define yy_set_interactive(is_interactive) \
344 { \
345 if ( ! YY_CURRENT_BUFFER ){ \
346 sgfensure_buffer_stack (); \
347 YY_CURRENT_BUFFER_LVALUE = \
348 sgf_create_buffer(sgfin,YY_BUF_SIZE ); \
349 } \
350 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
351 }
352
353 #define yy_set_bol(at_bol) \
354 { \
355 if ( ! YY_CURRENT_BUFFER ){\
356 sgfensure_buffer_stack (); \
357 YY_CURRENT_BUFFER_LVALUE = \
358 sgf_create_buffer(sgfin,YY_BUF_SIZE ); \
359 } \
360 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
361 }
362
363 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
364
365 /* Begin user sect3 */
366
367 #define sgfwrap() 1
368 #define YY_SKIP_YYWRAP
369
370 typedef unsigned char YY_CHAR;
371
372 FILE *sgfin = (FILE *) 0, *sgfout = (FILE *) 0;
373
374 typedef yyconst struct yy_trans_info *yy_state_type;
375
376 extern int sgflineno;
377
378 int sgflineno = 1;
379
380 extern char *sgftext;
381 #define yytext_ptr sgftext
382
383 static yy_state_type yy_get_previous_state (void );
384 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
385 static int yy_get_next_buffer (void );
386 static void yy_fatal_error (yyconst char msg[] ) __dead2;
387
388 /* Done after the current pattern has been matched and before the
389 * corresponding action - sets up sgftext.
390 */
391 #define YY_DO_BEFORE_ACTION \
392 (yytext_ptr) = yy_bp; \
393 sgfleng = (size_t) (yy_cp - yy_bp); \
394 (yy_hold_char) = *yy_cp; \
395 *yy_cp = '\0'; \
396 (yy_c_buf_p) = yy_cp;
397
398 #define YY_NUM_RULES 13
399 #define YY_END_OF_BUFFER 14
400 struct yy_trans_info
401 {
402 flex_int16_t yy_verify;
403 flex_int16_t yy_nxt;
404 };
405 static yyconst struct yy_trans_info yy_transition[2845] =
406 {
407 { 0, 0 }, { 0,2589 }, { 0, 0 }, { 0,2587 }, { 1,1032 },
408 { 2,1032 }, { 3,1032 }, { 4,1032 }, { 5,1032 }, { 6,1032 },
409 { 7,1032 }, { 8,1032 }, { 9,1034 }, { 10,1039 }, { 11,1034 },
410 { 12,1034 }, { 13,1034 }, { 14,1032 }, { 15,1032 }, { 16,1032 },
411 { 17,1032 }, { 18,1032 }, { 19,1032 }, { 20,1032 }, { 21,1032 },
412 { 22,1032 }, { 23,1032 }, { 24,1032 }, { 25,1032 }, { 26,1032 },
413 { 27,1032 }, { 28,1032 }, { 29,1032 }, { 30,1032 }, { 31,1032 },
414 { 32,1034 }, { 33,1032 }, { 34,1032 }, { 35,1032 }, { 36,1032 },
415 { 37,1032 }, { 38,1032 }, { 39,1032 }, { 40,1036 }, { 41,1036 },
416 { 42,1032 }, { 43,1032 }, { 44,1032 }, { 45,1032 }, { 46,1032 },
417
418 { 47,1032 }, { 48,1032 }, { 49,1032 }, { 50,1032 }, { 51,1032 },
419 { 52,1032 }, { 53,1032 }, { 54,1032 }, { 55,1032 }, { 56,1032 },
420 { 57,1032 }, { 58,1032 }, { 59,1036 }, { 60,1032 }, { 61,1032 },
421 { 62,1032 }, { 63,1032 }, { 64,1032 }, { 65,1041 }, { 66,1041 },
422 { 67,1041 }, { 68,1041 }, { 69,1041 }, { 70,1041 }, { 71,1041 },
423 { 72,1041 }, { 73,1041 }, { 74,1041 }, { 75,1041 }, { 76,1041 },
424 { 77,1041 }, { 78,1041 }, { 79,1041 }, { 80,1041 }, { 81,1041 },
425 { 82,1041 }, { 83,1041 }, { 84,1041 }, { 85,1041 }, { 86,1041 },
426 { 87,1041 }, { 88,1041 }, { 89,1041 }, { 90,1041 }, { 91,1054 },
427 { 92,1032 }, { 93,1032 }, { 94,1032 }, { 95,1032 }, { 96,1032 },
428
429 { 97,1099 }, { 98,1099 }, { 99,1099 }, { 100,1099 }, { 101,1099 },
430 { 102,1099 }, { 103,1099 }, { 104,1099 }, { 105,1099 }, { 106,1099 },
431 { 107,1099 }, { 108,1099 }, { 109,1099 }, { 110,1099 }, { 111,1099 },
432 { 112,1099 }, { 113,1099 }, { 114,1099 }, { 115,1099 }, { 116,1099 },
433 { 117,1099 }, { 118,1099 }, { 119,1099 }, { 120,1099 }, { 121,1099 },
434 { 122,1099 }, { 123,1032 }, { 124,1032 }, { 125,1032 }, { 126,1032 },
435 { 127,1032 }, { 128,1032 }, { 129,1032 }, { 130,1032 }, { 131,1032 },
436 { 132,1032 }, { 133,1032 }, { 134,1032 }, { 135,1032 }, { 136,1032 },
437 { 137,1032 }, { 138,1032 }, { 139,1032 }, { 140,1032 }, { 141,1032 },
438 { 142,1032 }, { 143,1032 }, { 144,1032 }, { 145,1032 }, { 146,1032 },
439
440 { 147,1032 }, { 148,1032 }, { 149,1032 }, { 150,1032 }, { 151,1032 },
441 { 152,1032 }, { 153,1032 }, { 154,1032 }, { 155,1032 }, { 156,1032 },
442 { 157,1032 }, { 158,1032 }, { 159,1032 }, { 160,1032 }, { 161,1032 },
443 { 162,1032 }, { 163,1032 }, { 164,1032 }, { 165,1032 }, { 166,1032 },
444 { 167,1032 }, { 168,1032 }, { 169,1032 }, { 170,1032 }, { 171,1032 },
445 { 172,1032 }, { 173,1032 }, { 174,1032 }, { 175,1032 }, { 176,1032 },
446 { 177,1032 }, { 178,1032 }, { 179,1032 }, { 180,1032 }, { 181,1032 },
447 { 182,1032 }, { 183,1032 }, { 184,1032 }, { 185,1032 }, { 186,1032 },
448 { 187,1032 }, { 188,1032 }, { 189,1032 }, { 190,1032 }, { 191,1032 },
449 { 192,1032 }, { 193,1032 }, { 194,1032 }, { 195,1032 }, { 196,1032 },
450
451 { 197,1032 }, { 198,1032 }, { 199,1032 }, { 200,1032 }, { 201,1032 },
452 { 202,1032 }, { 203,1032 }, { 204,1032 }, { 205,1032 }, { 206,1032 },
453 { 207,1032 }, { 208,1032 }, { 209,1032 }, { 210,1032 }, { 211,1032 },
454 { 212,1032 }, { 213,1032 }, { 214,1032 }, { 215,1032 }, { 216,1032 },
455 { 217,1032 }, { 218,1032 }, { 219,1032 }, { 220,1032 }, { 221,1032 },
456 { 222,1032 }, { 223,1032 }, { 224,1032 }, { 225,1032 }, { 226,1032 },
457 { 227,1032 }, { 228,1032 }, { 229,1032 }, { 230,1032 }, { 231,1032 },
458 { 232,1032 }, { 233,1032 }, { 234,1032 }, { 235,1032 }, { 236,1032 },
459 { 237,1032 }, { 238,1032 }, { 239,1032 }, { 240,1032 }, { 241,1032 },
460 { 242,1032 }, { 243,1032 }, { 244,1032 }, { 245,1032 }, { 246,1032 },
461
462 { 247,1032 }, { 248,1032 }, { 249,1032 }, { 250,1032 }, { 251,1032 },
463 { 252,1032 }, { 253,1032 }, { 254,1032 }, { 255,1032 }, { 256,1032 },
464 { 0, 0 }, { 0,2329 }, { 1, 774 }, { 2, 774 }, { 3, 774 },
465 { 4, 774 }, { 5, 774 }, { 6, 774 }, { 7, 774 }, { 8, 774 },
466 { 9, 776 }, { 10, 781 }, { 11, 776 }, { 12, 776 }, { 13, 776 },
467 { 14, 774 }, { 15, 774 }, { 16, 774 }, { 17, 774 }, { 18, 774 },
468 { 19, 774 }, { 20, 774 }, { 21, 774 }, { 22, 774 }, { 23, 774 },
469 { 24, 774 }, { 25, 774 }, { 26, 774 }, { 27, 774 }, { 28, 774 },
470 { 29, 774 }, { 30, 774 }, { 31, 774 }, { 32, 776 }, { 33, 774 },
471 { 34, 774 }, { 35, 774 }, { 36, 774 }, { 37, 774 }, { 38, 774 },
472
473 { 39, 774 }, { 40, 778 }, { 41, 778 }, { 42, 774 }, { 43, 774 },
474 { 44, 774 }, { 45, 774 }, { 46, 774 }, { 47, 774 }, { 48, 774 },
475 { 49, 774 }, { 50, 774 }, { 51, 774 }, { 52, 774 }, { 53, 774 },
476 { 54, 774 }, { 55, 774 }, { 56, 774 }, { 57, 774 }, { 58, 774 },
477 { 59, 778 }, { 60, 774 }, { 61, 774 }, { 62, 774 }, { 63, 774 },
478 { 64, 774 }, { 65, 783 }, { 66, 783 }, { 67, 783 }, { 68, 783 },
479 { 69, 783 }, { 70, 783 }, { 71, 783 }, { 72, 783 }, { 73, 783 },
480 { 74, 783 }, { 75, 783 }, { 76, 783 }, { 77, 783 }, { 78, 783 },
481 { 79, 783 }, { 80, 783 }, { 81, 783 }, { 82, 783 }, { 83, 783 },
482 { 84, 783 }, { 85, 783 }, { 86, 783 }, { 87, 783 }, { 88, 783 },
483
484 { 89, 783 }, { 90, 783 }, { 91, 796 }, { 92, 774 }, { 93, 774 },
485 { 94, 774 }, { 95, 774 }, { 96, 774 }, { 97, 841 }, { 98, 841 },
486 { 99, 841 }, { 100, 841 }, { 101, 841 }, { 102, 841 }, { 103, 841 },
487 { 104, 841 }, { 105, 841 }, { 106, 841 }, { 107, 841 }, { 108, 841 },
488 { 109, 841 }, { 110, 841 }, { 111, 841 }, { 112, 841 }, { 113, 841 },
489 { 114, 841 }, { 115, 841 }, { 116, 841 }, { 117, 841 }, { 118, 841 },
490 { 119, 841 }, { 120, 841 }, { 121, 841 }, { 122, 841 }, { 123, 774 },
491 { 124, 774 }, { 125, 774 }, { 126, 774 }, { 127, 774 }, { 128, 774 },
492 { 129, 774 }, { 130, 774 }, { 131, 774 }, { 132, 774 }, { 133, 774 },
493 { 134, 774 }, { 135, 774 }, { 136, 774 }, { 137, 774 }, { 138, 774 },
494
495 { 139, 774 }, { 140, 774 }, { 141, 774 }, { 142, 774 }, { 143, 774 },
496 { 144, 774 }, { 145, 774 }, { 146, 774 }, { 147, 774 }, { 148, 774 },
497 { 149, 774 }, { 150, 774 }, { 151, 774 }, { 152, 774 }, { 153, 774 },
498 { 154, 774 }, { 155, 774 }, { 156, 774 }, { 157, 774 }, { 158, 774 },
499 { 159, 774 }, { 160, 774 }, { 161, 774 }, { 162, 774 }, { 163, 774 },
500 { 164, 774 }, { 165, 774 }, { 166, 774 }, { 167, 774 }, { 168, 774 },
501 { 169, 774 }, { 170, 774 }, { 171, 774 }, { 172, 774 }, { 173, 774 },
502 { 174, 774 }, { 175, 774 }, { 176, 774 }, { 177, 774 }, { 178, 774 },
503 { 179, 774 }, { 180, 774 }, { 181, 774 }, { 182, 774 }, { 183, 774 },
504 { 184, 774 }, { 185, 774 }, { 186, 774 }, { 187, 774 }, { 188, 774 },
505
506 { 189, 774 }, { 190, 774 }, { 191, 774 }, { 192, 774 }, { 193, 774 },
507 { 194, 774 }, { 195, 774 }, { 196, 774 }, { 197, 774 }, { 198, 774 },
508 { 199, 774 }, { 200, 774 }, { 201, 774 }, { 202, 774 }, { 203, 774 },
509 { 204, 774 }, { 205, 774 }, { 206, 774 }, { 207, 774 }, { 208, 774 },
510 { 209, 774 }, { 210, 774 }, { 211, 774 }, { 212, 774 }, { 213, 774 },
511 { 214, 774 }, { 215, 774 }, { 216, 774 }, { 217, 774 }, { 218, 774 },
512 { 219, 774 }, { 220, 774 }, { 221, 774 }, { 222, 774 }, { 223, 774 },
513 { 224, 774 }, { 225, 774 }, { 226, 774 }, { 227, 774 }, { 228, 774 },
514 { 229, 774 }, { 230, 774 }, { 231, 774 }, { 232, 774 }, { 233, 774 },
515 { 234, 774 }, { 235, 774 }, { 236, 774 }, { 237, 774 }, { 238, 774 },
516
517 { 239, 774 }, { 240, 774 }, { 241, 774 }, { 242, 774 }, { 243, 774 },
518 { 244, 774 }, { 245, 774 }, { 246, 774 }, { 247, 774 }, { 248, 774 },
519 { 249, 774 }, { 250, 774 }, { 251, 774 }, { 252, 774 }, { 253, 774 },
520 { 254, 774 }, { 255, 774 }, { 256, 774 }, { 0, 0 }, { 0,2071 },
521 { 1, 707 }, { 2, 707 }, { 3, 707 }, { 4, 707 }, { 5, 707 },
522 { 6, 707 }, { 7, 707 }, { 8, 707 }, { 9, 707 }, { 10, 707 },
523 { 11, 707 }, { 12, 707 }, { 13, 707 }, { 14, 707 }, { 15, 707 },
524 { 16, 707 }, { 17, 707 }, { 18, 707 }, { 19, 707 }, { 20, 707 },
525 { 21, 707 }, { 22, 707 }, { 23, 707 }, { 24, 707 }, { 25, 707 },
526 { 26, 707 }, { 27, 707 }, { 28, 707 }, { 29, 707 }, { 30, 707 },
527
528 { 31, 707 }, { 32, 707 }, { 33, 707 }, { 34, 707 }, { 35, 707 },
529 { 36, 707 }, { 37, 707 }, { 38, 707 }, { 39, 707 }, { 40, 707 },
530 { 41, 707 }, { 42, 707 }, { 43, 707 }, { 44, 707 }, { 45, 707 },
531 { 46, 707 }, { 47, 707 }, { 48, 707 }, { 49, 707 }, { 50, 707 },
532 { 51, 707 }, { 52, 707 }, { 53, 707 }, { 54, 707 }, { 55, 707 },
533 { 56, 707 }, { 57, 707 }, { 58, 707 }, { 59, 707 }, { 60, 707 },
534 { 61, 707 }, { 62, 707 }, { 63, 707 }, { 64, 707 }, { 65, 707 },
535 { 66, 707 }, { 67, 707 }, { 68, 707 }, { 69, 707 }, { 70, 707 },
536 { 71, 707 }, { 72, 707 }, { 73, 707 }, { 74, 707 }, { 75, 707 },
537 { 76, 707 }, { 77, 707 }, { 78, 707 }, { 79, 707 }, { 80, 707 },
538
539 { 81, 707 }, { 82, 707 }, { 83, 707 }, { 84, 707 }, { 85, 707 },
540 { 86, 707 }, { 87, 707 }, { 88, 707 }, { 89, 707 }, { 90, 707 },
541 { 91, 707 }, { 92, 964 }, { 93, 540 }, { 94, 707 }, { 95, 707 },
542 { 96, 707 }, { 97, 707 }, { 98, 707 }, { 99, 707 }, { 100, 707 },
543 { 101, 707 }, { 102, 707 }, { 103, 707 }, { 104, 707 }, { 105, 707 },
544 { 106, 707 }, { 107, 707 }, { 108, 707 }, { 109, 707 }, { 110, 707 },
545 { 111, 707 }, { 112, 707 }, { 113, 707 }, { 114, 707 }, { 115, 707 },
546 { 116, 707 }, { 117, 707 }, { 118, 707 }, { 119, 707 }, { 120, 707 },
547 { 121, 707 }, { 122, 707 }, { 123, 707 }, { 124, 707 }, { 125, 707 },
548 { 126, 707 }, { 127, 707 }, { 128, 707 }, { 129, 707 }, { 130, 707 },
549
550 { 131, 707 }, { 132, 707 }, { 133, 707 }, { 134, 707 }, { 135, 707 },
551 { 136, 707 }, { 137, 707 }, { 138, 707 }, { 139, 707 }, { 140, 707 },
552 { 141, 707 }, { 142, 707 }, { 143, 707 }, { 144, 707 }, { 145, 707 },
553 { 146, 707 }, { 147, 707 }, { 148, 707 }, { 149, 707 }, { 150, 707 },
554 { 151, 707 }, { 152, 707 }, { 153, 707 }, { 154, 707 }, { 155, 707 },
555 { 156, 707 }, { 157, 707 }, { 158, 707 }, { 159, 707 }, { 160, 707 },
556 { 161, 707 }, { 162, 707 }, { 163, 707 }, { 164, 707 }, { 165, 707 },
557 { 166, 707 }, { 167, 707 }, { 168, 707 }, { 169, 707 }, { 170, 707 },
558 { 171, 707 }, { 172, 707 }, { 173, 707 }, { 174, 707 }, { 175, 707 },
559 { 176, 707 }, { 177, 707 }, { 178, 707 }, { 179, 707 }, { 180, 707 },
560
561 { 181, 707 }, { 182, 707 }, { 183, 707 }, { 184, 707 }, { 185, 707 },
562 { 186, 707 }, { 187, 707 }, { 188, 707 }, { 189, 707 }, { 190, 707 },
563 { 191, 707 }, { 192, 707 }, { 193, 707 }, { 194, 707 }, { 195, 707 },
564 { 196, 707 }, { 197, 707 }, { 198, 707 }, { 199, 707 }, { 200, 707 },
565 { 201, 707 }, { 202, 707 }, { 203, 707 }, { 204, 707 }, { 205, 707 },
566 { 206, 707 }, { 207, 707 }, { 208, 707 }, { 209, 707 }, { 210, 707 },
567 { 211, 707 }, { 212, 707 }, { 213, 707 }, { 214, 707 }, { 215, 707 },
568 { 216, 707 }, { 217, 707 }, { 218, 707 }, { 219, 707 }, { 220, 707 },
569 { 221, 707 }, { 222, 707 }, { 223, 707 }, { 224, 707 }, { 225, 707 },
570 { 226, 707 }, { 227, 707 }, { 228, 707 }, { 229, 707 }, { 230, 707 },
571
572 { 231, 707 }, { 232, 707 }, { 233, 707 }, { 234, 707 }, { 235, 707 },
573 { 236, 707 }, { 237, 707 }, { 238, 707 }, { 239, 707 }, { 240, 707 },
574 { 241, 707 }, { 242, 707 }, { 243, 707 }, { 244, 707 }, { 245, 707 },
575 { 246, 707 }, { 247, 707 }, { 248, 707 }, { 249, 707 }, { 250, 707 },
576 { 251, 707 }, { 252, 707 }, { 253, 707 }, { 254, 707 }, { 255, 707 },
577 { 256, 542 }, { 0, 0 }, { 0,1813 }, { 1, 449 }, { 2, 449 },
578 { 3, 449 }, { 4, 449 }, { 5, 449 }, { 6, 449 }, { 7, 449 },
579 { 8, 449 }, { 9, 449 }, { 10, 449 }, { 11, 449 }, { 12, 449 },
580 { 13, 449 }, { 14, 449 }, { 15, 449 }, { 16, 449 }, { 17, 449 },
581 { 18, 449 }, { 19, 449 }, { 20, 449 }, { 21, 449 }, { 22, 449 },
582
583 { 23, 449 }, { 24, 449 }, { 25, 449 }, { 26, 449 }, { 27, 449 },
584 { 28, 449 }, { 29, 449 }, { 30, 449 }, { 31, 449 }, { 32, 449 },
585 { 33, 449 }, { 34, 449 }, { 35, 449 }, { 36, 449 }, { 37, 449 },
586 { 38, 449 }, { 39, 449 }, { 40, 449 }, { 41, 449 }, { 42, 449 },
587 { 43, 449 }, { 44, 449 }, { 45, 449 }, { 46, 449 }, { 47, 449 },
588 { 48, 449 }, { 49, 449 }, { 50, 449 }, { 51, 449 }, { 52, 449 },
589 { 53, 449 }, { 54, 449 }, { 55, 449 }, { 56, 449 }, { 57, 449 },
590 { 58, 449 }, { 59, 449 }, { 60, 449 }, { 61, 449 }, { 62, 449 },
591 { 63, 449 }, { 64, 449 }, { 65, 449 }, { 66, 449 }, { 67, 449 },
592 { 68, 449 }, { 69, 449 }, { 70, 449 }, { 71, 449 }, { 72, 449 },
593
594 { 73, 449 }, { 74, 449 }, { 75, 449 }, { 76, 449 }, { 77, 449 },
595 { 78, 449 }, { 79, 449 }, { 80, 449 }, { 81, 449 }, { 82, 449 },
596 { 83, 449 }, { 84, 449 }, { 85, 449 }, { 86, 449 }, { 87, 449 },
597 { 88, 449 }, { 89, 449 }, { 90, 449 }, { 91, 449 }, { 92, 706 },
598 { 93, 282 }, { 94, 449 }, { 95, 449 }, { 96, 449 }, { 97, 449 },
599 { 98, 449 }, { 99, 449 }, { 100, 449 }, { 101, 449 }, { 102, 449 },
600 { 103, 449 }, { 104, 449 }, { 105, 449 }, { 106, 449 }, { 107, 449 },
601 { 108, 449 }, { 109, 449 }, { 110, 449 }, { 111, 449 }, { 112, 449 },
602 { 113, 449 }, { 114, 449 }, { 115, 449 }, { 116, 449 }, { 117, 449 },
603 { 118, 449 }, { 119, 449 }, { 120, 449 }, { 121, 449 }, { 122, 449 },
604
605 { 123, 449 }, { 124, 449 }, { 125, 449 }, { 126, 449 }, { 127, 449 },
606 { 128, 449 }, { 129, 449 }, { 130, 449 }, { 131, 449 }, { 132, 449 },
607 { 133, 449 }, { 134, 449 }, { 135, 449 }, { 136, 449 }, { 137, 449 },
608 { 138, 449 }, { 139, 449 }, { 140, 449 }, { 141, 449 }, { 142, 449 },
609 { 143, 449 }, { 144, 449 }, { 145, 449 }, { 146, 449 }, { 147, 449 },
610 { 148, 449 }, { 149, 449 }, { 150, 449 }, { 151, 449 }, { 152, 449 },
611 { 153, 449 }, { 154, 449 }, { 155, 449 }, { 156, 449 }, { 157, 449 },
612 { 158, 449 }, { 159, 449 }, { 160, 449 }, { 161, 449 }, { 162, 449 },
613 { 163, 449 }, { 164, 449 }, { 165, 449 }, { 166, 449 }, { 167, 449 },
614 { 168, 449 }, { 169, 449 }, { 170, 449 }, { 171, 449 }, { 172, 449 },
615
616 { 173, 449 }, { 174, 449 }, { 175, 449 }, { 176, 449 }, { 177, 449 },
617 { 178, 449 }, { 179, 449 }, { 180, 449 }, { 181, 449 }, { 182, 449 },
618 { 183, 449 }, { 184, 449 }, { 185, 449 }, { 186, 449 }, { 187, 449 },
619 { 188, 449 }, { 189, 449 }, { 190, 449 }, { 191, 449 }, { 192, 449 },
620 { 193, 449 }, { 194, 449 }, { 195, 449 }, { 196, 449 }, { 197, 449 },
621 { 198, 449 }, { 199, 449 }, { 200, 449 }, { 201, 449 }, { 202, 449 },
622 { 203, 449 }, { 204, 449 }, { 205, 449 }, { 206, 449 }, { 207, 449 },
623 { 208, 449 }, { 209, 449 }, { 210, 449 }, { 211, 449 }, { 212, 449 },
624 { 213, 449 }, { 214, 449 }, { 215, 449 }, { 216, 449 }, { 217, 449 },
625 { 218, 449 }, { 219, 449 }, { 220, 449 }, { 221, 449 }, { 222, 449 },
626
627 { 223, 449 }, { 224, 449 }, { 225, 449 }, { 226, 449 }, { 227, 449 },
628 { 228, 449 }, { 229, 449 }, { 230, 449 }, { 231, 449 }, { 232, 449 },
629 { 233, 449 }, { 234, 449 }, { 235, 449 }, { 236, 449 }, { 237, 449 },
630 { 238, 449 }, { 239, 449 }, { 240, 449 }, { 241, 449 }, { 242, 449 },
631 { 243, 449 }, { 244, 449 }, { 245, 449 }, { 246, 449 }, { 247, 449 },
632 { 248, 449 }, { 249, 449 }, { 250, 449 }, { 251, 449 }, { 252, 449 },
633 { 253, 449 }, { 254, 449 }, { 255, 449 }, { 256, 284 }, { 0, 6 },
634 { 0,1555 }, { 0, 1 }, { 0,1553 }, { 0, 2 }, { 0,1551 },
635 { 0, 0 }, { 0, 1 }, { 0,1548 }, { 0, 3 }, { 0,1546 },
636 { 0, 0 }, { 9, 704 }, { 10, 704 }, { 11, 704 }, { 12, 704 },
637
638 { 13, 704 }, { 9, 699 }, { 10, 699 }, { 11, 699 }, { 12, 699 },
639 { 13, 699 }, { 0, 5 }, { 0,1533 }, { 0, 10 }, { 0,1531 },
640 { 0, 7 }, { 0,1529 }, { 0, 12 }, { 0,1527 }, { 0, 9 },
641 { 0,1525 }, { 0, 8 }, { 0,1523 }, { 0, 0 }, { 32, 704 },
642 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 32, 699 },
643 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
644 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
645 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
646 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
647 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
648
649 { 0, 0 }, { 0, 4 }, { 0,1488 }, { 0, 0 }, { 0, 0 },
650 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 65, 699 },
651 { 66, 699 }, { 67, 699 }, { 68, 699 }, { 69, 699 }, { 70, 699 },
652 { 71, 699 }, { 72, 699 }, { 73, 699 }, { 74, 699 }, { 75, 699 },
653 { 76, 699 }, { 77, 699 }, { 78, 699 }, { 79, 699 }, { 80, 699 },
654 { 81, 699 }, { 82, 699 }, { 83, 699 }, { 84, 699 }, { 85, 699 },
655 { 86, 699 }, { 87, 699 }, { 88, 699 }, { 89, 699 }, { 90, 699 },
656 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
657 { 0, 0 }, { 97, 757 }, { 98, 757 }, { 99, 757 }, { 100, 757 },
658 { 101, 757 }, { 102, 757 }, { 103, 757 }, { 104, 757 }, { 105, 757 },
659
660 { 106, 757 }, { 107, 757 }, { 108, 757 }, { 109, 757 }, { 110, 757 },
661 { 111, 757 }, { 112, 757 }, { 113, 757 }, { 114, 757 }, { 115, 757 },
662 { 116, 757 }, { 117, 757 }, { 118, 757 }, { 119, 757 }, { 120, 757 },
663 { 121, 757 }, { 122, 757 }, { 65, 791 }, { 66, 791 }, { 67, 791 },
664 { 68, 791 }, { 69, 791 }, { 70, 791 }, { 71, 791 }, { 72, 791 },
665 { 73, 791 }, { 74, 791 }, { 75, 791 }, { 76, 791 }, { 77, 791 },
666 { 78, 791 }, { 79, 791 }, { 80, 791 }, { 81, 791 }, { 82, 791 },
667 { 83, 791 }, { 84, 791 }, { 85, 791 }, { 86, 791 }, { 87, 791 },
668 { 88, 791 }, { 89, 791 }, { 90, 791 }, { 0, 0 }, { 0, 0 },
669 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 97, 849 },
670
671 { 98, 849 }, { 99, 849 }, { 100, 849 }, { 101, 849 }, { 102, 849 },
672 { 103, 849 }, { 104, 849 }, { 105, 849 }, { 106, 849 }, { 107, 849 },
673 { 108, 849 }, { 109, 849 }, { 110, 849 }, { 111, 849 }, { 112, 849 },
674 { 113, 849 }, { 114, 849 }, { 115, 849 }, { 116, 849 }, { 117, 849 },
675 { 118, 849 }, { 119, 849 }, { 120, 849 }, { 121, 849 }, { 122, 849 },
676 { 0, 11 }, { 0,1364 }, { 1, 849 }, { 2, 849 }, { 3, 849 },
677 { 4, 849 }, { 5, 849 }, { 6, 849 }, { 7, 849 }, { 8, 849 },
678 { 9, 849 }, { 10, 849 }, { 11, 849 }, { 12, 849 }, { 13, 849 },
679 { 14, 849 }, { 15, 849 }, { 16, 849 }, { 17, 849 }, { 18, 849 },
680 { 19, 849 }, { 20, 849 }, { 21, 849 }, { 22, 849 }, { 23, 849 },
681
682 { 24, 849 }, { 25, 849 }, { 26, 849 }, { 27, 849 }, { 28, 849 },
683 { 29, 849 }, { 30, 849 }, { 31, 849 }, { 32, 849 }, { 33, 849 },
684 { 34, 849 }, { 35, 849 }, { 36, 849 }, { 37, 849 }, { 38, 849 },
685 { 39, 849 }, { 40, 849 }, { 41, 849 }, { 42, 849 }, { 43, 849 },
686 { 44, 849 }, { 45, 849 }, { 46, 849 }, { 47, 849 }, { 48, 849 },
687 { 49, 849 }, { 50, 849 }, { 51, 849 }, { 52, 849 }, { 53, 849 },
688 { 54, 849 }, { 55, 849 }, { 56, 849 }, { 57, 849 }, { 58, 849 },
689 { 59, 849 }, { 60, 849 }, { 61, 849 }, { 62, 849 }, { 63, 849 },
690 { 64, 849 }, { 65, 849 }, { 66, 849 }, { 67, 849 }, { 68, 849 },
691 { 69, 849 }, { 70, 849 }, { 71, 849 }, { 72, 849 }, { 73, 849 },
692
693 { 74, 849 }, { 75, 849 }, { 76, 849 }, { 77, 849 }, { 78, 849 },
694 { 79, 849 }, { 80, 849 }, { 81, 849 }, { 82, 849 }, { 83, 849 },
695 { 84, 849 }, { 85, 849 }, { 86, 849 }, { 87, 849 }, { 88, 849 },
696 { 89, 849 }, { 90, 849 }, { 91, 849 }, { 0, 0 }, { 0, 0 },
697 { 94, 849 }, { 95, 849 }, { 96, 849 }, { 97, 849 }, { 98, 849 },
698 { 99, 849 }, { 100, 849 }, { 101, 849 }, { 102, 849 }, { 103, 849 },
699 { 104, 849 }, { 105, 849 }, { 106, 849 }, { 107, 849 }, { 108, 849 },
700 { 109, 849 }, { 110, 849 }, { 111, 849 }, { 112, 849 }, { 113, 849 },
701 { 114, 849 }, { 115, 849 }, { 116, 849 }, { 117, 849 }, { 118, 849 },
702 { 119, 849 }, { 120, 849 }, { 121, 849 }, { 122, 849 }, { 123, 849 },
703
704 { 124, 849 }, { 125, 849 }, { 126, 849 }, { 127, 849 }, { 128, 849 },
705 { 129, 849 }, { 130, 849 }, { 131, 849 }, { 132, 849 }, { 133, 849 },
706 { 134, 849 }, { 135, 849 }, { 136, 849 }, { 137, 849 }, { 138, 849 },
707 { 139, 849 }, { 140, 849 }, { 141, 849 }, { 142, 849 }, { 143, 849 },
708 { 144, 849 }, { 145, 849 }, { 146, 849 }, { 147, 849 }, { 148, 849 },
709 { 149, 849 }, { 150, 849 }, { 151, 849 }, { 152, 849 }, { 153, 849 },
710 { 154, 849 }, { 155, 849 }, { 156, 849 }, { 157, 849 }, { 158, 849 },
711 { 159, 849 }, { 160, 849 }, { 161, 849 }, { 162, 849 }, { 163, 849 },
712 { 164, 849 }, { 165, 849 }, { 166, 849 }, { 167, 849 }, { 168, 849 },
713 { 169, 849 }, { 170, 849 }, { 171, 849 }, { 172, 849 }, { 173, 849 },
714
715 { 174, 849 }, { 175, 849 }, { 176, 849 }, { 177, 849 }, { 178, 849 },
716 { 179, 849 }, { 180, 849 }, { 181, 849 }, { 182, 849 }, { 183, 849 },
717 { 184, 849 }, { 185, 849 }, { 186, 849 }, { 187, 849 }, { 188, 849 },
718 { 189, 849 }, { 190, 849 }, { 191, 849 }, { 192, 849 }, { 193, 849 },
719 { 194, 849 }, { 195, 849 }, { 196, 849 }, { 197, 849 }, { 198, 849 },
720 { 199, 849 }, { 200, 849 }, { 201, 849 }, { 202, 849 }, { 203, 849 },
721 { 204, 849 }, { 205, 849 }, { 206, 849 }, { 207, 849 }, { 208, 849 },
722 { 209, 849 }, { 210, 849 }, { 211, 849 }, { 212, 849 }, { 213, 849 },
723 { 214, 849 }, { 215, 849 }, { 216, 849 }, { 217, 849 }, { 218, 849 },
724 { 219, 849 }, { 220, 849 }, { 221, 849 }, { 222, 849 }, { 223, 849 },
725
726 { 224, 849 }, { 225, 849 }, { 226, 849 }, { 227, 849 }, { 228, 849 },
727 { 229, 849 }, { 230, 849 }, { 231, 849 }, { 232, 849 }, { 233, 849 },
728 { 234, 849 }, { 235, 849 }, { 236, 849 }, { 237, 849 }, { 238, 849 },
729 { 239, 849 }, { 240, 849 }, { 241, 849 }, { 242, 849 }, { 243, 849 },
730 { 244, 849 }, { 245, 849 }, { 246, 849 }, { 247, 849 }, { 248, 849 },
731 { 249, 849 }, { 250, 849 }, { 251, 849 }, { 252, 849 }, { 253, 849 },
732 { 254, 849 }, { 255, 849 }, { 0, 12 }, { 0,1107 }, { 1,-420 },
733 { 2,-420 }, { 3,-420 }, { 4,-420 }, { 5,-420 }, { 6,-420 },
734 { 7,-420 }, { 8,-420 }, { 9,-420 }, { 10,-418 }, { 11,-420 },
735 { 12,-420 }, { 13,-420 }, { 14,-420 }, { 15,-420 }, { 16,-420 },
736
737 { 17,-420 }, { 18,-420 }, { 19,-420 }, { 20,-420 }, { 21,-420 },
738 { 22,-420 }, { 23,-420 }, { 24,-420 }, { 25,-420 }, { 26,-420 },
739 { 27,-420 }, { 28,-420 }, { 29,-420 }, { 30,-420 }, { 31,-420 },
740 { 32,-420 }, { 33,-420 }, { 34,-420 }, { 35,-420 }, { 36,-420 },
741 { 37,-420 }, { 38,-420 }, { 39,-420 }, { 40,-420 }, { 41,-420 },
742 { 42,-420 }, { 43,-420 }, { 44,-420 }, { 45,-420 }, { 46,-420 },
743 { 47,-420 }, { 48,-420 }, { 49,-420 }, { 50,-420 }, { 51,-420 },
744 { 52,-420 }, { 53,-420 }, { 54,-420 }, { 55,-420 }, { 56,-420 },
745 { 57,-420 }, { 58,-420 }, { 59,-420 }, { 60,-420 }, { 61,-420 },
746 { 62,-420 }, { 63,-420 }, { 64,-420 }, { 65,-420 }, { 66,-420 },
747
748 { 67,-420 }, { 68,-420 }, { 69,-420 }, { 70,-420 }, { 71,-420 },
749 { 72,-420 }, { 73,-420 }, { 74,-420 }, { 75,-420 }, { 76,-420 },
750 { 77,-420 }, { 78,-420 }, { 79,-420 }, { 80,-420 }, { 81,-420 },
751 { 82,-420 }, { 83,-420 }, { 84,-420 }, { 85,-420 }, { 86,-420 },
752 { 87,-420 }, { 88,-420 }, { 89,-420 }, { 90,-420 }, { 91,-420 },
753 { 92,-420 }, { 93,-416 }, { 94,-420 }, { 95,-420 }, { 96,-420 },
754 { 97,-420 }, { 98,-420 }, { 99,-420 }, { 100,-420 }, { 101,-420 },
755 { 102,-420 }, { 103,-420 }, { 104,-420 }, { 105,-420 }, { 106,-420 },
756 { 107,-420 }, { 108,-420 }, { 109,-420 }, { 110,-420 }, { 111,-420 },
757 { 112,-420 }, { 113,-420 }, { 114,-420 }, { 115,-420 }, { 116,-420 },
758
759 { 117,-420 }, { 118,-420 }, { 119,-420 }, { 120,-420 }, { 121,-420 },
760 { 122,-420 }, { 123,-420 }, { 124,-420 }, { 125,-420 }, { 126,-420 },
761 { 127,-420 }, { 128,-420 }, { 129,-420 }, { 130,-420 }, { 131,-420 },
762 { 132,-420 }, { 133,-420 }, { 134,-420 }, { 135,-420 }, { 136,-420 },
763 { 137,-420 }, { 138,-420 }, { 139,-420 }, { 140,-420 }, { 141,-420 },
764 { 142,-420 }, { 143,-420 }, { 144,-420 }, { 145,-420 }, { 146,-420 },
765 { 147,-420 }, { 148,-420 }, { 149,-420 }, { 150,-420 }, { 151,-420 },
766 { 152,-420 }, { 153,-420 }, { 154,-420 }, { 155,-420 }, { 156,-420 },
767 { 157,-420 }, { 158,-420 }, { 159,-420 }, { 160,-420 }, { 161,-420 },
768 { 162,-420 }, { 163,-420 }, { 164,-420 }, { 165,-420 }, { 166,-420 },
769
770 { 167,-420 }, { 168,-420 }, { 169,-420 }, { 170,-420 }, { 171,-420 },
771 { 172,-420 }, { 173,-420 }, { 174,-420 }, { 175,-420 }, { 176,-420 },
772 { 177,-420 }, { 178,-420 }, { 179,-420 }, { 180,-420 }, { 181,-420 },
773 { 182,-420 }, { 183,-420 }, { 184,-420 }, { 185,-420 }, { 186,-420 },
774 { 187,-420 }, { 188,-420 }, { 189,-420 }, { 190,-420 }, { 191,-420 },
775 { 192,-420 }, { 193,-420 }, { 194,-420 }, { 195,-420 }, { 196,-420 },
776 { 197,-420 }, { 198,-420 }, { 199,-420 }, { 200,-420 }, { 201,-420 },
777 { 202,-420 }, { 203,-420 }, { 204,-420 }, { 205,-420 }, { 206,-420 },
778 { 207,-420 }, { 208,-420 }, { 209,-420 }, { 210,-420 }, { 211,-420 },
779 { 212,-420 }, { 213,-420 }, { 214,-420 }, { 215,-420 }, { 216,-420 },
780
781 { 217,-420 }, { 218,-420 }, { 219,-420 }, { 220,-420 }, { 221,-420 },
782 { 222,-420 }, { 223,-420 }, { 224,-420 }, { 225,-420 }, { 226,-420 },
783 { 227,-420 }, { 228,-420 }, { 229,-420 }, { 230,-420 }, { 231,-420 },
784 { 232,-420 }, { 233,-420 }, { 234,-420 }, { 235,-420 }, { 236,-420 },
785 { 237,-420 }, { 238,-420 }, { 239,-420 }, { 240,-420 }, { 241,-420 },
786 { 242,-420 }, { 243,-420 }, { 244,-420 }, { 245,-420 }, { 246,-420 },
787 { 247,-420 }, { 248,-420 }, { 249,-420 }, { 250,-420 }, { 251,-420 },
788 { 252,-420 }, { 253,-420 }, { 254,-420 }, { 255,-420 }, { 256,-420 },
789 { 0, 1 }, { 0, 849 }, { 0, 3 }, { 0, 847 }, { 0, 0 },
790 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
791
792 { 9, 0 }, { 10, 0 }, { 11, 0 }, { 12, 0 }, { 13, 0 },
793 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
794 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
795 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
796 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 32, 0 }, { 0, 0 },
797 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
798 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
799 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
800 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
801 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
802
803 { 0, 3 }, { 0, 789 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
804 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
805 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
806 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
807 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
808 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
809 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
810 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
811 { 97, 589 }, { 98, 589 }, { 99, 589 }, { 100, 589 }, { 101, 589 },
812 { 102, 589 }, { 103, 589 }, { 104, 589 }, { 105, 589 }, { 106, 589 },
813
814 { 107, 589 }, { 108, 589 }, { 109, 589 }, { 110, 589 }, { 111, 589 },
815 { 112, 589 }, { 113, 589 }, { 114, 589 }, { 115, 589 }, { 116, 589 },
816 { 117, 589 }, { 118, 589 }, { 119, 589 }, { 120, 589 }, { 121, 589 },
817 { 122, 589 }, { 65, -58 }, { 66, -58 }, { 67, -58 }, { 68, -58 },
818 { 69, -58 }, { 70, -58 }, { 71, -58 }, { 72, -58 }, { 73, -58 },
819 { 74, -58 }, { 75, -58 }, { 76, -58 }, { 77, -58 }, { 78, -58 },
820 { 79, -58 }, { 80, -58 }, { 81, -58 }, { 82, -58 }, { 83, -58 },
821 { 84, -58 }, { 85, -58 }, { 86, -58 }, { 87, -58 }, { 88, -58 },
822 { 89, -58 }, { 90, -58 }, { 0, 3 }, { 0, 697 }, { 0, 0 },
823 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 97, 0 }, { 98, 0 },
824
825 { 99, 0 }, { 100, 0 }, { 101, 0 }, { 102, 0 }, { 103, 0 },
826 { 104, 0 }, { 105, 0 }, { 106, 0 }, { 107, 0 }, { 108, 0 },
827 { 109, 0 }, { 110, 0 }, { 111, 0 }, { 112, 0 }, { 113, 0 },
828 { 114, 0 }, { 115, 0 }, { 116, 0 }, { 117, 0 }, { 118, 0 },
829 { 119, 0 }, { 120, 0 }, { 121, 0 }, { 122, 0 }, { 0, 0 },
830 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
831 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
832 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
833 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
834 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
835
836 { 0, 4 }, { 0, 639 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
837 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 65,-150 }, { 66,-150 },
838 { 67,-150 }, { 68,-150 }, { 69,-150 }, { 70,-150 }, { 71,-150 },
839 { 72,-150 }, { 73,-150 }, { 74,-150 }, { 75,-150 }, { 76,-150 },
840 { 77,-150 }, { 78,-150 }, { 79,-150 }, { 80,-150 }, { 81,-150 },
841 { 82,-150 }, { 83,-150 }, { 84,-150 }, { 85,-150 }, { 86,-150 },
842 { 87,-150 }, { 88,-150 }, { 89,-150 }, { 90,-150 }, { 0, 0 },
843 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
844 { 97, -92 }, { 98, -92 }, { 99, -92 }, { 100, -92 }, { 101, -92 },
845 { 102, -92 }, { 103, -92 }, { 104, -92 }, { 105, -92 }, { 106, -92 },
846
847 { 107, -92 }, { 108, -92 }, { 109, -92 }, { 110, -92 }, { 111, -92 },
848 { 112, -92 }, { 113, -92 }, { 114, -92 }, { 115, -92 }, { 116, -92 },
849 { 117, -92 }, { 118, -92 }, { 119, -92 }, { 120, -92 }, { 121, -92 },
850 { 122, -92 }, { 65, -58 }, { 66, -58 }, { 67, -58 }, { 68, -58 },
851 { 69, -58 }, { 70, -58 }, { 71, -58 }, { 72, -58 }, { 73, -58 },
852 { 74, -58 }, { 75, -58 }, { 76, -58 }, { 77, -58 }, { 78, -58 },
853 { 79, -58 }, { 80, -58 }, { 81, -58 }, { 82, -58 }, { 83, -58 },
854 { 84, -58 }, { 85, -58 }, { 86, -58 }, { 87, -58 }, { 88, -58 },
855 { 89, -58 }, { 90, -58 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
856 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 97, 0 }, { 98, 0 },
857
858 { 99, 0 }, { 100, 0 }, { 101, 0 }, { 102, 0 }, { 103, 0 },
859 { 104, 0 }, { 105, 0 }, { 106, 0 }, { 107, 0 }, { 108, 0 },
860 { 109, 0 }, { 110, 0 }, { 111, 0 }, { 112, 0 }, { 113, 0 },
861 { 114, 0 }, { 115, 0 }, { 116, 0 }, { 117, 0 }, { 118, 0 },
862 { 119, 0 }, { 120, 0 }, { 121, 0 }, { 122, 0 }, { 0, 11 },
863 { 0, 515 }, { 1, 0 }, { 2, 0 }, { 3, 0 }, { 4, 0 },
864 { 5, 0 }, { 6, 0 }, { 7, 0 }, { 8, 0 }, { 9, 0 },
865 { 10, 0 }, { 11, 0 }, { 12, 0 }, { 13, 0 }, { 14, 0 },
866 { 15, 0 }, { 16, 0 }, { 17, 0 }, { 18, 0 }, { 19, 0 },
867 { 20, 0 }, { 21, 0 }, { 22, 0 }, { 23, 0 }, { 24, 0 },
868
869 { 25, 0 }, { 26, 0 }, { 27, 0 }, { 28, 0 }, { 29, 0 },
870 { 30, 0 }, { 31, 0 }, { 32, 0 }, { 33, 0 }, { 34, 0 },
871 { 35, 0 }, { 36, 0 }, { 37, 0 }, { 38, 0 }, { 39, 0 },
872 { 40, 0 }, { 41, 0 }, { 42, 0 }, { 43, 0 }, { 44, 0 },
873 { 45, 0 }, { 46, 0 }, { 47, 0 }, { 48, 0 }, { 49, 0 },
874 { 50, 0 }, { 51, 0 }, { 52, 0 }, { 53, 0 }, { 54, 0 },
875 { 55, 0 }, { 56, 0 }, { 57, 0 }, { 58, 0 }, { 59, 0 },
876 { 60, 0 }, { 61, 0 }, { 62, 0 }, { 63, 0 }, { 64, 0 },
877 { 65, 0 }, { 66, 0 }, { 67, 0 }, { 68, 0 }, { 69, 0 },
878 { 70, 0 }, { 71, 0 }, { 72, 0 }, { 73, 0 }, { 74, 0 },
879
880 { 75, 0 }, { 76, 0 }, { 77, 0 }, { 78, 0 }, { 79, 0 },
881 { 80, 0 }, { 81, 0 }, { 82, 0 }, { 83, 0 }, { 84, 0 },
882 { 85, 0 }, { 86, 0 }, { 87, 0 }, { 88, 0 }, { 89, 0 },
883 { 90, 0 }, { 91, 0 }, { 0, 0 }, { 0, 0 }, { 94, 0 },
884 { 95, 0 }, { 96, 0 }, { 97, 0 }, { 98, 0 }, { 99, 0 },
885 { 100, 0 }, { 101, 0 }, { 102, 0 }, { 103, 0 }, { 104, 0 },
886 { 105, 0 }, { 106, 0 }, { 107, 0 }, { 108, 0 }, { 109, 0 },
887 { 110, 0 }, { 111, 0 }, { 112, 0 }, { 113, 0 }, { 114, 0 },
888 { 115, 0 }, { 116, 0 }, { 117, 0 }, { 118, 0 }, { 119, 0 },
889 { 120, 0 }, { 121, 0 }, { 122, 0 }, { 123, 0 }, { 124, 0 },
890
891 { 125, 0 }, { 126, 0 }, { 127, 0 }, { 128, 0 }, { 129, 0 },
892 { 130, 0 }, { 131, 0 }, { 132, 0 }, { 133, 0 }, { 134, 0 },
893 { 135, 0 }, { 136, 0 }, { 137, 0 }, { 138, 0 }, { 139, 0 },
894 { 140, 0 }, { 141, 0 }, { 142, 0 }, { 143, 0 }, { 144, 0 },
895 { 145, 0 }, { 146, 0 }, { 147, 0 }, { 148, 0 }, { 149, 0 },
896 { 150, 0 }, { 151, 0 }, { 152, 0 }, { 153, 0 }, { 154, 0 },
897 { 155, 0 }, { 156, 0 }, { 157, 0 }, { 158, 0 }, { 159, 0 },
898 { 160, 0 }, { 161, 0 }, { 162, 0 }, { 163, 0 }, { 164, 0 },
899 { 165, 0 }, { 166, 0 }, { 167, 0 }, { 168, 0 }, { 169, 0 },
900 { 170, 0 }, { 171, 0 }, { 172, 0 }, { 173, 0 }, { 174, 0 },
901
902 { 175, 0 }, { 176, 0 }, { 177, 0 }, { 178, 0 }, { 179, 0 },
903 { 180, 0 }, { 181, 0 }, { 182, 0 }, { 183, 0 }, { 184, 0 },
904 { 185, 0 }, { 186, 0 }, { 187, 0 }, { 188, 0 }, { 189, 0 },
905 { 190, 0 }, { 191, 0 }, { 192, 0 }, { 193, 0 }, { 194, 0 },
906 { 195, 0 }, { 196, 0 }, { 197, 0 }, { 198, 0 }, { 199, 0 },
907 { 200, 0 }, { 201, 0 }, { 202, 0 }, { 203, 0 }, { 204, 0 },
908 { 205, 0 }, { 206, 0 }, { 207, 0 }, { 208, 0 }, { 209, 0 },
909 { 210, 0 }, { 211, 0 }, { 212, 0 }, { 213, 0 }, { 214, 0 },
910 { 215, 0 }, { 216, 0 }, { 217, 0 }, { 218, 0 }, { 219, 0 },
911 { 220, 0 }, { 221, 0 }, { 222, 0 }, { 223, 0 }, { 224, 0 },
912
913 { 225, 0 }, { 226, 0 }, { 227, 0 }, { 228, 0 }, { 229, 0 },
914 { 230, 0 }, { 231, 0 }, { 232, 0 }, { 233, 0 }, { 234, 0 },
915 { 235, 0 }, { 236, 0 }, { 237, 0 }, { 238, 0 }, { 239, 0 },
916 { 240, 0 }, { 241, 0 }, { 242, 0 }, { 243, 0 }, { 244, 0 },
917 { 245, 0 }, { 246, 0 }, { 247, 0 }, { 248, 0 }, { 249, 0 },
918 { 250, 0 }, { 251, 0 }, { 252, 0 }, { 253, 0 }, { 254, 0 },
919 { 255, 0 }, { 0, 3 }, { 0, 258 }, { 0, 0 }, { 0, 0 },
920 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
921 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
922 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
923
924 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
925 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
926 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
927 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
928 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
929 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
930 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
931 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
932 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
933 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
934
935 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
936 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
937 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
938 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
939 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
940 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 97, 0 },
941 { 98, 0 }, { 99, 0 }, { 100, 0 }, { 101, 0 }, { 102, 0 },
942 { 103, 0 }, { 104, 0 }, { 105, 0 }, { 106, 0 }, { 107, 0 },
943 { 108, 0 }, { 109, 0 }, { 110, 0 }, { 111, 0 }, { 112, 0 },
944 { 113, 0 }, { 114, 0 }, { 115, 0 }, { 116, 0 }, { 117, 0 },
945
946 { 118, 0 }, { 119, 0 }, { 120, 0 }, { 121, 0 }, { 122, 0 },
947 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
948 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
949 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
950 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
951 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
952 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
953 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
954 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
955 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
956
957 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
958 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
959 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
960 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
961 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
962 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
963 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
964 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
965 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
966 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
967
968 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
969 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
970 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
971 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
972 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
973 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
974 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
975 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 257, 14 },
976 { 1, 0 }, };
977
978 static yyconst struct yy_trans_info *yy_start_state_list[5] =
979 {
980 &yy_transition[1],
981 &yy_transition[3],
982 &yy_transition[261],
983 &yy_transition[519],
984 &yy_transition[777],
985
986 } ;
987
988 extern int sgf_flex_debug;
989 int sgf_flex_debug = 0;
990
991 /* The intent behind this definition is that it'll catch
992 * any uses of REJECT which flex missed.
993 */
994 #define REJECT reject_used_but_not_detected
995 #define yymore() yymore_used_but_not_detected
996 #define YY_MORE_ADJ 0
997 #define YY_RESTORE_YY_MORE_OFFSET
998 char *sgftext;
999 #line 1 "sgf_l.l"
1000 /*
1001 * sgf.l
1002 *
1003 * by Gary Wong <gtw@gnu.org>, 2000.
1004 *
1005 * This program is free software; you can redistribute it and/or modify
1006 * it under the terms of version 3 or later of the GNU General Public License as
1007 * published by the Free Software Foundation.
1008 *
1009 * This program is distributed in the hope that it will be useful,
1010 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1011 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1012 * GNU General Public License for more details.
1013 *
1014 * You should have received a copy of the GNU General Public License
1015 * along with this program; if not, write to the Free Software
1016 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1017 *
1018 * $Id: sgf_l.l,v 1.2 2015/10/08 00:29:39 mdpetch Exp $
1019 */
1020 #line 23 "sgf_l.l"
1021 #include "common.h"
1022 #include <ctype.h>
1023 #include "list.h"
1024 #include <string.h>
1025
1026 #include "sgf.h"
1027 #include "sgf_y.h"
1028 #include <glib/gi18n.h>
1029
1030 extern int _SGFWarning( char * );
1031
error(char * s)1032 static int error( char *s ) {
1033
1034 /* refer to yy_fatal_error, to shut up the compiler */
1035 (void) yy_fatal_error;
1036
1037 if( SGFErrorHandler )
1038 SGFErrorHandler( s, 0 );
1039 else
1040 fprintf( stderr, "%s\n", s );
1041
1042 return 0;
1043 }
1044
1045 #define YY_FATAL_ERROR(m) error(m)
1046 #define YY_NO_INPUT 1
1047
1048 #line 1049 "sgf_l.c"
1049
1050 #define INITIAL 0
1051 #define value 1
1052
1053 #ifndef YY_NO_UNISTD_H
1054 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1055 * down here because we want the user's section 1 to have been scanned first.
1056 * The user has a chance to override it with an option.
1057 */
1058 #include <unistd.h>
1059 #endif
1060
1061 #ifndef YY_EXTRA_TYPE
1062 #define YY_EXTRA_TYPE void *
1063 #endif
1064
1065 static int yy_init_globals (void );
1066
1067 /* Accessor methods to globals.
1068 These are made visible to non-reentrant scanners for convenience. */
1069
1070 int sgflex_destroy (void );
1071
1072 int sgfget_debug (void );
1073
1074 void sgfset_debug (int debug_flag );
1075
1076 YY_EXTRA_TYPE sgfget_extra (void );
1077
1078 void sgfset_extra (YY_EXTRA_TYPE user_defined );
1079
1080 FILE *sgfget_in (void );
1081
1082 void sgfset_in (FILE * in_str );
1083
1084 FILE *sgfget_out (void );
1085
1086 void sgfset_out (FILE * out_str );
1087
1088 yy_size_t sgfget_leng (void );
1089
1090 char *sgfget_text (void );
1091
1092 int sgfget_lineno (void );
1093
1094 void sgfset_lineno (int line_number );
1095
1096 /* Macros after this point can all be overridden by user definitions in
1097 * section 1.
1098 */
1099
1100 #ifndef YY_SKIP_YYWRAP
1101 #ifdef __cplusplus
1102 extern "C" int sgfwrap (void );
1103 #else
1104 extern int sgfwrap (void );
1105 #endif
1106 #endif
1107
1108 #ifndef yytext_ptr
1109 static void yy_flex_strncpy (char *,yyconst char *,int );
1110 #endif
1111
1112 #ifdef YY_NEED_STRLEN
1113 static int yy_flex_strlen (yyconst char * );
1114 #endif
1115
1116 #ifndef YY_NO_INPUT
1117
1118 #ifdef __cplusplus
1119 static int yyinput (void );
1120 #else
1121 static int input (void );
1122 #endif
1123
1124 #endif
1125
1126 /* Amount of stuff to slurp up with each read. */
1127 #ifndef YY_READ_BUF_SIZE
1128 #define YY_READ_BUF_SIZE 8192
1129 #endif
1130
1131 /* Copy whatever the last rule matched to the standard output. */
1132 #ifndef ECHO
1133 /* This used to be an fputs(), but since the string might contain NUL's,
1134 * we now use fwrite().
1135 */
1136 #define ECHO do { if (fwrite( sgftext, sgfleng, 1, sgfout )) {} } while (0)
1137 #endif
1138
1139 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1140 * is returned in "result".
1141 */
1142 #ifndef YY_INPUT
1143 #define YY_INPUT(buf,result,max_size) \
1144 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1145 { \
1146 int c = '*'; \
1147 size_t n; \
1148 for ( n = 0; n < max_size && \
1149 (c = getc( sgfin )) != EOF && c != '\n'; ++n ) \
1150 buf[n] = (char) c; \
1151 if ( c == '\n' ) \
1152 buf[n++] = (char) c; \
1153 if ( c == EOF && ferror( sgfin ) ) \
1154 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1155 result = n; \
1156 } \
1157 else \
1158 { \
1159 errno=0; \
1160 while ( (result = fread(buf, 1, max_size, sgfin))==0 && ferror(sgfin)) \
1161 { \
1162 if( errno != EINTR) \
1163 { \
1164 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1165 break; \
1166 } \
1167 errno=0; \
1168 clearerr(sgfin); \
1169 } \
1170 }\
1171 \
1172
1173 #endif
1174
1175 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1176 * we don't want an extra ';' after the "return" because that will cause
1177 * some compilers to complain about unreachable statements.
1178 */
1179 #ifndef yyterminate
1180 #define yyterminate() return YY_NULL
1181 #endif
1182
1183 /* Number of entries by which start-condition stack grows. */
1184 #ifndef YY_START_STACK_INCR
1185 #define YY_START_STACK_INCR 25
1186 #endif
1187
1188 /* Report a fatal error. */
1189 #ifndef YY_FATAL_ERROR
1190 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1191 #endif
1192
1193 /* end tables serialization structures and prototypes */
1194
1195 /* Default declaration of generated scanner - a define so the user can
1196 * easily add parameters.
1197 */
1198 #ifndef YY_DECL
1199 #define YY_DECL_IS_OURS 1
1200
1201 extern int sgflex (void);
1202
1203 #define YY_DECL int sgflex (void)
1204 #endif /* !YY_DECL */
1205
1206 /* Code executed at the beginning of each rule, after sgftext and sgfleng
1207 * have been set up.
1208 */
1209 #ifndef YY_USER_ACTION
1210 #define YY_USER_ACTION
1211 #endif
1212
1213 /* Code executed at the end of each rule. */
1214 #ifndef YY_BREAK
1215 #define YY_BREAK break;
1216 #endif
1217
1218 #define YY_RULE_SETUP \
1219 YY_USER_ACTION
1220
1221 /** The main scanner function which does all the work.
1222 */
1223 YY_DECL
1224 {
1225 yy_state_type yy_current_state;
1226 char *yy_cp, *yy_bp;
1227 int yy_act;
1228
1229 #line 67 "sgf_l.l"
1230
1231 #line 1232 "sgf_l.c"
1232
1233 if ( !(yy_init) )
1234 {
1235 (yy_init) = 1;
1236
1237 #ifdef YY_USER_INIT
1238 YY_USER_INIT;
1239 #endif
1240
1241 if ( ! (yy_start) )
1242 (yy_start) = 1; /* first start state */
1243
1244 if ( ! sgfin )
1245 sgfin = stdin;
1246
1247 if ( ! sgfout )
1248 sgfout = stdout;
1249
1250 if ( ! YY_CURRENT_BUFFER ) {
1251 sgfensure_buffer_stack ();
1252 YY_CURRENT_BUFFER_LVALUE =
1253 sgf_create_buffer(sgfin,YY_BUF_SIZE );
1254 }
1255
1256 sgf_load_buffer_state( );
1257 }
1258
1259 while ( 1 ) /* loops until end-of-file is reached */
1260 {
1261 yy_cp = (yy_c_buf_p);
1262
1263 /* Support of sgftext. */
1264 *yy_cp = (yy_hold_char);
1265
1266 /* yy_bp points to the position in yy_ch_buf of the start of
1267 * the current run.
1268 */
1269 yy_bp = yy_cp;
1270
1271 yy_current_state = yy_start_state_list[(yy_start)];
1272 yy_match:
1273 {
1274 yyconst struct yy_trans_info *yy_trans_info;
1275
1276 YY_CHAR yy_c;
1277
1278 for ( yy_c = YY_SC_TO_UI(*yy_cp);
1279 (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->
1280 yy_verify == yy_c;
1281 yy_c = YY_SC_TO_UI(*++yy_cp) )
1282 yy_current_state += yy_trans_info->yy_nxt;
1283 }
1284
1285 yy_find_action:
1286 yy_act = yy_current_state[-1].yy_nxt;
1287
1288 YY_DO_BEFORE_ACTION;
1289
1290 do_action: /* This label is used only to access EOF actions. */
1291
1292 switch ( yy_act )
1293 { /* beginning of action switch */
1294 case 1:
1295 /* rule 1 can match eol */
1296 YY_RULE_SETUP
1297 #line 68 "sgf_l.l"
1298 /* ignore */
1299 YY_BREAK
1300 case 2:
1301 YY_RULE_SETUP
1302 #line 69 "sgf_l.l"
1303 return *sgftext;
1304 YY_BREAK
1305 case 3:
1306 YY_RULE_SETUP
1307 #line 70 "sgf_l.l"
1308 {
1309 char *pch;
1310
1311 sgflval.ach[ 1 ] = 0;
1312
1313 for( pch = sgftext; *pch; pch++ )
1314 if( isupper( *pch ) ) {
1315 sgflval.ach[ 0 ] = *pch;
1316 break;
1317 }
1318
1319 for( pch++; *pch; pch++ )
1320 if( isupper( *pch ) ) {
1321 sgflval.ach[ 1 ] = *pch;
1322 break;
1323 }
1324
1325 return PROPERTY;
1326 }
1327 YY_BREAK
1328 case 4:
1329 YY_RULE_SETUP
1330 #line 89 "sgf_l.l"
1331 /* ignore -- this rule avoids making flex back up */
1332 YY_BREAK
1333 case 5:
1334 YY_RULE_SETUP
1335 #line 90 "sgf_l.l"
1336 BEGIN(value); return '[';
1337 YY_BREAK
1338 case 6:
1339 YY_RULE_SETUP
1340 #line 91 "sgf_l.l"
1341 { error( _("illegal character in SGF file" )); }
1342 YY_BREAK
1343 case 7:
1344 YY_RULE_SETUP
1345 #line 93 "sgf_l.l"
1346 /* ignore -- we want value strings null-terminated */
1347 YY_BREAK
1348 case 8:
1349 YY_RULE_SETUP
1350 #line 94 "sgf_l.l"
1351 { sgflval.pch = strdup( "]" ); return VALUETEXT; }
1352 YY_BREAK
1353 case 9:
1354 /* rule 9 can match eol */
1355 YY_RULE_SETUP
1356 #line 95 "sgf_l.l"
1357 /* ignore */
1358 YY_BREAK
1359 case 10:
1360 YY_RULE_SETUP
1361 #line 96 "sgf_l.l"
1362 BEGIN(INITIAL); return ']';
1363 YY_BREAK
1364 case 11:
1365 /* rule 11 can match eol */
1366 YY_RULE_SETUP
1367 #line 97 "sgf_l.l"
1368 { sgflval.pch = strdup( sgftext ); return VALUETEXT; }
1369 YY_BREAK
1370 case 12:
1371 YY_RULE_SETUP
1372 #line 98 "sgf_l.l"
1373 { sgflval.pch = strdup( sgftext ); return VALUETEXT; }
1374 YY_BREAK
1375 case 13:
1376 YY_RULE_SETUP
1377 #line 100 "sgf_l.l"
1378 YY_FATAL_ERROR( "flex scanner jammed" );
1379 YY_BREAK
1380 #line 1381 "sgf_l.c"
1381 case YY_STATE_EOF(INITIAL):
1382 case YY_STATE_EOF(value):
1383 yyterminate();
1384
1385 case YY_END_OF_BUFFER:
1386 {
1387 /* Amount of text matched not including the EOB char. */
1388 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1389
1390 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1391 *yy_cp = (yy_hold_char);
1392 YY_RESTORE_YY_MORE_OFFSET
1393
1394 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1395 {
1396 /* We're scanning a new file or input source. It's
1397 * possible that this happened because the user
1398 * just pointed sgfin at a new source and called
1399 * sgflex(). If so, then we have to assure
1400 * consistency between YY_CURRENT_BUFFER and our
1401 * globals. Here is the right place to do so, because
1402 * this is the first action (other than possibly a
1403 * back-up) that will match for the new input source.
1404 */
1405 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1406 YY_CURRENT_BUFFER_LVALUE->yy_input_file = sgfin;
1407 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1408 }
1409
1410 /* Note that here we test for yy_c_buf_p "<=" to the position
1411 * of the first EOB in the buffer, since yy_c_buf_p will
1412 * already have been incremented past the NUL character
1413 * (since all states make transitions on EOB to the
1414 * end-of-buffer state). Contrast this with the test
1415 * in input().
1416 */
1417 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1418 { /* This was really a NUL. */
1419 yy_state_type yy_next_state;
1420
1421 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1422
1423 yy_current_state = yy_get_previous_state( );
1424
1425 /* Okay, we're now positioned to make the NUL
1426 * transition. We couldn't have
1427 * yy_get_previous_state() go ahead and do it
1428 * for us because it doesn't know how to deal
1429 * with the possibility of jamming (and we don't
1430 * want to build jamming into it because then it
1431 * will run more slowly).
1432 */
1433
1434 yy_next_state = yy_try_NUL_trans( yy_current_state );
1435
1436 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1437
1438 if ( yy_next_state )
1439 {
1440 /* Consume the NUL. */
1441 yy_cp = ++(yy_c_buf_p);
1442 yy_current_state = yy_next_state;
1443 goto yy_match;
1444 }
1445
1446 else
1447 {
1448 yy_cp = (yy_c_buf_p);
1449 goto yy_find_action;
1450 }
1451 }
1452
1453 else switch ( yy_get_next_buffer( ) )
1454 {
1455 case EOB_ACT_END_OF_FILE:
1456 {
1457 (yy_did_buffer_switch_on_eof) = 0;
1458
1459 if ( sgfwrap( ) )
1460 {
1461 /* Note: because we've taken care in
1462 * yy_get_next_buffer() to have set up
1463 * sgftext, we can now set up
1464 * yy_c_buf_p so that if some total
1465 * hoser (like flex itself) wants to
1466 * call the scanner after we return the
1467 * YY_NULL, it'll still work - another
1468 * YY_NULL will get returned.
1469 */
1470 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1471
1472 yy_act = YY_STATE_EOF(YY_START);
1473 goto do_action;
1474 }
1475
1476 else
1477 {
1478 if ( ! (yy_did_buffer_switch_on_eof) )
1479 YY_NEW_FILE;
1480 }
1481 break;
1482 }
1483
1484 case EOB_ACT_CONTINUE_SCAN:
1485 (yy_c_buf_p) =
1486 (yytext_ptr) + yy_amount_of_matched_text;
1487
1488 yy_current_state = yy_get_previous_state( );
1489
1490 yy_cp = (yy_c_buf_p);
1491 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1492 goto yy_match;
1493
1494 case EOB_ACT_LAST_MATCH:
1495 (yy_c_buf_p) =
1496 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1497
1498 yy_current_state = yy_get_previous_state( );
1499
1500 yy_cp = (yy_c_buf_p);
1501 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1502 goto yy_find_action;
1503 }
1504 break;
1505 }
1506
1507 default:
1508 YY_FATAL_ERROR(
1509 "fatal flex scanner internal error--no action found" );
1510 } /* end of action switch */
1511 } /* end of scanning one token */
1512 } /* end of sgflex */
1513
1514 /* yy_get_next_buffer - try to read in a new buffer
1515 *
1516 * Returns a code representing an action:
1517 * EOB_ACT_LAST_MATCH -
1518 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1519 * EOB_ACT_END_OF_FILE - end of file
1520 */
yy_get_next_buffer(void)1521 static int yy_get_next_buffer (void)
1522 {
1523 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1524 char *source = (yytext_ptr);
1525 int number_to_move, i;
1526 int ret_val;
1527
1528 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1529 YY_FATAL_ERROR(
1530 "fatal flex scanner internal error--end of buffer missed" );
1531
1532 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1533 { /* Don't try to fill the buffer, so this is an EOF. */
1534 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1535 {
1536 /* We matched a single character, the EOB, so
1537 * treat this as a final EOF.
1538 */
1539 return EOB_ACT_END_OF_FILE;
1540 }
1541
1542 else
1543 {
1544 /* We matched some text prior to the EOB, first
1545 * process it.
1546 */
1547 return EOB_ACT_LAST_MATCH;
1548 }
1549 }
1550
1551 /* Try to read more data. */
1552
1553 /* First move last chars to start of buffer. */
1554 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1555
1556 for ( i = 0; i < number_to_move; ++i )
1557 *(dest++) = *(source++);
1558
1559 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1560 /* don't do the read, it's not guaranteed to return an EOF,
1561 * just force an EOF
1562 */
1563 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1564
1565 else
1566 {
1567 yy_size_t num_to_read =
1568 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1569
1570 while ( num_to_read <= 0 )
1571 { /* Not enough room in the buffer - grow it. */
1572
1573 /* just a shorter name for the current buffer */
1574 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1575
1576 int yy_c_buf_p_offset =
1577 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1578
1579 if ( b->yy_is_our_buffer )
1580 {
1581 yy_size_t new_size = b->yy_buf_size * 2;
1582
1583 if ( new_size <= 0 )
1584 b->yy_buf_size += b->yy_buf_size / 8;
1585 else
1586 b->yy_buf_size *= 2;
1587
1588 b->yy_ch_buf = (char *)
1589 /* Include room in for 2 EOB chars. */
1590 sgfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1591 }
1592 else
1593 /* Can't grow it, we don't own it. */
1594 b->yy_ch_buf = 0;
1595
1596 if ( ! b->yy_ch_buf )
1597 YY_FATAL_ERROR(
1598 "fatal error - scanner input buffer overflow" );
1599
1600 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1601
1602 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1603 number_to_move - 1;
1604
1605 }
1606
1607 if ( num_to_read > YY_READ_BUF_SIZE )
1608 num_to_read = YY_READ_BUF_SIZE;
1609
1610 /* Read in more data. */
1611 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1612 (yy_n_chars), num_to_read );
1613
1614 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1615 }
1616
1617 if ( (yy_n_chars) == 0 )
1618 {
1619 if ( number_to_move == YY_MORE_ADJ )
1620 {
1621 ret_val = EOB_ACT_END_OF_FILE;
1622 sgfrestart(sgfin );
1623 }
1624
1625 else
1626 {
1627 ret_val = EOB_ACT_LAST_MATCH;
1628 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1629 YY_BUFFER_EOF_PENDING;
1630 }
1631 }
1632
1633 else
1634 ret_val = EOB_ACT_CONTINUE_SCAN;
1635
1636 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1637 /* Extend the array by 50%, plus the number we really need. */
1638 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1639 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) sgfrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1640 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1641 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1642 }
1643
1644 (yy_n_chars) += number_to_move;
1645 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1646 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1647
1648 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1649
1650 return ret_val;
1651 }
1652
1653 /* yy_get_previous_state - get the state just before the EOB char was reached */
1654
yy_get_previous_state(void)1655 static yy_state_type yy_get_previous_state (void)
1656 {
1657 yy_state_type yy_current_state;
1658 char *yy_cp;
1659
1660 yy_current_state = yy_start_state_list[(yy_start)];
1661
1662 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1663 {
1664 yy_current_state += yy_current_state[(*yy_cp ? YY_SC_TO_UI(*yy_cp) : 256)].yy_nxt;
1665 }
1666
1667 return yy_current_state;
1668 }
1669
1670 /* yy_try_NUL_trans - try to make a transition on the NUL character
1671 *
1672 * synopsis
1673 * next_state = yy_try_NUL_trans( current_state );
1674 */
yy_try_NUL_trans(yy_state_type yy_current_state)1675 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1676 {
1677 int yy_is_jam;
1678
1679 int yy_c = 256;
1680 yyconst struct yy_trans_info *yy_trans_info;
1681
1682 yy_trans_info = &yy_current_state[(unsigned int) yy_c];
1683 yy_current_state += yy_trans_info->yy_nxt;
1684 yy_is_jam = (yy_trans_info->yy_verify != yy_c);
1685
1686 return yy_is_jam ? 0 : yy_current_state;
1687 }
1688
1689 #ifndef YY_NO_INPUT
1690 #ifdef __cplusplus
yyinput(void)1691 static int yyinput (void)
1692 #else
1693 static int input (void)
1694 #endif
1695
1696 {
1697 int c;
1698
1699 *(yy_c_buf_p) = (yy_hold_char);
1700
1701 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1702 {
1703 /* yy_c_buf_p now points to the character we want to return.
1704 * If this occurs *before* the EOB characters, then it's a
1705 * valid NUL; if not, then we've hit the end of the buffer.
1706 */
1707 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1708 /* This was really a NUL. */
1709 *(yy_c_buf_p) = '\0';
1710
1711 else
1712 { /* need more input */
1713 yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1714 ++(yy_c_buf_p);
1715
1716 switch ( yy_get_next_buffer( ) )
1717 {
1718 case EOB_ACT_LAST_MATCH:
1719 /* This happens because yy_g_n_b()
1720 * sees that we've accumulated a
1721 * token and flags that we need to
1722 * try matching the token before
1723 * proceeding. But for input(),
1724 * there's no matching to consider.
1725 * So convert the EOB_ACT_LAST_MATCH
1726 * to EOB_ACT_END_OF_FILE.
1727 */
1728
1729 /* Reset buffer status. */
1730 sgfrestart(sgfin );
1731
1732 /*FALLTHROUGH*/
1733
1734 case EOB_ACT_END_OF_FILE:
1735 {
1736 if ( sgfwrap( ) )
1737 return EOF;
1738
1739 if ( ! (yy_did_buffer_switch_on_eof) )
1740 YY_NEW_FILE;
1741 #ifdef __cplusplus
1742 return yyinput();
1743 #else
1744 return input();
1745 #endif
1746 }
1747
1748 case EOB_ACT_CONTINUE_SCAN:
1749 (yy_c_buf_p) = (yytext_ptr) + offset;
1750 break;
1751 }
1752 }
1753 }
1754
1755 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1756 *(yy_c_buf_p) = '\0'; /* preserve sgftext */
1757 (yy_hold_char) = *++(yy_c_buf_p);
1758
1759 return c;
1760 }
1761 #endif /* ifndef YY_NO_INPUT */
1762
1763 /** Immediately switch to a different input stream.
1764 * @param input_file A readable stream.
1765 *
1766 * @note This function does not reset the start condition to @c INITIAL .
1767 */
sgfrestart(FILE * input_file)1768 void sgfrestart (FILE * input_file )
1769 {
1770
1771 if ( ! YY_CURRENT_BUFFER ){
1772 sgfensure_buffer_stack ();
1773 YY_CURRENT_BUFFER_LVALUE =
1774 sgf_create_buffer(sgfin,YY_BUF_SIZE );
1775 }
1776
1777 sgf_init_buffer(YY_CURRENT_BUFFER,input_file );
1778 sgf_load_buffer_state( );
1779 }
1780
1781 /** Switch to a different input buffer.
1782 * @param new_buffer The new input buffer.
1783 *
1784 */
sgf_switch_to_buffer(YY_BUFFER_STATE new_buffer)1785 void sgf_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1786 {
1787
1788 /* TODO. We should be able to replace this entire function body
1789 * with
1790 * sgfpop_buffer_state();
1791 * sgfpush_buffer_state(new_buffer);
1792 */
1793 sgfensure_buffer_stack ();
1794 if ( YY_CURRENT_BUFFER == new_buffer )
1795 return;
1796
1797 if ( YY_CURRENT_BUFFER )
1798 {
1799 /* Flush out information for old buffer. */
1800 *(yy_c_buf_p) = (yy_hold_char);
1801 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1802 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1803 }
1804
1805 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1806 sgf_load_buffer_state( );
1807
1808 /* We don't actually know whether we did this switch during
1809 * EOF (sgfwrap()) processing, but the only time this flag
1810 * is looked at is after sgfwrap() is called, so it's safe
1811 * to go ahead and always set it.
1812 */
1813 (yy_did_buffer_switch_on_eof) = 1;
1814 }
1815
sgf_load_buffer_state(void)1816 static void sgf_load_buffer_state (void)
1817 {
1818 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1819 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1820 sgfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1821 (yy_hold_char) = *(yy_c_buf_p);
1822 }
1823
1824 /** Allocate and initialize an input buffer state.
1825 * @param file A readable stream.
1826 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1827 *
1828 * @return the allocated buffer state.
1829 */
sgf_create_buffer(FILE * file,int size)1830 YY_BUFFER_STATE sgf_create_buffer (FILE * file, int size )
1831 {
1832 YY_BUFFER_STATE b;
1833
1834 b = (YY_BUFFER_STATE) sgfalloc(sizeof( struct yy_buffer_state ) );
1835 if ( ! b )
1836 YY_FATAL_ERROR( "out of dynamic memory in sgf_create_buffer()" );
1837
1838 b->yy_buf_size = size;
1839
1840 /* yy_ch_buf has to be 2 characters longer than the size given because
1841 * we need to put in 2 end-of-buffer characters.
1842 */
1843 b->yy_ch_buf = (char *) sgfalloc(b->yy_buf_size + 2 );
1844 if ( ! b->yy_ch_buf )
1845 YY_FATAL_ERROR( "out of dynamic memory in sgf_create_buffer()" );
1846
1847 b->yy_is_our_buffer = 1;
1848
1849 sgf_init_buffer(b,file );
1850
1851 return b;
1852 }
1853
1854 /** Destroy the buffer.
1855 * @param b a buffer created with sgf_create_buffer()
1856 *
1857 */
sgf_delete_buffer(YY_BUFFER_STATE b)1858 void sgf_delete_buffer (YY_BUFFER_STATE b )
1859 {
1860
1861 if ( ! b )
1862 return;
1863
1864 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1865 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1866
1867 if ( b->yy_is_our_buffer )
1868 sgffree((void *) b->yy_ch_buf );
1869
1870 sgffree((void *) b );
1871 }
1872
1873 /* Initializes or reinitializes a buffer.
1874 * This function is sometimes called more than once on the same buffer,
1875 * such as during a sgfrestart() or at EOF.
1876 */
sgf_init_buffer(YY_BUFFER_STATE b,FILE * file)1877 static void sgf_init_buffer (YY_BUFFER_STATE b, FILE * file )
1878
1879 {
1880 int oerrno = errno;
1881
1882 sgf_flush_buffer(b );
1883
1884 b->yy_input_file = file;
1885 b->yy_fill_buffer = 1;
1886
1887 /* If b is the current buffer, then sgf_init_buffer was _probably_
1888 * called from sgfrestart() or through yy_get_next_buffer.
1889 * In that case, we don't want to reset the lineno or column.
1890 */
1891 if (b != YY_CURRENT_BUFFER){
1892 b->yy_bs_lineno = 1;
1893 b->yy_bs_column = 0;
1894 }
1895
1896 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1897
1898 errno = oerrno;
1899 }
1900
1901 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1902 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1903 *
1904 */
sgf_flush_buffer(YY_BUFFER_STATE b)1905 void sgf_flush_buffer (YY_BUFFER_STATE b )
1906 {
1907 if ( ! b )
1908 return;
1909
1910 b->yy_n_chars = 0;
1911
1912 /* We always need two end-of-buffer characters. The first causes
1913 * a transition to the end-of-buffer state. The second causes
1914 * a jam in that state.
1915 */
1916 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1917 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1918
1919 b->yy_buf_pos = &b->yy_ch_buf[0];
1920
1921 b->yy_at_bol = 1;
1922 b->yy_buffer_status = YY_BUFFER_NEW;
1923
1924 if ( b == YY_CURRENT_BUFFER )
1925 sgf_load_buffer_state( );
1926 }
1927
1928 /** Pushes the new state onto the stack. The new state becomes
1929 * the current state. This function will allocate the stack
1930 * if necessary.
1931 * @param new_buffer The new state.
1932 *
1933 */
sgfpush_buffer_state(YY_BUFFER_STATE new_buffer)1934 void sgfpush_buffer_state (YY_BUFFER_STATE new_buffer )
1935 {
1936 if (new_buffer == NULL)
1937 return;
1938
1939 sgfensure_buffer_stack();
1940
1941 /* This block is copied from sgf_switch_to_buffer. */
1942 if ( YY_CURRENT_BUFFER )
1943 {
1944 /* Flush out information for old buffer. */
1945 *(yy_c_buf_p) = (yy_hold_char);
1946 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1947 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1948 }
1949
1950 /* Only push if top exists. Otherwise, replace top. */
1951 if (YY_CURRENT_BUFFER)
1952 (yy_buffer_stack_top)++;
1953 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1954
1955 /* copied from sgf_switch_to_buffer. */
1956 sgf_load_buffer_state( );
1957 (yy_did_buffer_switch_on_eof) = 1;
1958 }
1959
1960 /** Removes and deletes the top of the stack, if present.
1961 * The next element becomes the new top.
1962 *
1963 */
sgfpop_buffer_state(void)1964 void sgfpop_buffer_state (void)
1965 {
1966 if (!YY_CURRENT_BUFFER)
1967 return;
1968
1969 sgf_delete_buffer(YY_CURRENT_BUFFER );
1970 YY_CURRENT_BUFFER_LVALUE = NULL;
1971 if ((yy_buffer_stack_top) > 0)
1972 --(yy_buffer_stack_top);
1973
1974 if (YY_CURRENT_BUFFER) {
1975 sgf_load_buffer_state( );
1976 (yy_did_buffer_switch_on_eof) = 1;
1977 }
1978 }
1979
1980 /* Allocates the stack if it does not exist.
1981 * Guarantees space for at least one push.
1982 */
sgfensure_buffer_stack(void)1983 static void sgfensure_buffer_stack (void)
1984 {
1985 yy_size_t num_to_alloc;
1986
1987 if (!(yy_buffer_stack)) {
1988
1989 /* First allocation is just for 2 elements, since we don't know if this
1990 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1991 * immediate realloc on the next call.
1992 */
1993 num_to_alloc = 1;
1994 (yy_buffer_stack) = (struct yy_buffer_state**)sgfalloc
1995 (num_to_alloc * sizeof(struct yy_buffer_state*)
1996 );
1997 if ( ! (yy_buffer_stack) )
1998 YY_FATAL_ERROR( "out of dynamic memory in sgfensure_buffer_stack()" );
1999
2000 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2001
2002 (yy_buffer_stack_max) = num_to_alloc;
2003 (yy_buffer_stack_top) = 0;
2004 return;
2005 }
2006
2007 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2008
2009 /* Increase the buffer to prepare for a possible push. */
2010 int grow_size = 8 /* arbitrary grow size */;
2011
2012 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2013 (yy_buffer_stack) = (struct yy_buffer_state**)sgfrealloc
2014 ((yy_buffer_stack),
2015 num_to_alloc * sizeof(struct yy_buffer_state*)
2016 );
2017 if ( ! (yy_buffer_stack) )
2018 YY_FATAL_ERROR( "out of dynamic memory in sgfensure_buffer_stack()" );
2019
2020 /* zero only the new slots.*/
2021 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2022 (yy_buffer_stack_max) = num_to_alloc;
2023 }
2024 }
2025
2026 #ifndef YY_EXIT_FAILURE
2027 #define YY_EXIT_FAILURE 2
2028 #endif
2029
yy_fatal_error(yyconst char * msg)2030 static void yy_fatal_error (yyconst char* msg )
2031 {
2032 (void) fprintf( stderr, "%s\n", msg );
2033 exit( YY_EXIT_FAILURE );
2034 }
2035
2036 /* Redefine yyless() so it works in section 3 code. */
2037
2038 #undef yyless
2039 #define yyless(n) \
2040 do \
2041 { \
2042 /* Undo effects of setting up sgftext. */ \
2043 int yyless_macro_arg = (n); \
2044 YY_LESS_LINENO(yyless_macro_arg);\
2045 sgftext[sgfleng] = (yy_hold_char); \
2046 (yy_c_buf_p) = sgftext + yyless_macro_arg; \
2047 (yy_hold_char) = *(yy_c_buf_p); \
2048 *(yy_c_buf_p) = '\0'; \
2049 sgfleng = yyless_macro_arg; \
2050 } \
2051 while ( 0 )
2052
2053 /* Accessor methods (get/set functions) to struct members. */
2054
2055 /** Get the current line number.
2056 *
2057 */
sgfget_lineno(void)2058 int sgfget_lineno (void)
2059 {
2060
2061 return sgflineno;
2062 }
2063
2064 /** Get the input stream.
2065 *
2066 */
sgfget_in(void)2067 FILE *sgfget_in (void)
2068 {
2069 return sgfin;
2070 }
2071
2072 /** Get the output stream.
2073 *
2074 */
sgfget_out(void)2075 FILE *sgfget_out (void)
2076 {
2077 return sgfout;
2078 }
2079
2080 /** Get the length of the current token.
2081 *
2082 */
sgfget_leng(void)2083 yy_size_t sgfget_leng (void)
2084 {
2085 return sgfleng;
2086 }
2087
2088 /** Get the current token.
2089 *
2090 */
2091
sgfget_text(void)2092 char *sgfget_text (void)
2093 {
2094 return sgftext;
2095 }
2096
2097 /** Set the current line number.
2098 * @param line_number
2099 *
2100 */
sgfset_lineno(int line_number)2101 void sgfset_lineno (int line_number )
2102 {
2103
2104 sgflineno = line_number;
2105 }
2106
2107 /** Set the input stream. This does not discard the current
2108 * input buffer.
2109 * @param in_str A readable stream.
2110 *
2111 * @see sgf_switch_to_buffer
2112 */
sgfset_in(FILE * in_str)2113 void sgfset_in (FILE * in_str )
2114 {
2115 sgfin = in_str ;
2116 }
2117
sgfset_out(FILE * out_str)2118 void sgfset_out (FILE * out_str )
2119 {
2120 sgfout = out_str ;
2121 }
2122
sgfget_debug(void)2123 int sgfget_debug (void)
2124 {
2125 return sgf_flex_debug;
2126 }
2127
sgfset_debug(int bdebug)2128 void sgfset_debug (int bdebug )
2129 {
2130 sgf_flex_debug = bdebug ;
2131 }
2132
yy_init_globals(void)2133 static int yy_init_globals (void)
2134 {
2135 /* Initialization is the same as for the non-reentrant scanner.
2136 * This function is called from sgflex_destroy(), so don't allocate here.
2137 */
2138
2139 (yy_buffer_stack) = 0;
2140 (yy_buffer_stack_top) = 0;
2141 (yy_buffer_stack_max) = 0;
2142 (yy_c_buf_p) = (char *) 0;
2143 (yy_init) = 0;
2144 (yy_start) = 0;
2145
2146 /* Defined in main.c */
2147 #ifdef YY_STDINIT
2148 sgfin = stdin;
2149 sgfout = stdout;
2150 #else
2151 sgfin = (FILE *) 0;
2152 sgfout = (FILE *) 0;
2153 #endif
2154
2155 /* For future reference: Set errno on error, since we are called by
2156 * sgflex_init()
2157 */
2158 return 0;
2159 }
2160
2161 /* sgflex_destroy is for both reentrant and non-reentrant scanners. */
sgflex_destroy(void)2162 int sgflex_destroy (void)
2163 {
2164
2165 /* Pop the buffer stack, destroying each element. */
2166 while(YY_CURRENT_BUFFER){
2167 sgf_delete_buffer(YY_CURRENT_BUFFER );
2168 YY_CURRENT_BUFFER_LVALUE = NULL;
2169 sgfpop_buffer_state();
2170 }
2171
2172 /* Destroy the stack itself. */
2173 sgffree((yy_buffer_stack) );
2174 (yy_buffer_stack) = NULL;
2175
2176 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2177 * sgflex() is called, initialization will occur. */
2178 yy_init_globals( );
2179
2180 return 0;
2181 }
2182
2183 /*
2184 * Internal utility routines.
2185 */
2186
2187 #ifndef yytext_ptr
yy_flex_strncpy(char * s1,yyconst char * s2,int n)2188 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2189 {
2190 int i;
2191 for ( i = 0; i < n; ++i )
2192 s1[i] = s2[i];
2193 }
2194 #endif
2195
2196 #ifdef YY_NEED_STRLEN
yy_flex_strlen(yyconst char * s)2197 static int yy_flex_strlen (yyconst char * s )
2198 {
2199 int n;
2200 for ( n = 0; s[n]; ++n )
2201 ;
2202
2203 return n;
2204 }
2205 #endif
2206
sgfalloc(yy_size_t size)2207 void *sgfalloc (yy_size_t size )
2208 {
2209 return (void *) malloc( size );
2210 }
2211
sgfrealloc(void * ptr,yy_size_t size)2212 void *sgfrealloc (void * ptr, yy_size_t size )
2213 {
2214 /* The cast to (char *) in the following accommodates both
2215 * implementations that use char* generic pointers, and those
2216 * that use void* generic pointers. It works with the latter
2217 * because both ANSI C and C++ allow castless assignment from
2218 * any pointer type to void*, and deal with argument conversions
2219 * as though doing an assignment.
2220 */
2221 return (void *) realloc( (char *) ptr, size );
2222 }
2223
sgffree(void * ptr)2224 void sgffree (void * ptr )
2225 {
2226 free( (char *) ptr ); /* see sgfrealloc() for (char *) cast */
2227 }
2228
2229 #define YYTABLES_NAME "yytables"
2230
2231 #line 100 "sgf_l.l"
2232
2233
2234
2235