/[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 143 - (show annotations) (download)
Wed Jun 23 18:54:08 2004 UTC (19 years, 10 months ago) by capela
File size: 99946 byte(s) 
* SET CHANNEL AUDIO_OUTPUT_TYPE <chan> <driver> command is back!
  creates an audio output device instance of the given driver type
  ('Jack' or 'Alsa') with default parameters if none exists,
  otherwise it just picks the first available device and assign
  it to the intended sampler channel.

* The AudioOutputDevice class get's a new pure virtual method,
  Driver(), which is implemented on both of the existing inherited
  classes, AudioOutputDeviceAlsa and AudioOutputDeviceJack, with
  the sole purpose to return the driver type name as a String
  ('Alsa' and 'Jack', respectively).

* The quoting on the filename argument for the LOAD INSTRUMENT
  command has been made optional; you can have both ways, with
  single quotes or none, keeping compability with older LSCP
  specification.

* An additional sanity check is made on LOAD INSTRUMENT, whether
  the sampler channel has an audio output device assigned, thus
  preventing the server from crashing on instrument file load.

* The GET AUDIO_OUTPUT_DEVICE INFO now includes the missing
  'driver' item, as predicted by the draft protocol document.
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 58
343 #define YY_END_OF_BUFFER 59
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[3538] =
350 {
351 { 0, 0 }, { 0,3282 }, { 0, 0 }, { 0,3280 }, { 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,3022 }, { 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,2764 },
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,2506 }, { 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, 57 },
578 { 0,2248 }, { 0, 2 }, { 0,2246 }, { 0, 3 }, { 0,2244 },
579 { 0, 1 }, { 0,2242 }, { 0, 4 }, { 0,2240 }, { 0, 47 },
580 { 0,2238 }, { 0, 57 }, { 0,2236 }, { 0, 5 }, { 0,2234 },
581
582 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
583 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 46 }, { 0,2224 },
584 { 0, 57 }, { 0,2222 }, { 0, 57 }, { 0,2220 }, { 0, 0 },
585 { 0, 0 }, { 0, 57 }, { 0,2216 }, { 0, 57 }, { 0,2214 },
586 { 0, 46 }, { 0,2212 }, { 0, 57 }, { 0,2210 }, { 0, 57 },
587 { 0,2208 }, { 0, 57 }, { 0,2206 }, { 0, 0 }, { 0, 57 },
588 { 0,2203 }, { 0, 0 }, { 0, 57 }, { 0,2200 }, { 0, 57 },
589 { 0,2198 }, { 0, 0 }, { 0, 57 }, { 0,2195 }, { 0, 57 },
590 { 0,2193 }, { 0, 57 }, { 0,2191 }, { 0, 57 }, { 0,2189 },
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, 57 }, { 0,2152 }, { 0, 57 }, { 0,2150 }, { 0, 56 },
600 { 0,2148 }, { 0, 0 }, { 0,2146 }, { 69, 681 }, { 72, 679 },
601 { 0, 0 }, { 0, 0 }, { 0,2141 }, { 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,2095 }, { 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, 48 }, { 0,2069 },
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, 58 }, { 0,1811 }, { 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,1553 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
732 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
733 { 0,1543 }, { 0, 0 }, { 0,1541 }, { 0, 0 }, { 0,1539 },
734 { 0, 0 }, { 0,1537 }, { 0, 0 }, { 0,1535 }, { 0, 0 },
735
736 { 0,1533 }, { 0, 46 }, { 0,1531 }, { 0, 0 }, { 0,1529 },
737 { 0, 0 }, { 0,1527 }, { 0, 0 }, { 0, 0 }, { 0,1524 },
738 { 0, 0 }, { 0,1522 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
739 { 0,1518 }, { 0, 0 }, { 0,1516 }, { 0, 0 }, { 0,1514 },
740 { 0, 0 }, { 0, 0 }, { 0,1511 }, { 0, 0 }, { 0, 0 },
741 { 0,1508 }, { 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,1469 },
750 { 0, 0 }, { 0,1467 }, { 69, 432 }, { 0, 0 }, { 0,1464 },
751 { 0, 0 }, { 0,1462 }, { 0, 0 }, { 0,1460 }, { 0, 0 },
752 { 71, 430 }, { 0, 0 }, { 0, 0 }, { 84, 431 }, { 70, 429 },
753 { 65, 429 }, { 0, 0 }, { 0,1451 }, { 83, 432 }, { 0, 0 },
754 { 68, 429 }, { 0, 55 }, { 0,1446 }, { 0, 53 }, { 0,1444 },
755 { 84, 430 }, { 0, 0 }, { 83, 431 }, { 0, 0 }, { 83, 431 },
756 { 0, 54 }, { 0,1437 }, { 78, 431 }, { 73, 431 }, { 0, 0 },
757
758 { 83, 431 }, { 0, 52 }, { 0,1431 }, { 84, 433 }, { 82, 432 },
759 { 0, 49 }, { 0,1427 }, { 0, 50 }, { 0,1425 }, { 0, 51 },
760 { 0,1423 }, { 0, 7 }, { 0,1421 }, { 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,1407 }, { 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, 48 },
771 { 0,1373 }, { 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,1115 }, { 0, 0 },
828 { 0,1113 }, { 0, 0 }, { 0,1111 }, { 0, 0 }, { 0, 0 },
829 { 0,1108 }, { 0, 0 }, { 0,1106 }, { 0, 0 }, { 0, 0 },
830 { 0,1103 }, { 0, 0 }, { 0,1101 }, { 0, 0 }, { 0,1099 },
831 { 0, 8 }, { 0,1097 }, { 0, 0 }, { 0,1095 }, { 0, 0 },
832 { 0,1093 }, { 0, 0 }, { 0,1091 }, { 0, 0 }, { 0,1089 },
833 { 0, 0 }, { 0,1087 }, { 0, 0 }, { 0,1085 }, { 0, 0 },
834
835 { 0,1083 }, { 0, 0 }, { 0,1081 }, { 0, 0 }, { 0,1079 },
836 { 0, 0 }, { 0,1077 }, { 0, 0 }, { 0,1075 }, { 0, 0 },
837 { 0,1073 }, { 0, 15 }, { 0,1071 }, { 0, 0 }, { 0,1069 },
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,1056 }, { 0, 0 }, { 0,1054 },
841 { 0, 0 }, { 0,1052 }, { 0, 0 }, { 0,1050 }, { 0, 0 },
842 { 0, 0 }, { 0,1047 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
843 { 0,1043 }, { 0, 0 }, { 70, 76 }, { 73, 70 }, { 69, 75 },
844 { 65, 74 }, { 0, 0 }, { 0, 0 }, { 0,1035 }, { 0, 0 },
845
846 { 0,1033 }, { 0, 0 }, { 0,1031 }, { 0, 0 }, { 0,1029 },
847 { 78, 75 }, { 0, 0 }, { 73, 77 }, { 0, 0 }, { 0,1024 },
848 { 0, 0 }, { 0,1022 }, { 68, 87 }, { 0, 23 }, { 0,1019 },
849 { 67, 91 }, { 84, 77 }, { 79, 76 }, { 0, 0 }, { 73, 89 },
850 { 0, 0 }, { 67, 93 }, { 0, 0 }, { 0,1010 }, { 84, 83 },
851 { 73, 92 }, { 84, 86 }, { 0, 11 }, { 0,1005 }, { 69, 95 },
852 { 0, 12 }, { 0,1002 }, { 0, 0 }, { 69, 93 }, { 0, 0 },
853 { 0, 998 }, { 0, 0 }, { 79, 94 }, { 0, 0 }, { 0, 994 },
854 { 84, 94 }, { 0, 0 }, { 0, 991 }, { 0, 0 }, { 0, 989 },
855 { 95, 92 }, { 0, 0 }, { 0, 986 }, { 67, 90 }, { 0, 45 },
856
857 { 0, 983 }, { 0, 0 }, { 0, 981 }, { 0, 0 }, { 0, 0 },
858 { 0, 978 }, { 0, 0 }, { 0, 976 }, { 0, 0 }, { 0, 974 },
859 { 83, 82 }, { 0, 0 }, { 0, 971 }, { 0, 0 }, { 85, 83 },
860 { 79, 89 }, { 76, 87 }, { 69, 81 }, { 85, 90 }, { 0, 0 },
861 { 0, 0 }, { 0, 962 }, { 0, 0 }, { 0, 960 }, { 0, 0 },
862 { 0, 958 }, { 0, 0 }, { 0, 956 }, { 0, 0 }, { 0, 954 },
863 { 78, 83 }, { 0, 41 }, { 0, 951 }, { 83, 82 }, { 0, 0 },
864 { 0, 948 }, { 0, 0 }, { 0, 946 }, { 84, 83 }, { 78, 84 },
865 { 0, 0 }, { 82, 84 }, { 0, 0 }, { 0, 940 }, { 0, 0 },
866 { 0, 938 }, { 0, 0 }, { 0, 936 }, { 0, 0 }, { 0, 0 },
867
868 { 0, 933 }, { 0, 0 }, { 0, 931 }, { 0, 0 }, { 0, 929 },
869 { 82, 74 }, { 0, 0 }, { 0, 926 }, { 69, 63 }, { 0, 0 },
870 { 0, 923 }, { 0, 0 }, { 0, 921 }, { 0, 0 }, { 70, 63 },
871 { 0, 0 }, { 69, 63 }, { 0, 43 }, { 0, 915 }, { 77, 62 },
872 { 0, 0 }, { 0, 912 }, { 65, 64 }, { 0, 0 }, { 0, 909 },
873 { 0, 0 }, { 67, 65 }, { 0, 0 }, { 66, 70 }, { 0, 0 },
874 { 95, 65 }, { 0, 0 }, { 0, 901 }, { 0, 0 }, { 0, 899 },
875 { 0, 0 }, { 0, 897 }, { 0, 0 }, { 86, 60 }, { 84, 63 },
876 { 69, 63 }, { 0, 0 }, { 65, 69 }, { 0, 0 }, { 0, 889 },
877 { 0, 0 }, { 0, 887 }, { 0, 0 }, { 0, 885 }, { 0, 0 },
878
879 { 77, 63 }, { 0, 0 }, { 0, 881 }, { 0, 0 }, { 69, 67 },
880 { 0, 0 }, { 69, 71 }, { 0, 9 }, { 0, 875 }, { 0, 0 },
881 { 0, 873 }, { 82, 69 }, { 0, 28 }, { 0, 870 }, { 69, 68 },
882 { 0, 0 }, { 0, 0 }, { 0, 866 }, { 0, 0 }, { 0, 864 },
883 { 95, 69 }, { 0, 0 }, { 79, 67 }, { 73, 69 }, { 0, 0 },
884 { 0, 858 }, { 0, 0 }, { 0, 856 }, { 76, 73 }, { 0, 0 },
885 { 73, 78 }, { 69, 78 }, { 85, 70 }, { 79, 73 }, { 0, 0 },
886 { 0, 848 }, { 0, 0 }, { 0, 846 }, { 78, 77 }, { 0, 14 },
887 { 0, 843 }, { 0, 0 }, { 0, 841 }, { 0, 0 }, { 0, 839 },
888 { 0, 0 }, { 0, 837 }, { 0, 0 }, { 77, 71 }, { 0, 0 },
889
890 { 0, 0 }, { 0, 832 }, { 0, 40 }, { 0, 830 }, { 0, 0 },
891 { 69, 67 }, { 82, 70 }, { 0, 0 }, { 0, 825 }, { 0, 0 },
892 { 0, 823 }, { 0, 0 }, { 66, 64 }, { 0, 0 }, { 0, 819 },
893 { 83, 64 }, { 0, 18 }, { 0, 816 }, { 0, 10 }, { 0, 814 },
894 { 0, 0 }, { 0, 812 }, { 0, 0 }, { 79, 64 }, { 0, 0 },
895 { 0, 808 }, { 0, 0 }, { 0, 806 }, { 76, 65 }, { 95, 67 },
896 { 0, 0 }, { 0, 802 }, { 0, 0 }, { 0, 800 }, { 0, 0 },
897 { 0, 0 }, { 0, 797 }, { 0, 0 }, { 0, 0 }, { 0, 794 },
898 { 0, 0 }, { 0, 792 }, { 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, 779 },
902 { 0, 0 }, { 0, 777 }, { 0, 0 }, { 0, 775 }, { 0, 0 },
903 { 0, 773 }, { 0, 0 }, { 0, 0 }, { 67, 58 }, { 0, 0 },
904 { 0, 768 }, { 0, 0 }, { 73, 47 }, { 67, 55 }, { 0, 22 },
905 { 0, 763 }, { 84, 49 }, { 0, 0 }, { 0, 760 }, { 0, 0 },
906 { 0, 758 }, { 0, 0 }, { 0, 756 }, { 0, 0 }, { 0, 0 },
907 { 0, 753 }, { 0, 0 }, { 0, 751 }, { 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, 730 }, { 0, 0 },
913 { 80, 50 }, { 67, 70 }, { 66, 70 }, { 0, 0 }, { 0, 724 },
914 { 0, 0 }, { 0, 722 }, { 0, 0 }, { 0, 720 }, { 0, 0 },
915 { 0, 718 }, { 0, 0 }, { 0, 716 }, { 0, 0 }, { 0, 714 },
916 { 0, 0 }, { 0, 0 }, { 0, 711 }, { 0, 0 }, { 0, 709 },
917 { 0, 0 }, { 0, 707 }, { 0, 0 }, { 0, 0 }, { 69, 59 },
918 { 0, 0 }, { 0, 0 }, { 0, 701 }, { 0, 13 }, { 0, 699 },
919 { 79, 59 }, { 82, 59 }, { 0, 0 }, { 73, 57 }, { 0, 0 },
920 { 0, 693 }, { 0, 0 }, { 84, 59 }, { 0, 0 }, { 0, 0 },
921 { 0, 0 }, { 0, 687 }, { 0, 0 }, { 0, 685 }, { 0, 16 },
922
923 { 0, 683 }, { 78, 51 }, { 0, 0 }, { 0, 680 }, { 0, 0 },
924 { 78, 55 }, { 76, 54 }, { 0, 0 }, { 0, 675 }, { 0, 0 },
925 { 85, 51 }, { 0, 0 }, { 0, 671 }, { 0, 0 }, { 0, 0 },
926 { 0, 668 }, { 84, 58 }, { 0, 0 }, { 0, 665 }, { 0, 27 },
927 { 0, 663 }, { 0, 0 }, { 0, 661 }, { 0, 0 }, { 71, 43 },
928 { 0, 0 }, { 0, 657 }, { 0, 0 }, { 0, 655 }, { 0, 0 },
929 { 69, 39 }, { 0, 42 }, { 0, 651 }, { 0, 0 }, { 0, 649 },
930 { 0, 0 }, { 73, 40 }, { 0, 0 }, { 79, 39 }, { 0, 0 },
931 { 0, 643 }, { 0, 0 }, { 0, 641 }, { 0, 0 }, { 0, 639 },
932 { 0, 0 }, { 0, 637 }, { 80, 45 }, { 76, 46 }, { 0, 0 },
933
934 { 85, 43 }, { 69, 44 }, { 0, 0 }, { 0, 0 }, { 0, 629 },
935 { 0, 24 }, { 0, 627 }, { 0, 0 }, { 84, 46 }, { 0, 0 },
936 { 84, 46 }, { 0, 0 }, { 0, 621 }, { 73, 38 }, { 95, 46 },
937 { 69, 36 }, { 0, 0 }, { 0, 616 }, { 0, 0 }, { 66, 37 },
938 { 0, 0 }, { 0, 612 }, { 0, 0 }, { 0, 610 }, { 0, 17 },
939 { 0, 608 }, { 0, 26 }, { 0, 606 }, { 0, 0 }, { 0, 604 },
940 { 65, 31 }, { 0, 0 }, { 0, 601 }, { 85, 36 }, { 69, 39 },
941 { 0, 0 }, { 78, 34 }, { 0, 0 }, { 0, 595 }, { 0, 0 },
942 { 0, 593 }, { 0, 0 }, { 0, 591 }, { 0, 0 }, { 76, 38 },
943 { 0, 0 }, { 0, 587 }, { 85, 32 }, { 0, 0 }, { 0, 584 },
944
945 { 0, 19 }, { 0, 582 }, { 0, 25 }, { 0, 580 }, { 0, 0 },
946 { 79, 41 }, { 0, 0 }, { 79, 43 }, { 0, 0 }, { 69, 35 },
947 { 0, 0 }, { 0, 572 }, { 78, 39 }, { 0, 0 }, { 0, 569 },
948 { 0, 0 }, { 0, 567 }, { 95, 40 }, { 0, 0 }, { 0, 564 },
949 { 0, 0 }, { 0, 562 }, { 0, 0 }, { 0, 0 }, { 0, 559 },
950 { 0, 0 }, { 84, 35 }, { 0, 0 }, { 84, 35 }, { 67, 28 },
951 { 0, 0 }, { 85, 36 }, { 78, 34 }, { 0, 44 }, { 0, 549 },
952 { 0, 0 }, { 0, 547 }, { 0, 0 }, { 0, 545 }, { 0, 0 },
953 { 0, 543 }, { 0, 0 }, { 80, 30 }, { 0, 0 }, { 0, 539 },
954 { 0, 0 }, { 84, 34 }, { 0, 0 }, { 0, 535 }, { 78, 30 },
955
956 { 68, 32 }, { 0, 0 }, { 85, 32 }, { 0, 0 }, { 0, 529 },
957 { 0, 0 }, { 0, 527 }, { 84, 30 }, { 0, 0 }, { 71, 28 },
958 { 0, 0 }, { 0, 522 }, { 72, 29 }, { 0, 0 }, { 0, 0 },
959 { 0, 0 }, { 0, 517 }, { 0, 0 }, { 0, 515 }, { 0, 0 },
960 { 0, 513 }, { 79, 29 }, { 0, 0 }, { 0, 510 }, { 95, 32 },
961 { 0, 0 }, { 0, 507 }, { 0, 0 }, { 67, 25 }, { 68, 27 },
962 { 0, 0 }, { 0, 502 }, { 83, 35 }, { 0, 0 }, { 65, 35 },
963 { 89, 28 }, { 0, 0 }, { 73, 30 }, { 0, 0 }, { 73, 32 },
964 { 0, 0 }, { 0, 492 }, { 0, 37 }, { 0, 490 }, { 0, 0 },
965 { 84, 29 }, { 0, 39 }, { 0, 486 }, { 0, 0 }, { 0, 484 },
966
967 { 0, 0 }, { 0, 482 }, { 0, 0 }, { 82, 35 }, { 80, 37 },
968 { 0, 0 }, { 0, 477 }, { 69, 30 }, { 72, 30 }, { 0, 0 },
969 { 0, 473 }, { 0, 0 }, { 0, 471 }, { 0, 0 }, { 0, 469 },
970 { 0, 0 }, { 0, 467 }, { 0, 0 }, { 0, 465 }, { 0, 0 },
971 { 82, 32 }, { 0, 0 }, { 0, 461 }, { 79, 32 }, { 0, 0 },
972 { 0, 458 }, { 78, 33 }, { 0, 36 }, { 0, 455 }, { 89, 33 },
973 { 69, 36 }, { 65, 33 }, { 78, 37 }, { 0, 0 }, { 0, 449 },
974 { 0, 20 }, { 0, 447 }, { 0, 0 }, { 0, 445 }, { 0, 0 },
975 { 84, 37 }, { 0, 0 }, { 0, 441 }, { 73, 36 }, { 0, 0 },
976 { 0, 0 }, { 0, 437 }, { 0, 0 }, { 0, 435 }, { 0, 0 },
977
978 { 69, 33 }, { 0, 0 }, { 0, 431 }, { 80, 37 }, { 86, 33 },
979 { 0, 38 }, { 0, 427 }, { 0, 0 }, { 0, 425 }, { 0, 29 },
980 { 0, 423 }, { 0, 32 }, { 0, 421 }, { 0, 0 }, { 0, 419 },
981 { 0, 34 }, { 0, 417 }, { 0, 30 }, { 0, 415 }, { 78, 25 },
982 { 0, 0 }, { 95, 36 }, { 0, 0 }, { 0, 410 }, { 73, 21 },
983 { 0, 0 }, { 0, 407 }, { 78, 19 }, { 0, 0 }, { 69, 18 },
984 { 0, 0 }, { 0, 402 }, { 0, 0 }, { 0, 400 }, { 0, 0 },
985 { 69, 22 }, { 0, 0 }, { 0, 396 }, { 0, 0 }, { 67, 24 },
986 { 0, 0 }, { 79, 22 }, { 86, 19 }, { 0, 0 }, { 69, 23 },
987 { 0, 0 }, { 78, 24 }, { 83, 22 }, { 0, 0 }, { 0, 384 },
988
989 { 0, 0 }, { 0, 382 }, { 0, 0 }, { 0, 380 }, { 0, 0 },
990 { 0, 378 }, { 0, 0 }, { 0, 376 }, { 0, 0 }, { 0, 374 },
991 { 0, 0 }, { 69, 16 }, { 0, 0 }, { 0, 370 }, { 76, 18 },
992 { 69, 14 }, { 0, 0 }, { 0, 366 }, { 0, 0 }, { 85, 18 },
993 { 0, 0 }, { 0, 362 }, { 0, 0 }, { 0, 360 }, { 0, 0 },
994 { 0, 358 }, { 0, 0 }, { 0, 0 }, { 0, 355 }, { 0, 0 },
995 { 82, 14 }, { 0, 0 }, { 0, 351 }, { 0, 0 }, { 76, 8 },
996 { 0, 0 }, { 84, 12 }, { 0, 0 }, { 0, 345 }, { 0, 0 },
997 { 0, 343 }, { 0, 0 }, { 0, 341 }, { 83, 8 }, { 80, 17 },
998 { 0, 0 }, { 0, 337 }, { 0, 0 }, { 0, 335 }, { 0, 0 },
999
1000 { 0, 333 }, { 0, 0 }, { 65, 18 }, { 80, 14 }, { 0, 0 },
1001 { 95, 13 }, { 80, 23 }, { 95, 14 }, { 0, 0 }, { 0, 324 },
1002 { 0, 0 }, { 95, 17 }, { 0, 0 }, { 80, 20 }, { 65, 8 },
1003 { 0, 0 }, { 85, 20 }, { 0, 0 }, { 65, 10 }, { 0, 0 },
1004 { 0, 313 }, { 0, 0 }, { 0, 311 }, { 0, 0 }, { 0, 0 },
1005 { 0, 308 }, { 0, 0 }, { 0, 306 }, { 0, 0 }, { 0, 304 },
1006 { 0, 0 }, { 0, 302 }, { 65, 11 }, { 0, 0 }, { 0, 299 },
1007 { 84, 8 }, { 65, 11 }, { 82, 12 }, { 0, 0 }, { 82, 14 },
1008 { 65, 15 }, { 68, 15 }, { 0, 0 }, { 0, 290 }, { 0, 0 },
1009 { 82, 12 }, { 0, 0 }, { 0, 286 }, { 0, 0 }, { 0, 284 },
1010
1011 { 0, 0 }, { 0, 282 }, { 0, 31 }, { 0, 280 }, { 95, 14 },
1012 { 77, 14 }, { 0, 33 }, { 0, 276 }, { 0, 0 }, { 77, 14 },
1013 { 0, 0 }, { 69, 17 }, { 0, 0 }, { 0, 270 }, { 0, 0 },
1014 { 69, 24 }, { 0, 0 }, { 77, 10 }, { 0, 0 }, { 69, 25 },
1015 { 82, 10 }, { 73, 24 }, { 0, 35 }, { 0, 260 }, { 0, 21 },
1016 { 0, 258 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1017 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1018 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1019 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 84, 18 }, { 0, 0 },
1020 { 0, 0 }, { 69, 16 }, { 0, 0 }, { 69, 18 }, { 0, 0 },
1021
1022 { 69, 18 }, { 0, 0 }, { 0, 0 }, { 69, 17 }, { 84, 9 },
1023 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 86, 9 }, { 84, 9 },
1024 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1025 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1026 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1027 { 82, 10 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 82, 10 },
1028 { 0, 0 }, { 82, 14 }, { 0, 0 }, { 82, 22 }, { 0, 0 },
1029 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1030 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1031 { 0, 0 }, { 83, 12 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1032
1033 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1034 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1035 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1036 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1037 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1038 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1039 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1040 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1041 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1042 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1043
1044 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1045 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1046 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1047 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1048 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1049 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1050 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1051 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1052 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1053 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1054
1055 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1056 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1057 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1058 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1059 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1060 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1061 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1062 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1063 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1064 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1065
1066 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1067 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1068 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1069 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1070 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1071 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
1072 { 0, 0 }, { 0, 0 }, { 257, 59 }, { 1, 0 }, };
1073
1074 static yyconst struct yy_trans_info *yy_start_state_list[5] =
1075 {
1076 &yy_transition[1],
1077 &yy_transition[3],
1078 &yy_transition[261],
1079 &yy_transition[519],
1080 &yy_transition[777],
1081
1082 } ;
1083
1084 /* The intent behind this definition is that it'll catch
1085 * any uses of REJECT which flex missed.
1086 */
1087 #define REJECT reject_used_but_not_detected
1088 #define yymore() yymore_used_but_not_detected
1089 #define YY_MORE_ADJ 0
1090 #define YY_RESTORE_YY_MORE_OFFSET
1091 #line 1 "lscp.l"
1092 /***************************************************************************
1093 * *
1094 * LinuxSampler - modular, streaming capable sampler *
1095 * *
1096 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
1097 * *
1098 * This program is free software; you can redistribute it and/or modify *
1099 * it under the terms of the GNU General Public License as published by *
1100 * the Free Software Foundation; either version 2 of the License, or *
1101 * (at your option) any later version. *
1102 * *
1103 * This program is distributed in the hope that it will be useful, *
1104 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
1105 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
1106 * GNU General Public License for more details. *
1107 * *
1108 * You should have received a copy of the GNU General Public License *
1109 * along with this program; if not, write to the Free Software *
1110 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
1111 * MA 02111-1307 USA *
1112 ***************************************************************************/
1113 #line 24 "lscp.l"
1114
1115 #include "lscpparser.h"
1116 #include "lscpsymbols.h"
1117
1118 /// handle for a client connection (FIXME: doesn't work for more than one network connections of course)
1119 int hSession;
1120
1121
1122 #line 1123 "lex.yy.c"
1123
1124 #define INITIAL 0
1125 #define INSTRING 1
1126
1127 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1128 * down here because we want the user's section 1 to have been scanned first.
1129 * The user has a chance to override it with an option.
1130 */
1131 #include <unistd.h>
1132
1133 #ifndef YY_EXTRA_TYPE
1134 #define YY_EXTRA_TYPE void *
1135 #endif
1136
1137 /* Holds the entire state of the reentrant scanner. */
1138 struct yyguts_t
1139 {
1140
1141 /* User-defined. Not touched by flex. */
1142 YY_EXTRA_TYPE yyextra_r;
1143
1144 /* The rest are the same as the globals declared in the non-reentrant scanner. */
1145 FILE *yyin_r, *yyout_r;
1146 size_t yy_buffer_stack_top; /**< index of top of stack. */
1147 size_t yy_buffer_stack_max; /**< capacity of stack. */
1148 YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
1149 char yy_hold_char;
1150 int yy_n_chars;
1151 int yyleng_r;
1152 char *yy_c_buf_p;
1153 int yy_init;
1154 int yy_start;
1155 int yy_did_buffer_switch_on_eof;
1156 int yy_start_stack_ptr;
1157 int yy_start_stack_depth;
1158 int *yy_start_stack;
1159 yy_state_type yy_last_accepting_state;
1160 char* yy_last_accepting_cpos;
1161
1162 int yylineno_r;
1163 int yy_flex_debug_r;
1164
1165 char *yytext_r;
1166 int yy_more_flag;
1167 int yy_more_len;
1168
1169 }; /* end struct yyguts_t */
1170
1171 /* Accessor methods to globals.
1172 These are made visible to non-reentrant scanners for convenience. */
1173
1174 int yylex_destroy (yyscan_t yyscanner );
1175
1176 int yyget_debug (yyscan_t yyscanner );
1177
1178 void yyset_debug (int debug_flag ,yyscan_t yyscanner );
1179
1180 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner );
1181
1182 void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
1183
1184 FILE *yyget_in (yyscan_t yyscanner );
1185
1186 void yyset_in (FILE * in_str ,yyscan_t yyscanner );
1187
1188 FILE *yyget_out (yyscan_t yyscanner );
1189
1190 void yyset_out (FILE * out_str ,yyscan_t yyscanner );
1191
1192 int yyget_leng (yyscan_t yyscanner );
1193
1194 char *yyget_text (yyscan_t yyscanner );
1195
1196 int yyget_lineno (yyscan_t yyscanner );
1197
1198 void yyset_lineno (int line_number ,yyscan_t yyscanner );
1199
1200 /* Macros after this point can all be overridden by user definitions in
1201 * section 1.
1202 */
1203
1204 #ifndef YY_SKIP_YYWRAP
1205 #ifdef __cplusplus
1206 extern "C" int yywrap (yyscan_t yyscanner );
1207 #else
1208 extern int yywrap (yyscan_t yyscanner );
1209 #endif
1210 #endif
1211
1212 static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner);
1213
1214 #ifndef yytext_ptr
1215 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
1216 #endif
1217
1218 #ifdef YY_NEED_STRLEN
1219 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
1220 #endif
1221
1222 #ifndef YY_NO_INPUT
1223
1224 #ifdef __cplusplus
1225 static int yyinput (yyscan_t yyscanner );
1226 #else
1227 static int input (yyscan_t yyscanner );
1228 #endif
1229
1230 #endif
1231
1232 /* Amount of stuff to slurp up with each read. */
1233 #ifndef YY_READ_BUF_SIZE
1234 #define YY_READ_BUF_SIZE 8192
1235 #endif
1236
1237 /* Copy whatever the last rule matched to the standard output. */
1238 #ifndef ECHO
1239 /* This used to be an fputs(), but since the string might contain NUL's,
1240 * we now use fwrite().
1241 */
1242 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1243 #endif
1244
1245 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1246 * is returned in "result".
1247 */
1248 #ifndef YY_INPUT
1249 #define YY_INPUT(buf,result,max_size) \
1250 errno=0; \
1251 while ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
1252 { \
1253 if( errno != EINTR) \
1254 { \
1255 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1256 break; \
1257 } \
1258 errno=0; \
1259 clearerr(yyin); \
1260 }\
1261 \
1262
1263 #endif
1264
1265 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1266 * we don't want an extra ';' after the "return" because that will cause
1267 * some compilers to complain about unreachable statements.
1268 */
1269 #ifndef yyterminate
1270 #define yyterminate() return YY_NULL
1271 #endif
1272
1273 /* Number of entries by which start-condition stack grows. */
1274 #ifndef YY_START_STACK_INCR
1275 #define YY_START_STACK_INCR 25
1276 #endif
1277
1278 /* Report a fatal error. */
1279 #ifndef YY_FATAL_ERROR
1280 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
1281 #endif
1282
1283 /* end tables serialization structures and prototypes */
1284
1285 /* Default declaration of generated scanner - a define so the user can
1286 * easily add parameters.
1287 */
1288 #ifndef YY_DECL
1289 #define YY_DECL_IS_OURS 1
1290
1291 extern int yylex (yyscan_t yyscanner);
1292
1293 #define YY_DECL int yylex (yyscan_t yyscanner)
1294 #endif /* !YY_DECL */
1295
1296 /* Code executed at the beginning of each rule, after yytext and yyleng
1297 * have been set up.
1298 */
1299 #ifndef YY_USER_ACTION
1300 #define YY_USER_ACTION
1301 #endif
1302
1303 /* Code executed at the end of each rule. */
1304 #ifndef YY_BREAK
1305 #define YY_BREAK break;
1306 #endif
1307
1308 #define YY_RULE_SETUP \
1309 YY_USER_ACTION
1310
1311 /** The main scanner function which does all the work.
1312 */
1313 YY_DECL
1314 {
1315 register yy_state_type yy_current_state;
1316 register char *yy_cp, *yy_bp;
1317 register int yy_act;
1318 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1319
1320 #line 39 "lscp.l"
1321
1322
1323 #line 1324 "lex.yy.c"
1324
1325 if ( yyg->yy_init )
1326 {
1327 yyg->yy_init = 0;
1328
1329 #ifdef YY_USER_INIT
1330 YY_USER_INIT;
1331 #endif
1332
1333 if ( ! yyg->yy_start )
1334 yyg->yy_start = 1; /* first start state */
1335
1336 if ( ! yyin )
1337 yyin = stdin;
1338
1339 if ( ! yyout )
1340 yyout = stdout;
1341
1342 if ( ! YY_CURRENT_BUFFER ) {
1343 yyensure_buffer_stack (yyscanner);
1344 YY_CURRENT_BUFFER_LVALUE =
1345 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1346 }
1347
1348 yy_load_buffer_state(yyscanner );
1349 }
1350
1351 while ( 1 ) /* loops until end-of-file is reached */
1352 {
1353 yy_cp = yyg->yy_c_buf_p;
1354
1355 /* Support of yytext. */
1356 *yy_cp = yyg->yy_hold_char;
1357
1358 /* yy_bp points to the position in yy_ch_buf of the start of
1359 * the current run.
1360 */
1361 yy_bp = yy_cp;
1362
1363 yy_current_state = yy_start_state_list[yyg->yy_start];
1364 yy_match:
1365 {
1366 register yyconst struct yy_trans_info *yy_trans_info;
1367
1368 register YY_CHAR yy_c;
1369
1370 for ( yy_c = YY_SC_TO_UI(*yy_cp);
1371 (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->
1372 yy_verify == yy_c;
1373 yy_c = YY_SC_TO_UI(*++yy_cp) )
1374 {
1375 yy_current_state += yy_trans_info->yy_nxt;
1376
1377 if ( yy_current_state[-1].yy_nxt )
1378 {
1379 yyg->yy_last_accepting_state = yy_current_state;
1380 yyg->yy_last_accepting_cpos = yy_cp;
1381 }
1382 }
1383 }
1384
1385 yy_find_action:
1386 yy_act = yy_current_state[-1].yy_nxt;
1387
1388 YY_DO_BEFORE_ACTION;
1389
1390 do_action: /* This label is used only to access EOF actions. */
1391
1392 switch ( yy_act )
1393 { /* beginning of action switch */
1394 case 0: /* must back up */
1395 /* undo the effects of YY_DO_BEFORE_ACTION */
1396 *yy_cp = yyg->yy_hold_char;
1397 yy_cp = yyg->yy_last_accepting_cpos + 1;
1398 yy_current_state = yyg->yy_last_accepting_state;
1399 goto yy_find_action;
1400
1401 case 1:
1402 YY_RULE_SETUP
1403 #line 41 "lscp.l"
1404 { return SP; }
1405 YY_BREAK
1406 case 2:
1407 /* rule 2 can match eol */
1408 YY_RULE_SETUP
1409 #line 42 "lscp.l"
1410 { return LF; }
1411 YY_BREAK
1412 case 3:
1413 YY_RULE_SETUP
1414 #line 43 "lscp.l"
1415 { return CR; }
1416 YY_BREAK
1417 case 4:
1418 YY_RULE_SETUP
1419 #line 44 "lscp.l"
1420 { return HASH; }
1421 YY_BREAK
1422 case 5:
1423 YY_RULE_SETUP
1424 #line 45 "lscp.l"
1425 { return EQ; }
1426 YY_BREAK
1427 case 6:
1428 YY_RULE_SETUP
1429 #line 46 "lscp.l"
1430 { yylval->Dotnum = atof(yytext); return DOTNUM; }
1431 YY_BREAK
1432 case 7:
1433 YY_RULE_SETUP
1434 #line 47 "lscp.l"
1435 { return ADD; }
1436 YY_BREAK
1437 case 8:
1438 YY_RULE_SETUP
1439 #line 48 "lscp.l"
1440 { return GET; }
1441 YY_BREAK
1442 case 9:
1443 YY_RULE_SETUP
1444 #line 49 "lscp.l"
1445 { return CREATE; }
1446 YY_BREAK
1447 case 10:
1448 YY_RULE_SETUP
1449 #line 50 "lscp.l"
1450 { return DESTROY; }
1451 YY_BREAK
1452 case 11:
1453 YY_RULE_SETUP
1454 #line 51 "lscp.l"
1455 { return LIST; }
1456 YY_BREAK
1457 case 12:
1458 YY_RULE_SETUP
1459 #line 52 "lscp.l"
1460 { return LOAD; }
1461 YY_BREAK
1462 case 13:
1463 YY_RULE_SETUP
1464 #line 53 "lscp.l"
1465 { return NON_MODAL; }
1466 YY_BREAK
1467 case 14:
1468 YY_RULE_SETUP
1469 #line 54 "lscp.l"
1470 { return REMOVE; }
1471 YY_BREAK
1472 case 15:
1473 YY_RULE_SETUP
1474 #line 55 "lscp.l"
1475 { return SET; }
1476 YY_BREAK
1477 case 16:
1478 YY_RULE_SETUP
1479 #line 56 "lscp.l"
1480 { return SUBSCRIBE; }
1481 YY_BREAK
1482 case 17:
1483 YY_RULE_SETUP
1484 #line 57 "lscp.l"
1485 { return UNSUBSCRIBE; }
1486 YY_BREAK
1487 case 18:
1488 YY_RULE_SETUP
1489 #line 58 "lscp.l"
1490 { return CHANNEL; }
1491 YY_BREAK
1492 case 19:
1493 YY_RULE_SETUP
1494 #line 59 "lscp.l"
1495 { return NOTIFICATION; }
1496 YY_BREAK
1497 case 20:
1498 YY_RULE_SETUP
1499 #line 60 "lscp.l"
1500 { return AVAILABLE_ENGINES; }
1501 YY_BREAK
1502 case 21:
1503 YY_RULE_SETUP
1504 #line 61 "lscp.l"
1505 { return AVAILABLE_AUDIO_OUTPUT_DRIVERS; }
1506 YY_BREAK
1507 case 22:
1508 YY_RULE_SETUP
1509 #line 62 "lscp.l"
1510 { return CHANNELS; }
1511 YY_BREAK
1512 case 23:
1513 YY_RULE_SETUP
1514 #line 63 "lscp.l"
1515 { return INFO; }
1516 YY_BREAK
1517 case 24:
1518 YY_RULE_SETUP
1519 #line 64 "lscp.l"
1520 { return BUFFER_FILL; }
1521 YY_BREAK
1522 case 25:
1523 YY_RULE_SETUP
1524 #line 65 "lscp.l"
1525 { return STREAM_COUNT; }
1526 YY_BREAK
1527 case 26:
1528 YY_RULE_SETUP
1529 #line 66 "lscp.l"
1530 { return VOICE_COUNT; }
1531 YY_BREAK
1532 case 27:
1533 YY_RULE_SETUP
1534 #line 67 "lscp.l"
1535 { return INSTRUMENT; }
1536 YY_BREAK
1537 case 28:
1538 YY_RULE_SETUP
1539 #line 68 "lscp.l"
1540 { return ENGINE; }
1541 YY_BREAK
1542 case 29:
1543 YY_RULE_SETUP
1544 #line 69 "lscp.l"
1545 { return AUDIO_OUTPUT_DEVICE; }
1546 YY_BREAK
1547 case 30:
1548 YY_RULE_SETUP
1549 #line 70 "lscp.l"
1550 { return AUDIO_OUTPUT_DEVICES; }
1551 YY_BREAK
1552 case 31:
1553 YY_RULE_SETUP
1554 #line 71 "lscp.l"
1555 { return AUDIO_OUTPUT_DEVICE_PARAMETER; }
1556 YY_BREAK
1557 case 32:
1558 YY_RULE_SETUP
1559 #line 72 "lscp.l"
1560 { return AUDIO_OUTPUT_DRIVER; }
1561 YY_BREAK
1562 case 33:
1563 YY_RULE_SETUP
1564 #line 73 "lscp.l"
1565 { return AUDIO_OUTPUT_DRIVER_PARAMETER; }
1566 YY_BREAK
1567 case 34:
1568 YY_RULE_SETUP
1569 #line 74 "lscp.l"
1570 { return AUDIO_OUTPUT_CHANNEL; }
1571 YY_BREAK
1572 case 35:
1573 YY_RULE_SETUP
1574 #line 75 "lscp.l"
1575 { return AUDIO_OUTPUT_CHANNEL_PARAMETER; }
1576 YY_BREAK
1577 case 36:
1578 YY_RULE_SETUP
1579 #line 76 "lscp.l"
1580 { return AUDIO_OUTPUT_TYPE; }
1581 YY_BREAK
1582 case 37:
1583 YY_RULE_SETUP
1584 #line 77 "lscp.l"
1585 { return MIDI_INPUT_PORT; }
1586 YY_BREAK
1587 case 38:
1588 YY_RULE_SETUP
1589 #line 78 "lscp.l"
1590 { return MIDI_INPUT_CHANNEL; }
1591 YY_BREAK
1592 case 39:
1593 YY_RULE_SETUP
1594 #line 79 "lscp.l"
1595 { return MIDI_INPUT_TYPE; }
1596 YY_BREAK
1597 case 40:
1598 YY_RULE_SETUP
1599 #line 80 "lscp.l"
1600 { return VOLUME; }
1601 YY_BREAK
1602 case 41:
1603 YY_RULE_SETUP
1604 #line 81 "lscp.l"
1605 { return BYTES; }
1606 YY_BREAK
1607 case 42:
1608 YY_RULE_SETUP
1609 #line 82 "lscp.l"
1610 { return PERCENTAGE; }
1611 YY_BREAK
1612 case 43:
1613 YY_RULE_SETUP
1614 #line 83 "lscp.l"
1615 { return RESET; }
1616 YY_BREAK
1617 case 44:
1618 YY_RULE_SETUP
1619 #line 84 "lscp.l"
1620 { return MISCELLANEOUS; }
1621 YY_BREAK
1622 case 45:
1623 YY_RULE_SETUP
1624 #line 85 "lscp.l"
1625 { return QUIT; }
1626 YY_BREAK
1627 case 46:
1628 YY_RULE_SETUP
1629 #line 86 "lscp.l"
1630 { yylval->Number = atoi(yytext); return NUMBER; }
1631 YY_BREAK
1632 case 47:
1633 YY_RULE_SETUP
1634 #line 87 "lscp.l"
1635 { yylval->String = ""; BEGIN(INSTRING); }
1636 YY_BREAK
1637 case 48:
1638 /* rule 48 can match eol */
1639 YY_RULE_SETUP
1640 #line 88 "lscp.l"
1641 { yylval->String += yytext; }
1642 YY_BREAK
1643 case 49:
1644 YY_RULE_SETUP
1645 #line 89 "lscp.l"
1646 { yylval->String += '\n'; }
1647 YY_BREAK
1648 case 50:
1649 YY_RULE_SETUP
1650 #line 90 "lscp.l"
1651 { yylval->String += '\r'; }
1652 YY_BREAK
1653 case 51:
1654 YY_RULE_SETUP
1655 #line 91 "lscp.l"
1656 { yylval->String += '\t'; }
1657 YY_BREAK
1658 case 52:
1659 YY_RULE_SETUP
1660 #line 92 "lscp.l"
1661 { yylval->String += '\\'; }
1662 YY_BREAK
1663 case 53:
1664 YY_RULE_SETUP
1665 #line 93 "lscp.l"
1666 { yylval->String += '\"'; }
1667 YY_BREAK
1668 case 54:
1669 YY_RULE_SETUP
1670 #line 94 "lscp.l"
1671 { yylval->String += '\''; }
1672 YY_BREAK
1673 case 55:
1674 /* rule 55 can match eol */
1675 YY_RULE_SETUP
1676 #line 95 "lscp.l"
1677 { yylval->String += yytext; }
1678 YY_BREAK
1679 case 56:
1680 YY_RULE_SETUP
1681 #line 96 "lscp.l"
1682 { BEGIN(INITIAL); return STRINGVAL; }
1683 YY_BREAK
1684 case 57:
1685 YY_RULE_SETUP
1686 #line 97 "lscp.l"
1687 { yylval->Char = yytext[0]; return CHAR; }
1688 YY_BREAK
1689 case 58:
1690 YY_RULE_SETUP
1691 #line 99 "lscp.l"
1692 ECHO;
1693 YY_BREAK
1694 #line 1695 "lex.yy.c"
1695 case YY_STATE_EOF(INITIAL):
1696 case YY_STATE_EOF(INSTRING):
1697 yyterminate();
1698
1699 case YY_END_OF_BUFFER:
1700 {
1701 /* Amount of text matched not including the EOB char. */
1702 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1703
1704 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1705 *yy_cp = yyg->yy_hold_char;
1706 YY_RESTORE_YY_MORE_OFFSET
1707
1708 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1709 {
1710 /* We're scanning a new file or input source. It's
1711 * possible that this happened because the user
1712 * just pointed yyin at a new source and called
1713 * yylex(). If so, then we have to assure
1714 * consistency between YY_CURRENT_BUFFER and our
1715 * globals. Here is the right place to do so, because
1716 * this is the first action (other than possibly a
1717 * back-up) that will match for the new input source.
1718 */
1719 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1720 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1721 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1722 }
1723
1724 /* Note that here we test for yy_c_buf_p "<=" to the position
1725 * of the first EOB in the buffer, since yy_c_buf_p will
1726 * already have been incremented past the NUL character
1727 * (since all states make transitions on EOB to the
1728 * end-of-buffer state). Contrast this with the test
1729 * in input().
1730 */
1731 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1732 { /* This was really a NUL. */
1733 yy_state_type yy_next_state;
1734
1735 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1736
1737 yy_current_state = yy_get_previous_state( yyscanner );
1738
1739 /* Okay, we're now positioned to make the NUL
1740 * transition. We couldn't have
1741 * yy_get_previous_state() go ahead and do it
1742 * for us because it doesn't know how to deal
1743 * with the possibility of jamming (and we don't
1744 * want to build jamming into it because then it
1745 * will run more slowly).
1746 */
1747
1748 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1749
1750 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1751
1752 if ( yy_next_state )
1753 {
1754 /* Consume the NUL. */
1755 yy_cp = ++yyg->yy_c_buf_p;
1756 yy_current_state = yy_next_state;
1757 goto yy_match;
1758 }
1759
1760 else
1761 {
1762 yy_cp = yyg->yy_c_buf_p;
1763 goto yy_find_action;
1764 }
1765 }
1766
1767 else switch ( yy_get_next_buffer( yyscanner ) )
1768 {
1769 case EOB_ACT_END_OF_FILE:
1770 {
1771 yyg->yy_did_buffer_switch_on_eof = 0;
1772
1773 if ( yywrap(yyscanner ) )
1774 {
1775 /* Note: because we've taken care in
1776 * yy_get_next_buffer() to have set up
1777 * yytext, we can now set up
1778 * yy_c_buf_p so that if some total
1779 * hoser (like flex itself) wants to
1780 * call the scanner after we return the
1781 * YY_NULL, it'll still work - another
1782 * YY_NULL will get returned.
1783 */
1784 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1785
1786 yy_act = YY_STATE_EOF(YY_START);
1787 goto do_action;
1788 }
1789
1790 else
1791 {
1792 if ( ! yyg->yy_did_buffer_switch_on_eof )
1793 YY_NEW_FILE;
1794 }
1795 break;
1796 }
1797
1798 case EOB_ACT_CONTINUE_SCAN:
1799 yyg->yy_c_buf_p =
1800 yyg->yytext_ptr + yy_amount_of_matched_text;
1801
1802 yy_current_state = yy_get_previous_state( yyscanner );
1803
1804 yy_cp = yyg->yy_c_buf_p;
1805 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1806 goto yy_match;
1807
1808 case EOB_ACT_LAST_MATCH:
1809 yyg->yy_c_buf_p =
1810 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1811
1812 yy_current_state = yy_get_previous_state( yyscanner );
1813
1814 yy_cp = yyg->yy_c_buf_p;
1815 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1816 goto yy_find_action;
1817 }
1818 break;
1819 }
1820
1821 default:
1822 YY_FATAL_ERROR(
1823 "fatal flex scanner internal error--no action found" );
1824 } /* end of action switch */
1825 } /* end of scanning one token */
1826 } /* end of yylex */
1827
1828 /* yy_get_next_buffer - try to read in a new buffer
1829 *
1830 * Returns a code representing an action:
1831 * EOB_ACT_LAST_MATCH -
1832 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1833 * EOB_ACT_END_OF_FILE - end of file
1834 */
1835 static int yy_get_next_buffer (yyscan_t yyscanner)
1836 {
1837 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1838 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1839 register char *source = yyg->yytext_ptr;
1840 register int number_to_move, i;
1841 int ret_val;
1842
1843 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1844 YY_FATAL_ERROR(
1845 "fatal flex scanner internal error--end of buffer missed" );
1846
1847 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1848 { /* Don't try to fill the buffer, so this is an EOF. */
1849 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1850 {
1851 /* We matched a single character, the EOB, so
1852 * treat this as a final EOF.
1853 */
1854 return EOB_ACT_END_OF_FILE;
1855 }
1856
1857 else
1858 {
1859 /* We matched some text prior to the EOB, first
1860 * process it.
1861 */
1862 return EOB_ACT_LAST_MATCH;
1863 }
1864 }
1865
1866 /* Try to read more data. */
1867
1868 /* First move last chars to start of buffer. */
1869 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1870
1871 for ( i = 0; i < number_to_move; ++i )
1872 *(dest++) = *(source++);
1873
1874 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1875 /* don't do the read, it's not guaranteed to return an EOF,
1876 * just force an EOF
1877 */
1878 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1879
1880 else
1881 {
1882 size_t num_to_read =
1883 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1884
1885 while ( num_to_read <= 0 )
1886 { /* Not enough room in the buffer - grow it. */
1887
1888 /* just a shorter name for the current buffer */
1889 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1890
1891 int yy_c_buf_p_offset =
1892 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1893
1894 if ( b->yy_is_our_buffer )
1895 {
1896 int new_size = b->yy_buf_size * 2;
1897
1898 if ( new_size <= 0 )
1899 b->yy_buf_size += b->yy_buf_size / 8;
1900 else
1901 b->yy_buf_size *= 2;
1902
1903 b->yy_ch_buf = (char *)
1904 /* Include room in for 2 EOB chars. */
1905 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1906 }
1907 else
1908 /* Can't grow it, we don't own it. */
1909 b->yy_ch_buf = 0;
1910
1911 if ( ! b->yy_ch_buf )
1912 YY_FATAL_ERROR(
1913 "fatal error - scanner input buffer overflow" );
1914
1915 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1916
1917 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1918 number_to_move - 1;
1919
1920 }
1921
1922 if ( num_to_read > YY_READ_BUF_SIZE )
1923 num_to_read = YY_READ_BUF_SIZE;
1924
1925 /* Read in more data. */
1926 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1927 yyg->yy_n_chars, num_to_read );
1928
1929 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1930 }
1931
1932 if ( yyg->yy_n_chars == 0 )
1933 {
1934 if ( number_to_move == YY_MORE_ADJ )
1935 {
1936 ret_val = EOB_ACT_END_OF_FILE;
1937 yyrestart(yyin ,yyscanner);
1938 }
1939
1940 else
1941 {
1942 ret_val = EOB_ACT_LAST_MATCH;
1943 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1944 YY_BUFFER_EOF_PENDING;
1945 }
1946 }
1947
1948 else
1949 ret_val = EOB_ACT_CONTINUE_SCAN;
1950
1951 yyg->yy_n_chars += number_to_move;
1952 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1953 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1954
1955 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1956
1957 return ret_val;
1958 }
1959
1960 /* yy_get_previous_state - get the state just before the EOB char was reached */
1961
1962 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1963 {
1964 register yy_state_type yy_current_state;
1965 register char *yy_cp;
1966 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1967
1968 yy_current_state = yy_start_state_list[yyg->yy_start];
1969
1970 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1971 {
1972 yy_current_state += yy_current_state[(*yy_cp ? YY_SC_TO_UI(*yy_cp) : 256)].yy_nxt;
1973 if ( yy_current_state[-1].yy_nxt )
1974 {
1975 yyg->yy_last_accepting_state = yy_current_state;
1976 yyg->yy_last_accepting_cpos = yy_cp;
1977 }
1978 }
1979
1980 return yy_current_state;
1981 }
1982
1983 /* yy_try_NUL_trans - try to make a transition on the NUL character
1984 *
1985 * synopsis
1986 * next_state = yy_try_NUL_trans( current_state );
1987 */
1988 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1989 {
1990 register int yy_is_jam;
1991 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1992 register char *yy_cp = yyg->yy_c_buf_p;
1993
1994 register int yy_c = 256;
1995 register yyconst struct yy_trans_info *yy_trans_info;
1996
1997 yy_trans_info = &yy_current_state[(unsigned int) yy_c];
1998 yy_current_state += yy_trans_info->yy_nxt;
1999 yy_is_jam = (yy_trans_info->yy_verify != yy_c);
2000
2001 if ( ! yy_is_jam )
2002 {
2003 if ( yy_current_state[-1].yy_nxt )
2004 {
2005 yyg->yy_last_accepting_state = yy_current_state;
2006 yyg->yy_last_accepting_cpos = yy_cp;
2007 }
2008 }
2009
2010 return yy_is_jam ? 0 : yy_current_state;
2011 }
2012
2013 static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)
2014 {
2015 register char *yy_cp;
2016 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2017
2018 yy_cp = yyg->yy_c_buf_p;
2019
2020 /* undo effects of setting up yytext */
2021 *yy_cp = yyg->yy_hold_char;
2022
2023 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2024 { /* need to shift things up to make room */
2025 /* +2 for EOB chars. */
2026 register int number_to_move = yyg->yy_n_chars + 2;
2027 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2028 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2029 register char *source =
2030 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2031
2032 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2033 *--dest = *--source;
2034
2035 yy_cp += (int) (dest - source);
2036 yy_bp += (int) (dest - source);
2037 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2038 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2039
2040 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2041 YY_FATAL_ERROR( "flex scanner push-back overflow" );
2042 }
2043
2044 *--yy_cp = (char) c;
2045
2046 yyg->yytext_ptr = yy_bp;
2047 yyg->yy_hold_char = *yy_cp;
2048 yyg->yy_c_buf_p = yy_cp;
2049 }
2050
2051 #ifndef YY_NO_INPUT
2052 #ifdef __cplusplus
2053 static int yyinput (yyscan_t yyscanner)
2054 #else
2055 static int input (yyscan_t yyscanner)
2056 #endif
2057
2058 {
2059 int c;
2060 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2061
2062 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2063
2064 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2065 {
2066 /* yy_c_buf_p now points to the character we want to return.
2067 * If this occurs *before* the EOB characters, then it's a
2068 * valid NUL; if not, then we've hit the end of the buffer.
2069 */
2070 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
2071 /* This was really a NUL. */
2072 *yyg->yy_c_buf_p = '\0';
2073
2074 else
2075 { /* need more input */
2076 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
2077 ++yyg->yy_c_buf_p;
2078
2079 switch ( yy_get_next_buffer( yyscanner ) )
2080 {
2081 case EOB_ACT_LAST_MATCH:
2082 /* This happens because yy_g_n_b()
2083 * sees that we've accumulated a
2084 * token and flags that we need to
2085 * try matching the token before
2086 * proceeding. But for input(),
2087 * there's no matching to consider.
2088 * So convert the EOB_ACT_LAST_MATCH
2089 * to EOB_ACT_END_OF_FILE.
2090 */
2091
2092 /* Reset buffer status. */
2093 yyrestart(yyin ,yyscanner);
2094
2095 /*FALLTHROUGH*/
2096
2097 case EOB_ACT_END_OF_FILE:
2098 {
2099 if ( yywrap(yyscanner ) )
2100 return EOF;
2101
2102 if ( ! yyg->yy_did_buffer_switch_on_eof )
2103 YY_NEW_FILE;
2104 #ifdef __cplusplus
2105 return yyinput(yyscanner);
2106 #else
2107 return input(yyscanner);
2108 #endif
2109 }
2110
2111 case EOB_ACT_CONTINUE_SCAN:
2112 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
2113 break;
2114 }
2115 }
2116 }
2117
2118 c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
2119 *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
2120 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
2121
2122 return c;
2123 }
2124 #endif /* ifndef YY_NO_INPUT */
2125
2126 /** Immediately switch to a different input stream.
2127 * @param input_file A readable stream.
2128 * @param yyscanner The scanner object.
2129 * @note This function does not reset the start condition to @c INITIAL .
2130 */
2131 void yyrestart (FILE * input_file , yyscan_t yyscanner)
2132 {
2133 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2134
2135 if ( ! YY_CURRENT_BUFFER ){
2136 yyensure_buffer_stack (yyscanner);
2137 YY_CURRENT_BUFFER_LVALUE =
2138 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
2139 }
2140
2141 yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
2142 yy_load_buffer_state(yyscanner );
2143 }
2144
2145 /** Switch to a different input buffer.
2146 * @param new_buffer The new input buffer.
2147 * @param yyscanner The scanner object.
2148 */
2149 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2150 {
2151 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2152
2153 /* TODO. We should be able to replace this entire function body
2154 * with
2155 * yypop_buffer_state();
2156 * yypush_buffer_state(new_buffer);
2157 */
2158 yyensure_buffer_stack (yyscanner);
2159 if ( YY_CURRENT_BUFFER == new_buffer )
2160 return;
2161
2162 if ( YY_CURRENT_BUFFER )
2163 {
2164 /* Flush out information for old buffer. */
2165 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2166 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2167 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2168 }
2169
2170 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2171 yy_load_buffer_state(yyscanner );
2172
2173 /* We don't actually know whether we did this switch during
2174 * EOF (yywrap()) processing, but the only time this flag
2175 * is looked at is after yywrap() is called, so it's safe
2176 * to go ahead and always set it.
2177 */
2178 yyg->yy_did_buffer_switch_on_eof = 1;
2179 }
2180
2181 static void yy_load_buffer_state (yyscan_t yyscanner)
2182 {
2183 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2184 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2185 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2186 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2187 yyg->yy_hold_char = *yyg->yy_c_buf_p;
2188 }
2189
2190 /** Allocate and initialize an input buffer state.
2191 * @param file A readable stream.
2192 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2193 * @param yyscanner The scanner object.
2194 * @return the allocated buffer state.
2195 */
2196 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
2197 {
2198 YY_BUFFER_STATE b;
2199
2200 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2201 if ( ! b )
2202 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2203
2204 b->yy_buf_size = size;
2205
2206 /* yy_ch_buf has to be 2 characters longer than the size given because
2207 * we need to put in 2 end-of-buffer characters.
2208 */
2209 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ,yyscanner );
2210 if ( ! b->yy_ch_buf )
2211 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2212
2213 b->yy_is_our_buffer = 1;
2214
2215 yy_init_buffer(b,file ,yyscanner);
2216
2217 return b;
2218 }
2219
2220 /** Destroy the buffer.
2221 * @param b a buffer created with yy_create_buffer()
2222 * @param yyscanner The scanner object.
2223 */
2224 void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
2225 {
2226 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2227
2228 if ( ! b )
2229 return;
2230
2231 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2232 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2233
2234 if ( b->yy_is_our_buffer )
2235 yyfree((void *) b->yy_ch_buf ,yyscanner );
2236
2237 yyfree((void *) b ,yyscanner );
2238 }
2239
2240 #ifndef __cplusplus
2241 extern int isatty (int );
2242 #endif /* __cplusplus */
2243
2244 /* Initializes or reinitializes a buffer.
2245 * This function is sometimes called more than once on the same buffer,
2246 * such as during a yyrestart() or at EOF.
2247 */
2248 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
2249
2250 {
2251 int oerrno = errno;
2252 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2253
2254 yy_flush_buffer(b ,yyscanner);
2255
2256 b->yy_input_file = file;
2257 b->yy_fill_buffer = 1;
2258
2259 /* If b is the current buffer, then yy_init_buffer was _probably_
2260 * called from yyrestart() or through yy_get_next_buffer.
2261 * In that case, we don't want to reset the lineno or column.
2262 */
2263 if (b != YY_CURRENT_BUFFER){
2264 b->yy_bs_lineno = 1;
2265 b->yy_bs_column = 0;
2266 }
2267
2268 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2269
2270 errno = oerrno;
2271 }
2272
2273 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2274 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2275 * @param yyscanner The scanner object.
2276 */
2277 void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
2278 {
2279 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2280 if ( ! b )
2281 return;
2282
2283 b->yy_n_chars = 0;
2284
2285 /* We always need two end-of-buffer characters. The first causes
2286 * a transition to the end-of-buffer state. The second causes
2287 * a jam in that state.
2288 */
2289 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2290 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2291
2292 b->yy_buf_pos = &b->yy_ch_buf[0];
2293
2294 b->yy_at_bol = 1;
2295 b->yy_buffer_status = YY_BUFFER_NEW;
2296
2297 if ( b == YY_CURRENT_BUFFER )
2298 yy_load_buffer_state(yyscanner );
2299 }
2300
2301 /** Pushes the new state onto the stack. The new state becomes
2302 * the current state. This function will allocate the stack
2303 * if necessary.
2304 * @param new_buffer The new state.
2305 * @param yyscanner The scanner object.
2306 */
2307 void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2308 {
2309 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2310 if (new_buffer == NULL)
2311 return;
2312
2313 yyensure_buffer_stack(yyscanner);
2314
2315 /* This block is copied from yy_switch_to_buffer. */
2316 if ( YY_CURRENT_BUFFER )
2317 {
2318 /* Flush out information for old buffer. */
2319 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2320 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2321 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2322 }
2323
2324 /* Only push if top exists. Otherwise, replace top. */
2325 if (YY_CURRENT_BUFFER)
2326 yyg->yy_buffer_stack_top++;
2327 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2328
2329 /* copied from yy_switch_to_buffer. */
2330 yy_load_buffer_state(yyscanner );
2331 yyg->yy_did_buffer_switch_on_eof = 1;
2332 }
2333
2334 /** Removes and deletes the top of the stack, if present.
2335 * The next element becomes the new top.
2336 * @param yyscanner The scanner object.
2337 */
2338 void yypop_buffer_state (yyscan_t yyscanner)
2339 {
2340 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2341 if (!YY_CURRENT_BUFFER)
2342 return;
2343
2344 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
2345 YY_CURRENT_BUFFER_LVALUE = NULL;
2346 if (yyg->yy_buffer_stack_top > 0)
2347 --yyg->yy_buffer_stack_top;
2348
2349 if (YY_CURRENT_BUFFER) {
2350 yy_load_buffer_state(yyscanner );
2351 yyg->yy_did_buffer_switch_on_eof = 1;
2352 }
2353 }
2354
2355 /* Allocates the stack if it does not exist.
2356 * Guarantees space for at least one push.
2357 */
2358 static void yyensure_buffer_stack (yyscan_t yyscanner)
2359 {
2360 int num_to_alloc;
2361 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2362
2363 if (!yyg->yy_buffer_stack) {
2364
2365 /* First allocation is just for 2 elements, since we don't know if this
2366 * scanner will even need a stack. We use 2 instead of 1 to avoid an
2367 * immediate realloc on the next call.
2368 */
2369 num_to_alloc = 1;
2370 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
2371 (num_to_alloc * sizeof(struct yy_buffer_state*)
2372 , yyscanner);
2373
2374 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2375
2376 yyg->yy_buffer_stack_max = num_to_alloc;
2377 yyg->yy_buffer_stack_top = 0;
2378 return;
2379 }
2380
2381 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
2382
2383 /* Increase the buffer to prepare for a possible push. */
2384 int grow_size = 8 /* arbitrary grow size */;
2385
2386 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
2387 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
2388 (yyg->yy_buffer_stack,
2389 num_to_alloc * sizeof(struct yy_buffer_state*)
2390 , yyscanner);
2391
2392 /* zero only the new slots.*/
2393 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
2394 yyg->yy_buffer_stack_max = num_to_alloc;
2395 }
2396 }
2397
2398 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2399 * @param base the character buffer
2400 * @param size the size in bytes of the character buffer
2401 * @param yyscanner The scanner object.
2402 * @return the newly allocated buffer state object.
2403 */
2404 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
2405 {
2406 YY_BUFFER_STATE b;
2407
2408 if ( size < 2 ||
2409 base[size-2] != YY_END_OF_BUFFER_CHAR ||
2410 base[size-1] != YY_END_OF_BUFFER_CHAR )
2411 /* They forgot to leave room for the EOB's. */
2412 return 0;
2413
2414 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2415 if ( ! b )
2416 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2417
2418 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2419 b->yy_buf_pos = b->yy_ch_buf = base;
2420 b->yy_is_our_buffer = 0;
2421 b->yy_input_file = 0;
2422 b->yy_n_chars = b->yy_buf_size;
2423 b->yy_is_interactive = 0;
2424 b->yy_at_bol = 1;
2425 b->yy_fill_buffer = 0;
2426 b->yy_buffer_status = YY_BUFFER_NEW;
2427
2428 yy_switch_to_buffer(b ,yyscanner );
2429
2430 return b;
2431 }
2432
2433 /** Setup the input buffer state to scan a string. The next call to yylex() will
2434 * scan from a @e copy of @a str.
2435 * @param str a NUL-terminated string to scan
2436 * @param yyscanner The scanner object.
2437 * @return the newly allocated buffer state object.
2438 * @note If you want to scan bytes that may contain NUL values, then use
2439 * yy_scan_bytes() instead.
2440 */
2441 YY_BUFFER_STATE yy_scan_string (yyconst char * str , yyscan_t yyscanner)
2442 {
2443
2444 return yy_scan_bytes(str,strlen(str) ,yyscanner);
2445 }
2446
2447 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2448 * scan from a @e copy of @a bytes.
2449 * @param bytes the byte buffer to scan
2450 * @param len the number of bytes in the buffer pointed to by @a bytes.
2451 * @param yyscanner The scanner object.
2452 * @return the newly allocated buffer state object.
2453 */
2454 YY_BUFFER_STATE yy_scan_bytes (yyconst char * bytes, int len , yyscan_t yyscanner)
2455 {
2456 YY_BUFFER_STATE b;
2457 char *buf;
2458 yy_size_t n;
2459 int i;
2460
2461 /* Get memory for full buffer, including space for trailing EOB's. */
2462 n = len + 2;
2463 buf = (char *) yyalloc(n ,yyscanner );
2464 if ( ! buf )
2465 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2466
2467 for ( i = 0; i < len; ++i )
2468 buf[i] = bytes[i];
2469
2470 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2471
2472 b = yy_scan_buffer(buf,n ,yyscanner);
2473 if ( ! b )
2474 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2475
2476 /* It's okay to grow etc. this buffer, and we should throw it
2477 * away when we're done.
2478 */
2479 b->yy_is_our_buffer = 1;
2480
2481 return b;
2482 }
2483
2484 #ifndef YY_EXIT_FAILURE
2485 #define YY_EXIT_FAILURE 2
2486 #endif
2487
2488 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
2489 {
2490 (void) fprintf( stderr, "%s\n", msg );
2491 exit( YY_EXIT_FAILURE );
2492 }
2493
2494 /* Redefine yyless() so it works in section 3 code. */
2495
2496 #undef yyless
2497 #define yyless(n) \
2498 do \
2499 { \
2500 /* Undo effects of setting up yytext. */ \
2501 int yyless_macro_arg = (n); \
2502 YY_LESS_LINENO(yyless_macro_arg);\
2503 yytext[yyleng] = yyg->yy_hold_char; \
2504 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
2505 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
2506 *yyg->yy_c_buf_p = '\0'; \
2507 yyleng = yyless_macro_arg; \
2508 } \
2509 while ( 0 )
2510
2511 /* Accessor methods (get/set functions) to struct members. */
2512
2513 /** Get the user-defined data for this scanner.
2514 * @param yyscanner The scanner object.
2515 */
2516 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
2517 {
2518 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2519 return yyextra;
2520 }
2521
2522 /** Get the current line number.
2523 * @param yyscanner The scanner object.
2524 */
2525 int yyget_lineno (yyscan_t yyscanner)
2526 {
2527 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2528
2529 if (! YY_CURRENT_BUFFER)
2530 return 0;
2531
2532 return yylineno;
2533 }
2534
2535 /** Get the current column number.
2536 * @param yyscanner The scanner object.
2537 */
2538 int yyget_column (yyscan_t yyscanner)
2539 {
2540 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2541
2542 if (! YY_CURRENT_BUFFER)
2543 return 0;
2544
2545 return yycolumn;
2546 }
2547
2548 /** Get the input stream.
2549 * @param yyscanner The scanner object.
2550 */
2551 FILE *yyget_in (yyscan_t yyscanner)
2552 {
2553 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2554 return yyin;
2555 }
2556
2557 /** Get the output stream.
2558 * @param yyscanner The scanner object.
2559 */
2560 FILE *yyget_out (yyscan_t yyscanner)
2561 {
2562 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2563 return yyout;
2564 }
2565
2566 /** Get the length of the current token.
2567 * @param yyscanner The scanner object.
2568 */
2569 int yyget_leng (yyscan_t yyscanner)
2570 {
2571 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2572 return yyleng;
2573 }
2574
2575 /** Get the current token.
2576 * @param yyscanner The scanner object.
2577 */
2578
2579 char *yyget_text (yyscan_t yyscanner)
2580 {
2581 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2582 return yytext;
2583 }
2584
2585 /** Set the user-defined data. This data is never touched by the scanner.
2586 * @param user_defined The data to be associated with this scanner.
2587 * @param yyscanner The scanner object.
2588 */
2589 void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
2590 {
2591 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2592 yyextra = user_defined ;
2593 }
2594
2595 /** Set the current line number.
2596 * @param line_number
2597 * @param yyscanner The scanner object.
2598 */
2599 void yyset_lineno (int line_number , yyscan_t yyscanner)
2600 {
2601 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2602
2603 /* lineno is only valid if an input buffer exists. */
2604 if (! YY_CURRENT_BUFFER )
2605 yy_fatal_error( "yyset_lineno called with no buffer" , yyscanner);
2606
2607 yylineno = line_number;
2608 }
2609
2610 /** Set the current column.
2611 * @param line_number
2612 * @param yyscanner The scanner object.
2613 */
2614 void yyset_column (int column_no , yyscan_t yyscanner)
2615 {
2616 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2617
2618 /* column is only valid if an input buffer exists. */
2619 if (! YY_CURRENT_BUFFER )
2620 yy_fatal_error( "yyset_column called with no buffer" , yyscanner);
2621
2622 yycolumn = column_no;
2623 }
2624
2625 /** Set the input stream. This does not discard the current
2626 * input buffer.
2627 * @param in_str A readable stream.
2628 * @param yyscanner The scanner object.
2629 * @see yy_switch_to_buffer
2630 */
2631 void yyset_in (FILE * in_str , yyscan_t yyscanner)
2632 {
2633 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2634 yyin = in_str ;
2635 }
2636
2637 void yyset_out (FILE * out_str , yyscan_t yyscanner)
2638 {
2639 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2640 yyout = out_str ;
2641 }
2642
2643 int yyget_debug (yyscan_t yyscanner)
2644 {
2645 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2646 return yy_flex_debug;
2647 }
2648
2649 void yyset_debug (int bdebug , yyscan_t yyscanner)
2650 {
2651 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2652 yy_flex_debug = bdebug ;
2653 }
2654
2655 /* Accessor methods for yylval and yylloc */
2656
2657 static int yy_init_globals (yyscan_t yyscanner)
2658 {
2659 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2660 /* Initialization is the same as for the non-reentrant scanner.
2661 This function is called once per scanner lifetime. */
2662
2663 yyg->yy_buffer_stack = 0;
2664 yyg->yy_buffer_stack_top = 0;
2665 yyg->yy_buffer_stack_max = 0;
2666 yyg->yy_c_buf_p = (char *) 0;
2667 yyg->yy_init = 1;
2668 yyg->yy_start = 0;
2669 yyg->yy_start_stack_ptr = 0;
2670 yyg->yy_start_stack_depth = 0;
2671 yyg->yy_start_stack = (int *) 0;
2672
2673 /* Defined in main.c */
2674 #ifdef YY_STDINIT
2675 yyin = stdin;
2676 yyout = stdout;
2677 #else
2678 yyin = (FILE *) 0;
2679 yyout = (FILE *) 0;
2680 #endif
2681
2682 /* For future reference: Set errno on error, since we are called by
2683 * yylex_init()
2684 */
2685 return 0;
2686 }
2687
2688 /* User-visible API */
2689
2690 /* yylex_init is special because it creates the scanner itself, so it is
2691 * the ONLY reentrant function that doesn't take the scanner as the last argument.
2692 * That's why we explicitly handle the declaration, instead of using our macros.
2693 */
2694
2695 int yylex_init(yyscan_t* ptr_yy_globals)
2696
2697 {
2698 if (ptr_yy_globals == NULL){
2699 errno = EINVAL;
2700 return 1;
2701 }
2702
2703 *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
2704
2705 if (*ptr_yy_globals == NULL){
2706 errno = ENOMEM;
2707 return 1;
2708 }
2709
2710 memset(*ptr_yy_globals,0,sizeof(struct yyguts_t));
2711
2712 return yy_init_globals ( *ptr_yy_globals );
2713 }
2714
2715 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2716 int yylex_destroy (yyscan_t yyscanner)
2717 {
2718 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2719
2720 /* Pop the buffer stack, destroying each element. */
2721 while(YY_CURRENT_BUFFER){
2722 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2723 YY_CURRENT_BUFFER_LVALUE = NULL;
2724 yypop_buffer_state(yyscanner);
2725 }
2726
2727 /* Destroy the stack itself. */
2728 yyfree(yyg->yy_buffer_stack ,yyscanner);
2729 yyg->yy_buffer_stack = NULL;
2730
2731 /* Destroy the start condition stack. */
2732 yyfree(yyg->yy_start_stack ,yyscanner );
2733 yyg->yy_start_stack = NULL;
2734
2735 /* Destroy the main struct (reentrant only). */
2736 yyfree ( yyscanner , yyscanner );
2737 return 0;
2738 }
2739
2740 /*
2741 * Internal utility routines.
2742 */
2743
2744 #ifndef yytext_ptr
2745 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2746 {
2747 register int i;
2748 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2749 for ( i = 0; i < n; ++i )
2750 s1[i] = s2[i];
2751 }
2752 #endif
2753
2754 #ifdef YY_NEED_STRLEN
2755 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
2756 {
2757 register int n;
2758 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2759 for ( n = 0; s[n]; ++n )
2760 ;
2761
2762 return n;
2763 }
2764 #endif
2765
2766 void *yyalloc (yy_size_t size , yyscan_t yyscanner)
2767 {
2768 return (void *) malloc( size );
2769 }
2770
2771 void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
2772 {
2773 /* The cast to (char *) in the following accommodates both
2774 * implementations that use char* generic pointers, and those
2775 * that use void* generic pointers. It works with the latter
2776 * because both ANSI C and C++ allow castless assignment from
2777 * any pointer type to void*, and deal with argument conversions
2778 * as though doing an assignment.
2779 */
2780 return (void *) realloc( (char *) ptr, size );
2781 }
2782
2783 void yyfree (void * ptr , yyscan_t yyscanner)
2784 {
2785 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2786 }
2787
2788 #define YYTABLES_NAME "yytables"
2789
2790 #undef YY_NEW_FILE
2791 #undef YY_FLUSH_BUFFER
2792 #undef yy_set_bol
2793 #undef yy_new_buffer
2794 #undef yy_set_interactive
2795 #undef yytext_ptr
2796 #undef YY_DO_BEFORE_ACTION
2797
2798 #ifdef YY_DECL_IS_OURS
2799 #undef YY_DECL_IS_OURS
2800 #undef YY_DECL
2801 #endif
2802 #line 99 "lscp.l"
2803
2804
2805
2806 /**
2807 * We provide our own version of yywrap() so we don't have to link against
2808 * the lex library.
2809 */
2810 int yywrap(yyscan_t yyscanner) {
2811 return 1; // continue scanning
2812 }
2813
  ViewVC Help
Powered by ViewVC