/[svn]/linuxsampler/trunk/src/network/lscpscanner.cpp
ViewVC logotype

Contents of /linuxsampler/trunk/src/network/lscpscanner.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 209 - (show annotations) (download)
Sun Jul 18 00:29:39 2004 UTC (19 years, 9 months ago) by schoenebeck
File size: 103694 byte(s) 
* src/Sampler.cpp: changed sampler channel index allocation from consistent
channel index allocation to incrementing channel index allocation, that is
it doesn't fill channel index gaps anymore (to avoid race conditions)
* implemented "LIST CHANNELS" LSCP command
1
2 #line 3 "lex.yy.c"
3
4 #define YY_INT_ALIGNED short int
5
6 /* A lexical scanner generated by flex */
7
8 #define FLEX_SCANNER
9 #define YY_FLEX_MAJOR_VERSION 2
10 #define YY_FLEX_MINOR_VERSION 5
11 #define YY_FLEX_SUBMINOR_VERSION 31
12 #if YY_FLEX_SUBMINOR_VERSION > 0
13 #define FLEX_BETA
14 #endif
15
16 /* First, we deal with platform-specific or compiler-specific issues. */
17
18 /* begin standard C headers. */
19 #include <stdio.h>
20 #include <string.h>
21 #include <errno.h>
22 #include <stdlib.h>
23
24 /* end standard C headers. */
25
26 /* flex integer type definitions */
27
28 #ifndef FLEXINT_H
29 #define FLEXINT_H
30
31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
32
33 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
34 #include <inttypes.h>
35 typedef int8_t flex_int8_t;
36 typedef uint8_t flex_uint8_t;
37 typedef int16_t flex_int16_t;
38 typedef uint16_t flex_uint16_t;
39 typedef int32_t flex_int32_t;
40 typedef uint32_t flex_uint32_t;
41 #else
42 typedef signed char flex_int8_t;
43 typedef short int flex_int16_t;
44 typedef int flex_int32_t;
45 typedef unsigned char flex_uint8_t;
46 typedef unsigned short int flex_uint16_t;
47 typedef unsigned int flex_uint32_t;
48 #endif /* ! C99 */
49
50 /* Limits of integral types. */
51 #ifndef INT8_MIN
52 #define INT8_MIN (-128)
53 #endif
54 #ifndef INT16_MIN
55 #define INT16_MIN (-32767-1)
56 #endif
57 #ifndef INT32_MIN
58 #define INT32_MIN (-2147483647-1)
59 #endif
60 #ifndef INT8_MAX
61 #define INT8_MAX (127)
62 #endif
63 #ifndef INT16_MAX
64 #define INT16_MAX (32767)
65 #endif
66 #ifndef INT32_MAX
67 #define INT32_MAX (2147483647)
68 #endif
69 #ifndef UINT8_MAX
70 #define UINT8_MAX (255U)
71 #endif
72 #ifndef UINT16_MAX
73 #define UINT16_MAX (65535U)
74 #endif
75 #ifndef UINT32_MAX
76 #define UINT32_MAX (4294967295U)
77 #endif
78
79 #endif /* ! FLEXINT_H */
80
81 #ifdef __cplusplus
82
83 /* The "const" storage-class-modifier is valid. */
84 #define YY_USE_CONST
85
86 #else /* ! __cplusplus */
87
88 #if __STDC__
89
90 #define YY_USE_CONST
91
92 #endif /* __STDC__ */
93 #endif /* ! __cplusplus */
94
95 #ifdef YY_USE_CONST
96 #define yyconst const
97 #else
98 #define yyconst
99 #endif
100
101 /* Returned upon end-of-file. */
102 #define YY_NULL 0
103
104 /* Promotes a possibly negative, possibly signed char to an unsigned
105 * integer for use as an array index. If the signed char is negative,
106 * we want to instead treat it as an 8-bit unsigned char, hence the
107 * double cast.
108 */
109 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
110
111 /* An opaque pointer. */
112 #ifndef YY_TYPEDEF_YY_SCANNER_T
113 #define YY_TYPEDEF_YY_SCANNER_T
114 typedef void* yyscan_t;
115 #endif
116
117 /* For convenience, these vars (plus the bison vars far below)
118 are macros in the reentrant scanner. */
119 #define yyin yyg->yyin_r
120 #define yyout yyg->yyout_r
121 #define yyextra yyg->yyextra_r
122 #define yyleng yyg->yyleng_r
123 #define yytext yyg->yytext_r
124 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
125 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
126 #define yy_flex_debug yyg->yy_flex_debug_r
127
128 int yylex_init (yyscan_t* scanner);
129
130 /* Enter a start condition. This macro really ought to take a parameter,
131 * but we do it the disgusting crufty way forced on us by the ()-less
132 * definition of BEGIN.
133 */
134 #define BEGIN yyg->yy_start = 1 + 2 *
135
136 /* Translate the current start state into a value that can be later handed
137 * to BEGIN to return to the state. The YYSTATE alias is for lex
138 * compatibility.
139 */
140 #define YY_START ((yyg->yy_start - 1) / 2)
141 #define YYSTATE YY_START
142
143 /* Action number for EOF rule of a given start state. */
144 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
145
146 /* Special action meaning "start processing a new file". */
147 #define YY_NEW_FILE yyrestart(yyin ,yyscanner )
148
149 #define YY_END_OF_BUFFER_CHAR 0
150
151 /* Size of default input buffer. */
152 #ifndef YY_BUF_SIZE
153 #define YY_BUF_SIZE 16384
154 #endif
155
156 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
157 #define YY_TYPEDEF_YY_BUFFER_STATE
158 typedef struct yy_buffer_state *YY_BUFFER_STATE;
159 #endif
160
161 #define EOB_ACT_CONTINUE_SCAN 0
162 #define EOB_ACT_END_OF_FILE 1
163 #define EOB_ACT_LAST_MATCH 2
164
165 #define YY_LESS_LINENO(n)
166
167 /* Return all but the first "n" matched characters back to the input stream. */
168 #define yyless(n) \
169 do \
170 { \
171 /* Undo effects of setting up yytext. */ \
172 int yyless_macro_arg = (n); \
173 YY_LESS_LINENO(yyless_macro_arg);\
174 *yy_cp = yyg->yy_hold_char; \
175 YY_RESTORE_YY_MORE_OFFSET \
176 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
177 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
178 } \
179 while ( 0 )
180
181 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
182
183 /* The following is because we cannot portably get our hands on size_t
184 * (without autoconf's help, which isn't available because we want
185 * flex-generated scanners to compile on their own).
186 */
187
188 #ifndef YY_TYPEDEF_YY_SIZE_T
189 #define YY_TYPEDEF_YY_SIZE_T
190 typedef unsigned int yy_size_t;
191 #endif
192
193 #ifndef YY_STRUCT_YY_BUFFER_STATE
194 #define YY_STRUCT_YY_BUFFER_STATE
195 struct yy_buffer_state
196 {
197 FILE *yy_input_file;
198
199 char *yy_ch_buf; /* input buffer */
200 char *yy_buf_pos; /* current position in input buffer */
201
202 /* Size of input buffer in bytes, not including room for EOB
203 * characters.
204 */
205 yy_size_t yy_buf_size;
206
207 /* Number of characters read into yy_ch_buf, not including EOB
208 * characters.
209 */
210 int yy_n_chars;
211
212 /* Whether we "own" the buffer - i.e., we know we created it,
213 * and can realloc() it to grow it, and should free() it to
214 * delete it.
215 */
216 int yy_is_our_buffer;
217
218 /* Whether this is an "interactive" input source; if so, and
219 * if we're using stdio for input, then we want to use getc()
220 * instead of fread(), to make sure we stop fetching input after
221 * each newline.
222 */
223 int yy_is_interactive;
224
225 /* Whether we're considered to be at the beginning of a line.
226 * If so, '^' rules will be active on the next match, otherwise
227 * not.
228 */
229 int yy_at_bol;
230
231 int yy_bs_lineno; /**< The line count. */
232 int yy_bs_column; /**< The column count. */
233
234 /* Whether to try to fill the input buffer when we reach the
235 * end of it.
236 */
237 int yy_fill_buffer;
238
239 int yy_buffer_status;
240
241 #define YY_BUFFER_NEW 0
242 #define YY_BUFFER_NORMAL 1
243 /* When an EOF's been seen but there's still some text to process
244 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
245 * shouldn't try reading from the input source any more. We might
246 * still have a bunch of tokens to match, though, because of
247 * possible backing-up.
248 *
249 * When we actually see the EOF, we change the status to "new"
250 * (via yyrestart()), so that the user can continue scanning by
251 * just pointing yyin at a new input file.
252 */
253 #define YY_BUFFER_EOF_PENDING 2
254
255 };
256 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
257
258 /* We provide macros for accessing buffer states in case in the
259 * future we want to put the buffer states in a more general
260 * "scanner state".
261 *
262 * Returns the top of the stack, or NULL.
263 */
264 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
265 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
266 : NULL)
267
268 /* Same as previous macro, but useful when we know that the buffer stack is not
269 * NULL or when we need an lvalue. For internal use only.
270 */
271 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
272
273 void yyrestart (FILE *input_file ,yyscan_t yyscanner );
274 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
275 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
276 void yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
277 void yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
278 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
279 void yypop_buffer_state (yyscan_t yyscanner );
280
281 static void yyensure_buffer_stack (yyscan_t yyscanner );
282 static void yy_load_buffer_state (yyscan_t yyscanner );
283 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
284
285 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
286
287 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
288 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
289 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
290
291 void *yyalloc (yy_size_t ,yyscan_t yyscanner );
292 void *yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
293 void yyfree (void * ,yyscan_t yyscanner );
294
295 #define yy_new_buffer yy_create_buffer
296
297 #define yy_set_interactive(is_interactive) \
298 { \
299 if ( ! YY_CURRENT_BUFFER ){ \
300 yyensure_buffer_stack (yyscanner); \
301 YY_CURRENT_BUFFER_LVALUE = \
302 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
303 } \
304 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
305 }
306
307 #define yy_set_bol(at_bol) \
308 { \
309 if ( ! YY_CURRENT_BUFFER ){\
310 yyensure_buffer_stack (yyscanner); \
311 YY_CURRENT_BUFFER_LVALUE = \
312 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
313 } \
314 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
315 }
316
317 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
318
319 /* Begin user sect3 */
320
321 typedef unsigned char YY_CHAR;
322
323 typedef yyconst struct yy_trans_info *yy_state_type;
324
325 #define yytext_ptr yytext_r
326
327 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
328 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
329 static int yy_get_next_buffer (yyscan_t yyscanner );
330 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
331
332 /* Done after the current pattern has been matched and before the
333 * corresponding action - sets up yytext.
334 */
335 #define YY_DO_BEFORE_ACTION \
336 yyg->yytext_ptr = yy_bp; \
337 yyleng = (size_t) (yy_cp - yy_bp); \
338 yyg->yy_hold_char = *yy_cp; \
339 *yy_cp = '\0'; \
340 yyg->yy_c_buf_p = yy_cp;
341
342 #define YY_NUM_RULES 66
343 #define YY_END_OF_BUFFER 67
344 struct yy_trans_info
345 {
346 flex_int16_t yy_verify;
347 flex_int16_t yy_nxt;
348 };
349 static yyconst struct yy_trans_info yy_transition[3759] =
350 {
351 { 0, 0 }, { 0,3503 }, { 0, 0 }, { 0,3501 }, { 1,1032 },
352 { 2,1032 }, { 3,1032 }, { 4,1032 }, { 5,1032 }, { 6,1032 },
353 { 7,1032 }, { 8,1032 }, { 9,1032 }, { 10,1034 }, { 11,1032 },
354 { 12,1032 }, { 13,1036 }, { 14,1032 }, { 15,1032 }, { 16,1032 },
355 { 17,1032 }, { 18,1032 }, { 19,1032 }, { 20,1032 }, { 21,1032 },
356 { 22,1032 }, { 23,1032 }, { 24,1032 }, { 25,1032 }, { 26,1032 },
357 { 27,1032 }, { 28,1032 }, { 29,1032 }, { 30,1032 }, { 31,1032 },
358 { 32,1038 }, { 33,1032 }, { 34,1032 }, { 35,1040 }, { 36,1032 },
359 { 37,1032 }, { 38,1032 }, { 39,1042 }, { 40,1032 }, { 41,1032 },
360 { 42,1032 }, { 43,1044 }, { 44,1032 }, { 45,1044 }, { 46,1032 },
361
362 { 47,1032 }, { 48,1056 }, { 49,1068 }, { 50,1068 }, { 51,1068 },
363 { 52,1068 }, { 53,1068 }, { 54,1068 }, { 55,1068 }, { 56,1068 },
364 { 57,1068 }, { 58,1032 }, { 59,1032 }, { 60,1032 }, { 61,1046 },
365 { 62,1032 }, { 63,1032 }, { 64,1032 }, { 65,1058 }, { 66,1060 },
366 { 67,1064 }, { 68,1066 }, { 69,1070 }, { 70,1032 }, { 71,1072 },
367 { 72,1032 }, { 73,1074 }, { 74,1032 }, { 75,1032 }, { 76,1077 },
368 { 77,1080 }, { 78,1082 }, { 79,1032 }, { 80,1085 }, { 81,1087 },
369 { 82,1089 }, { 83,1091 }, { 84,1032 }, { 85,1128 }, { 86,1130 },
370 { 87,1032 }, { 88,1032 }, { 89,1032 }, { 90,1032 }, { 91,1032 },
371 { 92,1032 }, { 93,1032 }, { 94,1032 }, { 95,1032 }, { 96,1032 },
372
373 { 97,1032 }, { 98,1032 }, { 99,1032 }, { 100,1032 }, { 101,1032 },
374 { 102,1032 }, { 103,1032 }, { 104,1032 }, { 105,1032 }, { 106,1032 },
375 { 107,1032 }, { 108,1032 }, { 109,1032 }, { 110,1032 }, { 111,1032 },
376 { 112,1032 }, { 113,1032 }, { 114,1032 }, { 115,1032 }, { 116,1032 },
377 { 117,1032 }, { 118,1032 }, { 119,1032 }, { 120,1032 }, { 121,1032 },
378 { 122,1032 }, { 123,1032 }, { 124,1032 }, { 125,1032 }, { 126,1032 },
379 { 127,1032 }, { 128,1032 }, { 129,1032 }, { 130,1032 }, { 131,1032 },
380 { 132,1032 }, { 133,1032 }, { 134,1032 }, { 135,1032 }, { 136,1032 },
381 { 137,1032 }, { 138,1032 }, { 139,1032 }, { 140,1032 }, { 141,1032 },
382 { 142,1032 }, { 143,1032 }, { 144,1032 }, { 145,1032 }, { 146,1032 },
383
384 { 147,1032 }, { 148,1032 }, { 149,1032 }, { 150,1032 }, { 151,1032 },
385 { 152,1032 }, { 153,1032 }, { 154,1032 }, { 155,1032 }, { 156,1032 },
386 { 157,1032 }, { 158,1032 }, { 159,1032 }, { 160,1032 }, { 161,1032 },
387 { 162,1032 }, { 163,1032 }, { 164,1032 }, { 165,1032 }, { 166,1032 },
388 { 167,1032 }, { 168,1032 }, { 169,1032 }, { 170,1032 }, { 171,1032 },
389 { 172,1032 }, { 173,1032 }, { 174,1032 }, { 175,1032 }, { 176,1032 },
390 { 177,1032 }, { 178,1032 }, { 179,1032 }, { 180,1032 }, { 181,1032 },
391 { 182,1032 }, { 183,1032 }, { 184,1032 }, { 185,1032 }, { 186,1032 },
392 { 187,1032 }, { 188,1032 }, { 189,1032 }, { 190,1032 }, { 191,1032 },
393 { 192,1032 }, { 193,1032 }, { 194,1032 }, { 195,1032 }, { 196,1032 },
394
395 { 197,1032 }, { 198,1032 }, { 199,1032 }, { 200,1032 }, { 201,1032 },
396 { 202,1032 }, { 203,1032 }, { 204,1032 }, { 205,1032 }, { 206,1032 },
397 { 207,1032 }, { 208,1032 }, { 209,1032 }, { 210,1032 }, { 211,1032 },
398 { 212,1032 }, { 213,1032 }, { 214,1032 }, { 215,1032 }, { 216,1032 },
399 { 217,1032 }, { 218,1032 }, { 219,1032 }, { 220,1032 }, { 221,1032 },
400 { 222,1032 }, { 223,1032 }, { 224,1032 }, { 225,1032 }, { 226,1032 },
401 { 227,1032 }, { 228,1032 }, { 229,1032 }, { 230,1032 }, { 231,1032 },
402 { 232,1032 }, { 233,1032 }, { 234,1032 }, { 235,1032 }, { 236,1032 },
403 { 237,1032 }, { 238,1032 }, { 239,1032 }, { 240,1032 }, { 241,1032 },
404 { 242,1032 }, { 243,1032 }, { 244,1032 }, { 245,1032 }, { 246,1032 },
405
406 { 247,1032 }, { 248,1032 }, { 249,1032 }, { 250,1032 }, { 251,1032 },
407 { 252,1032 }, { 253,1032 }, { 254,1032 }, { 255,1032 }, { 256,1032 },
408 { 0, 0 }, { 0,3243 }, { 1, 774 }, { 2, 774 }, { 3, 774 },
409 { 4, 774 }, { 5, 774 }, { 6, 774 }, { 7, 774 }, { 8, 774 },
410 { 9, 774 }, { 10, 776 }, { 11, 774 }, { 12, 774 }, { 13, 778 },
411 { 14, 774 }, { 15, 774 }, { 16, 774 }, { 17, 774 }, { 18, 774 },
412 { 19, 774 }, { 20, 774 }, { 21, 774 }, { 22, 774 }, { 23, 774 },
413 { 24, 774 }, { 25, 774 }, { 26, 774 }, { 27, 774 }, { 28, 774 },
414 { 29, 774 }, { 30, 774 }, { 31, 774 }, { 32, 780 }, { 33, 774 },
415 { 34, 774 }, { 35, 782 }, { 36, 774 }, { 37, 774 }, { 38, 774 },
416
417 { 39, 784 }, { 40, 774 }, { 41, 774 }, { 42, 774 }, { 43, 786 },
418 { 44, 774 }, { 45, 786 }, { 46, 774 }, { 47, 774 }, { 48, 798 },
419 { 49, 810 }, { 50, 810 }, { 51, 810 }, { 52, 810 }, { 53, 810 },
420 { 54, 810 }, { 55, 810 }, { 56, 810 }, { 57, 810 }, { 58, 774 },
421 { 59, 774 }, { 60, 774 }, { 61, 788 }, { 62, 774 }, { 63, 774 },
422 { 64, 774 }, { 65, 800 }, { 66, 802 }, { 67, 806 }, { 68, 808 },
423 { 69, 812 }, { 70, 774 }, { 71, 814 }, { 72, 774 }, { 73, 816 },
424 { 74, 774 }, { 75, 774 }, { 76, 819 }, { 77, 822 }, { 78, 824 },
425 { 79, 774 }, { 80, 827 }, { 81, 829 }, { 82, 831 }, { 83, 833 },
426 { 84, 774 }, { 85, 870 }, { 86, 872 }, { 87, 774 }, { 88, 774 },
427
428 { 89, 774 }, { 90, 774 }, { 91, 774 }, { 92, 774 }, { 93, 774 },
429 { 94, 774 }, { 95, 774 }, { 96, 774 }, { 97, 774 }, { 98, 774 },
430 { 99, 774 }, { 100, 774 }, { 101, 774 }, { 102, 774 }, { 103, 774 },
431 { 104, 774 }, { 105, 774 }, { 106, 774 }, { 107, 774 }, { 108, 774 },
432 { 109, 774 }, { 110, 774 }, { 111, 774 }, { 112, 774 }, { 113, 774 },
433 { 114, 774 }, { 115, 774 }, { 116, 774 }, { 117, 774 }, { 118, 774 },
434 { 119, 774 }, { 120, 774 }, { 121, 774 }, { 122, 774 }, { 123, 774 },
435 { 124, 774 }, { 125, 774 }, { 126, 774 }, { 127, 774 }, { 128, 774 },
436 { 129, 774 }, { 130, 774 }, { 131, 774 }, { 132, 774 }, { 133, 774 },
437 { 134, 774 }, { 135, 774 }, { 136, 774 }, { 137, 774 }, { 138, 774 },
438
439 { 139, 774 }, { 140, 774 }, { 141, 774 }, { 142, 774 }, { 143, 774 },
440 { 144, 774 }, { 145, 774 }, { 146, 774 }, { 147, 774 }, { 148, 774 },
441 { 149, 774 }, { 150, 774 }, { 151, 774 }, { 152, 774 }, { 153, 774 },
442 { 154, 774 }, { 155, 774 }, { 156, 774 }, { 157, 774 }, { 158, 774 },
443 { 159, 774 }, { 160, 774 }, { 161, 774 }, { 162, 774 }, { 163, 774 },
444 { 164, 774 }, { 165, 774 }, { 166, 774 }, { 167, 774 }, { 168, 774 },
445 { 169, 774 }, { 170, 774 }, { 171, 774 }, { 172, 774 }, { 173, 774 },
446 { 174, 774 }, { 175, 774 }, { 176, 774 }, { 177, 774 }, { 178, 774 },
447 { 179, 774 }, { 180, 774 }, { 181, 774 }, { 182, 774 }, { 183, 774 },
448 { 184, 774 }, { 185, 774 }, { 186, 774 }, { 187, 774 }, { 188, 774 },
449
450 { 189, 774 }, { 190, 774 }, { 191, 774 }, { 192, 774 }, { 193, 774 },
451 { 194, 774 }, { 195, 774 }, { 196, 774 }, { 197, 774 }, { 198, 774 },
452 { 199, 774 }, { 200, 774 }, { 201, 774 }, { 202, 774 }, { 203, 774 },
453 { 204, 774 }, { 205, 774 }, { 206, 774 }, { 207, 774 }, { 208, 774 },
454 { 209, 774 }, { 210, 774 }, { 211, 774 }, { 212, 774 }, { 213, 774 },
455 { 214, 774 }, { 215, 774 }, { 216, 774 }, { 217, 774 }, { 218, 774 },
456 { 219, 774 }, { 220, 774 }, { 221, 774 }, { 222, 774 }, { 223, 774 },
457 { 224, 774 }, { 225, 774 }, { 226, 774 }, { 227, 774 }, { 228, 774 },
458 { 229, 774 }, { 230, 774 }, { 231, 774 }, { 232, 774 }, { 233, 774 },
459 { 234, 774 }, { 235, 774 }, { 236, 774 }, { 237, 774 }, { 238, 774 },
460
461 { 239, 774 }, { 240, 774 }, { 241, 774 }, { 242, 774 }, { 243, 774 },
462 { 244, 774 }, { 245, 774 }, { 246, 774 }, { 247, 774 }, { 248, 774 },
463 { 249, 774 }, { 250, 774 }, { 251, 774 }, { 252, 774 }, { 253, 774 },
464 { 254, 774 }, { 255, 774 }, { 256, 774 }, { 0, 0 }, { 0,2985 },
465 { 1, 695 }, { 2, 695 }, { 3, 695 }, { 4, 695 }, { 5, 695 },
466 { 6, 695 }, { 7, 695 }, { 8, 695 }, { 9, 695 }, { 10, 695 },
467 { 11, 695 }, { 12, 695 }, { 13, 695 }, { 14, 695 }, { 15, 695 },
468 { 16, 695 }, { 17, 695 }, { 18, 695 }, { 19, 695 }, { 20, 695 },
469 { 21, 695 }, { 22, 695 }, { 23, 695 }, { 24, 695 }, { 25, 695 },
470 { 26, 695 }, { 27, 695 }, { 28, 695 }, { 29, 695 }, { 30, 695 },
471
472 { 31, 695 }, { 32, 695 }, { 33, 695 }, { 34, 695 }, { 35, 695 },
473 { 36, 695 }, { 37, 695 }, { 38, 695 }, { 39, 616 }, { 40, 695 },
474 { 41, 695 }, { 42, 695 }, { 43, 695 }, { 44, 695 }, { 45, 695 },
475 { 46, 695 }, { 47, 695 }, { 48, 695 }, { 49, 695 }, { 50, 695 },
476 { 51, 695 }, { 52, 695 }, { 53, 695 }, { 54, 695 }, { 55, 695 },
477 { 56, 695 }, { 57, 695 }, { 58, 695 }, { 59, 695 }, { 60, 695 },
478 { 61, 695 }, { 62, 695 }, { 63, 695 }, { 64, 695 }, { 65, 695 },
479 { 66, 695 }, { 67, 695 }, { 68, 695 }, { 69, 695 }, { 70, 695 },
480 { 71, 695 }, { 72, 695 }, { 73, 695 }, { 74, 695 }, { 75, 695 },
481 { 76, 695 }, { 77, 695 }, { 78, 695 }, { 79, 695 }, { 80, 695 },
482
483 { 81, 695 }, { 82, 695 }, { 83, 695 }, { 84, 695 }, { 85, 695 },
484 { 86, 695 }, { 87, 695 }, { 88, 695 }, { 89, 695 }, { 90, 695 },
485 { 91, 695 }, { 92, 953 }, { 93, 695 }, { 94, 695 }, { 95, 695 },
486 { 96, 695 }, { 97, 695 }, { 98, 695 }, { 99, 695 }, { 100, 695 },
487 { 101, 695 }, { 102, 695 }, { 103, 695 }, { 104, 695 }, { 105, 695 },
488 { 106, 695 }, { 107, 695 }, { 108, 695 }, { 109, 695 }, { 110, 695 },
489 { 111, 695 }, { 112, 695 }, { 113, 695 }, { 114, 695 }, { 115, 695 },
490 { 116, 695 }, { 117, 695 }, { 118, 695 }, { 119, 695 }, { 120, 695 },
491 { 121, 695 }, { 122, 695 }, { 123, 695 }, { 124, 695 }, { 125, 695 },
492 { 126, 695 }, { 127, 695 }, { 128, 695 }, { 129, 695 }, { 130, 695 },
493
494 { 131, 695 }, { 132, 695 }, { 133, 695 }, { 134, 695 }, { 135, 695 },
495 { 136, 695 }, { 137, 695 }, { 138, 695 }, { 139, 695 }, { 140, 695 },
496 { 141, 695 }, { 142, 695 }, { 143, 695 }, { 144, 695 }, { 145, 695 },
497 { 146, 695 }, { 147, 695 }, { 148, 695 }, { 149, 695 }, { 150, 695 },
498 { 151, 695 }, { 152, 695 }, { 153, 695 }, { 154, 695 }, { 155, 695 },
499 { 156, 695 }, { 157, 695 }, { 158, 695 }, { 159, 695 }, { 160, 695 },
500 { 161, 695 }, { 162, 695 }, { 163, 695 }, { 164, 695 }, { 165, 695 },
501 { 166, 695 }, { 167, 695 }, { 168, 695 }, { 169, 695 }, { 170, 695 },
502 { 171, 695 }, { 172, 695 }, { 173, 695 }, { 174, 695 }, { 175, 695 },
503 { 176, 695 }, { 177, 695 }, { 178, 695 }, { 179, 695 }, { 180, 695 },
504
505 { 181, 695 }, { 182, 695 }, { 183, 695 }, { 184, 695 }, { 185, 695 },
506 { 186, 695 }, { 187, 695 }, { 188, 695 }, { 189, 695 }, { 190, 695 },
507 { 191, 695 }, { 192, 695 }, { 193, 695 }, { 194, 695 }, { 195, 695 },
508 { 196, 695 }, { 197, 695 }, { 198, 695 }, { 199, 695 }, { 200, 695 },
509 { 201, 695 }, { 202, 695 }, { 203, 695 }, { 204, 695 }, { 205, 695 },
510 { 206, 695 }, { 207, 695 }, { 208, 695 }, { 209, 695 }, { 210, 695 },
511 { 211, 695 }, { 212, 695 }, { 213, 695 }, { 214, 695 }, { 215, 695 },
512 { 216, 695 }, { 217, 695 }, { 218, 695 }, { 219, 695 }, { 220, 695 },
513 { 221, 695 }, { 222, 695 }, { 223, 695 }, { 224, 695 }, { 225, 695 },
514 { 226, 695 }, { 227, 695 }, { 228, 695 }, { 229, 695 }, { 230, 695 },
515
516 { 231, 695 }, { 232, 695 }, { 233, 695 }, { 234, 695 }, { 235, 695 },
517 { 236, 695 }, { 237, 695 }, { 238, 695 }, { 239, 695 }, { 240, 695 },
518 { 241, 695 }, { 242, 695 }, { 243, 695 }, { 244, 695 }, { 245, 695 },
519 { 246, 695 }, { 247, 695 }, { 248, 695 }, { 249, 695 }, { 250, 695 },
520 { 251, 695 }, { 252, 695 }, { 253, 695 }, { 254, 695 }, { 255, 695 },
521 { 256, 695 }, { 0, 0 }, { 0,2727 }, { 1, 437 }, { 2, 437 },
522 { 3, 437 }, { 4, 437 }, { 5, 437 }, { 6, 437 }, { 7, 437 },
523 { 8, 437 }, { 9, 437 }, { 10, 437 }, { 11, 437 }, { 12, 437 },
524 { 13, 437 }, { 14, 437 }, { 15, 437 }, { 16, 437 }, { 17, 437 },
525 { 18, 437 }, { 19, 437 }, { 20, 437 }, { 21, 437 }, { 22, 437 },
526
527 { 23, 437 }, { 24, 437 }, { 25, 437 }, { 26, 437 }, { 27, 437 },
528 { 28, 437 }, { 29, 437 }, { 30, 437 }, { 31, 437 }, { 32, 437 },
529 { 33, 437 }, { 34, 437 }, { 35, 437 }, { 36, 437 }, { 37, 437 },
530 { 38, 437 }, { 39, 358 }, { 40, 437 }, { 41, 437 }, { 42, 437 },
531 { 43, 437 }, { 44, 437 }, { 45, 437 }, { 46, 437 }, { 47, 437 },
532 { 48, 437 }, { 49, 437 }, { 50, 437 }, { 51, 437 }, { 52, 437 },
533 { 53, 437 }, { 54, 437 }, { 55, 437 }, { 56, 437 }, { 57, 437 },
534 { 58, 437 }, { 59, 437 }, { 60, 437 }, { 61, 437 }, { 62, 437 },
535 { 63, 437 }, { 64, 437 }, { 65, 437 }, { 66, 437 }, { 67, 437 },
536 { 68, 437 }, { 69, 437 }, { 70, 437 }, { 71, 437 }, { 72, 437 },
537
538 { 73, 437 }, { 74, 437 }, { 75, 437 }, { 76, 437 }, { 77, 437 },
539 { 78, 437 }, { 79, 437 }, { 80, 437 }, { 81, 437 }, { 82, 437 },
540 { 83, 437 }, { 84, 437 }, { 85, 437 }, { 86, 437 }, { 87, 437 },
541 { 88, 437 }, { 89, 437 }, { 90, 437 }, { 91, 437 }, { 92, 695 },
542 { 93, 437 }, { 94, 437 }, { 95, 437 }, { 96, 437 }, { 97, 437 },
543 { 98, 437 }, { 99, 437 }, { 100, 437 }, { 101, 437 }, { 102, 437 },
544 { 103, 437 }, { 104, 437 }, { 105, 437 }, { 106, 437 }, { 107, 437 },
545 { 108, 437 }, { 109, 437 }, { 110, 437 }, { 111, 437 }, { 112, 437 },
546 { 113, 437 }, { 114, 437 }, { 115, 437 }, { 116, 437 }, { 117, 437 },
547 { 118, 437 }, { 119, 437 }, { 120, 437 }, { 121, 437 }, { 122, 437 },
548
549 { 123, 437 }, { 124, 437 }, { 125, 437 }, { 126, 437 }, { 127, 437 },
550 { 128, 437 }, { 129, 437 }, { 130, 437 }, { 131, 437 }, { 132, 437 },
551 { 133, 437 }, { 134, 437 }, { 135, 437 }, { 136, 437 }, { 137, 437 },
552 { 138, 437 }, { 139, 437 }, { 140, 437 }, { 141, 437 }, { 142, 437 },
553 { 143, 437 }, { 144, 437 }, { 145, 437 }, { 146, 437 }, { 147, 437 },
554 { 148, 437 }, { 149, 437 }, { 150, 437 }, { 151, 437 }, { 152, 437 },
555 { 153, 437 }, { 154, 437 }, { 155, 437 }, { 156, 437 }, { 157, 437 },
556 { 158, 437 }, { 159, 437 }, { 160, 437 }, { 161, 437 }, { 162, 437 },
557 { 163, 437 }, { 164, 437 }, { 165, 437 }, { 166, 437 }, { 167, 437 },
558 { 168, 437 }, { 169, 437 }, { 170, 437 }, { 171, 437 }, { 172, 437 },
559
560 { 173, 437 }, { 174, 437 }, { 175, 437 }, { 176, 437 }, { 177, 437 },
561 { 178, 437 }, { 179, 437 }, { 180, 437 }, { 181, 437 }, { 182, 437 },
562 { 183, 437 }, { 184, 437 }, { 185, 437 }, { 186, 437 }, { 187, 437 },
563 { 188, 437 }, { 189, 437 }, { 190, 437 }, { 191, 437 }, { 192, 437 },
564 { 193, 437 }, { 194, 437 }, { 195, 437 }, { 196, 437 }, { 197, 437 },
565 { 198, 437 }, { 199, 437 }, { 200, 437 }, { 201, 437 }, { 202, 437 },
566 { 203, 437 }, { 204, 437 }, { 205, 437 }, { 206, 437 }, { 207, 437 },
567 { 208, 437 }, { 209, 437 }, { 210, 437 }, { 211, 437 }, { 212, 437 },
568 { 213, 437 }, { 214, 437 }, { 215, 437 }, { 216, 437 }, { 217, 437 },
569 { 218, 437 }, { 219, 437 }, { 220, 437 }, { 221, 437 }, { 222, 437 },
570
571 { 223, 437 }, { 224, 437 }, { 225, 437 }, { 226, 437 }, { 227, 437 },
572 { 228, 437 }, { 229, 437 }, { 230, 437 }, { 231, 437 }, { 232, 437 },
573 { 233, 437 }, { 234, 437 }, { 235, 437 }, { 236, 437 }, { 237, 437 },
574 { 238, 437 }, { 239, 437 }, { 240, 437 }, { 241, 437 }, { 242, 437 },
575 { 243, 437 }, { 244, 437 }, { 245, 437 }, { 246, 437 }, { 247, 437 },
576 { 248, 437 }, { 249, 437 }, { 250, 437 }, { 251, 437 }, { 252, 437 },
577 { 253, 437 }, { 254, 437 }, { 255, 437 }, { 256, 437 }, { 0, 65 },
578 { 0,2469 }, { 0, 2 }, { 0,2467 }, { 0, 3 }, { 0,2465 },
579 { 0, 1 }, { 0,2463 }, { 0, 4 }, { 0,2461 }, { 0, 55 },
580 { 0,2459 }, { 0, 65 }, { 0,2457 }, { 0, 5 }, { 0,2455 },
581
582 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
583 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 54 }, { 0,2445 },
584 { 0, 65 }, { 0,2443 }, { 0, 65 }, { 0,2441 }, { 0, 0 },
585 { 0, 0 }, { 0, 65 }, { 0,2437 }, { 0, 65 }, { 0,2435 },
586 { 0, 54 }, { 0,2433 }, { 0, 65 }, { 0,2431 }, { 0, 65 },
587 { 0,2429 }, { 0, 65 }, { 0,2427 }, { 0, 0 }, { 0, 65 },
588 { 0,2424 }, { 0, 0 }, { 0, 65 }, { 0,2421 }, { 0, 65 },
589 { 0,2419 }, { 0, 0 }, { 0, 65 }, { 0,2416 }, { 0, 65 },
590 { 0,2414 }, { 0, 65 }, { 0,2412 }, { 0, 65 }, { 0,2410 },
591 { 48, 683 }, { 49, 683 }, { 50, 683 }, { 51, 683 }, { 52, 683 },
592
593 { 53, 683 }, { 54, 683 }, { 55, 683 }, { 56, 683 }, { 57, 683 },
594 { 46, 681 }, { 0, 0 }, { 48, 671 }, { 49, 671 }, { 50, 671 },
595 { 51, 671 }, { 52, 671 }, { 53, 671 }, { 54, 671 }, { 55, 671 },
596 { 56, 671 }, { 57, 671 }, { 46, 669 }, { 0, 0 }, { 48, 681 },
597 { 49, 681 }, { 50, 681 }, { 51, 681 }, { 52, 681 }, { 53, 681 },
598 { 54, 681 }, { 55, 681 }, { 56, 681 }, { 57, 681 }, { 68, 76 },
599 { 0, 65 }, { 0,2373 }, { 0, 65 }, { 0,2371 }, { 0, 64 },
600 { 0,2369 }, { 0, 0 }, { 0,2367 }, { 69, 681 }, { 72, 679 },
601 { 0, 0 }, { 0, 0 }, { 0,2362 }, { 0, 0 }, { 69, 681 },
602 { 0, 0 }, { 85, 81 }, { 86, 127 }, { 85, 679 }, { 82, 681 },
603
604 { 0, 0 }, { 78, 681 }, { 89, 681 }, { 73, 681 }, { 0, 0 },
605 { 78, 682 }, { 73, 684 }, { 69, 684 }, { 0, 0 }, { 79, 685 },
606 { 0, 0 }, { 69, 722 }, { 0, 0 }, { 69, 722 }, { 79, 684 },
607 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
608 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
609 { 85, 685 }, { 0, 0 }, { 0, 0 }, { 84, 725 }, { 85, 727 },
610 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
611 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0,2316 }, { 0, 0 },
612 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
613 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
614
615 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
616 { 68, 725 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 78, 692 },
617 { 68, 734 }, { 0, 0 }, { 79, 699 }, { 0, 56 }, { 0,2290 },
618 { 1, 696 }, { 2, 696 }, { 3, 696 }, { 4, 696 }, { 5, 696 },
619 { 6, 696 }, { 7, 696 }, { 8, 696 }, { 9, 696 }, { 10, 696 },
620 { 11, 696 }, { 12, 696 }, { 13, 696 }, { 14, 696 }, { 15, 696 },
621 { 16, 696 }, { 17, 696 }, { 18, 696 }, { 19, 696 }, { 20, 696 },
622 { 21, 696 }, { 22, 696 }, { 23, 696 }, { 24, 696 }, { 25, 696 },
623 { 26, 696 }, { 27, 696 }, { 28, 696 }, { 29, 696 }, { 30, 696 },
624 { 31, 696 }, { 32, 696 }, { 33, 696 }, { 34, 696 }, { 35, 696 },
625
626 { 36, 696 }, { 37, 696 }, { 38, 696 }, { 65, 982 }, { 40, 696 },
627 { 41, 696 }, { 42, 696 }, { 43, 696 }, { 44, 696 }, { 45, 696 },
628 { 46, 696 }, { 47, 696 }, { 48, 696 }, { 49, 696 }, { 50, 696 },
629 { 51, 696 }, { 52, 696 }, { 53, 696 }, { 54, 696 }, { 55, 696 },
630 { 56, 696 }, { 57, 696 }, { 58, 696 }, { 59, 696 }, { 60, 696 },
631 { 61, 696 }, { 62, 696 }, { 63, 696 }, { 64, 696 }, { 65, 696 },
632 { 66, 696 }, { 67, 696 }, { 68, 696 }, { 69, 696 }, { 70, 696 },
633 { 71, 696 }, { 72, 696 }, { 73, 696 }, { 74, 696 }, { 75, 696 },
634 { 76, 696 }, { 77, 696 }, { 78, 696 }, { 79, 696 }, { 80, 696 },
635 { 81, 696 }, { 82, 696 }, { 83, 696 }, { 84, 696 }, { 85, 696 },
636
637 { 86, 696 }, { 87, 696 }, { 88, 696 }, { 89, 696 }, { 90, 696 },
638 { 91, 696 }, { 0, 0 }, { 93, 696 }, { 94, 696 }, { 95, 696 },
639 { 96, 696 }, { 97, 696 }, { 98, 696 }, { 99, 696 }, { 100, 696 },
640 { 101, 696 }, { 102, 696 }, { 103, 696 }, { 104, 696 }, { 105, 696 },
641 { 106, 696 }, { 107, 696 }, { 108, 696 }, { 109, 696 }, { 110, 696 },
642 { 111, 696 }, { 112, 696 }, { 113, 696 }, { 114, 696 }, { 115, 696 },
643 { 116, 696 }, { 117, 696 }, { 118, 696 }, { 119, 696 }, { 120, 696 },
644 { 121, 696 }, { 122, 696 }, { 123, 696 }, { 124, 696 }, { 125, 696 },
645 { 126, 696 }, { 127, 696 }, { 128, 696 }, { 129, 696 }, { 130, 696 },
646 { 131, 696 }, { 132, 696 }, { 133, 696 }, { 134, 696 }, { 135, 696 },
647
648 { 136, 696 }, { 137, 696 }, { 138, 696 }, { 139, 696 }, { 140, 696 },
649 { 141, 696 }, { 142, 696 }, { 143, 696 }, { 144, 696 }, { 145, 696 },
650 { 146, 696 }, { 147, 696 }, { 148, 696 }, { 149, 696 }, { 150, 696 },
651 { 151, 696 }, { 152, 696 }, { 153, 696 }, { 154, 696 }, { 155, 696 },
652 { 156, 696 }, { 157, 696 }, { 158, 696 }, { 159, 696 }, { 160, 696 },
653 { 161, 696 }, { 162, 696 }, { 163, 696 }, { 164, 696 }, { 165, 696 },
654 { 166, 696 }, { 167, 696 }, { 168, 696 }, { 169, 696 }, { 170, 696 },
655 { 171, 696 }, { 172, 696 }, { 173, 696 }, { 174, 696 }, { 175, 696 },
656 { 176, 696 }, { 177, 696 }, { 178, 696 }, { 179, 696 }, { 180, 696 },
657 { 181, 696 }, { 182, 696 }, { 183, 696 }, { 184, 696 }, { 185, 696 },
658
659 { 186, 696 }, { 187, 696 }, { 188, 696 }, { 189, 696 }, { 190, 696 },
660 { 191, 696 }, { 192, 696 }, { 193, 696 }, { 194, 696 }, { 195, 696 },
661 { 196, 696 }, { 197, 696 }, { 198, 696 }, { 199, 696 }, { 200, 696 },
662 { 201, 696 }, { 202, 696 }, { 203, 696 }, { 204, 696 }, { 205, 696 },
663 { 206, 696 }, { 207, 696 }, { 208, 696 }, { 209, 696 }, { 210, 696 },
664 { 211, 696 }, { 212, 696 }, { 213, 696 }, { 214, 696 }, { 215, 696 },
665 { 216, 696 }, { 217, 696 }, { 218, 696 }, { 219, 696 }, { 220, 696 },
666 { 221, 696 }, { 222, 696 }, { 223, 696 }, { 224, 696 }, { 225, 696 },
667 { 226, 696 }, { 227, 696 }, { 228, 696 }, { 229, 696 }, { 230, 696 },
668 { 231, 696 }, { 232, 696 }, { 233, 696 }, { 234, 696 }, { 235, 696 },
669
670 { 236, 696 }, { 237, 696 }, { 238, 696 }, { 239, 696 }, { 240, 696 },
671 { 241, 696 }, { 242, 696 }, { 243, 696 }, { 244, 696 }, { 245, 696 },
672 { 246, 696 }, { 247, 696 }, { 248, 696 }, { 249, 696 }, { 250, 696 },
673 { 251, 696 }, { 252, 696 }, { 253, 696 }, { 254, 696 }, { 255, 696 },
674 { 256, 696 }, { 0, 66 }, { 0,2032 }, { 1, 365 }, { 2, 365 },
675 { 3, 365 }, { 4, 365 }, { 5, 365 }, { 6, 365 }, { 7, 365 },
676 { 8, 365 }, { 9, 365 }, { 10, 365 }, { 11, 365 }, { 12, 365 },
677 { 13, 365 }, { 14, 365 }, { 15, 365 }, { 16, 365 }, { 17, 365 },
678 { 18, 365 }, { 19, 365 }, { 20, 365 }, { 21, 365 }, { 22, 365 },
679 { 23, 365 }, { 24, 365 }, { 25, 365 }, { 26, 365 }, { 27, 365 },
680
681 { 28, 365 }, { 29, 365 }, { 30, 365 }, { 31, 365 }, { 32, 365 },
682 { 33, 365 }, { 34, 367 }, { 35, 365 }, { 36, 365 }, { 37, 365 },
683 { 38, 365 }, { 39, 374 }, { 40, 365 }, { 41, 365 }, { 42, 365 },
684 { 43, 365 }, { 44, 365 }, { 45, 365 }, { 46, 365 }, { 47, 365 },
685 { 48, 365 }, { 49, 365 }, { 50, 365 }, { 51, 365 }, { 52, 365 },
686 { 53, 365 }, { 54, 365 }, { 55, 365 }, { 56, 365 }, { 57, 365 },
687 { 58, 365 }, { 59, 365 }, { 60, 365 }, { 61, 365 }, { 62, 365 },
688 { 63, 365 }, { 64, 365 }, { 65, 365 }, { 66, 365 }, { 67, 365 },
689 { 68, 365 }, { 69, 365 }, { 70, 365 }, { 71, 365 }, { 72, 365 },
690 { 73, 365 }, { 74, 365 }, { 75, 365 }, { 76, 365 }, { 77, 365 },
691
692 { 78, 365 }, { 79, 365 }, { 80, 365 }, { 81, 365 }, { 82, 365 },
693 { 83, 365 }, { 84, 365 }, { 85, 365 }, { 86, 365 }, { 87, 365 },
694 { 88, 365 }, { 89, 365 }, { 90, 365 }, { 91, 365 }, { 92, 380 },
695 { 93, 365 }, { 94, 365 }, { 95, 365 }, { 96, 365 }, { 97, 365 },
696 { 98, 365 }, { 99, 365 }, { 100, 365 }, { 101, 365 }, { 102, 365 },
697 { 103, 365 }, { 104, 365 }, { 105, 365 }, { 106, 365 }, { 107, 365 },
698 { 108, 365 }, { 109, 365 }, { 110, 384 }, { 111, 365 }, { 112, 365 },
699 { 113, 365 }, { 114, 386 }, { 115, 365 }, { 116, 388 }, { 117, 365 },
700 { 118, 365 }, { 119, 365 }, { 120, 365 }, { 121, 365 }, { 122, 365 },
701 { 123, 365 }, { 124, 365 }, { 125, 365 }, { 126, 365 }, { 127, 365 },
702
703 { 128, 365 }, { 129, 365 }, { 130, 365 }, { 131, 365 }, { 132, 365 },
704 { 133, 365 }, { 134, 365 }, { 135, 365 }, { 136, 365 }, { 137, 365 },
705 { 138, 365 }, { 139, 365 }, { 140, 365 }, { 141, 365 }, { 142, 365 },
706 { 143, 365 }, { 144, 365 }, { 145, 365 }, { 146, 365 }, { 147, 365 },
707 { 148, 365 }, { 149, 365 }, { 150, 365 }, { 151, 365 }, { 152, 365 },
708 { 153, 365 }, { 154, 365 }, { 155, 365 }, { 156, 365 }, { 157, 365 },
709 { 158, 365 }, { 159, 365 }, { 160, 365 }, { 161, 365 }, { 162, 365 },
710 { 163, 365 }, { 164, 365 }, { 165, 365 }, { 166, 365 }, { 167, 365 },
711 { 168, 365 }, { 169, 365 }, { 170, 365 }, { 171, 365 }, { 172, 365 },
712 { 173, 365 }, { 174, 365 }, { 175, 365 }, { 176, 365 }, { 177, 365 },
713
714 { 178, 365 }, { 179, 365 }, { 180, 365 }, { 181, 365 }, { 182, 365 },
715 { 183, 365 }, { 184, 365 }, { 185, 365 }, { 186, 365 }, { 187, 365 },
716 { 188, 365 }, { 189, 365 }, { 190, 365 }, { 191, 365 }, { 192, 365 },
717 { 193, 365 }, { 194, 365 }, { 195, 365 }, { 196, 365 }, { 197, 365 },
718 { 198, 365 }, { 199, 365 }, { 200, 365 }, { 201, 365 }, { 202, 365 },
719 { 203, 365 }, { 204, 365 }, { 205, 365 }, { 206, 365 }, { 207, 365 },
720 { 208, 365 }, { 209, 365 }, { 210, 365 }, { 211, 365 }, { 212, 365 },
721 { 213, 365 }, { 214, 365 }, { 215, 365 }, { 216, 365 }, { 217, 365 },
722 { 218, 365 }, { 219, 365 }, { 220, 365 }, { 221, 365 }, { 222, 365 },
723 { 223, 365 }, { 224, 365 }, { 225, 365 }, { 226, 365 }, { 227, 365 },
724
725 { 228, 365 }, { 229, 365 }, { 230, 365 }, { 231, 365 }, { 232, 365 },
726 { 233, 365 }, { 234, 365 }, { 235, 365 }, { 236, 365 }, { 237, 365 },
727 { 238, 365 }, { 239, 365 }, { 240, 365 }, { 241, 365 }, { 242, 365 },
728 { 243, 365 }, { 244, 365 }, { 245, 365 }, { 246, 365 }, { 247, 365 },
729 { 248, 365 }, { 249, 365 }, { 250, 365 }, { 251, 365 }, { 252, 365 },
730 { 253, 365 }, { 254, 365 }, { 255, 365 }, { 256, 365 }, { 0, 0 },
731 { 0,1774 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
732 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
733 { 0,1764 }, { 0, 0 }, { 0,1762 }, { 0, 0 }, { 0,1760 },
734 { 0, 0 }, { 0,1758 }, { 0, 0 }, { 0,1756 }, { 0, 0 },
735
736 { 0,1754 }, { 0, 54 }, { 0,1752 }, { 0, 0 }, { 0,1750 },
737 { 0, 0 }, { 0,1748 }, { 0, 0 }, { 0, 0 }, { 0,1745 },
738 { 0, 0 }, { 0,1743 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
739 { 0,1739 }, { 0, 0 }, { 0,1737 }, { 0, 0 }, { 0,1735 },
740 { 0, 0 }, { 0, 0 }, { 0,1732 }, { 0, 0 }, { 0, 0 },
741 { 0,1729 }, { 46, 10 }, { 0, 0 }, { 48, 0 }, { 49, 0 },
742 { 50, 0 }, { 51, 0 }, { 52, 0 }, { 53, 0 }, { 54, 0 },
743 { 55, 0 }, { 56, 0 }, { 57, 0 }, { 48, 428 }, { 49, 428 },
744 { 50, 428 }, { 51, 428 }, { 52, 428 }, { 53, 428 }, { 54, 428 },
745 { 55, 428 }, { 56, 428 }, { 57, 428 }, { 46, -12 }, { 0, 0 },
746
747 { 48, 0 }, { 49, 0 }, { 50, 0 }, { 51, 0 }, { 52, 0 },
748 { 53, 0 }, { 54, 0 }, { 55, 0 }, { 56, 0 }, { 57, 0 },
749 { 0, 0 }, { 65, 431 }, { 70, 430 }, { 0, 0 }, { 0,1690 },
750 { 0, 0 }, { 0,1688 }, { 69, 432 }, { 0, 0 }, { 0,1685 },
751 { 0, 0 }, { 0,1683 }, { 0, 0 }, { 0,1681 }, { 0, 0 },
752 { 71, 430 }, { 0, 0 }, { 0, 0 }, { 84, 431 }, { 70, 429 },
753 { 65, 429 }, { 0, 0 }, { 0,1672 }, { 83, 432 }, { 0, 0 },
754 { 68, 429 }, { 0, 63 }, { 0,1667 }, { 0, 61 }, { 0,1665 },
755 { 84, 430 }, { 0, 0 }, { 83, 431 }, { 0, 0 }, { 83, 431 },
756 { 0, 62 }, { 0,1658 }, { 78, 431 }, { 73, 431 }, { 0, 0 },
757
758 { 83, 431 }, { 0, 60 }, { 0,1652 }, { 84, 433 }, { 82, 432 },
759 { 0, 57 }, { 0,1648 }, { 0, 58 }, { 0,1646 }, { 0, 59 },
760 { 0,1644 }, { 0, 7 }, { 0,1642 }, { 0, 0 }, { 0, 0 },
761 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
762 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
763 { 0, 0 }, { 0,1628 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
764 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
765 { 0, 0 }, { 0, 0 }, { 66, 406 }, { 0, 0 }, { 0, 0 },
766 { 0, 0 }, { 77, 394 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
767 { 0, 0 }, { 0, 0 }, { 83, 396 }, { 0, 0 }, { 0, 0 },
768
769 { 84, 396 }, { 82, 395 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
770 { 73, 399 }, { 83, 406 }, { 0, 0 }, { 76, 401 }, { 0, 56 },
771 { 0,1594 }, { 1, 0 }, { 2, 0 }, { 3, 0 }, { 4, 0 },
772 { 5, 0 }, { 6, 0 }, { 7, 0 }, { 8, 0 }, { 9, 0 },
773 { 10, 0 }, { 11, 0 }, { 12, 0 }, { 13, 0 }, { 14, 0 },
774 { 15, 0 }, { 16, 0 }, { 17, 0 }, { 18, 0 }, { 19, 0 },
775 { 20, 0 }, { 21, 0 }, { 22, 0 }, { 23, 0 }, { 24, 0 },
776 { 25, 0 }, { 26, 0 }, { 27, 0 }, { 28, 0 }, { 29, 0 },
777 { 30, 0 }, { 31, 0 }, { 32, 0 }, { 33, 0 }, { 34, 0 },
778 { 35, 0 }, { 36, 0 }, { 37, 0 }, { 38, 0 }, { 73, 360 },
779
780 { 40, 0 }, { 41, 0 }, { 42, 0 }, { 43, 0 }, { 44, 0 },
781 { 45, 0 }, { 46, 0 }, { 47, 0 }, { 48, 0 }, { 49, 0 },
782 { 50, 0 }, { 51, 0 }, { 52, 0 }, { 53, 0 }, { 54, 0 },
783 { 55, 0 }, { 56, 0 }, { 57, 0 }, { 58, 0 }, { 59, 0 },
784 { 60, 0 }, { 61, 0 }, { 62, 0 }, { 63, 0 }, { 64, 0 },
785 { 65, 0 }, { 66, 0 }, { 67, 0 }, { 68, 0 }, { 69, 0 },
786 { 70, 0 }, { 71, 0 }, { 72, 0 }, { 73, 0 }, { 74, 0 },
787 { 75, 0 }, { 76, 0 }, { 77, 0 }, { 78, 0 }, { 79, 0 },
788 { 80, 0 }, { 81, 0 }, { 82, 0 }, { 83, 0 }, { 84, 0 },
789 { 85, 0 }, { 86, 0 }, { 87, 0 }, { 88, 0 }, { 89, 0 },
790
791 { 90, 0 }, { 91, 0 }, { 0, 0 }, { 93, 0 }, { 94, 0 },
792 { 95, 0 }, { 96, 0 }, { 97, 0 }, { 98, 0 }, { 99, 0 },
793 { 100, 0 }, { 101, 0 }, { 102, 0 }, { 103, 0 }, { 104, 0 },
794 { 105, 0 }, { 106, 0 }, { 107, 0 }, { 108, 0 }, { 109, 0 },
795 { 110, 0 }, { 111, 0 }, { 112, 0 }, { 113, 0 }, { 114, 0 },
796 { 115, 0 }, { 116, 0 }, { 117, 0 }, { 118, 0 }, { 119, 0 },
797 { 120, 0 }, { 121, 0 }, { 122, 0 }, { 123, 0 }, { 124, 0 },
798 { 125, 0 }, { 126, 0 }, { 127, 0 }, { 128, 0 }, { 129, 0 },
799 { 130, 0 }, { 131, 0 }, { 132, 0 }, { 133, 0 }, { 134, 0 },
800 { 135, 0 }, { 136, 0 }, { 137, 0 }, { 138, 0 }, { 139, 0 },
801
802 { 140, 0 }, { 141, 0 }, { 142, 0 }, { 143, 0 }, { 144, 0 },
803 { 145, 0 }, { 146, 0 }, { 147, 0 }, { 148, 0 }, { 149, 0 },
804 { 150, 0 }, { 151, 0 }, { 152, 0 }, { 153, 0 }, { 154, 0 },
805 { 155, 0 }, { 156, 0 }, { 157, 0 }, { 158, 0 }, { 159, 0 },
806 { 160, 0 }, { 161, 0 }, { 162, 0 }, { 163, 0 }, { 164, 0 },
807 { 165, 0 }, { 166, 0 }, { 167, 0 }, { 168, 0 }, { 169, 0 },
808 { 170, 0 }, { 171, 0 }, { 172, 0 }, { 173, 0 }, { 174, 0 },
809 { 175, 0 }, { 176, 0 }, { 177, 0 }, { 178, 0 }, { 179, 0 },
810 { 180, 0 }, { 181, 0 }, { 182, 0 }, { 183, 0 }, { 184, 0 },
811 { 185, 0 }, { 186, 0 }, { 187, 0 }, { 188, 0 }, { 189, 0 },
812
813 { 190, 0 }, { 191, 0 }, { 192, 0 }, { 193, 0 }, { 194, 0 },
814 { 195, 0 }, { 196, 0 }, { 197, 0 }, { 198, 0 }, { 199, 0 },
815 { 200, 0 }, { 201, 0 }, { 202, 0 }, { 203, 0 }, { 204, 0 },
816 { 205, 0 }, { 206, 0 }, { 207, 0 }, { 208, 0 }, { 209, 0 },
817 { 210, 0 }, { 211, 0 }, { 212, 0 }, { 213, 0 }, { 214, 0 },
818 { 215, 0 }, { 216, 0 }, { 217, 0 }, { 218, 0 }, { 219, 0 },
819 { 220, 0 }, { 221, 0 }, { 222, 0 }, { 223, 0 }, { 224, 0 },
820 { 225, 0 }, { 226, 0 }, { 227, 0 }, { 228, 0 }, { 229, 0 },
821 { 230, 0 }, { 231, 0 }, { 232, 0 }, { 233, 0 }, { 234, 0 },
822 { 235, 0 }, { 236, 0 }, { 237, 0 }, { 238, 0 }, { 239, 0 },
823
824 { 240, 0 }, { 241, 0 }, { 242, 0 }, { 243, 0 }, { 244, 0 },
825 { 245, 0 }, { 246, 0 }, { 247, 0 }, { 248, 0 }, { 249, 0 },
826 { 250, 0 }, { 251, 0 }, { 252, 0 }, { 253, 0 }, { 254, 0 },
827 { 255, 0 }, { 256, 0 }, { 0, 6 }, { 0,1336 }, { 0, 0 },
828 { 0,1334 }, { 0, 0 }, { 0,1332 }, { 0, 0 }, { 0, 0 },
829 { 0,1329 }, { 0, 0 }, { 0,1327 }, { 0, 0 }, { 0, 0 },
830 { 0,1324 }, { 0, 0 }, { 0,1322 }, { 0, 0 }, { 0,1320 },
831 { 0, 8 }, { 0,1318 }, { 0, 0 }, { 0,1316 }, { 0, 0 },
832 { 0,1314 }, { 0, 0 }, { 0,1312 }, { 0, 0 }, { 0,1310 },
833 { 0, 0 }, { 0,1308 }, { 0, 0 }, { 0,1306 }, { 0, 0 },
834
835 { 0,1304 }, { 0, 0 }, { 0,1302 }, { 0, 0 }, { 0,1300 },
836 { 0, 0 }, { 0,1298 }, { 0, 0 }, { 0,1296 }, { 0, 0 },
837 { 0,1294 }, { 0, 15 }, { 0,1292 }, { 0, 0 }, { 0,1290 },
838 { 0, 0 }, { 48, 0 }, { 49, 0 }, { 50, 0 }, { 51, 0 },
839 { 52, 0 }, { 53, 0 }, { 54, 0 }, { 55, 0 }, { 56, 0 },
840 { 57, 0 }, { 0, 0 }, { 0,1277 }, { 0, 0 }, { 0,1275 },
841 { 0, 0 }, { 0,1273 }, { 0, 0 }, { 0,1271 }, { 0, 0 },
842 { 0, 0 }, { 0,1268 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
843 { 0,1264 }, { 0, 0 }, { 70, 76 }, { 73, 70 }, { 69, 75 },
844 { 65, 74 }, { 0, 0 }, { 0, 0 }, { 0,1256 }, { 0, 0 },
845
846 { 0,1254 }, { 0, 0 }, { 0,1252 }, { 0, 0 }, { 0,1250 },
847 { 78, 75 }, { 0, 0 }, { 73, 77 }, { 0, 0 }, { 0,1245 },
848 { 0, 0 }, { 0,1243 }, { 68, 87 }, { 0, 23 }, { 0,1240 },
849 { 67, 91 }, { 84, 77 }, { 79, 76 }, { 0, 0 }, { 73, 89 },
850 { 0, 0 }, { 67, 93 }, { 0, 0 }, { 0,1231 }, { 84, 83 },
851 { 73, 92 }, { 84, 86 }, { 0, 11 }, { 0,1226 }, { 69, 95 },
852 { 0, 12 }, { 0,1223 }, { 0, 0 }, { 69, 93 }, { 0, 0 },
853 { 0,1219 }, { 0, 0 }, { 79, 94 }, { 0, 0 }, { 0,1215 },
854 { 84, 94 }, { 0, 0 }, { 0,1212 }, { 0, 0 }, { 0,1210 },
855 { 95, 92 }, { 0, 0 }, { 0,1207 }, { 67, 90 }, { 0, 53 },
856
857 { 0,1204 }, { 0, 0 }, { 0,1202 }, { 0, 0 }, { 0, 0 },
858 { 0,1199 }, { 0, 0 }, { 0,1197 }, { 0, 0 }, { 0,1195 },
859 { 83, 82 }, { 0, 0 }, { 0,1192 }, { 0, 0 }, { 85, 83 },
860 { 79, 89 }, { 76, 87 }, { 69, 81 }, { 85, 90 }, { 0, 0 },
861 { 0, 0 }, { 0,1183 }, { 0, 0 }, { 0,1181 }, { 0, 0 },
862 { 0,1179 }, { 0, 0 }, { 0,1177 }, { 0, 0 }, { 0,1175 },
863 { 78, 83 }, { 0, 49 }, { 0,1172 }, { 83, 82 }, { 0, 0 },
864 { 0,1169 }, { 0, 0 }, { 0,1167 }, { 84, 83 }, { 78, 84 },
865 { 0, 0 }, { 82, 84 }, { 0, 0 }, { 0,1161 }, { 0, 0 },
866 { 0,1159 }, { 0, 0 }, { 0,1157 }, { 0, 0 }, { 0, 0 },
867
868 { 0,1154 }, { 0, 0 }, { 0,1152 }, { 0, 0 }, { 0,1150 },
869 { 82, 74 }, { 0, 0 }, { 0,1147 }, { 69, 63 }, { 0, 0 },
870 { 0,1144 }, { 0, 0 }, { 0,1142 }, { 0, 0 }, { 70, 63 },
871 { 0, 0 }, { 69, 63 }, { 0, 51 }, { 0,1136 }, { 77, 62 },
872 { 0, 0 }, { 0,1133 }, { 65, 64 }, { 0, 0 }, { 0,1130 },
873 { 0, 0 }, { 67, 65 }, { 0, 0 }, { 66, 70 }, { 0, 0 },
874 { 95, 65 }, { 0, 0 }, { 0,1122 }, { 0, 0 }, { 0,1120 },
875 { 0, 0 }, { 0,1118 }, { 0, 0 }, { 86, 60 }, { 84, 63 },
876 { 69, 63 }, { 0, 0 }, { 65, 69 }, { 0, 0 }, { 0,1110 },
877 { 0, 0 }, { 0,1108 }, { 0, 0 }, { 0,1106 }, { 0, 0 },
878
879 { 77, 63 }, { 0, 0 }, { 0,1102 }, { 0, 0 }, { 69, 67 },
880 { 0, 0 }, { 69, 71 }, { 0, 9 }, { 0,1096 }, { 0, 0 },
881 { 0,1094 }, { 82, 69 }, { 0, 28 }, { 0,1091 }, { 69, 68 },
882 { 0, 0 }, { 0, 0 }, { 0,1087 }, { 0, 0 }, { 0,1085 },
883 { 95, 69 }, { 0, 0 }, { 79, 67 }, { 73, 69 }, { 0, 0 },
884 { 0,1079 }, { 0, 0 }, { 0,1077 }, { 76, 73 }, { 0, 0 },
885 { 73, 78 }, { 69, 78 }, { 85, 70 }, { 79, 73 }, { 0, 0 },
886 { 0,1069 }, { 0, 0 }, { 0,1067 }, { 78, 77 }, { 0, 14 },
887 { 0,1064 }, { 0, 0 }, { 0,1062 }, { 0, 0 }, { 0,1060 },
888 { 0, 0 }, { 0,1058 }, { 0, 0 }, { 77, 71 }, { 0, 0 },
889
890 { 0, 0 }, { 0,1053 }, { 0, 48 }, { 0,1051 }, { 0, 0 },
891 { 69, 67 }, { 82, 70 }, { 0, 0 }, { 0,1046 }, { 0, 0 },
892 { 0,1044 }, { 0, 0 }, { 66, 64 }, { 0, 0 }, { 0,1040 },
893 { 83, 64 }, { 0, 18 }, { 0,1037 }, { 0, 10 }, { 0,1035 },
894 { 0, 0 }, { 0,1033 }, { 0, 0 }, { 79, 64 }, { 0, 0 },
895 { 0,1029 }, { 0, 0 }, { 0,1027 }, { 76, 65 }, { 95, 67 },
896 { 0, 0 }, { 0,1023 }, { 0, 0 }, { 0,1021 }, { 0, 0 },
897 { 0, 0 }, { 0,1018 }, { 0, 0 }, { 0, 0 }, { 0,1015 },
898 { 0, 0 }, { 0,1013 }, { 0, 0 }, { 95, 66 }, { 77, 54 },
899 { 68, 54 }, { 0, 0 }, { 78, 56 }, { 0, 0 }, { 89, 59 },
900
901 { 0, 0 }, { 76, 52 }, { 67, 48 }, { 0, 0 }, { 0,1000 },
902 { 0, 0 }, { 0, 998 }, { 0, 0 }, { 0, 996 }, { 0, 0 },
903 { 0, 994 }, { 0, 0 }, { 0, 0 }, { 67, 58 }, { 0, 0 },
904 { 0, 989 }, { 0, 0 }, { 73, 47 }, { 67, 55 }, { 0, 22 },
905 { 0, 984 }, { 84, 49 }, { 0, 0 }, { 0, 981 }, { 0, 0 },
906 { 0, 979 }, { 0, 0 }, { 0, 977 }, { 0, 0 }, { 0, 0 },
907 { 0, 974 }, { 0, 0 }, { 0, 972 }, { 0, 0 }, { 70, 51 },
908 { 0, 0 }, { 76, 50 }, { 95, 47 }, { 0, 0 }, { 0, 0 },
909 { 69, 52 }, { 0, 0 }, { 65, 50 }, { 85, 50 }, { 0, 0 },
910 { 0, 0 }, { 65, 49 }, { 0, 0 }, { 65, 49 }, { 0, 0 },
911
912 { 83, 53 }, { 65, 67 }, { 0, 0 }, { 0, 951 }, { 0, 0 },
913 { 80, 50 }, { 67, 70 }, { 66, 70 }, { 0, 0 }, { 0, 945 },
914 { 0, 0 }, { 0, 943 }, { 0, 0 }, { 0, 941 }, { 0, 0 },
915 { 0, 939 }, { 0, 0 }, { 0, 937 }, { 0, 0 }, { 0, 935 },
916 { 0, 0 }, { 0, 0 }, { 0, 932 }, { 0, 0 }, { 0, 930 },
917 { 0, 0 }, { 0, 928 }, { 0, 0 }, { 0, 0 }, { 69, 59 },
918 { 0, 0 }, { 0, 0 }, { 0, 922 }, { 0, 13 }, { 0, 920 },
919 { 79, 59 }, { 82, 59 }, { 0, 0 }, { 73, 57 }, { 0, 0 },
920 { 0, 914 }, { 0, 0 }, { 84, 59 }, { 0, 0 }, { 0, 0 },
921 { 0, 0 }, { 0, 908 }, { 0, 0 }, { 0, 906 }, { 0, 16 },
922
923 { 0, 904 }, { 78, 51 }, { 0, 0 }, { 0, 901 }, { 0, 0 },
924 { 78, 55 }, { 76, 54 }, { 0, 0 }, { 0, 896 }, { 0, 0 },
925 { 85, 51 }, { 0, 0 }, { 0, 892 }, { 0, 0 }, { 0, 0 },
926 { 0, 889 }, { 84, 58 }, { 0, 0 }, { 0, 886 }, { 0, 27 },
927 { 0, 884 }, { 0, 47 }, { 0, 882 }, { 0, 0 }, { 71, 43 },
928 { 0, 0 }, { 0, 878 }, { 0, 0 }, { 0, 876 }, { 0, 0 },
929 { 69, 39 }, { 0, 50 }, { 0, 872 }, { 0, 0 }, { 0, 870 },
930 { 0, 0 }, { 73, 40 }, { 0, 0 }, { 79, 39 }, { 0, 0 },
931 { 0, 864 }, { 0, 0 }, { 0, 862 }, { 0, 0 }, { 0, 860 },
932 { 0, 0 }, { 0, 858 }, { 80, 45 }, { 76, 46 }, { 0, 0 },
933
934 { 85, 43 }, { 69, 44 }, { 0, 0 }, { 0, 0 }, { 0, 850 },
935 { 0, 0 }, { 0, 848 }, { 0, 0 }, { 84, 46 }, { 0, 0 },
936 { 84, 46 }, { 0, 24 }, { 0, 842 }, { 73, 38 }, { 95, 46 },
937 { 69, 36 }, { 0, 0 }, { 0, 837 }, { 0, 0 }, { 66, 37 },
938 { 0, 0 }, { 0, 833 }, { 0, 0 }, { 0, 0 }, { 0, 830 },
939 { 0, 0 }, { 0, 828 }, { 0, 17 }, { 0, 826 }, { 0, 0 },
940 { 65, 31 }, { 0, 26 }, { 0, 822 }, { 85, 36 }, { 69, 39 },
941 { 0, 0 }, { 78, 34 }, { 0, 0 }, { 0, 816 }, { 0, 0 },
942 { 0, 814 }, { 0, 0 }, { 77, 41 }, { 0, 0 }, { 76, 44 },
943 { 0, 0 }, { 0, 808 }, { 85, 32 }, { 0, 0 }, { 0, 0 },
944
945 { 0, 804 }, { 0, 0 }, { 0, 802 }, { 0, 0 }, { 0, 800 },
946 { 79, 45 }, { 0, 0 }, { 79, 46 }, { 0, 0 }, { 69, 38 },
947 { 0, 0 }, { 0, 793 }, { 78, 42 }, { 0, 0 }, { 0, 790 },
948 { 0, 0 }, { 0, 788 }, { 95, 45 }, { 0, 19 }, { 0, 785 },
949 { 0, 25 }, { 0, 783 }, { 0, 0 }, { 0, 0 }, { 0, 780 },
950 { 0, 0 }, { 84, 40 }, { 0, 0 }, { 84, 44 }, { 73, 44 },
951 { 0, 0 }, { 85, 44 }, { 78, 42 }, { 0, 0 }, { 67, 35 },
952 { 68, 37 }, { 0, 0 }, { 0, 767 }, { 0, 0 }, { 0, 765 },
953 { 0, 0 }, { 0, 763 }, { 0, 0 }, { 0, 0 }, { 0, 760 },
954 { 0, 0 }, { 0, 758 }, { 80, 44 }, { 0, 0 }, { 0, 755 },
955
956 { 0, 0 }, { 84, 47 }, { 78, 45 }, { 0, 0 }, { 0, 750 },
957 { 0, 0 }, { 85, 45 }, { 0, 0 }, { 68, 47 }, { 0, 0 },
958 { 84, 45 }, { 0, 0 }, { 0, 742 }, { 0, 52 }, { 0, 740 },
959 { 0, 0 }, { 0, 738 }, { 71, 43 }, { 68, 41 }, { 0, 0 },
960 { 0, 734 }, { 0, 0 }, { 0, 732 }, { 69, 42 }, { 72, 42 },
961 { 0, 0 }, { 0, 728 }, { 0, 0 }, { 0, 726 }, { 0, 0 },
962 { 0, 724 }, { 0, 0 }, { 0, 722 }, { 95, 36 }, { 0, 0 },
963 { 0, 719 }, { 82, 45 }, { 0, 0 }, { 0, 716 }, { 0, 0 },
964 { 79, 43 }, { 67, 42 }, { 68, 46 }, { 0, 0 }, { 0, 710 },
965 { 0, 0 }, { 0, 708 }, { 0, 0 }, { 0, 706 }, { 83, 48 },
966
967 { 0, 0 }, { 0, 703 }, { 0, 0 }, { 89, 48 }, { 0, 0 },
968 { 0, 0 }, { 0, 698 }, { 0, 0 }, { 84, 48 }, { 65, 38 },
969 { 73, 39 }, { 0, 0 }, { 73, 39 }, { 0, 0 }, { 73, 39 },
970 { 0, 0 }, { 0, 688 }, { 0, 0 }, { 0, 686 }, { 0, 0 },
971 { 0, 684 }, { 0, 0 }, { 73, 39 }, { 0, 0 }, { 0, 680 },
972 { 0, 0 }, { 0, 678 }, { 0, 0 }, { 0, 676 }, { 0, 0 },
973 { 0, 674 }, { 0, 0 }, { 86, 39 }, { 0, 44 }, { 0, 670 },
974 { 0, 0 }, { 82, 40 }, { 0, 0 }, { 72, 32 }, { 69, 31 },
975 { 0, 46 }, { 0, 663 }, { 80, 34 }, { 0, 0 }, { 0, 660 },
976 { 0, 0 }, { 0, 658 }, { 0, 0 }, { 0, 656 }, { 0, 0 },
977
978 { 0, 0 }, { 0, 653 }, { 82, 36 }, { 0, 0 }, { 0, 650 },
979 { 79, 42 }, { 78, 42 }, { 0, 0 }, { 73, 43 }, { 0, 0 },
980 { 78, 44 }, { 89, 44 }, { 0, 0 }, { 65, 46 }, { 0, 0 },
981 { 69, 45 }, { 0, 0 }, { 0, 637 }, { 0, 0 }, { 0, 635 },
982 { 0, 0 }, { 0, 633 }, { 0, 0 }, { 0, 631 }, { 86, 42 },
983 { 95, 44 }, { 0, 0 }, { 0, 627 }, { 84, 40 }, { 73, 42 },
984 { 0, 0 }, { 0, 623 }, { 0, 0 }, { 0, 0 }, { 0, 620 },
985 { 0, 0 }, { 0, 618 }, { 86, 45 }, { 0, 0 }, { 69, 47 },
986 { 0, 0 }, { 0, 613 }, { 0, 36 }, { 0, 611 }, { 0, 0 },
987 { 67, 45 }, { 80, 35 }, { 73, 45 }, { 0, 0 }, { 69, 47 },
988
989 { 0, 0 }, { 0, 603 }, { 0, 20 }, { 0, 601 }, { 78, 45 },
990 { 0, 0 }, { 0, 0 }, { 0, 597 }, { 0, 0 }, { 0, 595 },
991 { 0, 41 }, { 0, 593 }, { 0, 0 }, { 95, 36 }, { 0, 43 },
992 { 0, 589 }, { 0, 0 }, { 0, 587 }, { 0, 0 }, { 73, 40 },
993 { 69, 42 }, { 0, 0 }, { 78, 40 }, { 0, 0 }, { 0, 580 },
994 { 0, 0 }, { 0, 578 }, { 0, 0 }, { 0, 0 }, { 95, 47 },
995 { 0, 0 }, { 0, 573 }, { 0, 0 }, { 79, 47 }, { 86, 43 },
996 { 0, 0 }, { 0, 568 }, { 0, 0 }, { 0, 566 }, { 0, 0 },
997 { 69, 38 }, { 0, 0 }, { 69, 38 }, { 0, 45 }, { 0, 560 },
998 { 0, 40 }, { 0, 558 }, { 78, 38 }, { 0, 0 }, { 0, 555 },
999
1000 { 83, 36 }, { 0, 0 }, { 0, 552 }, { 67, 40 }, { 0, 0 },
1001 { 0, 549 }, { 0, 0 }, { 0, 547 }, { 0, 0 }, { 82, 38 },
1002 { 69, 40 }, { 80, 36 }, { 78, 40 }, { 0, 31 }, { 0, 540 },
1003 { 0, 33 }, { 0, 538 }, { 0, 0 }, { 0, 536 }, { 0, 0 },
1004 { 0, 534 }, { 0, 0 }, { 0, 0 }, { 0, 531 }, { 0, 0 },
1005 { 0, 529 }, { 0, 0 }, { 0, 527 }, { 0, 35 }, { 0, 525 },
1006 { 0, 30 }, { 0, 523 }, { 65, 38 }, { 0, 0 }, { 0, 520 },
1007 { 76, 35 }, { 85, 35 }, { 80, 31 }, { 0, 0 }, { 0, 515 },
1008 { 0, 0 }, { 0, 513 }, { 0, 0 }, { 69, 33 }, { 83, 35 },
1009 { 69, 38 }, { 0, 0 }, { 0, 507 }, { 0, 0 }, { 0, 505 },
1010
1011 { 0, 0 }, { 0, 503 }, { 0, 0 }, { 0, 501 }, { 0, 0 },
1012 { 0, 499 }, { 95, 38 }, { 0, 0 }, { 0, 496 }, { 0, 0 },
1013 { 95, 37 }, { 0, 0 }, { 0, 492 }, { 82, 35 }, { 0, 0 },
1014 { 0, 489 }, { 0, 0 }, { 0, 0 }, { 0, 486 }, { 0, 0 },
1015 { 84, 32 }, { 0, 0 }, { 0, 482 }, { 85, 32 }, { 0, 0 },
1016 { 0, 479 }, { 0, 0 }, { 0, 477 }, { 0, 0 }, { 80, 24 },
1017 { 0, 0 }, { 0, 0 }, { 80, 23 }, { 76, 22 }, { 0, 0 },
1018 { 0, 469 }, { 0, 0 }, { 82, 22 }, { 65, 26 }, { 0, 0 },
1019 { 65, 26 }, { 0, 0 }, { 65, 26 }, { 0, 0 }, { 0, 460 },
1020 { 0, 0 }, { 0, 458 }, { 83, 17 }, { 80, 23 }, { 0, 0 },
1021
1022 { 0, 454 }, { 0, 0 }, { 0, 452 }, { 0, 0 }, { 84, 27 },
1023 { 0, 0 }, { 0, 448 }, { 0, 0 }, { 0, 446 }, { 95, 20 },
1024 { 0, 0 }, { 95, 23 }, { 0, 0 }, { 0, 441 }, { 80, 24 },
1025 { 0, 0 }, { 0, 438 }, { 0, 0 }, { 0, 0 }, { 80, 23 },
1026 { 0, 0 }, { 0, 433 }, { 0, 0 }, { 65, 36 }, { 95, 26 },
1027 { 0, 0 }, { 85, 24 }, { 65, 34 }, { 0, 0 }, { 0, 425 },
1028 { 77, 24 }, { 82, 23 }, { 0, 0 }, { 82, 24 }, { 0, 0 },
1029 { 80, 30 }, { 68, 34 }, { 65, 34 }, { 0, 0 }, { 0, 415 },
1030 { 65, 33 }, { 0, 0 }, { 95, 21 }, { 0, 0 }, { 0, 410 },
1031 { 0, 0 }, { 69, 36 }, { 0, 0 }, { 0, 0 }, { 84, 35 },
1032
1033 { 65, 31 }, { 0, 0 }, { 0, 402 }, { 0, 0 }, { 0, 400 },
1034 { 0, 0 }, { 0, 398 }, { 0, 0 }, { 0, 0 }, { 0, 395 },
1035 { 0, 0 }, { 0, 393 }, { 0, 0 }, { 0, 391 }, { 0, 0 },
1036 { 0, 389 }, { 0, 0 }, { 0, 387 }, { 0, 0 }, { 0, 0 },
1037 { 0, 384 }, { 0, 0 }, { 0, 382 }, { 0, 0 }, { 0, 0 },
1038 { 0, 379 }, { 82, 27 }, { 0, 0 }, { 82, 33 }, { 0, 0 },
1039 { 0, 0 }, { 0, 373 }, { 0, 0 }, { 77, 46 }, { 82, 42 },
1040 { 77, 46 }, { 65, 40 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1041 { 0, 364 }, { 0, 0 }, { 0, 362 }, { 0, 0 }, { 65, 34 },
1042 { 95, 39 }, { 0, 0 }, { 84, 43 }, { 82, 43 }, { 0, 0 },
1043
1044 { 0, 354 }, { 0, 0 }, { 0, 352 }, { 0, 0 }, { 0, 0 },
1045 { 0, 349 }, { 0, 0 }, { 68, 26 }, { 0, 0 }, { 0, 345 },
1046 { 0, 39 }, { 0, 343 }, { 0, 0 }, { 0, 341 }, { 0, 0 },
1047 { 0, 339 }, { 0, 0 }, { 73, 23 }, { 0, 0 }, { 0, 335 },
1048 { 0, 0 }, { 69, 18 }, { 0, 0 }, { 69, 18 }, { 65, 22 },
1049 { 69, 19 }, { 0, 0 }, { 0, 327 }, { 0, 0 }, { 0, 325 },
1050 { 0, 0 }, { 0, 0 }, { 0, 322 }, { 0, 0 }, { 0, 320 },
1051 { 0, 0 }, { 0, 318 }, { 0, 0 }, { 77, 29 }, { 0, 0 },
1052 { 77, 29 }, { 0, 0 }, { 0, 0 }, { 0, 311 }, { 0, 0 },
1053 { 0, 0 }, { 0, 308 }, { 82, 35 }, { 0, 0 }, { 0, 305 },
1054
1055 { 0, 0 }, { 0, 303 }, { 0, 0 }, { 86, 35 }, { 84, 35 },
1056 { 0, 0 }, { 84, 37 }, { 82, 36 }, { 77, 32 }, { 69, 25 },
1057 { 0, 0 }, { 69, 27 }, { 0, 38 }, { 0, 291 }, { 0, 42 },
1058 { 0, 289 }, { 0, 0 }, { 0, 287 }, { 0, 0 }, { 0, 285 },
1059 { 0, 0 }, { 69, 27 }, { 0, 0 }, { 73, 27 }, { 69, 27 },
1060 { 0, 0 }, { 0, 278 }, { 0, 0 }, { 69, 25 }, { 0, 0 },
1061 { 0, 274 }, { 0, 0 }, { 69, 23 }, { 0, 37 }, { 0, 270 },
1062 { 0, 0 }, { 0, 268 }, { 0, 29 }, { 0, 266 }, { 0, 32 },
1063 { 0, 264 }, { 0, 0 }, { 0, 262 }, { 0, 34 }, { 0, 260 },
1064 { 0, 21 }, { 0, 258 }, { 0, 0 }, { 0, 0 }, { 84, 28 },
1065
1066 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 84, 27 }, { 0, 0 },
1067 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1068 { 0, 0 }, { 82, 22 }, { 69, 26 }, { 86, 22 }, { 82, 31 },
1069 { 69, 30 }, { 82, 31 }, { 0, 0 }, { 69, 31 }, { 0, 0 },
1070 { 84, 31 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1071 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1072 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 83, 33 },
1073 { 0, 0 }, { 69, 19 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1074 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1075 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1076
1077 { 0, 0 }, { 82, 19 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1078 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 82, 14 }, { 0, 0 },
1079 { 0, 0 }, { 0, 0 }, { 82, 12 }, { 0, 0 }, { 0, 0 },
1080 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 82, 8 }, { 0, 0 },
1081 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1082 { 83, 4 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1083 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1084 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1085 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1086 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1087
1088 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1089 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1090 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1091 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1092 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1093 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1094 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1095 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1096 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1097 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1098
1099 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1100 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1101 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1102 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1103 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1104 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1105 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1106 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1107 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1108 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1109
1110 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1111 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1112 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1113 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1114 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1115 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1116 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1117 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1118 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1119 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1120
1121 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 257, 67 }, { 1, 0 },
1122 };
1123
1124 static yyconst struct yy_trans_info *yy_start_state_list[5] =
1125 {
1126 &yy_transition[1],
1127 &yy_transition[3],
1128 &yy_transition[261],
1129 &yy_transition[519],
1130 &yy_transition[777],
1131 } ;
1132
1133 /* The intent behind this definition is that it'll catch
1134 * any uses of REJECT which flex missed.
1135 */
1136 #define REJECT reject_used_but_not_detected
1137 #define yymore() yymore_used_but_not_detected
1138 #define YY_MORE_ADJ 0
1139 #define YY_RESTORE_YY_MORE_OFFSET
1140 #line 1 "lscp.l"
1141 /***************************************************************************
1142 * *
1143 * LinuxSampler - modular, streaming capable sampler *
1144 * *
1145 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
1146 * *
1147 * This program is free software; you can redistribute it and/or modify *
1148 * it under the terms of the GNU General Public License as published by *
1149 * the Free Software Foundation; either version 2 of the License, or *
1150 * (at your option) any later version. *
1151 * *
1152 * This program is distributed in the hope that it will be useful, *
1153 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
1154 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
1155 * GNU General Public License for more details. *
1156 * *
1157 * You should have received a copy of the GNU General Public License *
1158 * along with this program; if not, write to the Free Software *
1159 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
1160 * MA 02111-1307 USA *
1161 ***************************************************************************/
1162 #line 24 "lscp.l"
1163
1164 #include "lscpparser.h"
1165 #include "lscpsymbols.h"
1166
1167
1168 #line 1169 "lex.yy.c"
1169
1170 #define INITIAL 0
1171 #define INSTRING 1
1172
1173 #ifndef YY_NO_UNISTD_H
1174 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1175 * down here because we want the user's section 1 to have been scanned first.
1176 * The user has a chance to override it with an option.
1177 */
1178 #include <unistd.h>
1179 #endif
1180
1181 #ifndef YY_EXTRA_TYPE
1182 #define YY_EXTRA_TYPE void *
1183 #endif
1184
1185 /* Holds the entire state of the reentrant scanner. */
1186 struct yyguts_t
1187 {
1188
1189 /* User-defined. Not touched by flex. */
1190 YY_EXTRA_TYPE yyextra_r;
1191
1192 /* The rest are the same as the globals declared in the non-reentrant scanner. */
1193 FILE *yyin_r, *yyout_r;
1194 size_t yy_buffer_stack_top; /**< index of top of stack. */
1195 size_t yy_buffer_stack_max; /**< capacity of stack. */
1196 YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
1197 char yy_hold_char;
1198 int yy_n_chars;
1199 int yyleng_r;
1200 char *yy_c_buf_p;
1201 int yy_init;
1202 int yy_start;
1203 int yy_did_buffer_switch_on_eof;
1204 int yy_start_stack_ptr;
1205 int yy_start_stack_depth;
1206 int *yy_start_stack;
1207 yy_state_type yy_last_accepting_state;
1208 char* yy_last_accepting_cpos;
1209
1210 int yylineno_r;
1211 int yy_flex_debug_r;
1212
1213 char *yytext_r;
1214 int yy_more_flag;
1215 int yy_more_len;
1216
1217 }; /* end struct yyguts_t */
1218
1219 /* Accessor methods to globals.
1220 These are made visible to non-reentrant scanners for convenience. */
1221
1222 int yylex_destroy (yyscan_t yyscanner );
1223
1224 int yyget_debug (yyscan_t yyscanner );
1225
1226 void yyset_debug (int debug_flag ,yyscan_t yyscanner );
1227
1228 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner );
1229
1230 void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
1231
1232 FILE *yyget_in (yyscan_t yyscanner );
1233
1234 void yyset_in (FILE * in_str ,yyscan_t yyscanner );
1235
1236 FILE *yyget_out (yyscan_t yyscanner );
1237
1238 void yyset_out (FILE * out_str ,yyscan_t yyscanner );
1239
1240 int yyget_leng (yyscan_t yyscanner );
1241
1242 char *yyget_text (yyscan_t yyscanner );
1243
1244 int yyget_lineno (yyscan_t yyscanner );
1245
1246 void yyset_lineno (int line_number ,yyscan_t yyscanner );
1247
1248 /* Macros after this point can all be overridden by user definitions in
1249 * section 1.
1250 */
1251
1252 #ifndef YY_SKIP_YYWRAP
1253 #ifdef __cplusplus
1254 extern "C" int yywrap (yyscan_t yyscanner );
1255 #else
1256 extern int yywrap (yyscan_t yyscanner );
1257 #endif
1258 #endif
1259
1260 static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner);
1261
1262 #ifndef yytext_ptr
1263 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
1264 #endif
1265
1266 #ifdef YY_NEED_STRLEN
1267 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
1268 #endif
1269
1270 #ifndef YY_NO_INPUT
1271
1272 #ifdef __cplusplus
1273 static int yyinput (yyscan_t yyscanner );
1274 #else
1275 static int input (yyscan_t yyscanner );
1276 #endif
1277
1278 #endif
1279
1280 /* Amount of stuff to slurp up with each read. */
1281 #ifndef YY_READ_BUF_SIZE
1282 #define YY_READ_BUF_SIZE 8192
1283 #endif
1284
1285 /* Copy whatever the last rule matched to the standard output. */
1286 #ifndef ECHO
1287 /* This used to be an fputs(), but since the string might contain NUL's,
1288 * we now use fwrite().
1289 */
1290 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1291 #endif
1292
1293 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1294 * is returned in "result".
1295 */
1296 #ifndef YY_INPUT
1297 #define YY_INPUT(buf,result,max_size) \
1298 errno=0; \
1299 while ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
1300 { \
1301 if( errno != EINTR) \
1302 { \
1303 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1304 break; \
1305 } \
1306 errno=0; \
1307 clearerr(yyin); \
1308 }\
1309 \
1310
1311 #endif
1312
1313 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1314 * we don't want an extra ';' after the "return" because that will cause
1315 * some compilers to complain about unreachable statements.
1316 */
1317 #ifndef yyterminate
1318 #define yyterminate() return YY_NULL
1319 #endif
1320
1321 /* Number of entries by which start-condition stack grows. */
1322 #ifndef YY_START_STACK_INCR
1323 #define YY_START_STACK_INCR 25
1324 #endif
1325
1326 /* Report a fatal error. */
1327 #ifndef YY_FATAL_ERROR
1328 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
1329 #endif
1330
1331 /* end tables serialization structures and prototypes */
1332
1333 /* Default declaration of generated scanner - a define so the user can
1334 * easily add parameters.
1335 */
1336 #ifndef YY_DECL
1337 #define YY_DECL_IS_OURS 1
1338
1339 extern int yylex (yyscan_t yyscanner);
1340
1341 #define YY_DECL int yylex (yyscan_t yyscanner)
1342 #endif /* !YY_DECL */
1343
1344 /* Code executed at the beginning of each rule, after yytext and yyleng
1345 * have been set up.
1346 */
1347 #ifndef YY_USER_ACTION
1348 #define YY_USER_ACTION
1349 #endif
1350
1351 /* Code executed at the end of each rule. */
1352 #ifndef YY_BREAK
1353 #define YY_BREAK break;
1354 #endif
1355
1356 #define YY_RULE_SETUP \
1357 YY_USER_ACTION
1358
1359 /** The main scanner function which does all the work.
1360 */
1361 YY_DECL
1362 {
1363 register yy_state_type yy_current_state;
1364 register char *yy_cp, *yy_bp;
1365 register int yy_act;
1366 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1367
1368 #line 36 "lscp.l"
1369
1370
1371 #line 1372 "lex.yy.c"
1372
1373 if ( yyg->yy_init )
1374 {
1375 yyg->yy_init = 0;
1376
1377 #ifdef YY_USER_INIT
1378 YY_USER_INIT;
1379 #endif
1380
1381 if ( ! yyg->yy_start )
1382 yyg->yy_start = 1; /* first start state */
1383
1384 if ( ! yyin )
1385 yyin = stdin;
1386
1387 if ( ! yyout )
1388 yyout = stdout;
1389
1390 if ( ! YY_CURRENT_BUFFER ) {
1391 yyensure_buffer_stack (yyscanner);
1392 YY_CURRENT_BUFFER_LVALUE =
1393 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1394 }
1395
1396 yy_load_buffer_state(yyscanner );
1397 }
1398
1399 while ( 1 ) /* loops until end-of-file is reached */
1400 {
1401 yy_cp = yyg->yy_c_buf_p;
1402
1403 /* Support of yytext. */
1404 *yy_cp = yyg->yy_hold_char;
1405
1406 /* yy_bp points to the position in yy_ch_buf of the start of
1407 * the current run.
1408 */
1409 yy_bp = yy_cp;
1410
1411 yy_current_state = yy_start_state_list[yyg->yy_start];
1412 yy_match:
1413 {
1414 register yyconst struct yy_trans_info *yy_trans_info;
1415
1416 register YY_CHAR yy_c;
1417
1418 for ( yy_c = YY_SC_TO_UI(*yy_cp);
1419 (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->
1420 yy_verify == yy_c;
1421 yy_c = YY_SC_TO_UI(*++yy_cp) )
1422 {
1423 yy_current_state += yy_trans_info->yy_nxt;
1424
1425 if ( yy_current_state[-1].yy_nxt )
1426 {
1427 yyg->yy_last_accepting_state = yy_current_state;
1428 yyg->yy_last_accepting_cpos = yy_cp;
1429 }
1430 }
1431 }
1432
1433 yy_find_action:
1434 yy_act = yy_current_state[-1].yy_nxt;
1435
1436 YY_DO_BEFORE_ACTION;
1437
1438 do_action: /* This label is used only to access EOF actions. */
1439
1440 switch ( yy_act )
1441 { /* beginning of action switch */
1442 case 0: /* must back up */
1443 /* undo the effects of YY_DO_BEFORE_ACTION */
1444 *yy_cp = yyg->yy_hold_char;
1445 yy_cp = yyg->yy_last_accepting_cpos + 1;
1446 yy_current_state = yyg->yy_last_accepting_state;
1447 goto yy_find_action;
1448
1449 case 1:
1450 YY_RULE_SETUP
1451 #line 38 "lscp.l"
1452 { return SP; }
1453 YY_BREAK
1454 case 2:
1455 /* rule 2 can match eol */
1456 YY_RULE_SETUP
1457 #line 39 "lscp.l"
1458 { return LF; }
1459 YY_BREAK
1460 case 3:
1461 YY_RULE_SETUP
1462 #line 40 "lscp.l"
1463 { return CR; }
1464 YY_BREAK
1465 case 4:
1466 YY_RULE_SETUP
1467 #line 41 "lscp.l"
1468 { return HASH; }
1469 YY_BREAK
1470 case 5:
1471 YY_RULE_SETUP
1472 #line 42 "lscp.l"
1473 { return EQ; }
1474 YY_BREAK
1475 case 6:
1476 YY_RULE_SETUP
1477 #line 43 "lscp.l"
1478 { yylval->Dotnum = atof(yytext); return DOTNUM; }
1479 YY_BREAK
1480 case 7:
1481 YY_RULE_SETUP
1482 #line 44 "lscp.l"
1483 { return ADD; }
1484 YY_BREAK
1485 case 8:
1486 YY_RULE_SETUP
1487 #line 45 "lscp.l"
1488 { return GET; }
1489 YY_BREAK
1490 case 9:
1491 YY_RULE_SETUP
1492 #line 46 "lscp.l"
1493 { return CREATE; }
1494 YY_BREAK
1495 case 10:
1496 YY_RULE_SETUP
1497 #line 47 "lscp.l"
1498 { return DESTROY; }
1499 YY_BREAK
1500 case 11:
1501 YY_RULE_SETUP
1502 #line 48 "lscp.l"
1503 { return LIST; }
1504 YY_BREAK
1505 case 12:
1506 YY_RULE_SETUP
1507 #line 49 "lscp.l"
1508 { return LOAD; }
1509 YY_BREAK
1510 case 13:
1511 YY_RULE_SETUP
1512 #line 50 "lscp.l"
1513 { return NON_MODAL; }
1514 YY_BREAK
1515 case 14:
1516 YY_RULE_SETUP
1517 #line 51 "lscp.l"
1518 { return REMOVE; }
1519 YY_BREAK
1520 case 15:
1521 YY_RULE_SETUP
1522 #line 52 "lscp.l"
1523 { return SET; }
1524 YY_BREAK
1525 case 16:
1526 YY_RULE_SETUP
1527 #line 53 "lscp.l"
1528 { return SUBSCRIBE; }
1529 YY_BREAK
1530 case 17:
1531 YY_RULE_SETUP
1532 #line 54 "lscp.l"
1533 { return UNSUBSCRIBE; }
1534 YY_BREAK
1535 case 18:
1536 YY_RULE_SETUP
1537 #line 55 "lscp.l"
1538 { return CHANNEL; }
1539 YY_BREAK
1540 case 19:
1541 YY_RULE_SETUP
1542 #line 56 "lscp.l"
1543 { return NOTIFICATION; }
1544 YY_BREAK
1545 case 20:
1546 YY_RULE_SETUP
1547 #line 57 "lscp.l"
1548 { return AVAILABLE_ENGINES; }
1549 YY_BREAK
1550 case 21:
1551 YY_RULE_SETUP
1552 #line 58 "lscp.l"
1553 { return AVAILABLE_AUDIO_OUTPUT_DRIVERS; }
1554 YY_BREAK
1555 case 22:
1556 YY_RULE_SETUP
1557 #line 59 "lscp.l"
1558 { return CHANNELS; }
1559 YY_BREAK
1560 case 23:
1561 YY_RULE_SETUP
1562 #line 60 "lscp.l"
1563 { return INFO; }
1564 YY_BREAK
1565 case 24:
1566 YY_RULE_SETUP
1567 #line 61 "lscp.l"
1568 { return BUFFER_FILL; }
1569 YY_BREAK
1570 case 25:
1571 YY_RULE_SETUP
1572 #line 62 "lscp.l"
1573 { return STREAM_COUNT; }
1574 YY_BREAK
1575 case 26:
1576 YY_RULE_SETUP
1577 #line 63 "lscp.l"
1578 { return VOICE_COUNT; }
1579 YY_BREAK
1580 case 27:
1581 YY_RULE_SETUP
1582 #line 64 "lscp.l"
1583 { return INSTRUMENT; }
1584 YY_BREAK
1585 case 28:
1586 YY_RULE_SETUP
1587 #line 65 "lscp.l"
1588 { return ENGINE; }
1589 YY_BREAK
1590 case 29:
1591 YY_RULE_SETUP
1592 #line 66 "lscp.l"
1593 { return AUDIO_OUTPUT_DEVICE_PARAMETER; }
1594 YY_BREAK
1595 case 30:
1596 YY_RULE_SETUP
1597 #line 67 "lscp.l"
1598 { return AUDIO_OUTPUT_DEVICES; }
1599 YY_BREAK
1600 case 31:
1601 YY_RULE_SETUP
1602 #line 68 "lscp.l"
1603 { return AUDIO_OUTPUT_DEVICE; }
1604 YY_BREAK
1605 case 32:
1606 YY_RULE_SETUP
1607 #line 69 "lscp.l"
1608 { return AUDIO_OUTPUT_DRIVER_PARAMETER; }
1609 YY_BREAK
1610 case 33:
1611 YY_RULE_SETUP
1612 #line 70 "lscp.l"
1613 { return AUDIO_OUTPUT_DRIVER; }
1614 YY_BREAK
1615 case 34:
1616 YY_RULE_SETUP
1617 #line 71 "lscp.l"
1618 { return AUDIO_OUTPUT_CHANNEL_PARAMETER; }
1619 YY_BREAK
1620 case 35:
1621 YY_RULE_SETUP
1622 #line 72 "lscp.l"
1623 { return AUDIO_OUTPUT_CHANNEL; }
1624 YY_BREAK
1625 case 36:
1626 YY_RULE_SETUP
1627 #line 73 "lscp.l"
1628 { return AUDIO_OUTPUT_TYPE; }
1629 YY_BREAK
1630 case 37:
1631 YY_RULE_SETUP
1632 #line 74 "lscp.l"
1633 { return AVAILABLE_MIDI_INPUT_DRIVERS; }
1634 YY_BREAK
1635 case 38:
1636 YY_RULE_SETUP
1637 #line 75 "lscp.l"
1638 { return MIDI_INPUT_DEVICE_PARAMETER; }
1639 YY_BREAK
1640 case 39:
1641 YY_RULE_SETUP
1642 #line 76 "lscp.l"
1643 { return MIDI_INPUT_PORT_PARAMETER; }
1644 YY_BREAK
1645 case 40:
1646 YY_RULE_SETUP
1647 #line 77 "lscp.l"
1648 { return MIDI_INPUT_DEVICES; }
1649 YY_BREAK
1650 case 41:
1651 YY_RULE_SETUP
1652 #line 78 "lscp.l"
1653 { return MIDI_INPUT_DEVICE; }
1654 YY_BREAK
1655 case 42:
1656 YY_RULE_SETUP
1657 #line 79 "lscp.l"
1658 { return MIDI_INPUT_DRIVER_PARAMETER; }
1659 YY_BREAK
1660 case 43:
1661 YY_RULE_SETUP
1662 #line 80 "lscp.l"
1663 { return MIDI_INPUT_DRIVER; }
1664 YY_BREAK
1665 case 44:
1666 YY_RULE_SETUP
1667 #line 81 "lscp.l"
1668 { return MIDI_INPUT_PORT; }
1669 YY_BREAK
1670 case 45:
1671 YY_RULE_SETUP
1672 #line 82 "lscp.l"
1673 { return MIDI_INPUT_CHANNEL; }
1674 YY_BREAK
1675 case 46:
1676 YY_RULE_SETUP
1677 #line 83 "lscp.l"
1678 { return MIDI_INPUT_TYPE; }
1679 YY_BREAK
1680 case 47:
1681 YY_RULE_SETUP
1682 #line 84 "lscp.l"
1683 { return MIDI_INPUT; }
1684 YY_BREAK
1685 case 48:
1686 YY_RULE_SETUP
1687 #line 85 "lscp.l"
1688 { return VOLUME; }
1689 YY_BREAK
1690 case 49:
1691 YY_RULE_SETUP
1692 #line 86 "lscp.l"
1693 { return BYTES; }
1694 YY_BREAK
1695 case 50:
1696 YY_RULE_SETUP
1697 #line 87 "lscp.l"
1698 { return PERCENTAGE; }
1699 YY_BREAK
1700 case 51:
1701 YY_RULE_SETUP
1702 #line 88 "lscp.l"
1703 { return RESET; }
1704 YY_BREAK
1705 case 52:
1706 YY_RULE_SETUP
1707 #line 89 "lscp.l"
1708 { return MISCELLANEOUS; }
1709 YY_BREAK
1710 case 53:
1711 YY_RULE_SETUP
1712 #line 90 "lscp.l"
1713 { return QUIT; }
1714 YY_BREAK
1715 case 54:
1716 YY_RULE_SETUP
1717 #line 91 "lscp.l"
1718 { yylval->Number = atoi(yytext); return NUMBER; }
1719 YY_BREAK
1720 case 55:
1721 YY_RULE_SETUP
1722 #line 92 "lscp.l"
1723 { yylval->String = ""; BEGIN(INSTRING); }
1724 YY_BREAK
1725 case 56:
1726 /* rule 56 can match eol */
1727 YY_RULE_SETUP
1728 #line 93 "lscp.l"
1729 { yylval->String += yytext; }
1730 YY_BREAK
1731 case 57:
1732 YY_RULE_SETUP
1733 #line 94 "lscp.l"
1734 { yylval->String += '\n'; }
1735 YY_BREAK
1736 case 58:
1737 YY_RULE_SETUP
1738 #line 95 "lscp.l"
1739 { yylval->String += '\r'; }
1740 YY_BREAK
1741 case 59:
1742 YY_RULE_SETUP
1743 #line 96 "lscp.l"
1744 { yylval->String += '\t'; }
1745 YY_BREAK
1746 case 60:
1747 YY_RULE_SETUP
1748 #line 97 "lscp.l"
1749 { yylval->String += '\\'; }
1750 YY_BREAK
1751 case 61:
1752 YY_RULE_SETUP
1753 #line 98 "lscp.l"
1754 { yylval->String += '\"'; }
1755 YY_BREAK
1756 case 62:
1757 YY_RULE_SETUP
1758 #line 99 "lscp.l"
1759 { yylval->String += '\''; }
1760 YY_BREAK
1761 case 63:
1762 /* rule 63 can match eol */
1763 YY_RULE_SETUP
1764 #line 100 "lscp.l"
1765 { yylval->String += yytext; }
1766 YY_BREAK
1767 case 64:
1768 YY_RULE_SETUP
1769 #line 101 "lscp.l"
1770 { BEGIN(INITIAL); return STRINGVAL; }
1771 YY_BREAK
1772 case 65:
1773 YY_RULE_SETUP
1774 #line 102 "lscp.l"
1775 { yylval->Char = yytext[0]; return CHAR; }
1776 YY_BREAK
1777 case 66:
1778 YY_RULE_SETUP
1779 #line 104 "lscp.l"
1780 ECHO;
1781 YY_BREAK
1782 #line 1783 "lex.yy.c"
1783 case YY_STATE_EOF(INITIAL):
1784 case YY_STATE_EOF(INSTRING):
1785 yyterminate();
1786
1787 case YY_END_OF_BUFFER:
1788 {
1789 /* Amount of text matched not including the EOB char. */
1790 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1791
1792 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1793 *yy_cp = yyg->yy_hold_char;
1794 YY_RESTORE_YY_MORE_OFFSET
1795
1796 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1797 {
1798 /* We're scanning a new file or input source. It's
1799 * possible that this happened because the user
1800 * just pointed yyin at a new source and called
1801 * yylex(). If so, then we have to assure
1802 * consistency between YY_CURRENT_BUFFER and our
1803 * globals. Here is the right place to do so, because
1804 * this is the first action (other than possibly a
1805 * back-up) that will match for the new input source.
1806 */
1807 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1808 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1809 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1810 }
1811
1812 /* Note that here we test for yy_c_buf_p "<=" to the position
1813 * of the first EOB in the buffer, since yy_c_buf_p will
1814 * already have been incremented past the NUL character
1815 * (since all states make transitions on EOB to the
1816 * end-of-buffer state). Contrast this with the test
1817 * in input().
1818 */
1819 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1820 { /* This was really a NUL. */
1821 yy_state_type yy_next_state;
1822
1823 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1824
1825 yy_current_state = yy_get_previous_state( yyscanner );
1826
1827 /* Okay, we're now positioned to make the NUL
1828 * transition. We couldn't have
1829 * yy_get_previous_state() go ahead and do it
1830 * for us because it doesn't know how to deal
1831 * with the possibility of jamming (and we don't
1832 * want to build jamming into it because then it
1833 * will run more slowly).
1834 */
1835
1836 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1837
1838 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1839
1840 if ( yy_next_state )
1841 {
1842 /* Consume the NUL. */
1843 yy_cp = ++yyg->yy_c_buf_p;
1844 yy_current_state = yy_next_state;
1845 goto yy_match;
1846 }
1847
1848 else
1849 {
1850 yy_cp = yyg->yy_c_buf_p;
1851 goto yy_find_action;
1852 }
1853 }
1854
1855 else switch ( yy_get_next_buffer( yyscanner ) )
1856 {
1857 case EOB_ACT_END_OF_FILE:
1858 {
1859 yyg->yy_did_buffer_switch_on_eof = 0;
1860
1861 if ( yywrap(yyscanner ) )
1862 {
1863 /* Note: because we've taken care in
1864 * yy_get_next_buffer() to have set up
1865 * yytext, we can now set up
1866 * yy_c_buf_p so that if some total
1867 * hoser (like flex itself) wants to
1868 * call the scanner after we return the
1869 * YY_NULL, it'll still work - another
1870 * YY_NULL will get returned.
1871 */
1872 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1873
1874 yy_act = YY_STATE_EOF(YY_START);
1875 goto do_action;
1876 }
1877
1878 else
1879 {
1880 if ( ! yyg->yy_did_buffer_switch_on_eof )
1881 YY_NEW_FILE;
1882 }
1883 break;
1884 }
1885
1886 case EOB_ACT_CONTINUE_SCAN:
1887 yyg->yy_c_buf_p =
1888 yyg->yytext_ptr + yy_amount_of_matched_text;
1889
1890 yy_current_state = yy_get_previous_state( yyscanner );
1891
1892 yy_cp = yyg->yy_c_buf_p;
1893 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1894 goto yy_match;
1895
1896 case EOB_ACT_LAST_MATCH:
1897 yyg->yy_c_buf_p =
1898 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1899
1900 yy_current_state = yy_get_previous_state( yyscanner );
1901
1902 yy_cp = yyg->yy_c_buf_p;
1903 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1904 goto yy_find_action;
1905 }
1906 break;
1907 }
1908
1909 default:
1910 YY_FATAL_ERROR(
1911 "fatal flex scanner internal error--no action found" );
1912 } /* end of action switch */
1913 } /* end of scanning one token */
1914 } /* end of yylex */
1915
1916 /* yy_get_next_buffer - try to read in a new buffer
1917 *
1918 * Returns a code representing an action:
1919 * EOB_ACT_LAST_MATCH -
1920 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1921 * EOB_ACT_END_OF_FILE - end of file
1922 */
1923 static int yy_get_next_buffer (yyscan_t yyscanner)
1924 {
1925 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1926 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1927 register char *source = yyg->yytext_ptr;
1928 register int number_to_move, i;
1929 int ret_val;
1930
1931 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1932 YY_FATAL_ERROR(
1933 "fatal flex scanner internal error--end of buffer missed" );
1934
1935 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1936 { /* Don't try to fill the buffer, so this is an EOF. */
1937 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1938 {
1939 /* We matched a single character, the EOB, so
1940 * treat this as a final EOF.
1941 */
1942 return EOB_ACT_END_OF_FILE;
1943 }
1944
1945 else
1946 {
1947 /* We matched some text prior to the EOB, first
1948 * process it.
1949 */
1950 return EOB_ACT_LAST_MATCH;
1951 }
1952 }
1953
1954 /* Try to read more data. */
1955
1956 /* First move last chars to start of buffer. */
1957 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1958
1959 for ( i = 0; i < number_to_move; ++i )
1960 *(dest++) = *(source++);
1961
1962 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1963 /* don't do the read, it's not guaranteed to return an EOF,
1964 * just force an EOF
1965 */
1966 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1967
1968 else
1969 {
1970 size_t num_to_read =
1971 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1972
1973 while ( num_to_read <= 0 )
1974 { /* Not enough room in the buffer - grow it. */
1975
1976 /* just a shorter name for the current buffer */
1977 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1978
1979 int yy_c_buf_p_offset =
1980 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1981
1982 if ( b->yy_is_our_buffer )
1983 {
1984 int new_size = b->yy_buf_size * 2;
1985
1986 if ( new_size <= 0 )
1987 b->yy_buf_size += b->yy_buf_size / 8;
1988 else
1989 b->yy_buf_size *= 2;
1990
1991 b->yy_ch_buf = (char *)
1992 /* Include room in for 2 EOB chars. */
1993 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1994 }
1995 else
1996 /* Can't grow it, we don't own it. */
1997 b->yy_ch_buf = 0;
1998
1999 if ( ! b->yy_ch_buf )
2000 YY_FATAL_ERROR(
2001 "fatal error - scanner input buffer overflow" );
2002
2003 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2004
2005 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2006 number_to_move - 1;
2007
2008 }
2009
2010 if ( num_to_read > YY_READ_BUF_SIZE )
2011 num_to_read = YY_READ_BUF_SIZE;
2012
2013 /* Read in more data. */
2014 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2015 yyg->yy_n_chars, num_to_read );
2016
2017 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2018 }
2019
2020 if ( yyg->yy_n_chars == 0 )
2021 {
2022 if ( number_to_move == YY_MORE_ADJ )
2023 {
2024 ret_val = EOB_ACT_END_OF_FILE;
2025 yyrestart(yyin ,yyscanner);
2026 }
2027
2028 else
2029 {
2030 ret_val = EOB_ACT_LAST_MATCH;
2031 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2032 YY_BUFFER_EOF_PENDING;
2033 }
2034 }
2035
2036 else
2037 ret_val = EOB_ACT_CONTINUE_SCAN;
2038
2039 yyg->yy_n_chars += number_to_move;
2040 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2041 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2042
2043 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2044
2045 return ret_val;
2046 }
2047
2048 /* yy_get_previous_state - get the state just before the EOB char was reached */
2049
2050 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
2051 {
2052 register yy_state_type yy_current_state;
2053 register char *yy_cp;
2054 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2055
2056 yy_current_state = yy_start_state_list[yyg->yy_start];
2057
2058 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
2059 {
2060 yy_current_state += yy_current_state[(*yy_cp ? YY_SC_TO_UI(*yy_cp) : 256)].yy_nxt;
2061 if ( yy_current_state[-1].yy_nxt )
2062 {
2063 yyg->yy_last_accepting_state = yy_current_state;
2064 yyg->yy_last_accepting_cpos = yy_cp;
2065 }
2066 }
2067
2068 return yy_current_state;
2069 }
2070
2071 /* yy_try_NUL_trans - try to make a transition on the NUL character
2072 *
2073 * synopsis
2074 * next_state = yy_try_NUL_trans( current_state );
2075 */
2076 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
2077 {
2078 register int yy_is_jam;
2079 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2080 register char *yy_cp = yyg->yy_c_buf_p;
2081
2082 register int yy_c = 256;
2083 register yyconst struct yy_trans_info *yy_trans_info;
2084
2085 yy_trans_info = &yy_current_state[(unsigned int) yy_c];
2086 yy_current_state += yy_trans_info->yy_nxt;
2087 yy_is_jam = (yy_trans_info->yy_verify != yy_c);
2088
2089 if ( ! yy_is_jam )
2090 {
2091 if ( yy_current_state[-1].yy_nxt )
2092 {
2093 yyg->yy_last_accepting_state = yy_current_state;
2094 yyg->yy_last_accepting_cpos = yy_cp;
2095 }
2096 }
2097
2098 return yy_is_jam ? 0 : yy_current_state;
2099 }
2100
2101 static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)
2102 {
2103 register char *yy_cp;
2104 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2105
2106 yy_cp = yyg->yy_c_buf_p;
2107
2108 /* undo effects of setting up yytext */
2109 *yy_cp = yyg->yy_hold_char;
2110
2111 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2112 { /* need to shift things up to make room */
2113 /* +2 for EOB chars. */
2114 register int number_to_move = yyg->yy_n_chars + 2;
2115 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2116 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2117 register char *source =
2118 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2119
2120 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2121 *--dest = *--source;
2122
2123 yy_cp += (int) (dest - source);
2124 yy_bp += (int) (dest - source);
2125 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2126 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2127
2128 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2129 YY_FATAL_ERROR( "flex scanner push-back overflow" );
2130 }
2131
2132 *--yy_cp = (char) c;
2133
2134 yyg->yytext_ptr = yy_bp;
2135 yyg->yy_hold_char = *yy_cp;
2136 yyg->yy_c_buf_p = yy_cp;
2137 }
2138
2139 #ifndef YY_NO_INPUT
2140 #ifdef __cplusplus
2141 static int yyinput (yyscan_t yyscanner)
2142 #else
2143 static int input (yyscan_t yyscanner)
2144 #endif
2145
2146 {
2147 int c;
2148 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2149
2150 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2151
2152 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2153 {
2154 /* yy_c_buf_p now points to the character we want to return.
2155 * If this occurs *before* the EOB characters, then it's a
2156 * valid NUL; if not, then we've hit the end of the buffer.
2157 */
2158 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
2159 /* This was really a NUL. */
2160 *yyg->yy_c_buf_p = '\0';
2161
2162 else
2163 { /* need more input */
2164 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
2165 ++yyg->yy_c_buf_p;
2166
2167 switch ( yy_get_next_buffer( yyscanner ) )
2168 {
2169 case EOB_ACT_LAST_MATCH:
2170 /* This happens because yy_g_n_b()
2171 * sees that we've accumulated a
2172 * token and flags that we need to
2173 * try matching the token before
2174 * proceeding. But for input(),
2175 * there's no matching to consider.
2176 * So convert the EOB_ACT_LAST_MATCH
2177 * to EOB_ACT_END_OF_FILE.
2178 */
2179
2180 /* Reset buffer status. */
2181 yyrestart(yyin ,yyscanner);
2182
2183 /*FALLTHROUGH*/
2184
2185 case EOB_ACT_END_OF_FILE:
2186 {
2187 if ( yywrap(yyscanner ) )
2188 return EOF;
2189
2190 if ( ! yyg->yy_did_buffer_switch_on_eof )
2191 YY_NEW_FILE;
2192 #ifdef __cplusplus
2193 return yyinput(yyscanner);
2194 #else
2195 return input(yyscanner);
2196 #endif
2197 }
2198
2199 case EOB_ACT_CONTINUE_SCAN:
2200 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
2201 break;
2202 }
2203 }
2204 }
2205
2206 c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
2207 *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
2208 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
2209
2210 return c;
2211 }
2212 #endif /* ifndef YY_NO_INPUT */
2213
2214 /** Immediately switch to a different input stream.
2215 * @param input_file A readable stream.
2216 * @param yyscanner The scanner object.
2217 * @note This function does not reset the start condition to @c INITIAL .
2218 */
2219 void yyrestart (FILE * input_file , yyscan_t yyscanner)
2220 {
2221 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2222
2223 if ( ! YY_CURRENT_BUFFER ){
2224 yyensure_buffer_stack (yyscanner);
2225 YY_CURRENT_BUFFER_LVALUE =
2226 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
2227 }
2228
2229 yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
2230 yy_load_buffer_state(yyscanner );
2231 }
2232
2233 /** Switch to a different input buffer.
2234 * @param new_buffer The new input buffer.
2235 * @param yyscanner The scanner object.
2236 */
2237 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2238 {
2239 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2240
2241 /* TODO. We should be able to replace this entire function body
2242 * with
2243 * yypop_buffer_state();
2244 * yypush_buffer_state(new_buffer);
2245 */
2246 yyensure_buffer_stack (yyscanner);
2247 if ( YY_CURRENT_BUFFER == new_buffer )
2248 return;
2249
2250 if ( YY_CURRENT_BUFFER )
2251 {
2252 /* Flush out information for old buffer. */
2253 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2254 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2255 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2256 }
2257
2258 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2259 yy_load_buffer_state(yyscanner );
2260
2261 /* We don't actually know whether we did this switch during
2262 * EOF (yywrap()) processing, but the only time this flag
2263 * is looked at is after yywrap() is called, so it's safe
2264 * to go ahead and always set it.
2265 */
2266 yyg->yy_did_buffer_switch_on_eof = 1;
2267 }
2268
2269 static void yy_load_buffer_state (yyscan_t yyscanner)
2270 {
2271 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2272 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2273 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2274 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2275 yyg->yy_hold_char = *yyg->yy_c_buf_p;
2276 }
2277
2278 /** Allocate and initialize an input buffer state.
2279 * @param file A readable stream.
2280 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2281 * @param yyscanner The scanner object.
2282 * @return the allocated buffer state.
2283 */
2284 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
2285 {
2286 YY_BUFFER_STATE b;
2287
2288 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2289 if ( ! b )
2290 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2291
2292 b->yy_buf_size = size;
2293
2294 /* yy_ch_buf has to be 2 characters longer than the size given because
2295 * we need to put in 2 end-of-buffer characters.
2296 */
2297 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ,yyscanner );
2298 if ( ! b->yy_ch_buf )
2299 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2300
2301 b->yy_is_our_buffer = 1;
2302
2303 yy_init_buffer(b,file ,yyscanner);
2304
2305 return b;
2306 }
2307
2308 /** Destroy the buffer.
2309 * @param b a buffer created with yy_create_buffer()
2310 * @param yyscanner The scanner object.
2311 */
2312 void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
2313 {
2314 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2315
2316 if ( ! b )
2317 return;
2318
2319 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2320 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2321
2322 if ( b->yy_is_our_buffer )
2323 yyfree((void *) b->yy_ch_buf ,yyscanner );
2324
2325 yyfree((void *) b ,yyscanner );
2326 }
2327
2328 #ifndef __cplusplus
2329 extern int isatty (int );
2330 #endif /* __cplusplus */
2331
2332 /* Initializes or reinitializes a buffer.
2333 * This function is sometimes called more than once on the same buffer,
2334 * such as during a yyrestart() or at EOF.
2335 */
2336 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
2337
2338 {
2339 int oerrno = errno;
2340 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2341
2342 yy_flush_buffer(b ,yyscanner);
2343
2344 b->yy_input_file = file;
2345 b->yy_fill_buffer = 1;
2346
2347 /* If b is the current buffer, then yy_init_buffer was _probably_
2348 * called from yyrestart() or through yy_get_next_buffer.
2349 * In that case, we don't want to reset the lineno or column.
2350 */
2351 if (b != YY_CURRENT_BUFFER){
2352 b->yy_bs_lineno = 1;
2353 b->yy_bs_column = 0;
2354 }
2355
2356 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2357
2358 errno = oerrno;
2359 }
2360
2361 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2362 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2363 * @param yyscanner The scanner object.
2364 */
2365 void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
2366 {
2367 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2368 if ( ! b )
2369 return;
2370
2371 b->yy_n_chars = 0;
2372
2373 /* We always need two end-of-buffer characters. The first causes
2374 * a transition to the end-of-buffer state. The second causes
2375 * a jam in that state.
2376 */
2377 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2378 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2379
2380 b->yy_buf_pos = &b->yy_ch_buf[0];
2381
2382 b->yy_at_bol = 1;
2383 b->yy_buffer_status = YY_BUFFER_NEW;
2384
2385 if ( b == YY_CURRENT_BUFFER )
2386 yy_load_buffer_state(yyscanner );
2387 }
2388
2389 /** Pushes the new state onto the stack. The new state becomes
2390 * the current state. This function will allocate the stack
2391 * if necessary.
2392 * @param new_buffer The new state.
2393 * @param yyscanner The scanner object.
2394 */
2395 void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2396 {
2397 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2398 if (new_buffer == NULL)
2399 return;
2400
2401 yyensure_buffer_stack(yyscanner);
2402
2403 /* This block is copied from yy_switch_to_buffer. */
2404 if ( YY_CURRENT_BUFFER )
2405 {
2406 /* Flush out information for old buffer. */
2407 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2408 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2409 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2410 }
2411
2412 /* Only push if top exists. Otherwise, replace top. */
2413 if (YY_CURRENT_BUFFER)
2414 yyg->yy_buffer_stack_top++;
2415 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2416
2417 /* copied from yy_switch_to_buffer. */
2418 yy_load_buffer_state(yyscanner );
2419 yyg->yy_did_buffer_switch_on_eof = 1;
2420 }
2421
2422 /** Removes and deletes the top of the stack, if present.
2423 * The next element becomes the new top.
2424 * @param yyscanner The scanner object.
2425 */
2426 void yypop_buffer_state (yyscan_t yyscanner)
2427 {
2428 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2429 if (!YY_CURRENT_BUFFER)
2430 return;
2431
2432 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
2433 YY_CURRENT_BUFFER_LVALUE = NULL;
2434 if (yyg->yy_buffer_stack_top > 0)
2435 --yyg->yy_buffer_stack_top;
2436
2437 if (YY_CURRENT_BUFFER) {
2438 yy_load_buffer_state(yyscanner );
2439 yyg->yy_did_buffer_switch_on_eof = 1;
2440 }
2441 }
2442
2443 /* Allocates the stack if it does not exist.
2444 * Guarantees space for at least one push.
2445 */
2446 static void yyensure_buffer_stack (yyscan_t yyscanner)
2447 {
2448 int num_to_alloc;
2449 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2450
2451 if (!yyg->yy_buffer_stack) {
2452
2453 /* First allocation is just for 2 elements, since we don't know if this
2454 * scanner will even need a stack. We use 2 instead of 1 to avoid an
2455 * immediate realloc on the next call.
2456 */
2457 num_to_alloc = 1;
2458 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
2459 (num_to_alloc * sizeof(struct yy_buffer_state*)
2460 , yyscanner);
2461
2462 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2463
2464 yyg->yy_buffer_stack_max = num_to_alloc;
2465 yyg->yy_buffer_stack_top = 0;
2466 return;
2467 }
2468
2469 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
2470
2471 /* Increase the buffer to prepare for a possible push. */
2472 int grow_size = 8 /* arbitrary grow size */;
2473
2474 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
2475 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
2476 (yyg->yy_buffer_stack,
2477 num_to_alloc * sizeof(struct yy_buffer_state*)
2478 , yyscanner);
2479
2480 /* zero only the new slots.*/
2481 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
2482 yyg->yy_buffer_stack_max = num_to_alloc;
2483 }
2484 }
2485
2486 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2487 * @param base the character buffer
2488 * @param size the size in bytes of the character buffer
2489 * @param yyscanner The scanner object.
2490 * @return the newly allocated buffer state object.
2491 */
2492 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
2493 {
2494 YY_BUFFER_STATE b;
2495
2496 if ( size < 2 ||
2497 base[size-2] != YY_END_OF_BUFFER_CHAR ||
2498 base[size-1] != YY_END_OF_BUFFER_CHAR )
2499 /* They forgot to leave room for the EOB's. */
2500 return 0;
2501
2502 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2503 if ( ! b )
2504 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2505
2506 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2507 b->yy_buf_pos = b->yy_ch_buf = base;
2508 b->yy_is_our_buffer = 0;
2509 b->yy_input_file = 0;
2510 b->yy_n_chars = b->yy_buf_size;
2511 b->yy_is_interactive = 0;
2512 b->yy_at_bol = 1;
2513 b->yy_fill_buffer = 0;
2514 b->yy_buffer_status = YY_BUFFER_NEW;
2515
2516 yy_switch_to_buffer(b ,yyscanner );
2517
2518 return b;
2519 }
2520
2521 /** Setup the input buffer state to scan a string. The next call to yylex() will
2522 * scan from a @e copy of @a str.
2523 * @param str a NUL-terminated string to scan
2524 * @param yyscanner The scanner object.
2525 * @return the newly allocated buffer state object.
2526 * @note If you want to scan bytes that may contain NUL values, then use
2527 * yy_scan_bytes() instead.
2528 */
2529 YY_BUFFER_STATE yy_scan_string (yyconst char * yy_str , yyscan_t yyscanner)
2530 {
2531
2532 return yy_scan_bytes(yy_str,strlen(yy_str) ,yyscanner);
2533 }
2534
2535 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2536 * scan from a @e copy of @a bytes.
2537 * @param bytes the byte buffer to scan
2538 * @param len the number of bytes in the buffer pointed to by @a bytes.
2539 * @param yyscanner The scanner object.
2540 * @return the newly allocated buffer state object.
2541 */
2542 YY_BUFFER_STATE yy_scan_bytes (yyconst char * bytes, int len , yyscan_t yyscanner)
2543 {
2544 YY_BUFFER_STATE b;
2545 char *buf;
2546 yy_size_t n;
2547 int i;
2548
2549 /* Get memory for full buffer, including space for trailing EOB's. */
2550 n = len + 2;
2551 buf = (char *) yyalloc(n ,yyscanner );
2552 if ( ! buf )
2553 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2554
2555 for ( i = 0; i < len; ++i )
2556 buf[i] = bytes[i];
2557
2558 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2559
2560 b = yy_scan_buffer(buf,n ,yyscanner);
2561 if ( ! b )
2562 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2563
2564 /* It's okay to grow etc. this buffer, and we should throw it
2565 * away when we're done.
2566 */
2567 b->yy_is_our_buffer = 1;
2568
2569 return b;
2570 }
2571
2572 #ifndef YY_EXIT_FAILURE
2573 #define YY_EXIT_FAILURE 2
2574 #endif
2575
2576 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
2577 {
2578 (void) fprintf( stderr, "%s\n", msg );
2579 exit( YY_EXIT_FAILURE );
2580 }
2581
2582 /* Redefine yyless() so it works in section 3 code. */
2583
2584 #undef yyless
2585 #define yyless(n) \
2586 do \
2587 { \
2588 /* Undo effects of setting up yytext. */ \
2589 int yyless_macro_arg = (n); \
2590 YY_LESS_LINENO(yyless_macro_arg);\
2591 yytext[yyleng] = yyg->yy_hold_char; \
2592 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
2593 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
2594 *yyg->yy_c_buf_p = '\0'; \
2595 yyleng = yyless_macro_arg; \
2596 } \
2597 while ( 0 )
2598
2599 /* Accessor methods (get/set functions) to struct members. */
2600
2601 /** Get the user-defined data for this scanner.
2602 * @param yyscanner The scanner object.
2603 */
2604 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
2605 {
2606 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2607 return yyextra;
2608 }
2609
2610 /** Get the current line number.
2611 * @param yyscanner The scanner object.
2612 */
2613 int yyget_lineno (yyscan_t yyscanner)
2614 {
2615 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2616
2617 if (! YY_CURRENT_BUFFER)
2618 return 0;
2619
2620 return yylineno;
2621 }
2622
2623 /** Get the current column number.
2624 * @param yyscanner The scanner object.
2625 */
2626 int yyget_column (yyscan_t yyscanner)
2627 {
2628 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2629
2630 if (! YY_CURRENT_BUFFER)
2631 return 0;
2632
2633 return yycolumn;
2634 }
2635
2636 /** Get the input stream.
2637 * @param yyscanner The scanner object.
2638 */
2639 FILE *yyget_in (yyscan_t yyscanner)
2640 {
2641 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2642 return yyin;
2643 }
2644
2645 /** Get the output stream.
2646 * @param yyscanner The scanner object.
2647 */
2648 FILE *yyget_out (yyscan_t yyscanner)
2649 {
2650 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2651 return yyout;
2652 }
2653
2654 /** Get the length of the current token.
2655 * @param yyscanner The scanner object.
2656 */
2657 int yyget_leng (yyscan_t yyscanner)
2658 {
2659 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2660 return yyleng;
2661 }
2662
2663 /** Get the current token.
2664 * @param yyscanner The scanner object.
2665 */
2666
2667 char *yyget_text (yyscan_t yyscanner)
2668 {
2669 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2670 return yytext;
2671 }
2672
2673 /** Set the user-defined data. This data is never touched by the scanner.
2674 * @param user_defined The data to be associated with this scanner.
2675 * @param yyscanner The scanner object.
2676 */
2677 void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
2678 {
2679 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2680 yyextra = user_defined ;
2681 }
2682
2683 /** Set the current line number.
2684 * @param line_number
2685 * @param yyscanner The scanner object.
2686 */
2687 void yyset_lineno (int line_number , yyscan_t yyscanner)
2688 {
2689 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2690
2691 /* lineno is only valid if an input buffer exists. */
2692 if (! YY_CURRENT_BUFFER )
2693 yy_fatal_error( "yyset_lineno called with no buffer" , yyscanner);
2694
2695 yylineno = line_number;
2696 }
2697
2698 /** Set the current column.
2699 * @param line_number
2700 * @param yyscanner The scanner object.
2701 */
2702 void yyset_column (int column_no , yyscan_t yyscanner)
2703 {
2704 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2705
2706 /* column is only valid if an input buffer exists. */
2707 if (! YY_CURRENT_BUFFER )
2708 yy_fatal_error( "yyset_column called with no buffer" , yyscanner);
2709
2710 yycolumn = column_no;
2711 }
2712
2713 /** Set the input stream. This does not discard the current
2714 * input buffer.
2715 * @param in_str A readable stream.
2716 * @param yyscanner The scanner object.
2717 * @see yy_switch_to_buffer
2718 */
2719 void yyset_in (FILE * in_str , yyscan_t yyscanner)
2720 {
2721 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2722 yyin = in_str ;
2723 }
2724
2725 void yyset_out (FILE * out_str , yyscan_t yyscanner)
2726 {
2727 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2728 yyout = out_str ;
2729 }
2730
2731 int yyget_debug (yyscan_t yyscanner)
2732 {
2733 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2734 return yy_flex_debug;
2735 }
2736
2737 void yyset_debug (int bdebug , yyscan_t yyscanner)
2738 {
2739 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2740 yy_flex_debug = bdebug ;
2741 }
2742
2743 /* Accessor methods for yylval and yylloc */
2744
2745 static int yy_init_globals (yyscan_t yyscanner)
2746 {
2747 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2748 /* Initialization is the same as for the non-reentrant scanner.
2749 This function is called once per scanner lifetime. */
2750
2751 yyg->yy_buffer_stack = 0;
2752 yyg->yy_buffer_stack_top = 0;
2753 yyg->yy_buffer_stack_max = 0;
2754 yyg->yy_c_buf_p = (char *) 0;
2755 yyg->yy_init = 1;
2756 yyg->yy_start = 0;
2757 yyg->yy_start_stack_ptr = 0;
2758 yyg->yy_start_stack_depth = 0;
2759 yyg->yy_start_stack = (int *) 0;
2760
2761 /* Defined in main.c */
2762 #ifdef YY_STDINIT
2763 yyin = stdin;
2764 yyout = stdout;
2765 #else
2766 yyin = (FILE *) 0;
2767 yyout = (FILE *) 0;
2768 #endif
2769
2770 /* For future reference: Set errno on error, since we are called by
2771 * yylex_init()
2772 */
2773 return 0;
2774 }
2775
2776 /* User-visible API */
2777
2778 /* yylex_init is special because it creates the scanner itself, so it is
2779 * the ONLY reentrant function that doesn't take the scanner as the last argument.
2780 * That's why we explicitly handle the declaration, instead of using our macros.
2781 */
2782
2783 int yylex_init(yyscan_t* ptr_yy_globals)
2784
2785 {
2786 if (ptr_yy_globals == NULL){
2787 errno = EINVAL;
2788 return 1;
2789 }
2790
2791 *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
2792
2793 if (*ptr_yy_globals == NULL){
2794 errno = ENOMEM;
2795 return 1;
2796 }
2797
2798 memset(*ptr_yy_globals,0,sizeof(struct yyguts_t));
2799
2800 return yy_init_globals ( *ptr_yy_globals );
2801 }
2802
2803 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2804 int yylex_destroy (yyscan_t yyscanner)
2805 {
2806 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2807
2808 /* Pop the buffer stack, destroying each element. */
2809 while(YY_CURRENT_BUFFER){
2810 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2811 YY_CURRENT_BUFFER_LVALUE = NULL;
2812 yypop_buffer_state(yyscanner);
2813 }
2814
2815 /* Destroy the stack itself. */
2816 yyfree(yyg->yy_buffer_stack ,yyscanner);
2817 yyg->yy_buffer_stack = NULL;
2818
2819 /* Destroy the start condition stack. */
2820 yyfree(yyg->yy_start_stack ,yyscanner );
2821 yyg->yy_start_stack = NULL;
2822
2823 /* Destroy the main struct (reentrant only). */
2824 yyfree ( yyscanner , yyscanner );
2825 return 0;
2826 }
2827
2828 /*
2829 * Internal utility routines.
2830 */
2831
2832 #ifndef yytext_ptr
2833 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2834 {
2835 register int i;
2836 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2837 for ( i = 0; i < n; ++i )
2838 s1[i] = s2[i];
2839 }
2840 #endif
2841
2842 #ifdef YY_NEED_STRLEN
2843 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
2844 {
2845 register int n;
2846 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2847 for ( n = 0; s[n]; ++n )
2848 ;
2849
2850 return n;
2851 }
2852 #endif
2853
2854 void *yyalloc (yy_size_t size , yyscan_t yyscanner)
2855 {
2856 return (void *) malloc( size );
2857 }
2858
2859 void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
2860 {
2861 /* The cast to (char *) in the following accommodates both
2862 * implementations that use char* generic pointers, and those
2863 * that use void* generic pointers. It works with the latter
2864 * because both ANSI C and C++ allow castless assignment from
2865 * any pointer type to void*, and deal with argument conversions
2866 * as though doing an assignment.
2867 */
2868 return (void *) realloc( (char *) ptr, size );
2869 }
2870
2871 void yyfree (void * ptr , yyscan_t yyscanner)
2872 {
2873 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2874 }
2875
2876 #define YYTABLES_NAME "yytables"
2877
2878 #undef YY_NEW_FILE
2879 #undef YY_FLUSH_BUFFER
2880 #undef yy_set_bol
2881 #undef yy_new_buffer
2882 #undef yy_set_interactive
2883 #undef yytext_ptr
2884 #undef YY_DO_BEFORE_ACTION
2885
2886 #ifdef YY_DECL_IS_OURS
2887 #undef YY_DECL_IS_OURS
2888 #undef YY_DECL
2889 #endif
2890 #line 104 "lscp.l"
2891
2892
2893
2894 /**
2895 * We provide our own version of yywrap() so we don't have to link against
2896 * the lex library.
2897 */
2898 int yywrap(yyscan_t yyscanner) {
2899 return 1; // continue scanning
2900 }
2901
  ViewVC Help
Powered by ViewVC