From 4fcaf4c810336cce85e5cedf494433a53c39712c Mon Sep 17 00:00:00 2001 From: iska Date: Fri, 8 May 2015 00:31:39 +0200 Subject: [PATCH] Add implementation for a CSS Selector Tokenizer The Tokenizer is based on a flex-generated lexer for the grammar defined in the CSS Selectors Level 3 Spec http://www.w3.org/TR/css3-selectors/#lex --- HTMLKit.xcodeproj/project.pbxproj | 28 + HTMLKit/CSSLexer.c | 3156 +++++++++++++++++++++++++++++ HTMLKit/CSSLexer.h | 329 +++ HTMLKit/CSSTokenizer.h | 44 + HTMLKit/CSSTokenizer.m | 56 + 5 files changed, 3613 insertions(+) create mode 100644 HTMLKit/CSSLexer.c create mode 100644 HTMLKit/CSSLexer.h create mode 100644 HTMLKit/CSSTokenizer.h create mode 100644 HTMLKit/CSSTokenizer.m diff --git a/HTMLKit.xcodeproj/project.pbxproj b/HTMLKit.xcodeproj/project.pbxproj index e00d8ff..3eed2ab 100644 --- a/HTMLKit.xcodeproj/project.pbxproj +++ b/HTMLKit.xcodeproj/project.pbxproj @@ -7,6 +7,7 @@ objects = { /* Begin PBXBuildFile section */ + 620802021AFD939200F2962F /* CSSTokenizer.h in Headers */ = {isa = PBXBuildFile; fileRef = 623F13A81AFC11D900C90BF4 /* CSSTokenizer.h */; }; 623406E11ADB04F9004677A3 /* HTMLTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 623406DF1ADB04F9004677A3 /* HTMLTemplate.h */; }; 623406E21ADB04F9004677A3 /* HTMLTemplate.m in Sources */ = {isa = PBXBuildFile; fileRef = 623406E01ADB04F9004677A3 /* HTMLTemplate.m */; }; 623406E31ADB04F9004677A3 /* HTMLTemplate.m in Sources */ = {isa = PBXBuildFile; fileRef = 623406E01ADB04F9004677A3 /* HTMLTemplate.m */; }; @@ -63,12 +64,17 @@ 6239755F1AC364BB007E26F1 /* HTML5LibTreeConstructionTest.m in Sources */ = {isa = PBXBuildFile; fileRef = 6239755D1AC364BB007E26F1 /* HTML5LibTreeConstructionTest.m */; }; 623CAF9D1AD88BEA00E34C32 /* HTMLKitParserPerformance.m in Sources */ = {isa = PBXBuildFile; fileRef = 623CAF9C1AD88BEA00E34C32 /* HTMLKitParserPerformance.m */; }; 623CAF9E1AD88BEA00E34C32 /* HTMLKitParserPerformance.m in Sources */ = {isa = PBXBuildFile; fileRef = 623CAF9C1AD88BEA00E34C32 /* HTMLKitParserPerformance.m */; }; + 623F13AB1AFC11D900C90BF4 /* CSSTokenizer.m in Sources */ = {isa = PBXBuildFile; fileRef = 623F13A91AFC11D900C90BF4 /* CSSTokenizer.m */; }; + 623F13AC1AFC11D900C90BF4 /* CSSTokenizer.m in Sources */ = {isa = PBXBuildFile; fileRef = 623F13A91AFC11D900C90BF4 /* CSSTokenizer.m */; }; 624493A619CCC54100BCDDF4 /* HTMLTokenizer.h in Headers */ = {isa = PBXBuildFile; fileRef = 624493A419CCC54100BCDDF4 /* HTMLTokenizer.h */; }; 624493A719CCC54100BCDDF4 /* HTMLTokenizer.m in Sources */ = {isa = PBXBuildFile; fileRef = 624493A519CCC54100BCDDF4 /* HTMLTokenizer.m */; }; 624493A819CCC54100BCDDF4 /* HTMLTokenizer.m in Sources */ = {isa = PBXBuildFile; fileRef = 624493A519CCC54100BCDDF4 /* HTMLTokenizer.m */; }; 624493AC19CD0CBE00BCDDF4 /* HTMLToken.h in Headers */ = {isa = PBXBuildFile; fileRef = 624493AA19CD0CBE00BCDDF4 /* HTMLToken.h */; }; 624493AD19CD0CBE00BCDDF4 /* HTMLToken.m in Sources */ = {isa = PBXBuildFile; fileRef = 624493AB19CD0CBE00BCDDF4 /* HTMLToken.m */; }; 624493AE19CD0CBE00BCDDF4 /* HTMLToken.m in Sources */ = {isa = PBXBuildFile; fileRef = 624493AB19CD0CBE00BCDDF4 /* HTMLToken.m */; }; + 62491C471AFE51F100ACF9E2 /* CSSLexer.c in Sources */ = {isa = PBXBuildFile; fileRef = 62491C451AFE51F100ACF9E2 /* CSSLexer.c */; }; + 62491C481AFE51F100ACF9E2 /* CSSLexer.c in Sources */ = {isa = PBXBuildFile; fileRef = 62491C451AFE51F100ACF9E2 /* CSSLexer.c */; }; + 62491C491AFE51F100ACF9E2 /* CSSLexer.h in Headers */ = {isa = PBXBuildFile; fileRef = 62491C461AFE51F100ACF9E2 /* CSSLexer.h */; }; 624AC8FF19FBF59800BD3C4A /* HTMLTokens.h in Headers */ = {isa = PBXBuildFile; fileRef = 624AC8FE19FBF4F700BD3C4A /* HTMLTokens.h */; }; 624AC90119FBF9ED00BD3C4A /* HTMLKitTokenizerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 624AC90019FBF9ED00BD3C4A /* HTMLKitTokenizerTests.m */; }; 624AC90219FBF9ED00BD3C4A /* HTMLKitTokenizerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 624AC90019FBF9ED00BD3C4A /* HTMLKitTokenizerTests.m */; }; @@ -207,11 +213,15 @@ 6239755C1AC364BB007E26F1 /* HTML5LibTreeConstructionTest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HTML5LibTreeConstructionTest.h; sourceTree = ""; }; 6239755D1AC364BB007E26F1 /* HTML5LibTreeConstructionTest.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = HTML5LibTreeConstructionTest.m; sourceTree = ""; }; 623CAF9C1AD88BEA00E34C32 /* HTMLKitParserPerformance.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = HTMLKitParserPerformance.m; sourceTree = ""; }; + 623F13A81AFC11D900C90BF4 /* CSSTokenizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSTokenizer.h; sourceTree = ""; }; + 623F13A91AFC11D900C90BF4 /* CSSTokenizer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CSSTokenizer.m; sourceTree = ""; }; 624493A419CCC54100BCDDF4 /* HTMLTokenizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HTMLTokenizer.h; sourceTree = ""; }; 624493A519CCC54100BCDDF4 /* HTMLTokenizer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = HTMLTokenizer.m; sourceTree = ""; }; 624493A919CCE84A00BCDDF4 /* HTMLTokenizerStates.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = HTMLTokenizerStates.h; sourceTree = ""; }; 624493AA19CD0CBE00BCDDF4 /* HTMLToken.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HTMLToken.h; sourceTree = ""; }; 624493AB19CD0CBE00BCDDF4 /* HTMLToken.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = HTMLToken.m; sourceTree = ""; }; + 62491C451AFE51F100ACF9E2 /* CSSLexer.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = CSSLexer.c; sourceTree = ""; }; + 62491C461AFE51F100ACF9E2 /* CSSLexer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSLexer.h; sourceTree = ""; }; 624AC8FE19FBF4F700BD3C4A /* HTMLTokens.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = HTMLTokens.h; sourceTree = ""; }; 624AC90019FBF9ED00BD3C4A /* HTMLKitTokenizerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = HTMLKitTokenizerTests.m; sourceTree = ""; }; 624AC90419FBFE8A00BD3C4A /* html5lib-tests */ = {isa = PBXFileReference; lastKnownFileType = folder; path = "html5lib-tests"; sourceTree = ""; }; @@ -302,6 +312,17 @@ /* End PBXFrameworksBuildPhase section */ /* Begin PBXGroup section */ + 62079BE61AF5656600D3B402 /* Selectors */ = { + isa = PBXGroup; + children = ( + 623F13A81AFC11D900C90BF4 /* CSSTokenizer.h */, + 623F13A91AFC11D900C90BF4 /* CSSTokenizer.m */, + 62491C461AFE51F100ACF9E2 /* CSSLexer.h */, + 62491C451AFE51F100ACF9E2 /* CSSLexer.c */, + ); + name = Selectors; + sourceTree = ""; + }; 6236738C1AC0CD2400FF89B3 /* Tokenizer */ = { isa = PBXGroup; children = ( @@ -424,6 +445,7 @@ 623719441AA1472B002E03C8 /* Nodes */, 628E16ED1ADAE73700B15A06 /* Categories */, 628E16EE1ADAE75300B15A06 /* Structures */, + 62079BE61AF5656600D3B402 /* Selectors */, 625A14B619C7829400AD0C32 /* Supporting Files */, ); name = "Source Code"; @@ -567,7 +589,9 @@ 625A150419C783EB00AD0C32 /* HTMLKit.h in Headers */, 625A150819C78ABA00AD0C32 /* HTMLInputStreamReader.h in Headers */, 6238579B1A9E8934003A45D9 /* HTMLComment.h in Headers */, + 620802021AFD939200F2962F /* CSSTokenizer.h in Headers */, 62AE593519F97D880043F069 /* HTMLParseErrorToken.h in Headers */, + 62491C491AFE51F100ACF9E2 /* CSSLexer.h in Headers */, 62AE594919F9948A0043F069 /* HTMLCharacterToken.h in Headers */, 623857961A9E8606003A45D9 /* HTMLDocumentType.h in Headers */, 623406E61ADB05AD004677A3 /* HTMLDocumentFragment.h in Headers */, @@ -744,6 +768,8 @@ 623857931A9E772B003A45D9 /* HTMLDocument.m in Sources */, 623406E81ADB05AD004677A3 /* HTMLDocumentFragment.m in Sources */, 624493A819CCC54100BCDDF4 /* HTMLTokenizer.m in Sources */, + 623F13AC1AFC11D900C90BF4 /* CSSTokenizer.m in Sources */, + 62491C481AFE51F100ACF9E2 /* CSSLexer.c in Sources */, 625A14BE19C7829400AD0C32 /* HTMLKit.m in Sources */, 623857981A9E8606003A45D9 /* HTMLDocumentType.m in Sources */, 62AE594B19F9948A0043F069 /* HTMLCharacterToken.m in Sources */, @@ -796,6 +822,8 @@ 623857921A9E772B003A45D9 /* HTMLDocument.m in Sources */, 623406E71ADB05AD004677A3 /* HTMLDocumentFragment.m in Sources */, 624493A719CCC54100BCDDF4 /* HTMLTokenizer.m in Sources */, + 623F13AB1AFC11D900C90BF4 /* CSSTokenizer.m in Sources */, + 62491C471AFE51F100ACF9E2 /* CSSLexer.c in Sources */, 625A150219C783DE00AD0C32 /* HTMLKit.m in Sources */, 623857971A9E8606003A45D9 /* HTMLDocumentType.m in Sources */, 62AE594A19F9948A0043F069 /* HTMLCharacterToken.m in Sources */, diff --git a/HTMLKit/CSSLexer.c b/HTMLKit/CSSLexer.c new file mode 100644 index 0000000..219d14c --- /dev/null +++ b/HTMLKit/CSSLexer.c @@ -0,0 +1,3156 @@ + +#line 3 "CSSLexer.c" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 +#define YY_FLEX_SUBMINOR_VERSION 35 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +typedef uint64_t flex_uint64_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; +#endif /* ! C99 */ + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#endif /* ! FLEXINT_H */ + +#ifdef __cplusplus + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +/* C99 requires __STDC__ to be defined as 1. */ +#if defined (__STDC__) + +#define YY_USE_CONST + +#endif /* defined (__STDC__) */ +#endif /* ! __cplusplus */ + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* An opaque pointer. */ +#ifndef YY_TYPEDEF_YY_SCANNER_T +#define YY_TYPEDEF_YY_SCANNER_T +typedef void* yyscan_t; +#endif + +/* For convenience, these vars (plus the bison vars far below) + are macros in the reentrant scanner. */ +#define yyin yyg->yyin_r +#define yyout yyg->yyout_r +#define yyextra yyg->yyextra_r +#define yyleng yyg->yyleng_r +#define yytext yyg->yytext_r +#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) +#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) +#define yy_flex_debug yyg->yy_flex_debug_r + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yyg->yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yyg->yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE cssrestart(yyin ,yyscanner ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#define YY_BUF_SIZE 16384 +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +#define YY_LESS_LINENO(n) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ +do \ +{ \ +/* Undo effects of setting up yytext. */ \ +int yyless_macro_arg = (n); \ +YY_LESS_LINENO(yyless_macro_arg);\ +*yy_cp = yyg->yy_hold_char; \ +YY_RESTORE_YY_MORE_OFFSET \ +yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ +YY_DO_BEFORE_ACTION; /* set up yytext again */ \ +} \ +while ( 0 ) + +#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state +{ + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + yy_size_t yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via cssrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + +}; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ +? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ +: NULL) + +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] + +void cssrestart (FILE *input_file ,yyscan_t yyscanner ); +void css_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); +YY_BUFFER_STATE css_create_buffer (FILE *file,int size ,yyscan_t yyscanner ); +void css_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); +void css_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); +void csspush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); +void csspop_buffer_state (yyscan_t yyscanner ); + +static void cssensure_buffer_stack (yyscan_t yyscanner ); +static void css_load_buffer_state (yyscan_t yyscanner ); +static void css_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner ); + +#define YY_FLUSH_BUFFER css_flush_buffer(YY_CURRENT_BUFFER ,yyscanner) + +YY_BUFFER_STATE css_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); +YY_BUFFER_STATE css_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); +YY_BUFFER_STATE css_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner ); + +void *cssalloc (yy_size_t ,yyscan_t yyscanner ); +void *cssrealloc (void *,yy_size_t ,yyscan_t yyscanner ); +void cssfree (void * ,yyscan_t yyscanner ); + +#define yy_new_buffer css_create_buffer + +#define yy_set_interactive(is_interactive) \ +{ \ +if ( ! YY_CURRENT_BUFFER ){ \ +cssensure_buffer_stack (yyscanner); \ +YY_CURRENT_BUFFER_LVALUE = \ +css_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ +} \ +YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ +} + +#define yy_set_bol(at_bol) \ +{ \ +if ( ! YY_CURRENT_BUFFER ){\ +cssensure_buffer_stack (yyscanner); \ +YY_CURRENT_BUFFER_LVALUE = \ +css_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ +} \ +YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ +} + +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +#define csswrap(n) 1 +#define YY_SKIP_YYWRAP + +typedef unsigned char YY_CHAR; + +typedef yyconst struct yy_trans_info *yy_state_type; + +#define yytext_ptr yytext_r + +static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); +static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner); +static int yy_get_next_buffer (yyscan_t yyscanner ); +static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ +yyg->yytext_ptr = yy_bp; \ +yyleng = (yy_size_t) (yy_cp - yy_bp); \ +yyg->yy_hold_char = *yy_cp; \ +*yy_cp = '\0'; \ +yyg->yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 25 +#define YY_END_OF_BUFFER 26 +struct yy_trans_info +{ + flex_int16_t yy_verify; + flex_int16_t yy_nxt; +}; +static yyconst struct yy_trans_info yy_transition[5613] = +{ + { 0, 0 }, { 0,5567 }, { 0, 0 }, { 0,5565 }, { 1, 96 }, + { 2, 98 }, { 3, 105 }, { 4, 98 }, { 5, 98 }, { 6, 96 }, + { 7, 145 }, { 8, 193 }, { 9, 115 }, { 10, 96 }, { 11, 241 }, + { 12, 96 }, { 13, 122 }, { 14, 124 }, { 15, 128 }, { 16, 289 }, + { 17, 291 }, { 18, 135 }, { 19, 317 }, { 20, 317 }, { 21, 317 }, + { 22, 317 }, { 23, 317 }, { 24, 317 }, { 25, 343 }, { 26, 362 }, + { 27, 96 }, { 28, 365 }, { 29, 367 }, { 30, 412 }, { 31, 412 }, + { 32, 412 }, { 33, 412 }, { 34, 412 }, { 35, 412 }, { 36, 412 }, + { 37, 460 }, { 38, 387 }, { 39, 412 }, { 40, 412 }, { 41, 412 }, + { 42, 412 }, { 43, 412 }, { 44, 389 }, { 45, 391 }, { 46, 412 }, + + { 0, 0 }, { 0,5517 }, { 1, 48 }, { 2, 50 }, { 3, 57 }, + { 4, 50 }, { 5, 50 }, { 6, 48 }, { 7, 97 }, { 8, 145 }, + { 9, 67 }, { 10, 48 }, { 11, 193 }, { 12, 48 }, { 13, 74 }, + { 14, 76 }, { 15, 80 }, { 16, 241 }, { 17, 243 }, { 18, 87 }, + { 19, 269 }, { 20, 269 }, { 21, 269 }, { 22, 269 }, { 23, 269 }, + { 24, 269 }, { 25, 295 }, { 26, 314 }, { 27, 48 }, { 28, 317 }, + { 29, 319 }, { 30, 364 }, { 31, 364 }, { 32, 364 }, { 33, 364 }, + { 34, 364 }, { 35, 364 }, { 36, 364 }, { 37, 412 }, { 38, 339 }, + { 39, 364 }, { 40, 364 }, { 41, 364 }, { 42, 364 }, { 43, 364 }, + { 44, 341 }, { 45, 343 }, { 46, 364 }, { 0, 24 }, { 0,5469 }, + + { 0, 1 }, { 0,5467 }, { 0, 0 }, { 2, 410 }, { 3, 410 }, + { 4, 410 }, { 5, 410 }, { 0, 1 }, { 0,5460 }, { 0, 0 }, + { 2, 403 }, { 3, 403 }, { 4, 403 }, { 5, 403 }, { 0, 0 }, + { 14, 295 }, { 15, 297 }, { 0, 24 }, { 0,5450 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 14, 288 }, { 15, 290 }, { 0, 24 }, + { 0,5443 }, { 0, 12 }, { 0,5441 }, { 0, 0 }, { 28, 322 }, + { 0, 14 }, { 0,5437 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 28, 315 }, { 0, 24 }, { 0,5430 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 27, 315 }, { 45, 324 }, { 0, 18 }, { 0,5420 }, { 1, 403 }, + + { 2, 403 }, { 13, 941 }, { 27, 316 }, { 45, 317 }, { 6, 403 }, + { 7, 281 }, { 8, 403 }, { 9, 403 }, { 10, 403 }, { 11, 403 }, + { 12, 403 }, { 13, 403 }, { 14, 403 }, { 15, 403 }, { 16, 403 }, + { 17, 403 }, { 18, 403 }, { 19, 403 }, { 20, 403 }, { 21, 403 }, + { 22, 403 }, { 23, 403 }, { 24, 403 }, { 25, 403 }, { 26, 403 }, + { 27, 403 }, { 28, 403 }, { 29, 403 }, { 30, 403 }, { 31, 403 }, + { 32, 403 }, { 33, 403 }, { 34, 403 }, { 35, 403 }, { 36, 403 }, + { 37, 451 }, { 38, 403 }, { 39, 403 }, { 40, 403 }, { 41, 403 }, + { 42, 403 }, { 43, 403 }, { 44, 403 }, { 45, 403 }, { 46, 499 }, + { 0, 24 }, { 0,5372 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 16, 499 }, { 0, 0 }, { 0, 0 }, + { 19, 499 }, { 20, 499 }, { 21, 499 }, { 22, 499 }, { 23, 499 }, + { 24, 499 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 30, 499 }, { 31, 499 }, { 32, 499 }, { 33, 499 }, + { 34, 499 }, { 35, 499 }, { 36, 499 }, { 37, 547 }, { 0, 0 }, + { 39, 499 }, { 40, 499 }, { 41, 499 }, { 42, 499 }, { 43, 499 }, + { 0, 0 }, { 0, 0 }, { 46, 499 }, { 0, 18 }, { 0,5324 }, + { 1, 547 }, { 2, 547 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 6, 547 }, { 7, 547 }, { 8, 547 }, { 9, 547 }, { 10, 547 }, + { 11, 185 }, { 12, 547 }, { 13, 547 }, { 14, 547 }, { 15, 547 }, + { 16, 547 }, { 17, 547 }, { 18, 547 }, { 19, 547 }, { 20, 547 }, + { 21, 547 }, { 22, 547 }, { 23, 547 }, { 24, 547 }, { 25, 547 }, + { 26, 547 }, { 27, 547 }, { 28, 547 }, { 29, 547 }, { 30, 547 }, + { 31, 547 }, { 32, 547 }, { 33, 547 }, { 34, 547 }, { 35, 547 }, + { 36, 547 }, { 37, 595 }, { 38, 547 }, { 39, 547 }, { 40, 547 }, + { 41, 547 }, { 42, 547 }, { 43, 547 }, { 44, 547 }, { 45, 547 }, + { 46, 643 }, { 0, 24 }, { 0,5276 }, { 0, 24 }, { 0,5274 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16, 226 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 19, 737 }, { 20, 737 }, + { 21, 737 }, { 22, 737 }, { 23, 737 }, { 24, 737 }, { 0, 10 }, + { 0,5248 }, { 0, 0 }, { 30, 643 }, { 31, 643 }, { 32, 643 }, + { 33, 643 }, { 34, 643 }, { 35, 643 }, { 36, 643 }, { 37, 691 }, + { 10, 200 }, { 39, 643 }, { 40, 643 }, { 41, 643 }, { 42, 643 }, + { 43, 643 }, { 16, 807 }, { 17, 809 }, { 46, 643 }, { 19, 835 }, + { 20, 835 }, { 21, 835 }, { 22, 835 }, { 23, 835 }, { 24, 835 }, + { 0, 24 }, { 0,5222 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 30, 863 }, { 31, 863 }, { 32, 863 }, { 33, 863 }, { 34, 863 }, + { 35, 863 }, { 36, 863 }, { 37, 911 }, { 0, 0 }, { 39, 863 }, + { 40, 863 }, { 41, 863 }, { 42, 863 }, { 43, 863 }, { 0, 24 }, + { 0,5203 }, { 46, 863 }, { 0, 13 }, { 0,5200 }, { 0, 24 }, + { 0,5198 }, { 6, 918 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 34, 933 }, { 0, 0 }, { 0, 0 }, { 37, 935 }, { 0, 0 }, + { 0, 0 }, { 16, 923 }, { 41, 933 }, { 0, 0 }, { 0, 24 }, + { 0,5178 }, { 0, 24 }, { 0,5176 }, { 0, 15 }, { 0,5174 }, + { 0, 12 }, { 0,5172 }, { 0, 14 }, { 0,5170 }, { 0, 0 }, + + { 30, 968 }, { 31, 968 }, { 32, 968 }, { 33, 968 }, { 34, 968 }, + { 35, 968 }, { 36, 968 }, { 37,1016 }, { 0, 0 }, { 39, 968 }, + { 40, 968 }, { 41, 968 }, { 42, 968 }, { 43, 968 }, { 0, 7 }, + { 0,5153 }, { 46, 968 }, { 27, 897 }, { 0, 0 }, { 27, 897 }, + { 0, 0 }, { 27, 897 }, { 0, 13 }, { 0,5145 }, { 0, 15 }, + { 0,5143 }, { 0, 0 }, { 12, 870 }, { 0, 8 }, { 0,5139 }, + { 0, 0 }, { 16,1019 }, { 0, 5 }, { 0,5135 }, { 19,1019 }, + { 20,1019 }, { 21,1019 }, { 22,1019 }, { 23,1019 }, { 24,1019 }, + { 0, 6 }, { 0,5127 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30,1019 }, { 31,1019 }, { 32,1019 }, { 33,1019 }, { 34,1019 }, + + { 35,1019 }, { 36,1019 }, { 37,1067 }, { 0, 0 }, { 39,1019 }, + { 40,1019 }, { 41,1019 }, { 42,1019 }, { 43,1019 }, { 0, 0 }, + { 0, 0 }, { 46,1019 }, { 0, 24 }, { 0,5105 }, { 1,1067 }, + { 2,1067 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 6,1067 }, + { 7,1067 }, { 8,1067 }, { 9,1067 }, { 10,1067 }, { 11,1067 }, + { 12,1067 }, { 13,1067 }, { 14,1067 }, { 15,1067 }, { 16,1067 }, + { 17,1067 }, { 18,1067 }, { 19,1112 }, { 20,1112 }, { 21,1112 }, + { 22,1112 }, { 23,1112 }, { 24,1112 }, { 25,1067 }, { 26,1067 }, + { 27,1067 }, { 28,1067 }, { 29,1067 }, { 30,1112 }, { 31,1112 }, + { 32,1112 }, { 33,1067 }, { 34,1067 }, { 35,1067 }, { 36,1067 }, + + { 37,1067 }, { 38,1067 }, { 39,1112 }, { 40,1112 }, { 41,1067 }, + { 42,1067 }, { 43,1067 }, { 44,1067 }, { 45,1067 }, { 46,1067 }, + { 0, 1 }, { 0,5057 }, { 0, 0 }, { 2, 0 }, { 3, 0 }, + { 4, 0 }, { 5, 0 }, { 0, 0 }, { 0,5050 }, { 0, 19 }, + { 0,5048 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 14,-115 }, { 15,-113 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 28, -88 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 28, 777 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0, 18 }, { 0,5017 }, { 1, 0 }, { 2, 0 }, { 0, 0 }, + { 0, 0 }, { 45, -86 }, { 6, 0 }, { 7,-122 }, { 8, 0 }, + { 9, 0 }, { 10, 0 }, { 11, 0 }, { 12, 0 }, { 13, 0 }, + { 14, 0 }, { 15, 0 }, { 16, 0 }, { 17, 0 }, { 18, 0 }, + { 19, 0 }, { 20, 0 }, { 21, 0 }, { 22, 0 }, { 23, 0 }, + { 24, 0 }, { 25, 0 }, { 26, 0 }, { 27, 0 }, { 28, 0 }, + { 29, 0 }, { 30, 0 }, { 31, 0 }, { 32, 0 }, { 33, 0 }, + { 34, 0 }, { 35, 0 }, { 36, 0 }, { 37, 48 }, { 38, 0 }, + { 39, 0 }, { 40, 0 }, { 41, 0 }, { 42, 0 }, { 43, 0 }, + { 44, 0 }, { 45, 0 }, { 46, 96 }, { 0, 0 }, { 0,4969 }, + + { 1,1024 }, { 2,1024 }, { 3, -48 }, { 4, -48 }, { 5,1072 }, + { 6,1024 }, { 7,1024 }, { 8,1024 }, { 9,1024 }, { 10,1024 }, + { 11,1024 }, { 12,1024 }, { 13,1024 }, { 14,1024 }, { 15,1024 }, + { 16,1024 }, { 17,1024 }, { 18,1024 }, { 19,1120 }, { 20,1120 }, + { 21,1120 }, { 22,1120 }, { 23,1120 }, { 24,1120 }, { 25,1024 }, + { 26,1024 }, { 27,1024 }, { 28,1024 }, { 29,1024 }, { 30,1120 }, + { 31,1120 }, { 32,1120 }, { 33,1024 }, { 34,1024 }, { 35,1024 }, + { 36,1024 }, { 37,1024 }, { 38,1024 }, { 39,1120 }, { 40,1120 }, + { 41,1024 }, { 42,1024 }, { 43,1024 }, { 44,1024 }, { 45,1024 }, + { 46,1024 }, { 0, 18 }, { 0,4921 }, { 1, -96 }, { 2, -96 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 6, -96 }, { 7,-218 }, + { 8, -96 }, { 9, -96 }, { 10, -96 }, { 11, -96 }, { 12, -96 }, + { 13, -96 }, { 14, -96 }, { 15, -96 }, { 16, -96 }, { 17, -96 }, + { 18, -96 }, { 19, -96 }, { 20, -96 }, { 21, -96 }, { 22, -96 }, + { 23, -96 }, { 24, -96 }, { 25, -96 }, { 26, -96 }, { 27, -96 }, + { 28, -96 }, { 29, -96 }, { 30, -96 }, { 31, -96 }, { 32, -96 }, + { 33, -96 }, { 34, -96 }, { 35, -96 }, { 36, -96 }, { 37, -48 }, + { 38, -96 }, { 39, -96 }, { 40, -96 }, { 41, -96 }, { 42, -96 }, + { 43, -96 }, { 44, -96 }, { 45, -96 }, { 46, 0 }, { 0, 11 }, + { 0,4873 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16, 0 }, { 0, 0 }, { 0, 0 }, { 19, 0 }, + { 20, 0 }, { 21, 0 }, { 22, 0 }, { 23, 0 }, { 24, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 0 }, { 31, 0 }, { 32, 0 }, { 33, 0 }, { 34, 0 }, + { 35, 0 }, { 36, 0 }, { 37, 48 }, { 0, 0 }, { 39, 0 }, + { 40, 0 }, { 41, 0 }, { 42, 0 }, { 43, 0 }, { 0, 0 }, + { 0, 0 }, { 46, 0 }, { 0, 0 }, { 0,4825 }, { 1,1024 }, + { 2,1024 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 6,1024 }, + + { 7,1024 }, { 8,1024 }, { 9,1024 }, { 10,1024 }, { 11,1024 }, + { 12,1024 }, { 13,1024 }, { 14,1024 }, { 15,1024 }, { 16,1024 }, + { 17,1024 }, { 18,1024 }, { 19,1069 }, { 20,1069 }, { 21,1069 }, + { 22,1069 }, { 23,1069 }, { 24,1069 }, { 25,1024 }, { 26,1024 }, + { 27,1024 }, { 28,1024 }, { 29,1024 }, { 30,1069 }, { 31,1069 }, + { 32,1069 }, { 33,1024 }, { 34,1024 }, { 35,1024 }, { 36,1024 }, + { 37,1024 }, { 38,1024 }, { 39,1069 }, { 40,1069 }, { 41,1024 }, + { 42,1024 }, { 43,1024 }, { 44,1024 }, { 45,1024 }, { 46,1024 }, + { 0, 18 }, { 0,4777 }, { 1, 0 }, { 2, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 6, 0 }, { 7, 0 }, { 8, 0 }, + + { 9, 0 }, { 10, 0 }, { 11,-362 }, { 12, 0 }, { 13, 0 }, + { 14, 0 }, { 15, 0 }, { 16, 0 }, { 17, 0 }, { 18, 0 }, + { 19, 0 }, { 20, 0 }, { 21, 0 }, { 22, 0 }, { 23, 0 }, + { 24, 0 }, { 25, 0 }, { 26, 0 }, { 27, 0 }, { 28, 0 }, + { 29, 0 }, { 30, 0 }, { 31, 0 }, { 32, 0 }, { 33, 0 }, + { 34, 0 }, { 35, 0 }, { 36, 0 }, { 37, 48 }, { 38, 0 }, + { 39, 0 }, { 40, 0 }, { 41, 0 }, { 42, 0 }, { 43, 0 }, + { 44, 0 }, { 45, 0 }, { 46, 96 }, { 0, 0 }, { 0,4729 }, + { 1,1021 }, { 2,1021 }, { 3, -48 }, { 4, -48 }, { 5,1069 }, + { 6,1021 }, { 7,1021 }, { 8,1021 }, { 9,1021 }, { 10,1021 }, + + { 11,1021 }, { 12,1021 }, { 13,1021 }, { 14,1021 }, { 15,1021 }, + { 16,1021 }, { 17,1021 }, { 18,1021 }, { 19,1117 }, { 20,1117 }, + { 21,1117 }, { 22,1117 }, { 23,1117 }, { 24,1117 }, { 25,1021 }, + { 26,1021 }, { 27,1021 }, { 28,1021 }, { 29,1021 }, { 30,1117 }, + { 31,1117 }, { 32,1117 }, { 33,1021 }, { 34,1021 }, { 35,1021 }, + { 36,1021 }, { 37,1021 }, { 38,1021 }, { 39,1117 }, { 40,1117 }, + { 41,1021 }, { 42,1021 }, { 43,1021 }, { 44,1021 }, { 45,1021 }, + { 46,1021 }, { 0, 18 }, { 0,4681 }, { 1, -96 }, { 2, -96 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 6, -96 }, { 7, -96 }, + { 8, -96 }, { 9, -96 }, { 10, -96 }, { 11,-458 }, { 12, -96 }, + + { 13, -96 }, { 14, -96 }, { 15, -96 }, { 16, -96 }, { 17, -96 }, + { 18, -96 }, { 19, -96 }, { 20, -96 }, { 21, -96 }, { 22, -96 }, + { 23, -96 }, { 24, -96 }, { 25, -96 }, { 26, -96 }, { 27, -96 }, + { 28, -96 }, { 29, -96 }, { 30, -96 }, { 31, -96 }, { 32, -96 }, + { 33, -96 }, { 34, -96 }, { 35, -96 }, { 36, -96 }, { 37, -48 }, + { 38, -96 }, { 39, -96 }, { 40, -96 }, { 41, -96 }, { 42, -96 }, + { 43, -96 }, { 44, -96 }, { 45, -96 }, { 46, 0 }, { 0, 7 }, + { 0,4633 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 12, 350 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 16, 499 }, { 0, 0 }, { 0, 0 }, { 19, 499 }, + { 20, 499 }, { 21, 499 }, { 22, 499 }, { 23, 499 }, { 24, 499 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 499 }, { 31, 499 }, { 32, 499 }, { 33, 499 }, { 34, 499 }, + { 35, 499 }, { 36, 499 }, { 37, 547 }, { 0, 0 }, { 39, 499 }, + { 40, 499 }, { 41, 499 }, { 42, 499 }, { 43, 499 }, { 0, 0 }, + { 0, 0 }, { 46, 499 }, { 0, 0 }, { 0,4585 }, { 1, 547 }, + { 2, 547 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 6, 547 }, + { 7, 547 }, { 8, 547 }, { 9, 547 }, { 10, 547 }, { 11, 547 }, + { 12, 547 }, { 13, 547 }, { 14, 547 }, { 15, 547 }, { 16, 547 }, + + { 17, 547 }, { 18, 547 }, { 19, 592 }, { 20, 592 }, { 21, 592 }, + { 22, 592 }, { 23, 592 }, { 24, 592 }, { 25, 547 }, { 26, 547 }, + { 27, 547 }, { 28, 547 }, { 29, 547 }, { 30, 592 }, { 31, 592 }, + { 32, 592 }, { 33, 547 }, { 34, 547 }, { 35, 547 }, { 36, 547 }, + { 37, 547 }, { 38, 547 }, { 39, 592 }, { 40, 592 }, { 41, 547 }, + { 42, 547 }, { 43, 547 }, { 44, 547 }, { 45, 547 }, { 46, 547 }, + { 0, 10 }, { 0,4537 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 10,-511 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 16, 96 }, { 0, 0 }, { 0, 0 }, + + { 19, 0 }, { 20, 0 }, { 21, 0 }, { 22, 0 }, { 23, 0 }, + { 24, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 30, 152 }, { 31, 152 }, { 32, 152 }, { 33, 152 }, + { 34, 152 }, { 35, 152 }, { 36, 152 }, { 37, 200 }, { 0, 0 }, + { 39, 152 }, { 40, 152 }, { 41, 152 }, { 42, 152 }, { 43, 152 }, + { 0, 0 }, { 0, 0 }, { 46, 152 }, { 0, 0 }, { 0,4489 }, + { 1, 925 }, { 2, 925 }, { 3, 925 }, { 4, 925 }, { 5, 925 }, + { 6, 925 }, { 7, 925 }, { 8, 925 }, { 9, 925 }, { 10, 925 }, + { 11, 925 }, { 12, 925 }, { 13, 973 }, { 14, 925 }, { 15, 925 }, + { 16, 925 }, { 17, 925 }, { 18, 925 }, { 19, 925 }, { 20, 925 }, + + { 21, 925 }, { 22, 925 }, { 23, 925 }, { 24, 925 }, { 25, 925 }, + { 26, 925 }, { 27, 925 }, { 28, 925 }, { 29, 925 }, { 30, 925 }, + { 31, 925 }, { 32, 925 }, { 33, 925 }, { 34, 925 }, { 35, 925 }, + { 36, 925 }, { 37, 925 }, { 38, 925 }, { 39, 925 }, { 40, 925 }, + { 41, 925 }, { 42, 925 }, { 43, 925 }, { 44, 925 }, { 45, 925 }, + { 46, 925 }, { 0, 0 }, { 0,4441 }, { 0, 0 }, { 0,4439 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 19, -98 }, { 20, -98 }, + + { 21, -98 }, { 22, -98 }, { 23, -98 }, { 24, -98 }, { 0, 10 }, + { 0,4413 }, { 0, 0 }, { 30, 56 }, { 31, 56 }, { 32, 56 }, + { 33, 56 }, { 34, 56 }, { 35, 56 }, { 36, 56 }, { 37, 104 }, + { 10,-635 }, { 39, 56 }, { 40, 56 }, { 41, 56 }, { 42, 56 }, + { 43, 56 }, { 16, -28 }, { 17, -26 }, { 46, 56 }, { 19, 0 }, + { 20, 0 }, { 21, 0 }, { 22, 0 }, { 23, 0 }, { 24, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 20 }, { 0,4385 }, { 0, 0 }, + { 30, 28 }, { 31, 28 }, { 32, 28 }, { 33, 28 }, { 34, 28 }, + { 35, 28 }, { 36, 28 }, { 37, 76 }, { 0, 0 }, { 39, 28 }, + { 40, 28 }, { 41, 28 }, { 42, 28 }, { 43, 28 }, { 16, 917 }, + + { 0, 0 }, { 46, 28 }, { 19, 917 }, { 20, 917 }, { 21, 917 }, + { 22, 917 }, { 23, 917 }, { 24, 917 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 917 }, { 31, 917 }, + { 32, 917 }, { 33, 917 }, { 34, 917 }, { 35, 917 }, { 36, 917 }, + { 37, 965 }, { 0, 0 }, { 39, 917 }, { 40, 917 }, { 41, 917 }, + { 42, 917 }, { 43, 917 }, { 0, 0 }, { 0, 0 }, { 46, 917 }, + { 0, 0 }, { 0,4337 }, { 1, 965 }, { 2, 965 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 6, 965 }, { 7, 965 }, { 8, 965 }, + { 9, 965 }, { 10, 965 }, { 11, 965 }, { 12, 965 }, { 13, 965 }, + { 14, 965 }, { 15, 965 }, { 16, 965 }, { 17, 965 }, { 18, 965 }, + + { 19,1010 }, { 20,1010 }, { 21,1010 }, { 22,1010 }, { 23,1010 }, + { 24,1010 }, { 25, 965 }, { 26, 965 }, { 27, 965 }, { 28, 965 }, + { 29, 965 }, { 30,1010 }, { 31,1010 }, { 32,1010 }, { 33, 965 }, + { 34, 965 }, { 35, 965 }, { 36, 965 }, { 37, 965 }, { 38, 965 }, + { 39,1010 }, { 40,1010 }, { 41, 965 }, { 42, 965 }, { 43, 965 }, + { 44, 965 }, { 45, 965 }, { 46, 965 }, { 0, 0 }, { 0,4289 }, + { 0, 0 }, { 0,4287 }, { 0, 0 }, { 0,4285 }, { 0, 9 }, + { 0,4283 }, { 0, 4 }, { 0,4281 }, { 0, 3 }, { 0,4279 }, + { 0, 2 }, { 0,4277 }, { 0, 0 }, { 0,4275 }, { 0, 22 }, + { 0,4273 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16, 541 }, + + { 19, 159 }, { 0, 0 }, { 21, 167 }, { 0, 0 }, { 23, 308 }, + { 0, 0 }, { 0,4262 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 35, 27 }, + { 34, 504 }, { 37, 988 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 42, 27 }, { 41, 504 }, { 30, 45 }, { 31, 45 }, + { 32, 45 }, { 33, 45 }, { 34, 45 }, { 35, 45 }, { 36, 45 }, + { 37, 93 }, { 0, 0 }, { 39, 45 }, { 40, 45 }, { 41, 45 }, + { 42, 45 }, { 43, 45 }, { 0, 17 }, { 0,4230 }, { 46, 45 }, + { 0, 0 }, { 0, 0 }, { 36, 532 }, { 37,1945 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 43, 532 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16, 954 }, + { 0, 0 }, { 0, 0 }, { 19, 954 }, { 20, 954 }, { 21, 954 }, + { 22, 954 }, { 23, 954 }, { 24, 954 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 954 }, { 31, 954 }, + { 32, 954 }, { 33, 954 }, { 34, 954 }, { 35, 954 }, { 36, 954 }, + { 37,1002 }, { 0, 0 }, { 39, 954 }, { 40, 954 }, { 41, 954 }, + { 42, 954 }, { 43, 954 }, { 0, 0 }, { 0, 0 }, { 46, 954 }, + { 0, 0 }, { 0,4182 }, { 1,1002 }, { 2,1002 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 6,1002 }, { 7,1002 }, { 8,1002 }, + { 9,1002 }, { 10,1002 }, { 11,1002 }, { 12,1002 }, { 13,1002 }, + + { 14,1002 }, { 15,1002 }, { 16,1002 }, { 17,1002 }, { 18,1002 }, + { 19,1047 }, { 20,1047 }, { 21,1047 }, { 22,1047 }, { 23,1047 }, + { 24,1047 }, { 25,1002 }, { 26,1002 }, { 27,1002 }, { 28,1002 }, + { 29,1002 }, { 30,1047 }, { 31,1047 }, { 32,1047 }, { 33,1002 }, + { 34,1002 }, { 35,1002 }, { 36,1002 }, { 37,1002 }, { 38,1002 }, + { 39,1047 }, { 40,1047 }, { 41,1002 }, { 42,1002 }, { 43,1002 }, + { 44,1002 }, { 45,1002 }, { 46,1002 }, { 0, 7 }, { 0,4134 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0,4128 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 12,-149 }, { 0, 0 }, { 0,4120 }, { 0, 0 }, + + { 16, 0 }, { 0, 0 }, { 0, 0 }, { 19, 0 }, { 20, 0 }, + { 21, 0 }, { 22, 0 }, { 23, 0 }, { 24, 0 }, { 19, 954 }, + { 0, 0 }, { 21, 8 }, { 0, 0 }, { 23, 149 }, { 30, 0 }, + { 31, 0 }, { 32, 0 }, { 33, 0 }, { 34, 0 }, { 35, 0 }, + { 36, 0 }, { 37, 48 }, { 0, 0 }, { 39, 0 }, { 40, 0 }, + { 41, 0 }, { 42, 0 }, { 43, 0 }, { 0, 0 }, { 31,1829 }, + { 46, 0 }, { 0, 0 }, { 0,4086 }, { 1, 996 }, { 2, 996 }, + { 0, 0 }, { 0, 0 }, { 39,1829 }, { 6, 996 }, { 7, 996 }, + { 8, 996 }, { 9, 996 }, { 10, 996 }, { 11, 996 }, { 12, 996 }, + { 13, 996 }, { 14, 996 }, { 15, 996 }, { 16, 996 }, { 17, 996 }, + + { 18, 996 }, { 19,1041 }, { 20,1041 }, { 21,1041 }, { 22,1041 }, + { 23,1041 }, { 24,1041 }, { 25, 996 }, { 26, 996 }, { 27, 996 }, + { 28, 996 }, { 29, 996 }, { 30,1041 }, { 31,1041 }, { 32,1041 }, + { 33, 996 }, { 34, 996 }, { 35, 996 }, { 36, 996 }, { 37, 996 }, + { 38, 996 }, { 39,1041 }, { 40,1041 }, { 41, 996 }, { 42, 996 }, + { 43, 996 }, { 44, 996 }, { 45, 996 }, { 46, 996 }, { 0, 7 }, + { 0,4038 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 12,-245 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16, -96 }, { 0, 0 }, { 0, 0 }, { 19, -96 }, + + { 20, -96 }, { 21, -96 }, { 22, -96 }, { 23, -96 }, { 24, -96 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, -96 }, { 31, -96 }, { 32, -96 }, { 33, -96 }, { 34, -96 }, + { 35, -96 }, { 36, -96 }, { 37, -48 }, { 0, 0 }, { 39, -96 }, + { 40, -96 }, { 41, -96 }, { 42, -96 }, { 43, -96 }, { 0, 7 }, + { 0,3993 }, { 46, -96 }, { 2, -45 }, { 3, -45 }, { 4, -45 }, + { 5, 993 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 12,-290 }, { 0, 0 }, { 0,3979 }, + { 0, 0 }, { 16,-141 }, { 0, 0 }, { 0, 0 }, { 19,1038 }, + { 20,1038 }, { 21,1038 }, { 22,1038 }, { 23,1038 }, { 24,1038 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30,1038 }, { 31,1038 }, { 32,1038 }, { 33,-141 }, { 34,-141 }, + { 35,-141 }, { 36,-141 }, { 37, -93 }, { 0, 0 }, { 39,1038 }, + { 40,1038 }, { 41,-141 }, { 42,-141 }, { 43,-141 }, { 0, 0 }, + { 31,1697 }, { 46,-141 }, { 0, 18 }, { 0,3945 }, { 1,-1072 }, + { 2,-1072 }, { 0, 0 }, { 0, 0 }, { 39,1697 }, { 6,-1072 }, + { 7,-1194 }, { 8,-1072 }, { 9,-1072 }, { 10,-1072 }, { 11,-1072 }, + { 12,-1072 }, { 13,-1072 }, { 14,-1072 }, { 15,-1072 }, { 16,-1072 }, + { 17,-1072 }, { 18,-1072 }, { 19,-1072 }, { 20,-1072 }, { 21,-1072 }, + { 22,-1072 }, { 23,-1072 }, { 24,-1072 }, { 25,-1072 }, { 26,-1072 }, + + { 27,-1072 }, { 28,-1072 }, { 29,-1072 }, { 30,-1072 }, { 31,-1072 }, + { 32,-1072 }, { 33,-1072 }, { 34,-1072 }, { 35,-1072 }, { 36,-1072 }, + { 37,-1024 }, { 38,-1072 }, { 39,-1072 }, { 40,-1072 }, { 41,-1072 }, + { 42,-1072 }, { 43,-1072 }, { 44,-1072 }, { 45,-1072 }, { 46,-976 }, + { 0, 18 }, { 0,3897 }, { 1,-1120 }, { 2,-1120 }, { 3,-1120 }, + { 0, 0 }, { 0, 0 }, { 6,-1120 }, { 7,-1242 }, { 8,-1120 }, + { 9,-1120 }, { 10,-1120 }, { 11,-1120 }, { 12,-1120 }, { 13,-1120 }, + { 14,-1120 }, { 15,-1120 }, { 16,-1120 }, { 17,-1120 }, { 18,-1120 }, + { 19,-1120 }, { 20,-1120 }, { 21,-1120 }, { 22,-1120 }, { 23,-1120 }, + { 24,-1120 }, { 25,-1120 }, { 26,-1120 }, { 27,-1120 }, { 28,-1120 }, + + { 29,-1120 }, { 30,-1120 }, { 31,-1120 }, { 32,-1120 }, { 33,-1120 }, + { 34,-1120 }, { 35,-1120 }, { 36,-1120 }, { 37,-1072 }, { 38,-1120 }, + { 39,-1120 }, { 40,-1120 }, { 41,-1120 }, { 42,-1120 }, { 43,-1120 }, + { 44,-1120 }, { 45,-1120 }, { 46,-1024 }, { 0, 18 }, { 0,3849 }, + { 1,-1168 }, { 2, 942 }, { 3, -96 }, { 4, -96 }, { 5, 990 }, + { 6,-1168 }, { 7,-1290 }, { 8,-1168 }, { 9,-1168 }, { 10,-1168 }, + { 11,-1168 }, { 12,-1168 }, { 13,-1168 }, { 14,-1168 }, { 15,-1168 }, + { 16,-1168 }, { 17,-1168 }, { 18,-1168 }, { 19,1038 }, { 20,1038 }, + { 21,1038 }, { 22,1038 }, { 23,1038 }, { 24,1038 }, { 25,-1168 }, + { 26,-1168 }, { 27,-1168 }, { 28,-1168 }, { 29,-1168 }, { 30,1038 }, + + { 31,1038 }, { 32,1038 }, { 33,-1168 }, { 34,-1168 }, { 35,-1168 }, + { 36,-1168 }, { 37,-1120 }, { 38,-1168 }, { 39,1038 }, { 40,1038 }, + { 41,-1168 }, { 42,-1168 }, { 43,-1168 }, { 44,-1168 }, { 45,-1168 }, + { 46,-1072 }, { 0, 11 }, { 0,3801 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-1072 }, { 0, 0 }, + { 0,3783 }, { 19,-1072 }, { 20,-1072 }, { 21,-1072 }, { 22,-1072 }, + { 23,-1072 }, { 24,-1072 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 30,-1072 }, { 31,-1072 }, { 32,-1072 }, + + { 33,-1072 }, { 34,-1072 }, { 35,-1072 }, { 36,-1072 }, { 37,-1024 }, + { 0, 0 }, { 39,-1072 }, { 40,-1072 }, { 41,-1072 }, { 42,-1072 }, + { 43,-1072 }, { 0, 11 }, { 0,3756 }, { 46,-1072 }, { 2, -45 }, + { 3, -45 }, { 4, -45 }, { 5, 993 }, { 0, 0 }, { 0, 0 }, + { 35,-479 }, { 0, 0 }, { 37, 482 }, { 0, 0 }, { 0,3744 }, + { 0, 23 }, { 0,3742 }, { 42,-479 }, { 16,-1117 }, { 0, 0 }, + { 0, 0 }, { 19,1038 }, { 20,1038 }, { 21,1038 }, { 22,1038 }, + { 23,1038 }, { 24,1038 }, { 0, 0 }, { 0,3730 }, { 0, 0 }, + { 16, 572 }, { 0, 0 }, { 30,1038 }, { 31,1038 }, { 32,1038 }, + { 33,-1117 }, { 34,-1117 }, { 35,-1117 }, { 36,-1117 }, { 37,-1069 }, + + { 12, 560 }, { 39,1038 }, { 40,1038 }, { 41,-1117 }, { 42,-1117 }, + { 43,-1117 }, { 0, 0 }, { 0, 0 }, { 46,-1117 }, { 0, 18 }, + { 0,3708 }, { 1,-1069 }, { 2,-1069 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 6,-1069 }, { 7,-1069 }, { 8,-1069 }, { 9,-1069 }, + { 10,-1069 }, { 11,-1431 }, { 12,-1069 }, { 13,-1069 }, { 14,-1069 }, + { 15,-1069 }, { 16,-1069 }, { 17,-1069 }, { 18,-1069 }, { 19,-1069 }, + { 20,-1069 }, { 21,-1069 }, { 22,-1069 }, { 23,-1069 }, { 24,-1069 }, + { 25,-1069 }, { 26,-1069 }, { 27,-1069 }, { 28,-1069 }, { 29,-1069 }, + { 30,-1069 }, { 31,-1069 }, { 32,-1069 }, { 33,-1069 }, { 34,-1069 }, + { 35,-1069 }, { 36,-1069 }, { 37,-1021 }, { 38,-1069 }, { 39,-1069 }, + + { 40,-1069 }, { 41,-1069 }, { 42,-1069 }, { 43,-1069 }, { 44,-1069 }, + { 45,-1069 }, { 46,-973 }, { 0, 18 }, { 0,3660 }, { 1,-1117 }, + { 2,-1117 }, { 3,-1117 }, { 0, 0 }, { 0, 0 }, { 6,-1117 }, + { 7,-1117 }, { 8,-1117 }, { 9,-1117 }, { 10,-1117 }, { 11,-1479 }, + { 12,-1117 }, { 13,-1117 }, { 14,-1117 }, { 15,-1117 }, { 16,-1117 }, + { 17,-1117 }, { 18,-1117 }, { 19,-1117 }, { 20,-1117 }, { 21,-1117 }, + { 22,-1117 }, { 23,-1117 }, { 24,-1117 }, { 25,-1117 }, { 26,-1117 }, + { 27,-1117 }, { 28,-1117 }, { 29,-1117 }, { 30,-1117 }, { 31,-1117 }, + { 32,-1117 }, { 33,-1117 }, { 34,-1117 }, { 35,-1117 }, { 36,-1117 }, + { 37,-1069 }, { 38,-1117 }, { 39,-1117 }, { 40,-1117 }, { 41,-1117 }, + + { 42,-1117 }, { 43,-1117 }, { 44,-1117 }, { 45,-1117 }, { 46,-1021 }, + { 0, 18 }, { 0,3612 }, { 1,-1165 }, { 2, 942 }, { 3, -96 }, + { 4, -96 }, { 5, 990 }, { 6,-1165 }, { 7,-1165 }, { 8,-1165 }, + { 9,-1165 }, { 10,-1165 }, { 11,-1527 }, { 12,-1165 }, { 13,-1165 }, + { 14,-1165 }, { 15,-1165 }, { 16,-1165 }, { 17,-1165 }, { 18,-1165 }, + { 19,1038 }, { 20,1038 }, { 21,1038 }, { 22,1038 }, { 23,1038 }, + { 24,1038 }, { 25,-1165 }, { 26,-1165 }, { 27,-1165 }, { 28,-1165 }, + { 29,-1165 }, { 30,1038 }, { 31,1038 }, { 32,1038 }, { 33,-1165 }, + { 34,-1165 }, { 35,-1165 }, { 36,-1165 }, { 37,-1117 }, { 38,-1165 }, + { 39,1038 }, { 40,1038 }, { 41,-1165 }, { 42,-1165 }, { 43,-1165 }, + + { 44,-1165 }, { 45,-1165 }, { 46,-1069 }, { 0, 0 }, { 0,3564 }, + { 1, 0 }, { 2, 0 }, { 3, 0 }, { 4, 0 }, { 5, 0 }, + { 6, 0 }, { 7, 0 }, { 8, 0 }, { 9, 0 }, { 10, 0 }, + { 11, 0 }, { 12, 0 }, { 13, 48 }, { 14, 0 }, { 15, 0 }, + { 16, 0 }, { 17, 0 }, { 18, 0 }, { 19, 0 }, { 20, 0 }, + { 21, 0 }, { 22, 0 }, { 23, 0 }, { 24, 0 }, { 25, 0 }, + { 26, 0 }, { 27, 0 }, { 28, 0 }, { 29, 0 }, { 30, 0 }, + { 31, 0 }, { 32, 0 }, { 33, 0 }, { 34, 0 }, { 35, 0 }, + { 36, 0 }, { 37, 0 }, { 38, 0 }, { 39, 0 }, { 40, 0 }, + { 41, 0 }, { 42, 0 }, { 43, 0 }, { 44, 0 }, { 45, 0 }, + + { 46, 0 }, { 0, 0 }, { 0,3516 }, { 1, 990 }, { 2, 990 }, + { 3, 990 }, { 4, 990 }, { 5, 990 }, { 6, 990 }, { 7, 990 }, + { 8, 990 }, { 9, 990 }, { 10, 990 }, { 11, 990 }, { 12, 990 }, + { 13, 0 }, { 14, 990 }, { 15, 990 }, { 16, 990 }, { 17, 990 }, + { 18,-226 }, { 19, 990 }, { 20, 990 }, { 21, 990 }, { 22, 990 }, + { 23, 990 }, { 24, 990 }, { 25, 990 }, { 26, 990 }, { 27, 990 }, + { 28, 990 }, { 29, 990 }, { 30, 990 }, { 31, 990 }, { 32, 990 }, + { 33, 990 }, { 34, 990 }, { 35, 990 }, { 36, 990 }, { 37, 990 }, + { 38, 990 }, { 39, 990 }, { 40, 990 }, { 41, 990 }, { 42, 990 }, + { 43, 990 }, { 44, 990 }, { 45, 990 }, { 46, 990 }, { 0, 20 }, + + { 0,3468 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0,3462 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0,3456 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16, 0 }, { 0, 0 }, { 0, 0 }, { 19, 0 }, + { 20, 0 }, { 21, 0 }, { 22, 0 }, { 23, 0 }, { 24, 0 }, + { 19, 468 }, { 0, 0 }, { 21, 6 }, { 0, 0 }, { 23, 147 }, + { 30, 0 }, { 31, 0 }, { 32, 0 }, { 33, 0 }, { 34, 0 }, + { 35, 0 }, { 36, 0 }, { 37, 48 }, { 0, 0 }, { 39, 0 }, + { 40, 0 }, { 41, 0 }, { 42, 0 }, { 43, 0 }, { 32,1854 }, + { 0, 0 }, { 46, 0 }, { 0, 0 }, { 0,3420 }, { 1, 942 }, + + { 2, 942 }, { 0, 0 }, { 40,1854 }, { 0, 0 }, { 6, 942 }, + { 7, 942 }, { 8, 942 }, { 9, 942 }, { 10, 942 }, { 11, 942 }, + { 12, 942 }, { 13, 942 }, { 14, 942 }, { 15, 942 }, { 16, 942 }, + { 17, 942 }, { 18, 942 }, { 19, 987 }, { 20, 987 }, { 21, 987 }, + { 22, 987 }, { 23, 987 }, { 24, 987 }, { 25, 942 }, { 26, 942 }, + { 27, 942 }, { 28, 942 }, { 29, 942 }, { 30, 987 }, { 31, 987 }, + { 32, 987 }, { 33, 942 }, { 34, 942 }, { 35, 942 }, { 36, 942 }, + { 37, 942 }, { 38, 942 }, { 39, 987 }, { 40, 987 }, { 41, 942 }, + { 42, 942 }, { 43, 942 }, { 44, 942 }, { 45, 942 }, { 46, 942 }, + { 0, 20 }, { 0,3372 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 16, -96 }, { 0, 0 }, { 0, 0 }, + { 19, -96 }, { 20, -96 }, { 21, -96 }, { 22, -96 }, { 23, -96 }, + { 24, -96 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 30, -96 }, { 31, -96 }, { 32, -96 }, { 33, -96 }, + { 34, -96 }, { 35, -96 }, { 36, -96 }, { 37, -48 }, { 0, 0 }, + { 39, -96 }, { 40, -96 }, { 41, -96 }, { 42, -96 }, { 43, -96 }, + { 0, 20 }, { 0,3327 }, { 46, -96 }, { 2, -45 }, { 3, -45 }, + { 4, -45 }, { 5, 939 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0,3315 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 16,-141 }, { 0, 0 }, { 0, 0 }, + { 19, 984 }, { 20, 984 }, { 21, 984 }, { 22, 984 }, { 23, 984 }, + { 24, 984 }, { 0, 0 }, { 0,3301 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 30, 984 }, { 31, 984 }, { 32, 984 }, { 33,-141 }, + { 34,-141 }, { 35,-141 }, { 36,-141 }, { 37, -93 }, { 0, 0 }, + { 39, 984 }, { 40, 984 }, { 41,-141 }, { 42,-141 }, { 43,-141 }, + { 32,1755 }, { 19,-161 }, { 46,-141 }, { 21,-155 }, { 0, 0 }, + { 23, -14 }, { 0, 17 }, { 0,3276 }, { 40,1755 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0,3268 }, { 0, 0 }, { 35, 33 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16, 0 }, { 42, 33 }, + { 0, 0 }, { 19, 0 }, { 20, 0 }, { 21, 0 }, { 22, 0 }, + { 23, 0 }, { 24, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 30, 0 }, { 31, 0 }, { 32, 0 }, + { 33, 0 }, { 34, 0 }, { 35, 0 }, { 36, 0 }, { 37, 48 }, + { 0, 0 }, { 39, 0 }, { 40, 0 }, { 41, 0 }, { 42, 0 }, + { 43, 0 }, { 36,-462 }, { 37, 951 }, { 46, 0 }, { 0, 0 }, + { 0,3228 }, { 1, 970 }, { 2, 970 }, { 43,-462 }, { 0, 0 }, + { 0, 0 }, { 6, 970 }, { 7, 970 }, { 8, 970 }, { 9, 970 }, + + { 10, 970 }, { 11, 970 }, { 12, 970 }, { 13, 970 }, { 14, 970 }, + { 15, 970 }, { 16, 970 }, { 17, 970 }, { 18, 970 }, { 19,1015 }, + { 20,1015 }, { 21,1015 }, { 22,1015 }, { 23,1015 }, { 24,1015 }, + { 25, 970 }, { 26, 970 }, { 27, 970 }, { 28, 970 }, { 29, 970 }, + { 30,1015 }, { 31,1015 }, { 32,1015 }, { 33, 970 }, { 34, 970 }, + { 35, 970 }, { 36, 970 }, { 37, 970 }, { 38, 970 }, { 39,1015 }, + { 40,1015 }, { 41, 970 }, { 42, 970 }, { 43, 970 }, { 44, 970 }, + { 45, 970 }, { 46, 970 }, { 0, 17 }, { 0,3180 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0,3174 }, + { 0, 21 }, { 0,3172 }, { 0, 16 }, { 0,3170 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16, -96 }, + { 0, 0 }, { 0, 0 }, { 19, -96 }, { 20, -96 }, { 21, -96 }, + { 22, -96 }, { 23, -96 }, { 24, -96 }, { 19, 417 }, { 0, 0 }, + { 21,-946 }, { 0, 0 }, { 23,-805 }, { 30, -96 }, { 31, -96 }, + { 32, -96 }, { 33, -96 }, { 34, -96 }, { 35, -96 }, { 36, -96 }, + { 37, -48 }, { 0, 0 }, { 39, -96 }, { 40, -96 }, { 41, -96 }, + { 42, -96 }, { 43, -96 }, { 0, 17 }, { 0,3135 }, { 46, -96 }, + { 2, -45 }, { 3, -45 }, { 4, -45 }, { 5, 967 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-141 }, + + { 0, 0 }, { 0, 0 }, { 19,1012 }, { 20,1012 }, { 21,1012 }, + { 22,1012 }, { 23,1012 }, { 24,1012 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0,3107 }, { 0, 0 }, { 30,1012 }, { 31,1012 }, + { 32,1012 }, { 33,-141 }, { 34,-141 }, { 35,-141 }, { 36,-141 }, + { 37, -93 }, { 0, 0 }, { 39,1012 }, { 40,1012 }, { 41,-141 }, + { 42,-141 }, { 43,-141 }, { 0, 7 }, { 0,3090 }, { 46,-141 }, + { 19, 823 }, { 0, 0 }, { 0,3086 }, { 22, 21 }, { 0, 0 }, + { 24, 69 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 12,-1193 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-1044 }, + { 0, 0 }, { 0, 0 }, { 19,-1044 }, { 20,-1044 }, { 21,-1044 }, + + { 22,-1044 }, { 23,-1044 }, { 24,-1044 }, { 21,2013 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30,-1044 }, { 31,-1044 }, + { 32,-1044 }, { 33,-1044 }, { 34,-1044 }, { 35,-1044 }, { 36,-1044 }, + { 37,-996 }, { 0, 0 }, { 39,-1044 }, { 40,-1044 }, { 41,-1044 }, + { 42,-1044 }, { 43,-1044 }, { 0, 7 }, { 0,3045 }, { 46,-1044 }, + { 2, -45 }, { 3, -45 }, { 4, -45 }, { 5, 967 }, { 0, 0 }, + { 0,3038 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 12,-1238 }, { 0, 0 }, { 0,3031 }, { 0, 0 }, { 16,-1089 }, + { 0, 0 }, { 0, 0 }, { 19,1012 }, { 20,1012 }, { 21,1012 }, + { 22,1012 }, { 23,1012 }, { 24,1012 }, { 0, 0 }, { 12,-139 }, + + { 0, 0 }, { 21,1965 }, { 0, 0 }, { 30,1012 }, { 31,1012 }, + { 32,1012 }, { 33,-1089 }, { 34,-1089 }, { 35,-1089 }, { 36,-1089 }, + { 37,-1041 }, { 0, 0 }, { 39,1012 }, { 40,1012 }, { 41,-1089 }, + { 42,-1089 }, { 43,-1089 }, { 0, 7 }, { 0,3000 }, { 46,-1089 }, + { 0, 0 }, { 3,-1038 }, { 0, 0 }, { 0, 0 }, { 0,2994 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 12,-1283 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-1134 }, + { 0, 0 }, { 0, 0 }, { 19,-1134 }, { 20,-1134 }, { 21,-1134 }, + { 22,-1134 }, { 23,-1134 }, { 24,-1134 }, { 19, 723 }, { 0, 0 }, + { 21,-462 }, { 0, 0 }, { 23,-321 }, { 30,-1134 }, { 31,-1134 }, + + { 32,-1134 }, { 33,-1134 }, { 34,-1134 }, { 35,-1134 }, { 36,-1134 }, + { 37,-1086 }, { 0, 0 }, { 39,-1134 }, { 40,-1134 }, { 41,-1134 }, + { 42,-1134 }, { 43,-1134 }, { 0, 7 }, { 0,2955 }, { 46,-1134 }, + { 2,-1083 }, { 3,-1083 }, { 4,-1083 }, { 5, -45 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 12,-1328 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-1179 }, + { 0, 0 }, { 0, 0 }, { 19, 967 }, { 20, 967 }, { 21, 967 }, + { 22, 967 }, { 23, 967 }, { 24, 967 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 967 }, { 31, 967 }, + { 32, 967 }, { 33,-1179 }, { 34,-1179 }, { 35,-1179 }, { 36,-1179 }, + + { 37,-1131 }, { 0, 0 }, { 39, 967 }, { 40, 967 }, { 41,-1179 }, + { 42,-1179 }, { 43,-1179 }, { 0, 0 }, { 0, 0 }, { 46,-1179 }, + { 0, 18 }, { 0,2907 }, { 1,-2110 }, { 2,-2110 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 6,-2110 }, { 7,-2232 }, { 8,-2110 }, + { 9,-2110 }, { 10,-2110 }, { 11,-2110 }, { 12,-2110 }, { 13,-2110 }, + { 14,-2110 }, { 15,-2110 }, { 16,-2110 }, { 17,-2110 }, { 18,-2110 }, + { 19,-2110 }, { 20,-2110 }, { 21,-2110 }, { 22,-2110 }, { 23,-2110 }, + { 24,-2110 }, { 25,-2110 }, { 26,-2110 }, { 27,-2110 }, { 28,-2110 }, + { 29,-2110 }, { 30,-2110 }, { 31,-2110 }, { 32,-2110 }, { 33,-2110 }, + { 34,-2110 }, { 35,-2110 }, { 36,-2110 }, { 37,-2062 }, { 38,-2110 }, + + { 39,-2110 }, { 40,-2110 }, { 41,-2110 }, { 42,-2110 }, { 43,-2110 }, + { 44,-2110 }, { 45,-2110 }, { 46,-2014 }, { 0, 18 }, { 0,2859 }, + { 1,-2158 }, { 2,-2158 }, { 3,-1086 }, { 0, 0 }, { 0, 0 }, + { 6,-2158 }, { 7,-2280 }, { 8,-2158 }, { 9,-2158 }, { 10,-2158 }, + { 11,-2158 }, { 12,-2158 }, { 13,-2158 }, { 14,-2158 }, { 15,-2158 }, + { 16,-2158 }, { 17,-2158 }, { 18,-2158 }, { 19,-2158 }, { 20,-2158 }, + { 21,-2158 }, { 22,-2158 }, { 23,-2158 }, { 24,-2158 }, { 25,-2158 }, + { 26,-2158 }, { 27,-2158 }, { 28,-2158 }, { 29,-2158 }, { 30,-2158 }, + { 31,-2158 }, { 32,-2158 }, { 33,-2158 }, { 34,-2158 }, { 35,-2158 }, + { 36,-2158 }, { 37,-2110 }, { 38,-2158 }, { 39,-2158 }, { 40,-2158 }, + + { 41,-2158 }, { 42,-2158 }, { 43,-2158 }, { 44,-2158 }, { 45,-2158 }, + { 46,-2062 }, { 0, 18 }, { 0,2811 }, { 1,-2206 }, { 2, -96 }, + { 3,-1134 }, { 4,-1134 }, { 5, -48 }, { 6,-2206 }, { 7,-2328 }, + { 8,-2206 }, { 9,-2206 }, { 10,-2206 }, { 11,-2206 }, { 12,-2206 }, + { 13,-2206 }, { 14,-2206 }, { 15,-2206 }, { 16,-2206 }, { 17,-2206 }, + { 18,-2206 }, { 19, 871 }, { 20, 871 }, { 21, 871 }, { 22, 871 }, + { 23, 871 }, { 24, 871 }, { 25,-2206 }, { 26,-2206 }, { 27,-2206 }, + { 28,-2206 }, { 29,-2206 }, { 30, 871 }, { 31, 871 }, { 32, 871 }, + { 33,-2206 }, { 34,-2206 }, { 35,-2206 }, { 36,-2206 }, { 37,-2158 }, + { 38,-2206 }, { 39, 871 }, { 40, 871 }, { 41,-2206 }, { 42,-2206 }, + + { 43,-2206 }, { 44,-2206 }, { 45,-2206 }, { 46,-2110 }, { 0, 11 }, + { 0,2763 }, { 0, 0 }, { 0, 0 }, { 3,-1038 }, { 0, 0 }, + { 0, 0 }, { 0,2757 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-2110 }, { 0, 0 }, { 0,2745 }, { 19,-2110 }, + { 20,-2110 }, { 21,-2110 }, { 22,-2110 }, { 23,-2110 }, { 24,-2110 }, + { 19, 570 }, { 0, 0 }, { 21,-1363 }, { 0, 0 }, { 23,-1222 }, + { 30,-2110 }, { 31,-2110 }, { 32,-2110 }, { 33,-2110 }, { 34,-2110 }, + { 35,-2110 }, { 36,-2110 }, { 37,-2062 }, { 0, 0 }, { 39,-2110 }, + { 40,-2110 }, { 41,-2110 }, { 42,-2110 }, { 43,-2110 }, { 0, 11 }, + + { 0,2718 }, { 46,-2110 }, { 2,-1083 }, { 3,-1083 }, { 4,-1083 }, + { 5, -45 }, { 0, 0 }, { 0, 0 }, { 35,-1517 }, { 0, 0 }, + { 37,-556 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 42,-1517 }, { 16,-2155 }, { 0, 0 }, { 0, 0 }, { 19, 826 }, + { 20, 826 }, { 21, 826 }, { 22, 826 }, { 23, 826 }, { 24, 826 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 826 }, { 31, 826 }, { 32, 826 }, { 33,-2155 }, { 34,-2155 }, + { 35,-2155 }, { 36,-2155 }, { 37,-2107 }, { 0, 0 }, { 39, 826 }, + { 40, 826 }, { 41,-2155 }, { 42,-2155 }, { 43,-2155 }, { 0, 0 }, + { 0, 0 }, { 46,-2155 }, { 0, 18 }, { 0,2670 }, { 1,-2107 }, + + { 2,-2107 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 6,-2107 }, + { 7,-2107 }, { 8,-2107 }, { 9,-2107 }, { 10,-2107 }, { 11,-2469 }, + { 12,-2107 }, { 13,-2107 }, { 14,-2107 }, { 15,-2107 }, { 16,-2107 }, + { 17,-2107 }, { 18,-2107 }, { 19,-2107 }, { 20,-2107 }, { 21,-2107 }, + { 22,-2107 }, { 23,-2107 }, { 24,-2107 }, { 25,-2107 }, { 26,-2107 }, + { 27,-2107 }, { 28,-2107 }, { 29,-2107 }, { 30,-2107 }, { 31,-2107 }, + { 32,-2107 }, { 33,-2107 }, { 34,-2107 }, { 35,-2107 }, { 36,-2107 }, + { 37,-2059 }, { 38,-2107 }, { 39,-2107 }, { 40,-2107 }, { 41,-2107 }, + { 42,-2107 }, { 43,-2107 }, { 44,-2107 }, { 45,-2107 }, { 46,-2011 }, + { 0, 18 }, { 0,2622 }, { 1,-2155 }, { 2,-2155 }, { 3,-1086 }, + + { 0, 0 }, { 0, 0 }, { 6,-2155 }, { 7,-2155 }, { 8,-2155 }, + { 9,-2155 }, { 10,-2155 }, { 11,-2517 }, { 12,-2155 }, { 13,-2155 }, + { 14,-2155 }, { 15,-2155 }, { 16,-2155 }, { 17,-2155 }, { 18,-2155 }, + { 19,-2155 }, { 20,-2155 }, { 21,-2155 }, { 22,-2155 }, { 23,-2155 }, + { 24,-2155 }, { 25,-2155 }, { 26,-2155 }, { 27,-2155 }, { 28,-2155 }, + { 29,-2155 }, { 30,-2155 }, { 31,-2155 }, { 32,-2155 }, { 33,-2155 }, + { 34,-2155 }, { 35,-2155 }, { 36,-2155 }, { 37,-2107 }, { 38,-2155 }, + { 39,-2155 }, { 40,-2155 }, { 41,-2155 }, { 42,-2155 }, { 43,-2155 }, + { 44,-2155 }, { 45,-2155 }, { 46,-2059 }, { 0, 18 }, { 0,2574 }, + { 1,-2203 }, { 2, -96 }, { 3,-1134 }, { 4,-1134 }, { 5, -48 }, + + { 6,-2203 }, { 7,-2203 }, { 8,-2203 }, { 9,-2203 }, { 10,-2203 }, + { 11,-2565 }, { 12,-2203 }, { 13,-2203 }, { 14,-2203 }, { 15,-2203 }, + { 16,-2203 }, { 17,-2203 }, { 18,-2203 }, { 19, 730 }, { 20, 730 }, + { 21, 730 }, { 22, 730 }, { 23, 730 }, { 24, 730 }, { 25,-2203 }, + { 26,-2203 }, { 27,-2203 }, { 28,-2203 }, { 29,-2203 }, { 30, 730 }, + { 31, 730 }, { 32, 730 }, { 33,-2203 }, { 34,-2203 }, { 35,-2203 }, + { 36,-2203 }, { 37,-2155 }, { 38,-2203 }, { 39, 730 }, { 40, 730 }, + { 41,-2203 }, { 42,-2203 }, { 43,-2203 }, { 44,-2203 }, { 45,-2203 }, + { 46,-2107 }, { 0, 0 }, { 0,2526 }, { 1, 730 }, { 2, 730 }, + { 3, 730 }, { 4, 730 }, { 5, 730 }, { 6, 730 }, { 7, 730 }, + + { 8, 730 }, { 9, 730 }, { 10, 730 }, { 11, 730 }, { 12, 730 }, + { 13, 778 }, { 14, 730 }, { 15, 730 }, { 16, 730 }, { 17, 730 }, + { 18, 730 }, { 19, 730 }, { 20, 730 }, { 21, 730 }, { 22, 730 }, + { 23, 730 }, { 24, 730 }, { 25, 730 }, { 26, 730 }, { 27, 730 }, + { 28, 730 }, { 29, 730 }, { 30, 730 }, { 31, 730 }, { 32, 730 }, + { 33, 730 }, { 34, 730 }, { 35, 730 }, { 36, 730 }, { 37, 730 }, + { 38, 730 }, { 39, 730 }, { 40, 730 }, { 41, 730 }, { 42, 730 }, + { 43, 730 }, { 44, 730 }, { 45, 730 }, { 46, 730 }, { 0, 20 }, + { 0,2478 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-990 }, { 0, 0 }, { 0, 0 }, { 19,-990 }, + { 20,-990 }, { 21,-990 }, { 22,-990 }, { 23,-990 }, { 24,-990 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30,-990 }, { 31,-990 }, { 32,-990 }, { 33,-990 }, { 34,-990 }, + { 35,-990 }, { 36,-990 }, { 37,-942 }, { 0, 0 }, { 39,-990 }, + { 40,-990 }, { 41,-990 }, { 42,-990 }, { 43,-990 }, { 0, 20 }, + { 0,2433 }, { 46,-990 }, { 2, -45 }, { 3, -45 }, { 4, -45 }, + { 5, 733 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0,2421 }, { 0, 0 }, { 0, 0 }, + + { 3,-324 }, { 16,-1035 }, { 0, 0 }, { 0, 0 }, { 19, 778 }, + { 20, 778 }, { 21, 778 }, { 22, 778 }, { 23, 778 }, { 24, 778 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 778 }, { 31, 778 }, { 32, 778 }, { 33,-1035 }, { 34,-1035 }, + { 35,-1035 }, { 36,-1035 }, { 37,-987 }, { 0, 0 }, { 39, 778 }, + { 40, 778 }, { 41,-1035 }, { 42,-1035 }, { 43,-1035 }, { 0, 20 }, + { 0,2388 }, { 46,-1035 }, { 35,-1841 }, { 3,-984 }, { 37,-880 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 42,-1841 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-1080 }, { 0, 0 }, { 0, 0 }, { 19,-1080 }, + + { 20,-1080 }, { 21,-1080 }, { 22,-1080 }, { 23,-1080 }, { 24,-1080 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30,-1080 }, { 31,-1080 }, { 32,-1080 }, { 33,-1080 }, { 34,-1080 }, + { 35,-1080 }, { 36,-1080 }, { 37,-1032 }, { 0, 0 }, { 39,-1080 }, + { 40,-1080 }, { 41,-1080 }, { 42,-1080 }, { 43,-1080 }, { 0, 20 }, + { 0,2343 }, { 46,-1080 }, { 2,-1029 }, { 3,-1029 }, { 4,-1029 }, + { 5, -45 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-1125 }, { 0, 0 }, { 0, 0 }, { 19, 733 }, + { 20, 733 }, { 21, 733 }, { 22, 733 }, { 23, 733 }, { 24, 733 }, + + { 0, 0 }, { 0,2317 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 733 }, { 31, 733 }, { 32, 733 }, { 33,-1125 }, { 34,-1125 }, + { 35,-1125 }, { 36,-1125 }, { 37,-1077 }, { 0, 0 }, { 39, 733 }, + { 40, 733 }, { 41,-1125 }, { 42,-1125 }, { 43,-1125 }, { 0, 0 }, + { 19,-790 }, { 46,-1125 }, { 0, 0 }, { 22,-769 }, { 0, 0 }, + { 24,-721 }, { 0, 0 }, { 0,2291 }, { 0, 0 }, { 2,-454 }, + { 3,-454 }, { 4,-454 }, { 5,-130 }, { 0, 0 }, { 0,2284 }, + { 0, 0 }, { 0,2282 }, { 36,-714 }, { 2,-463 }, { 3,-463 }, + { 4,-463 }, { 5,-139 }, { 0, 0 }, { 0, 0 }, { 43,-714 }, + { 0, 0 }, { 0, 0 }, { 0,2271 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 19, 189 }, { 0, 0 }, + { 0, 0 }, { 22,-802 }, { 0, 0 }, { 24,-754 }, { 0, 17 }, + { 0,2258 }, { 0, 0 }, { 35,-1971 }, { 0, 0 }, { 37,-1010 }, + { 0, 0 }, { 19, 576 }, { 0, 0 }, { 21,-1185 }, { 42,-1971 }, + { 23,-1044 }, { 35,-1980 }, { 0, 0 }, { 37,-1019 }, { 0, 0 }, + { 0,2243 }, { 16,-1018 }, { 0, 0 }, { 42,-1980 }, { 19,-1018 }, + { 20,-1018 }, { 21,-1018 }, { 22,-1018 }, { 23,-1018 }, { 24,-1018 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30,-1018 }, { 31,-1018 }, { 32,-1018 }, { 33,-1018 }, { 34,-1018 }, + { 35,-1018 }, { 36,-1018 }, { 37,-970 }, { 0, 0 }, { 39,-1018 }, + + { 40,-1018 }, { 41,-1018 }, { 42,-1018 }, { 43,-1018 }, { 0, 17 }, + { 0,2213 }, { 46,-1018 }, { 2, -45 }, { 3, -45 }, { 4, -45 }, + { 5, 678 }, { 36,-1487 }, { 37, -74 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 43,-1487 }, { 0, 0 }, + { 0,2198 }, { 16,-1063 }, { 0, 0 }, { 3, -45 }, { 19, 723 }, + { 20, 723 }, { 21, 723 }, { 22, 723 }, { 23, 723 }, { 24, 723 }, + { 0, 0 }, { 0,2187 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 723 }, { 31, 723 }, { 32, 723 }, { 33,-1063 }, { 34,-1063 }, + { 35,-1063 }, { 36,-1063 }, { 37,-1015 }, { 0, 0 }, { 39, 723 }, + { 40, 723 }, { 41,-1063 }, { 42,-1063 }, { 43,-1063 }, { 0, 17 }, + + { 0,2168 }, { 46,-1063 }, { 21,-1933 }, { 3,-1012 }, { 23,-1792 }, + { 0, 0 }, { 36,-1532 }, { 37,-119 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 43,-1532 }, { 0, 0 }, + { 0, 0 }, { 16,-1108 }, { 0, 0 }, { 0, 0 }, { 19,-1108 }, + { 20,-1108 }, { 21,-1108 }, { 22,-1108 }, { 23,-1108 }, { 24,-1108 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30,-1108 }, { 31,-1108 }, { 32,-1108 }, { 33,-1108 }, { 34,-1108 }, + { 35,-1108 }, { 36,-1108 }, { 37,-1060 }, { 0, 0 }, { 39,-1108 }, + { 40,-1108 }, { 41,-1108 }, { 42,-1108 }, { 43,-1108 }, { 0, 17 }, + { 0,2123 }, { 46,-1108 }, { 2,-1057 }, { 3,-1057 }, { 4,-1057 }, + + { 5, -45 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-1153 }, { 0, 0 }, { 0, 0 }, { 19, 678 }, + { 20, 678 }, { 21, 678 }, { 22, 678 }, { 23, 678 }, { 24, 678 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0,2095 }, { 0, 0 }, + { 30, 678 }, { 31, 678 }, { 32, 678 }, { 33,-1153 }, { 34,-1153 }, + { 35,-1153 }, { 36,-1153 }, { 37,-1105 }, { 0, 0 }, { 39, 678 }, + { 40, 678 }, { 41,-1153 }, { 42,-1153 }, { 43,-1153 }, { 0, 7 }, + { 0,2078 }, { 46,-1153 }, { 19, 533 }, { 3,-1012 }, { 0, 0 }, + { 22,-991 }, { 0, 0 }, { 24,-943 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 12,-2205 }, { 0, 0 }, { 0,2064 }, + { 0, 0 }, { 16,-2056 }, { 0, 0 }, { 0, 0 }, { 19,-2056 }, + { 20,-2056 }, { 21,-2056 }, { 22,-2056 }, { 23,-2056 }, { 24,-2056 }, + { 0, 0 }, { 12,-1106 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30,-2056 }, { 31,-2056 }, { 32,-2056 }, { 33,-2056 }, { 34,-2056 }, + { 35,-2056 }, { 36,-2056 }, { 37,-2008 }, { 0, 0 }, { 39,-2056 }, + { 40,-2056 }, { 41,-2056 }, { 42,-2056 }, { 43,-2056 }, { 0, 7 }, + { 0,2033 }, { 46,-2056 }, { 2,-1057 }, { 3,-1057 }, { 4,-1057 }, + { 5, -45 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 12,-2250 }, { 0, 0 }, { 0,2019 }, + + { 0, 0 }, { 16,-2101 }, { 3, -45 }, { 0, 0 }, { 19, 633 }, + { 20, 633 }, { 21, 633 }, { 22, 633 }, { 23, 633 }, { 24, 633 }, + { 0, 0 }, { 12,-1151 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 633 }, { 31, 633 }, { 32, 633 }, { 33,-2101 }, { 34,-2101 }, + { 35,-2101 }, { 36,-2101 }, { 37,-2053 }, { 0, 0 }, { 39, 633 }, + { 40, 633 }, { 41,-2101 }, { 42,-2101 }, { 43,-2101 }, { 0, 7 }, + { 0,1988 }, { 46,-2101 }, { 2,-2050 }, { 3,-2050 }, { 4,-2050 }, + { 5,-1012 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 12,-2295 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-2146 }, { 0, 0 }, { 0, 0 }, { 19, 633 }, + + { 20, 633 }, { 21, 633 }, { 22, 633 }, { 23, 633 }, { 24, 633 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 633 }, { 31, 633 }, { 32, 633 }, { 33,-2146 }, { 34,-2146 }, + { 35,-2146 }, { 36,-2146 }, { 37,-2098 }, { 0, 0 }, { 39, 633 }, + { 40, 633 }, { 41,-2146 }, { 42,-2146 }, { 43,-2146 }, { 0, 0 }, + { 0, 0 }, { 46,-2146 }, { 0, 18 }, { 0,1940 }, { 1,-3077 }, + { 2,-967 }, { 3,-2005 }, { 4,-2005 }, { 5,-919 }, { 6,-3077 }, + { 7,-3199 }, { 8,-3077 }, { 9,-3077 }, { 10,-3077 }, { 11,-3077 }, + { 12,-3077 }, { 13,-3077 }, { 14,-3077 }, { 15,-3077 }, { 16,-3077 }, + { 17,-3077 }, { 18,-3077 }, { 19, 633 }, { 20, 633 }, { 21, 633 }, + + { 22, 633 }, { 23, 633 }, { 24, 633 }, { 25,-3077 }, { 26,-3077 }, + { 27,-3077 }, { 28,-3077 }, { 29,-3077 }, { 30, 633 }, { 31, 633 }, + { 32, 633 }, { 33,-3077 }, { 34,-3077 }, { 35,-3077 }, { 36,-3077 }, + { 37,-3029 }, { 38,-3077 }, { 39, 633 }, { 40, 633 }, { 41,-3077 }, + { 42,-3077 }, { 43,-3077 }, { 44,-3077 }, { 45,-3077 }, { 46,-2981 }, + { 0, 11 }, { 0,1892 }, { 0, 0 }, { 2,-1909 }, { 3,-1909 }, + { 4,-1909 }, { 5,-871 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 16,-2981 }, { 0, 0 }, { 0, 0 }, + { 19, 633 }, { 20, 633 }, { 21, 633 }, { 22, 633 }, { 23, 633 }, + + { 24, 633 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 30, 633 }, { 31, 633 }, { 32, 633 }, { 33,-2981 }, + { 34,-2981 }, { 35,-2981 }, { 36,-2981 }, { 37,-2933 }, { 0, 0 }, + { 39, 633 }, { 40, 633 }, { 41,-2981 }, { 42,-2981 }, { 43,-2981 }, + { 0, 0 }, { 0, 0 }, { 46,-2981 }, { 0, 18 }, { 0,1844 }, + { 1,-2933 }, { 2,-826 }, { 3,-1864 }, { 4,-1864 }, { 5,-778 }, + { 6,-2933 }, { 7,-2933 }, { 8,-2933 }, { 9,-2933 }, { 10,-2933 }, + { 11,-3295 }, { 12,-2933 }, { 13,-2933 }, { 14,-2933 }, { 15,-2933 }, + { 16,-2933 }, { 17,-2933 }, { 18,-2933 }, { 19, 633 }, { 20, 633 }, + { 21, 633 }, { 22, 633 }, { 23, 633 }, { 24, 633 }, { 25,-2933 }, + + { 26,-2933 }, { 27,-2933 }, { 28,-2933 }, { 29,-2933 }, { 30, 633 }, + { 31, 633 }, { 32, 633 }, { 33,-2933 }, { 34,-2933 }, { 35,-2933 }, + { 36,-2933 }, { 37,-2885 }, { 38,-2933 }, { 39, 633 }, { 40, 633 }, + { 41,-2933 }, { 42,-2933 }, { 43,-2933 }, { 44,-2933 }, { 45,-2933 }, + { 46,-2837 }, { 0, 0 }, { 0,1796 }, { 1, 0 }, { 2, 0 }, + { 3, 0 }, { 4, 0 }, { 5, 0 }, { 6, 0 }, { 7, 0 }, + { 8, 0 }, { 9, 0 }, { 10, 0 }, { 11, 0 }, { 12, 0 }, + { 13, 48 }, { 14, 0 }, { 15, 0 }, { 16, 0 }, { 17, 0 }, + { 18, 0 }, { 19, 0 }, { 20, 0 }, { 21, 0 }, { 22, 0 }, + { 23, 0 }, { 24, 0 }, { 25, 0 }, { 26, 0 }, { 27, 0 }, + + { 28, 0 }, { 29, 0 }, { 30, 0 }, { 31, 0 }, { 32, 0 }, + { 33, 0 }, { 34, 0 }, { 35, 0 }, { 36, 0 }, { 37, 0 }, + { 38, 0 }, { 39, 0 }, { 40, 0 }, { 41, 0 }, { 42, 0 }, + { 43, 0 }, { 44, 0 }, { 45, 0 }, { 46, 0 }, { 0, 0 }, + { 0,1748 }, { 1,-778 }, { 2,-778 }, { 3,-778 }, { 4,-778 }, + { 5,-778 }, { 6,-778 }, { 7,-778 }, { 8,-778 }, { 9,-778 }, + { 10,-778 }, { 11,-778 }, { 12,-778 }, { 13, 0 }, { 14,-778 }, + { 15,-778 }, { 16,-778 }, { 17,-778 }, { 18,-1994 }, { 19,-778 }, + { 20,-778 }, { 21,-778 }, { 22,-778 }, { 23,-778 }, { 24,-778 }, + { 25,-778 }, { 26,-778 }, { 27,-778 }, { 28,-778 }, { 29,-778 }, + + { 30,-778 }, { 31,-778 }, { 32,-778 }, { 33,-778 }, { 34,-778 }, + { 35,-778 }, { 36,-778 }, { 37,-778 }, { 38,-778 }, { 39,-778 }, + { 40,-778 }, { 41,-778 }, { 42,-778 }, { 43,-778 }, { 44,-778 }, + { 45,-778 }, { 46,-778 }, { 0, 20 }, { 0,1700 }, { 0, 0 }, + { 0, 0 }, { 3,-778 }, { 0, 0 }, { 0,1695 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-1768 }, + { 0, 0 }, { 0, 0 }, { 19,-1768 }, { 20,-1768 }, { 21,-1768 }, + { 22,-1768 }, { 23,-1768 }, { 24,-1768 }, { 0, 0 }, { 21,-1761 }, + { 0, 0 }, { 23,-1620 }, { 0, 0 }, { 30,-1768 }, { 31,-1768 }, + + { 32,-1768 }, { 33,-1768 }, { 34,-1768 }, { 35,-1768 }, { 36,-1768 }, + { 37,-1720 }, { 0, 0 }, { 39,-1768 }, { 40,-1768 }, { 41,-1768 }, + { 42,-1768 }, { 43,-1768 }, { 0, 20 }, { 0,1655 }, { 46,-1768 }, + { 2,-823 }, { 3,-823 }, { 4,-823 }, { 5, -45 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-1813 }, + { 0, 0 }, { 0, 0 }, { 19, 492 }, { 20, 492 }, { 21, 492 }, + { 22, 492 }, { 23, 492 }, { 24, 492 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 492 }, { 31, 492 }, + { 32, 492 }, { 33,-1813 }, { 34,-1813 }, { 35,-1813 }, { 36,-1813 }, + + { 37,-1765 }, { 0, 0 }, { 39, 492 }, { 40, 492 }, { 41,-1813 }, + { 42,-1813 }, { 43,-1813 }, { 0, 20 }, { 0,1610 }, { 46,-1813 }, + { 2,-1762 }, { 3,-1762 }, { 4,-1762 }, { 5,-778 }, { 0, 0 }, + { 0, 0 }, { 0,1602 }, { 0, 0 }, { 2,-641 }, { 3,-641 }, + { 4,-641 }, { 5,-596 }, { 0, 0 }, { 0, 0 }, { 16,-1858 }, + { 0, 0 }, { 0, 0 }, { 19, 492 }, { 20, 492 }, { 21, 492 }, + { 22, 492 }, { 23, 492 }, { 24, 492 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 492 }, { 31, 492 }, + { 32, 492 }, { 33,-1858 }, { 34,-1858 }, { 35,-1858 }, { 36,-1858 }, + { 37,-1810 }, { 0, 0 }, { 39, 492 }, { 40, 492 }, { 41,-1858 }, + + { 42,-1858 }, { 43,-1858 }, { 36,-2128 }, { 37,-715 }, { 46,-1858 }, + { 0, 0 }, { 0,1562 }, { 0, 0 }, { 0,1560 }, { 43,-2128 }, + { 2,-683 }, { 3,-683 }, { 4,-683 }, { 5,-638 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 22,-1524 }, { 0, 0 }, + { 24,-1476 }, { 0, 0 }, { 0, 17 }, { 0,1535 }, { 0, 0 }, + { 0, 0 }, { 3,-723 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 36,-2170 }, + { 37,-757 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-1741 }, + + { 0, 0 }, { 43,-2170 }, { 19,-1741 }, { 20,-1741 }, { 21,-1741 }, + { 22,-1741 }, { 23,-1741 }, { 24,-1741 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30,-1741 }, { 31,-1741 }, + { 32,-1741 }, { 33,-1741 }, { 34,-1741 }, { 35,-1741 }, { 36,-1741 }, + { 37,-1693 }, { 0, 0 }, { 39,-1741 }, { 40,-1741 }, { 41,-1741 }, + { 42,-1741 }, { 43,-1741 }, { 0, 17 }, { 0,1490 }, { 46,-1741 }, + { 2,-768 }, { 3,-768 }, { 4,-768 }, { 5, -45 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-1786 }, + { 0, 0 }, { 0, 0 }, { 19, 428 }, { 20, 428 }, { 21, 428 }, + + { 22, 428 }, { 23, 428 }, { 24, 428 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 428 }, { 31, 428 }, + { 32, 428 }, { 33,-1786 }, { 34,-1786 }, { 35,-1786 }, { 36,-1786 }, + { 37,-1738 }, { 0, 0 }, { 39, 428 }, { 40, 428 }, { 41,-1786 }, + { 42,-1786 }, { 43,-1786 }, { 0, 17 }, { 0,1445 }, { 46,-1786 }, + { 2,-1735 }, { 3,-1735 }, { 4,-1735 }, { 5,-723 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-1831 }, + { 0, 0 }, { 0, 0 }, { 19, 428 }, { 20, 428 }, { 21, 428 }, + { 22, 428 }, { 23, 428 }, { 24, 428 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 428 }, { 31, 428 }, + { 32, 428 }, { 33,-1831 }, { 34,-1831 }, { 35,-1831 }, { 36,-1831 }, + { 37,-1783 }, { 0, 0 }, { 39, 428 }, { 40, 428 }, { 41,-1831 }, + { 42,-1831 }, { 43,-1831 }, { 0, 7 }, { 0,1400 }, { 46,-1831 }, + { 2,-1690 }, { 3,-1690 }, { 4,-1690 }, { 5,-678 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 12,-2883 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-2734 }, + { 0, 0 }, { 0, 0 }, { 19, 428 }, { 20, 428 }, { 21, 428 }, + { 22, 428 }, { 23, 428 }, { 24, 428 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 428 }, { 31, 428 }, + + { 32, 428 }, { 33,-2734 }, { 34,-2734 }, { 35,-2734 }, { 36,-2734 }, + { 37,-2686 }, { 0, 0 }, { 39, 428 }, { 40, 428 }, { 41,-2734 }, + { 42,-2734 }, { 43,-2734 }, { 0, 7 }, { 0,1355 }, { 46,-2734 }, + { 2,-2683 }, { 3,-2683 }, { 4,-2683 }, { 5,-1645 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 12,-2928 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-2779 }, + { 0, 0 }, { 0, 0 }, { 19, 428 }, { 20, 428 }, { 21, 428 }, + { 22, 428 }, { 23, 428 }, { 24, 428 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 428 }, { 31, 428 }, + { 32, 428 }, { 33,-2779 }, { 34,-2779 }, { 35,-2779 }, { 36,-2779 }, + + { 37,-2731 }, { 0, 0 }, { 39, 428 }, { 40, 428 }, { 41,-2779 }, + { 42,-2779 }, { 43,-2779 }, { 0, 0 }, { 0, 0 }, { 46,-2779 }, + { 0, 18 }, { 0,1307 }, { 1,-3710 }, { 2,-1600 }, { 3,-2638 }, + { 4,-2638 }, { 5,-1552 }, { 6,-3710 }, { 7,-3832 }, { 8,-3710 }, + { 9,-3710 }, { 10,-3710 }, { 11,-3710 }, { 12,-3710 }, { 13,-3710 }, + { 14,-3710 }, { 15,-3710 }, { 16,-3710 }, { 17,-3710 }, { 18,-3710 }, + { 19, 428 }, { 20, 428 }, { 21, 428 }, { 22, 428 }, { 23, 428 }, + { 24, 428 }, { 25,-3710 }, { 26,-3710 }, { 27,-3710 }, { 28,-3710 }, + { 29,-3710 }, { 30, 428 }, { 31, 428 }, { 32, 428 }, { 33,-3710 }, + { 34,-3710 }, { 35,-3710 }, { 36,-3710 }, { 37,-3662 }, { 38,-3710 }, + + { 39, 428 }, { 40, 428 }, { 41,-3710 }, { 42,-3710 }, { 43,-3710 }, + { 44,-3710 }, { 45,-3710 }, { 46,-3614 }, { 0, 11 }, { 0,1259 }, + { 0, 0 }, { 2,-2542 }, { 3,-2542 }, { 4,-2542 }, { 5,-1504 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 16,-3614 }, { 0, 0 }, { 0, 0 }, { 19, 428 }, { 20, 428 }, + { 21, 428 }, { 22, 428 }, { 23, 428 }, { 24, 428 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 428 }, + { 31, 428 }, { 32, 428 }, { 33,-3614 }, { 34,-3614 }, { 35,-3614 }, + { 36,-3614 }, { 37,-3566 }, { 0, 0 }, { 39, 428 }, { 40, 428 }, + + { 41,-3614 }, { 42,-3614 }, { 43,-3614 }, { 0, 0 }, { 0, 0 }, + { 46,-3614 }, { 0, 18 }, { 0,1211 }, { 1,-3566 }, { 2,-1459 }, + { 3,-2497 }, { 4,-2497 }, { 5,-1411 }, { 6,-3566 }, { 7,-3566 }, + { 8,-3566 }, { 9,-3566 }, { 10,-3566 }, { 11,-3928 }, { 12,-3566 }, + { 13,-3566 }, { 14,-3566 }, { 15,-3566 }, { 16,-3566 }, { 17,-3566 }, + { 18,-3566 }, { 19, 428 }, { 20, 428 }, { 21, 428 }, { 22, 428 }, + { 23, 428 }, { 24, 428 }, { 25,-3566 }, { 26,-3566 }, { 27,-3566 }, + { 28,-3566 }, { 29,-3566 }, { 30, 428 }, { 31, 428 }, { 32, 428 }, + { 33,-3566 }, { 34,-3566 }, { 35,-3566 }, { 36,-3566 }, { 37,-3518 }, + { 38,-3566 }, { 39, 428 }, { 40, 428 }, { 41,-3566 }, { 42,-3566 }, + + { 43,-3566 }, { 44,-3566 }, { 45,-3566 }, { 46,-3470 }, { 0, 20 }, + { 0,1163 }, { 0, 0 }, { 2,-1315 }, { 3,-1315 }, { 4,-1315 }, + { 5,-537 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-2305 }, { 0, 0 }, { 0, 0 }, { 19, 428 }, + { 20, 428 }, { 21, 428 }, { 22, 428 }, { 23, 428 }, { 24, 428 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 428 }, { 31, 428 }, { 32, 428 }, { 33,-2305 }, { 34,-2305 }, + { 35,-2305 }, { 36,-2305 }, { 37,-2257 }, { 0, 0 }, { 39, 428 }, + { 40, 428 }, { 41,-2305 }, { 42,-2305 }, { 43,-2305 }, { 0, 20 }, + + { 0,1118 }, { 46,-2305 }, { 2,-2254 }, { 3,-2254 }, { 4,-2254 }, + { 5,-1270 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-2350 }, { 0, 0 }, { 0, 0 }, { 19, 428 }, + { 20, 428 }, { 21, 428 }, { 22, 428 }, { 23, 428 }, { 24, 428 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 428 }, { 31, 428 }, { 32, 428 }, { 33,-2350 }, { 34,-2350 }, + { 35,-2350 }, { 36,-2350 }, { 37,-2302 }, { 0, 0 }, { 39, 428 }, + { 40, 428 }, { 41,-2350 }, { 42,-2350 }, { 43,-2350 }, { 0, 0 }, + { 0,1073 }, { 46,-2350 }, { 2,-991 }, { 3,-991 }, { 4,-991 }, + + { 5,-946 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 17 }, { 0,1062 }, { 12,-2097 }, { 2,-1196 }, { 3,-1196 }, + { 4,-1196 }, { 5,-473 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 16,-2214 }, { 0, 0 }, { 0, 0 }, + { 19, 417 }, { 20, 417 }, { 21, 417 }, { 22, 417 }, { 23, 417 }, + { 24, 417 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 30, 417 }, { 31, 417 }, { 32, 417 }, { 33,-2214 }, + { 34,-2214 }, { 35,-2214 }, { 36,-2214 }, { 37,-2166 }, { 0, 0 }, + { 39, 417 }, { 40, 417 }, { 41,-2214 }, { 42,-2214 }, { 43,-2214 }, + + { 0, 17 }, { 0,1017 }, { 46,-2214 }, { 2,-2163 }, { 3,-2163 }, + { 4,-2163 }, { 5,-1151 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 16,-2259 }, { 0, 0 }, { 0, 0 }, + { 19, 417 }, { 20, 417 }, { 21, 417 }, { 22, 417 }, { 23, 417 }, + { 24, 417 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 30, 417 }, { 31, 417 }, { 32, 417 }, { 33,-2259 }, + { 34,-2259 }, { 35,-2259 }, { 36,-2259 }, { 37,-2211 }, { 0, 0 }, + { 39, 417 }, { 40, 417 }, { 41,-2259 }, { 42,-2259 }, { 43,-2259 }, + { 0, 7 }, { 0, 972 }, { 46,-2259 }, { 2,-2118 }, { 3,-2118 }, + + { 4,-2118 }, { 5,-1106 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 12,-3311 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 16,-3162 }, { 0, 0 }, { 0, 0 }, + { 19, 417 }, { 20, 417 }, { 21, 417 }, { 22, 417 }, { 23, 417 }, + { 24, 417 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 30, 417 }, { 31, 417 }, { 32, 417 }, { 33,-3162 }, + { 34,-3162 }, { 35,-3162 }, { 36,-3162 }, { 37,-3114 }, { 0, 0 }, + { 39, 417 }, { 40, 417 }, { 41,-3162 }, { 42,-3162 }, { 43,-3162 }, + { 0, 7 }, { 0, 927 }, { 46,-3162 }, { 2,-3111 }, { 3,-3111 }, + { 4,-3111 }, { 5,-2073 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 12,-3356 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 16,-3207 }, { 0, 0 }, { 0, 0 }, + { 19, 417 }, { 20, 417 }, { 21, 417 }, { 22, 417 }, { 23, 417 }, + { 24, 417 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 30, 417 }, { 31, 417 }, { 32, 417 }, { 33,-3207 }, + { 34,-3207 }, { 35,-3207 }, { 36,-3207 }, { 37,-3159 }, { 0, 0 }, + { 39, 417 }, { 40, 417 }, { 41,-3207 }, { 42,-3207 }, { 43,-3207 }, + { 0, 0 }, { 0, 0 }, { 46,-3207 }, { 0, 18 }, { 0, 879 }, + { 1,-4138 }, { 2,-2028 }, { 3,-3066 }, { 4,-3066 }, { 5,-1980 }, + { 6,-4138 }, { 7,-4260 }, { 8,-4138 }, { 9,-4138 }, { 10,-4138 }, + + { 11,-4138 }, { 12,-4138 }, { 13,-4138 }, { 14,-4138 }, { 15,-4138 }, + { 16,-4138 }, { 17,-4138 }, { 18,-4138 }, { 19, 417 }, { 20, 417 }, + { 21, 417 }, { 22, 417 }, { 23, 417 }, { 24, 417 }, { 25,-4138 }, + { 26,-4138 }, { 27,-4138 }, { 28,-4138 }, { 29,-4138 }, { 30, 417 }, + { 31, 417 }, { 32, 417 }, { 33,-4138 }, { 34,-4138 }, { 35,-4138 }, + { 36,-4138 }, { 37,-4090 }, { 38,-4138 }, { 39, 417 }, { 40, 417 }, + { 41,-4138 }, { 42,-4138 }, { 43,-4138 }, { 44,-4138 }, { 45,-4138 }, + { 46,-4042 }, { 0, 11 }, { 0, 831 }, { 0, 0 }, { 2,-2970 }, + { 3,-2970 }, { 4,-2970 }, { 5,-1932 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-4042 }, { 0, 0 }, + { 0, 0 }, { 19, 417 }, { 20, 417 }, { 21, 417 }, { 22, 417 }, + { 23, 417 }, { 24, 417 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 30, 417 }, { 31, 417 }, { 32, 417 }, + { 33,-4042 }, { 34,-4042 }, { 35,-4042 }, { 36,-4042 }, { 37,-3994 }, + { 0, 0 }, { 39, 417 }, { 40, 417 }, { 41,-4042 }, { 42,-4042 }, + { 43,-4042 }, { 0, 0 }, { 0, 0 }, { 46,-4042 }, { 0, 18 }, + { 0, 783 }, { 1,-3994 }, { 2,-1887 }, { 3,-2925 }, { 4,-2925 }, + { 5,-1839 }, { 6,-3994 }, { 7,-3994 }, { 8,-3994 }, { 9,-3994 }, + { 10,-3994 }, { 11,-4356 }, { 12,-3994 }, { 13,-3994 }, { 14,-3994 }, + + { 15,-3994 }, { 16,-3994 }, { 17,-3994 }, { 18,-3994 }, { 19, 417 }, + { 20, 417 }, { 21, 417 }, { 22, 417 }, { 23, 417 }, { 24, 417 }, + { 25,-3994 }, { 26,-3994 }, { 27,-3994 }, { 28,-3994 }, { 29,-3994 }, + { 30, 417 }, { 31, 417 }, { 32, 417 }, { 33,-3994 }, { 34,-3994 }, + { 35,-3994 }, { 36,-3994 }, { 37,-3946 }, { 38,-3994 }, { 39, 417 }, + { 40, 417 }, { 41,-3994 }, { 42,-3994 }, { 43,-3994 }, { 44,-3994 }, + { 45,-3994 }, { 46,-3898 }, { 0, 20 }, { 0, 735 }, { 0, 0 }, + { 2,-1743 }, { 3,-1743 }, { 4,-1743 }, { 5,-965 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-2733 }, + + { 0, 0 }, { 0, 0 }, { 19, 417 }, { 20, 417 }, { 21, 417 }, + { 22, 417 }, { 23, 417 }, { 24, 417 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 417 }, { 31, 417 }, + { 32, 417 }, { 33,-2733 }, { 34,-2733 }, { 35,-2733 }, { 36,-2733 }, + { 37,-2685 }, { 0, 0 }, { 39, 417 }, { 40, 417 }, { 41,-2733 }, + { 42,-2733 }, { 43,-2733 }, { 0, 20 }, { 0, 690 }, { 46,-2733 }, + { 2,-2682 }, { 3,-2682 }, { 4,-2682 }, { 5,-1698 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-2778 }, + { 0, 0 }, { 0, 0 }, { 19, 417 }, { 20, 417 }, { 21, 417 }, + + { 22, 417 }, { 23, 417 }, { 24, 417 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 417 }, { 31, 417 }, + { 32, 417 }, { 33,-2778 }, { 34,-2778 }, { 35,-2778 }, { 36,-2778 }, + { 37,-2730 }, { 0, 0 }, { 39, 417 }, { 40, 417 }, { 41,-2778 }, + { 42,-2778 }, { 43,-2778 }, { 0, 17 }, { 0, 645 }, { 46,-2778 }, + { 2,-1613 }, { 3,-1613 }, { 4,-1613 }, { 5,-890 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-2631 }, + { 0, 0 }, { 0, 0 }, { 19, 417 }, { 20, 417 }, { 21, 417 }, + { 22, 417 }, { 23, 417 }, { 24, 417 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 417 }, { 31, 417 }, + { 32, 417 }, { 33,-2631 }, { 34,-2631 }, { 35,-2631 }, { 36,-2631 }, + { 37,-2583 }, { 0, 0 }, { 39, 417 }, { 40, 417 }, { 41,-2631 }, + { 42,-2631 }, { 43,-2631 }, { 0, 17 }, { 0, 600 }, { 46,-2631 }, + { 2,-2580 }, { 3,-2580 }, { 4,-2580 }, { 5,-1568 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-2676 }, + { 0, 0 }, { 0, 0 }, { 19, 417 }, { 20, 417 }, { 21, 417 }, + { 22, 417 }, { 23, 417 }, { 24, 417 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 417 }, { 31, 417 }, + + { 32, 417 }, { 33,-2676 }, { 34,-2676 }, { 35,-2676 }, { 36,-2676 }, + { 37,-2628 }, { 0, 0 }, { 39, 417 }, { 40, 417 }, { 41,-2676 }, + { 42,-2676 }, { 43,-2676 }, { 0, 7 }, { 0, 555 }, { 46,-2676 }, + { 2,-2535 }, { 3,-2535 }, { 4,-2535 }, { 5,-1523 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 12,-3728 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-3579 }, + { 0, 0 }, { 0, 0 }, { 19, 417 }, { 20, 417 }, { 21, 417 }, + { 22, 417 }, { 23, 417 }, { 24, 417 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30, 417 }, { 31, 417 }, + { 32, 417 }, { 33,-3579 }, { 34,-3579 }, { 35,-3579 }, { 36,-3579 }, + + { 37,-3531 }, { 0, 0 }, { 39, 417 }, { 40, 417 }, { 41,-3579 }, + { 42,-3579 }, { 43,-3579 }, { 0, 7 }, { 0, 510 }, { 46,-3579 }, + { 2,-3528 }, { 3,-3528 }, { 4,-3528 }, { 5,-2490 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 12,-3773 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 16,-3624 }, + { 0, 0 }, { 0, 0 }, { 19,-3624 }, { 20,-3624 }, { 21,-3624 }, + { 22,-3624 }, { 23,-3624 }, { 24,-3624 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30,-3624 }, { 31,-3624 }, + { 32,-3624 }, { 33,-3624 }, { 34,-3624 }, { 35,-3624 }, { 36,-3624 }, + { 37,-3576 }, { 0, 0 }, { 39,-3624 }, { 40,-3624 }, { 41,-3624 }, + + { 42,-3624 }, { 43,-3624 }, { 0, 0 }, { 0, 0 }, { 46,-3624 }, + { 0, 18 }, { 0, 462 }, { 1,-4555 }, { 2,-2445 }, { 3,-3483 }, + { 4,-3483 }, { 5,-2397 }, { 6,-4555 }, { 7,-4677 }, { 8,-4555 }, + { 9,-4555 }, { 10,-4555 }, { 11,-4555 }, { 12,-4555 }, { 13,-4555 }, + { 14,-4555 }, { 15,-4555 }, { 16,-4555 }, { 17,-4555 }, { 18,-4555 }, + { 19,-4555 }, { 20,-4555 }, { 21,-4555 }, { 22,-4555 }, { 23,-4555 }, + { 24,-4555 }, { 25,-4555 }, { 26,-4555 }, { 27,-4555 }, { 28,-4555 }, + { 29,-4555 }, { 30,-4555 }, { 31,-4555 }, { 32,-4555 }, { 33,-4555 }, + { 34,-4555 }, { 35,-4555 }, { 36,-4555 }, { 37,-4507 }, { 38,-4555 }, + { 39,-4555 }, { 40,-4555 }, { 41,-4555 }, { 42,-4555 }, { 43,-4555 }, + + { 44,-4555 }, { 45,-4555 }, { 46,-4459 }, { 0, 11 }, { 0, 414 }, + { 0, 0 }, { 2,-3387 }, { 3,-3387 }, { 4,-3387 }, { 5,-2349 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 16,-4459 }, { 0, 0 }, { 0, 0 }, { 19,-4459 }, { 20,-4459 }, + { 21,-4459 }, { 22,-4459 }, { 23,-4459 }, { 24,-4459 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 30,-4459 }, + { 31,-4459 }, { 32,-4459 }, { 33,-4459 }, { 34,-4459 }, { 35,-4459 }, + { 36,-4459 }, { 37,-4411 }, { 0, 0 }, { 39,-4459 }, { 40,-4459 }, + { 41,-4459 }, { 42,-4459 }, { 43,-4459 }, { 0, 0 }, { 0, 0 }, + + { 46,-4459 }, { 0, 18 }, { 0, 366 }, { 1,-4411 }, { 2,-2304 }, + { 3,-3342 }, { 4,-3342 }, { 5,-2256 }, { 6,-4411 }, { 7,-4411 }, + { 8,-4411 }, { 9,-4411 }, { 10,-4411 }, { 11,-4773 }, { 12,-4411 }, + { 13,-4411 }, { 14,-4411 }, { 15,-4411 }, { 16,-4411 }, { 17,-4411 }, + { 18,-4411 }, { 19,-4411 }, { 20,-4411 }, { 21,-4411 }, { 22,-4411 }, + { 23,-4411 }, { 24,-4411 }, { 25,-4411 }, { 26,-4411 }, { 27,-4411 }, + { 28,-4411 }, { 29,-4411 }, { 30,-4411 }, { 31,-4411 }, { 32,-4411 }, + { 33,-4411 }, { 34,-4411 }, { 35,-4411 }, { 36,-4411 }, { 37,-4363 }, + { 38,-4411 }, { 39,-4411 }, { 40,-4411 }, { 41,-4411 }, { 42,-4411 }, + { 43,-4411 }, { 44,-4411 }, { 45,-4411 }, { 46,-4315 }, { 0, 20 }, + + { 0, 318 }, { 0, 0 }, { 2,-2160 }, { 3,-2160 }, { 4,-2160 }, + { 5,-1382 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-3150 }, { 0, 0 }, { 0, 0 }, { 19, 225 }, + { 20, 225 }, { 21, 225 }, { 22, 225 }, { 23, 225 }, { 24, 225 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 225 }, { 31, 225 }, { 32, 225 }, { 33,-3150 }, { 34,-3150 }, + { 35,-3150 }, { 36,-3150 }, { 37,-3102 }, { 0, 0 }, { 39, 225 }, + { 40, 225 }, { 41,-3150 }, { 42,-3150 }, { 43,-3150 }, { 0, 20 }, + { 0, 273 }, { 46,-3150 }, { 2,-3099 }, { 3,-3099 }, { 4,-3099 }, + + { 5,-2115 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-3195 }, { 0, 0 }, { 0, 0 }, { 19,-3195 }, + { 20,-3195 }, { 21,-3195 }, { 22,-3195 }, { 23,-3195 }, { 24,-3195 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30,-3195 }, { 31,-3195 }, { 32,-3195 }, { 33,-3195 }, { 34,-3195 }, + { 35,-3195 }, { 36,-3195 }, { 37,-3147 }, { 0, 0 }, { 39,-3195 }, + { 40,-3195 }, { 41,-3195 }, { 42,-3195 }, { 43,-3195 }, { 0, 17 }, + { 0, 228 }, { 46,-3195 }, { 2,-2030 }, { 3,-2030 }, { 4,-2030 }, + { 5,-1307 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-3048 }, { 0, 0 }, { 0, 0 }, { 19, 180 }, + { 20, 180 }, { 21, 180 }, { 22, 180 }, { 23, 180 }, { 24, 180 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30, 180 }, { 31, 180 }, { 32, 180 }, { 33,-3048 }, { 34,-3048 }, + { 35,-3048 }, { 36,-3048 }, { 37,-3000 }, { 0, 0 }, { 39, 180 }, + { 40, 180 }, { 41,-3048 }, { 42,-3048 }, { 43,-3048 }, { 0, 17 }, + { 0, 183 }, { 46,-3048 }, { 2,-2997 }, { 3,-2997 }, { 4,-2997 }, + { 5,-1985 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 0, 0 }, { 16,-3093 }, { 0, 0 }, { 0, 0 }, { 19,-3093 }, + { 20,-3093 }, { 21,-3093 }, { 22,-3093 }, { 23,-3093 }, { 24,-3093 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30,-3093 }, { 31,-3093 }, { 32,-3093 }, { 33,-3093 }, { 34,-3093 }, + { 35,-3093 }, { 36,-3093 }, { 37,-3045 }, { 0, 0 }, { 39,-3093 }, + { 40,-3093 }, { 41,-3093 }, { 42,-3093 }, { 43,-3093 }, { 0, 7 }, + { 0, 138 }, { 46,-3093 }, { 2,-2952 }, { 3,-2952 }, { 4,-2952 }, + { 5,-1940 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 12,-4145 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-3996 }, { 0, 0 }, { 0, 0 }, { 19,-3996 }, + + { 20,-3996 }, { 21,-3996 }, { 22,-3996 }, { 23,-3996 }, { 24,-3996 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30,-3996 }, { 31,-3996 }, { 32,-3996 }, { 33,-3996 }, { 34,-3996 }, + { 35,-3996 }, { 36,-3996 }, { 37,-3948 }, { 0, 0 }, { 39,-3996 }, + { 40,-3996 }, { 41,-3996 }, { 42,-3996 }, { 43,-3996 }, { 0, 20 }, + { 0, 93 }, { 46,-3996 }, { 2,-2385 }, { 3,-2385 }, { 4,-2385 }, + { 5,-1607 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-3375 }, { 0, 0 }, { 0, 0 }, { 19,-3375 }, + { 20,-3375 }, { 21,-3375 }, { 22,-3375 }, { 23,-3375 }, { 24,-3375 }, + + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 30,-3375 }, { 31,-3375 }, { 32,-3375 }, { 33,-3375 }, { 34,-3375 }, + { 35,-3375 }, { 36,-3375 }, { 37,-3327 }, { 0, 0 }, { 39,-3375 }, + { 40,-3375 }, { 41,-3375 }, { 42,-3375 }, { 43,-3375 }, { 0, 17 }, + { 0, 48 }, { 46,-3375 }, { 2,-2210 }, { 3,-2210 }, { 4,-2210 }, + { 5,-1487 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + { 0, 0 }, { 16,-3228 }, { 0, 0 }, { 0, 0 }, { 19,-3228 }, + { 20,-3228 }, { 21,-3228 }, { 22,-3228 }, { 23,-3228 }, { 24,-3228 }, + { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, + + { 30,-3228 }, { 31,-3228 }, { 32,-3228 }, { 33,-3228 }, { 34,-3228 }, + { 35,-3228 }, { 36,-3228 }, { 37,-3180 }, { 0, 0 }, { 39,-3228 }, + { 40,-3228 }, { 41,-3228 }, { 42,-3228 }, { 43,-3228 }, { 0, 0 }, + { 0, 0 }, { 46,-3228 }, { 47, 26 }, { 1, 0 }, }; + +static yyconst struct yy_trans_info *yy_start_state_list[3] = +{ + &yy_transition[1], + &yy_transition[3], + &yy_transition[51], + +} ; + +static yyconst flex_int32_t yy_ec[256] = +{ 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 4, 5, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 6, 7, 8, 9, 10, 1, 11, 12, + 1, 13, 14, 15, 16, 17, 18, 19, 20, 20, + 20, 21, 22, 23, 24, 20, 20, 25, 1, 26, + 27, 28, 1, 29, 30, 30, 30, 30, 31, 32, + 33, 33, 33, 33, 33, 33, 33, 34, 35, 33, + 33, 33, 33, 36, 33, 33, 33, 33, 33, 33, + 1, 37, 1, 38, 33, 1, 30, 30, 30, 30, + + 39, 40, 33, 33, 33, 33, 33, 33, 33, 41, + 42, 33, 33, 33, 33, 43, 33, 33, 33, 33, + 33, 33, 1, 44, 1, 45, 1, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, + 46, 46, 46, 46, 46 +} ; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +#define YY_NO_INPUT 1 +enum css_token { + SPACE = 1, + INCLUDES, + DASHMATCH, + PREFIXMATCH, + SUFFIXMATCH, + SUBSTRINGMATCH, + IDENT, + STRING, + FUNCTION, + NUMBER, + HASH, + PLUS, + GREATER, + COMMA, + TILDE, + NOT, + ATKEYWORD, + INVALID, + PERCENTAGE, + DIMENSION, + CDO, + CDC +}; + +#define INITIAL 0 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +/* Holds the entire state of the reentrant scanner. */ +struct yyguts_t +{ + + /* User-defined. Not touched by flex. */ + YY_EXTRA_TYPE yyextra_r; + + /* The rest are the same as the globals declared in the non-reentrant scanner. */ + FILE *yyin_r, *yyout_r; + size_t yy_buffer_stack_top; /**< index of top of stack. */ + size_t yy_buffer_stack_max; /**< capacity of stack. */ + YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ + char yy_hold_char; + yy_size_t yy_n_chars; + yy_size_t yyleng_r; + char *yy_c_buf_p; + int yy_init; + int yy_start; + int yy_did_buffer_switch_on_eof; + int yy_start_stack_ptr; + int yy_start_stack_depth; + int *yy_start_stack; + yy_state_type yy_last_accepting_state; + char* yy_last_accepting_cpos; + + int yylineno_r; + int yy_flex_debug_r; + + char *yytext_r; + int yy_more_flag; + int yy_more_len; + +}; /* end struct yyguts_t */ + +static int yy_init_globals (yyscan_t yyscanner ); + +int csslex_init (yyscan_t* scanner); + +int csslex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int csslex_destroy (yyscan_t yyscanner ); + +int cssget_debug (yyscan_t yyscanner ); + +void cssset_debug (int debug_flag ,yyscan_t yyscanner ); + +YY_EXTRA_TYPE cssget_extra (yyscan_t yyscanner ); + +void cssset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); + +FILE *cssget_in (yyscan_t yyscanner ); + +void cssset_in (FILE * in_str ,yyscan_t yyscanner ); + +FILE *cssget_out (yyscan_t yyscanner ); + +void cssset_out (FILE * out_str ,yyscan_t yyscanner ); + +yy_size_t cssget_leng (yyscan_t yyscanner ); + +char *cssget_text (yyscan_t yyscanner ); + +int cssget_lineno (yyscan_t yyscanner ); + +void cssset_lineno (int line_number ,yyscan_t yyscanner ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int csswrap (yyscan_t yyscanner ); +#else +extern int csswrap (yyscan_t yyscanner ); +#endif +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner); +#endif + +#ifndef YY_NO_INPUT + +#ifdef __cplusplus +static int yyinput (yyscan_t yyscanner ); +#else +static int input (yyscan_t yyscanner ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ +errno=0; \ +while ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \ +{ \ +if( errno != EINTR) \ +{ \ +YY_FATAL_ERROR( "input in flex scanner failed" ); \ +break; \ +} \ +errno=0; \ +clearerr(yyin); \ +}\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int csslex (yyscan_t yyscanner); + +#define YY_DECL int csslex (yyscan_t yyscanner) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ +YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if ( !yyg->yy_init ) + { + yyg->yy_init = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yyg->yy_start ) + yyg->yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + cssensure_buffer_stack (yyscanner); + YY_CURRENT_BUFFER_LVALUE = + css_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); + } + + css_load_buffer_state(yyscanner ); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yyg->yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yyg->yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start_state_list[yyg->yy_start]; + yy_match: + { + register yyconst struct yy_trans_info *yy_trans_info; + + register YY_CHAR yy_c; + + for ( yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + (yy_trans_info = &yy_current_state[(unsigned int) yy_c])-> + yy_verify == yy_c; + yy_c = yy_ec[YY_SC_TO_UI(*++yy_cp)] ) + { + yy_current_state += yy_trans_info->yy_nxt; + + if ( yy_current_state[-1].yy_nxt ) + { + yyg->yy_last_accepting_state = yy_current_state; + yyg->yy_last_accepting_cpos = yy_cp; + } + } + } + + yy_find_action: + yy_act = yy_current_state[-1].yy_nxt; + + YY_DO_BEFORE_ACTION; + + do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yyg->yy_hold_char; + yy_cp = yyg->yy_last_accepting_cpos + 1; + yy_current_state = yyg->yy_last_accepting_state; + goto yy_find_action; + + case 1: + /* rule 1 can match eol */ + YY_RULE_SETUP + return SPACE; + YY_BREAK + case 2: + YY_RULE_SETUP + return INCLUDES; + YY_BREAK + case 3: + YY_RULE_SETUP + return DASHMATCH; + YY_BREAK + case 4: + YY_RULE_SETUP + return PREFIXMATCH; + YY_BREAK + case 5: + YY_RULE_SETUP + return SUFFIXMATCH; + YY_BREAK + case 6: + YY_RULE_SETUP + return SUBSTRINGMATCH; + YY_BREAK + case 7: + /* rule 7 can match eol */ + YY_RULE_SETUP + return IDENT; + YY_BREAK + case 8: + /* rule 8 can match eol */ + YY_RULE_SETUP + return STRING; + YY_BREAK + case 9: + /* rule 9 can match eol */ + YY_RULE_SETUP + return FUNCTION; + YY_BREAK + case 10: + YY_RULE_SETUP + return NUMBER; + YY_BREAK + case 11: + /* rule 11 can match eol */ + YY_RULE_SETUP + return HASH; + YY_BREAK + case 12: + /* rule 12 can match eol */ + YY_RULE_SETUP + return PLUS; + YY_BREAK + case 13: + /* rule 13 can match eol */ + YY_RULE_SETUP + return GREATER; + YY_BREAK + case 14: + /* rule 14 can match eol */ + YY_RULE_SETUP + return COMMA; + YY_BREAK + case 15: + /* rule 15 can match eol */ + YY_RULE_SETUP + return TILDE; + YY_BREAK + case 16: + /* rule 16 can match eol */ + YY_RULE_SETUP + return NOT; + YY_BREAK + case 17: + /* rule 17 can match eol */ + YY_RULE_SETUP + return ATKEYWORD; + YY_BREAK + case 18: + /* rule 18 can match eol */ + YY_RULE_SETUP + return INVALID; + YY_BREAK + case 19: + YY_RULE_SETUP + return PERCENTAGE; + YY_BREAK + case 20: + /* rule 20 can match eol */ + YY_RULE_SETUP + return DIMENSION; + YY_BREAK + case 21: + YY_RULE_SETUP + return CDO; + YY_BREAK + case 22: + YY_RULE_SETUP + return CDC; + YY_BREAK + case 23: + /* rule 23 can match eol */ + YY_RULE_SETUP + /* ignore comments */ + YY_BREAK + case 24: + YY_RULE_SETUP + return *yytext; + YY_BREAK + case 25: + YY_RULE_SETUP + YY_FATAL_ERROR( "flex scanner jammed" ); + YY_BREAK + case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yyg->yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * csslex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( yyscanner ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); + + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yyg->yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yyg->yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( yyscanner ) ) + { + case EOB_ACT_END_OF_FILE: + { + yyg->yy_did_buffer_switch_on_eof = 0; + + if ( csswrap(yyscanner ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yyg->yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yyg->yy_c_buf_p = + yyg->yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( yyscanner ); + + yy_cp = yyg->yy_c_buf_p; + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yyg->yy_c_buf_p = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; + + yy_current_state = yy_get_previous_state( yyscanner ); + + yy_cp = yyg->yy_c_buf_p; + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ +} /* end of csslex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + register char *source = yyg->yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; + + else + { + yy_size_t num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER; + + int yy_c_buf_p_offset = + (int) (yyg->yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + yy_size_t new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + cssrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + yyg->yy_n_chars, num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + if ( yyg->yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + cssrestart(yyin ,yyscanner); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) cssrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + } + + yyg->yy_n_chars += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state (yyscan_t yyscanner) +{ + register yy_state_type yy_current_state; + register char *yy_cp; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + yy_current_state = yy_start_state_list[yyg->yy_start]; + + for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) + { + yy_current_state += yy_current_state[(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)].yy_nxt; + if ( yy_current_state[-1].yy_nxt ) + { + yyg->yy_last_accepting_state = yy_current_state; + yyg->yy_last_accepting_cpos = yy_cp; + } + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ +static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) +{ + register int yy_is_jam; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ + register char *yy_cp = yyg->yy_c_buf_p; + + register int yy_c = 1; + register yyconst struct yy_trans_info *yy_trans_info; + + yy_trans_info = &yy_current_state[(unsigned int) yy_c]; + yy_current_state += yy_trans_info->yy_nxt; + yy_is_jam = (yy_trans_info->yy_verify != yy_c); + + if ( ! yy_is_jam ) + { + if ( yy_current_state[-1].yy_nxt ) + { + yyg->yy_last_accepting_state = yy_current_state; + yyg->yy_last_accepting_cpos = yy_cp; + } + } + + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput (yyscan_t yyscanner) +#else +static int input (yyscan_t yyscanner) +#endif + +{ + int c; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + *yyg->yy_c_buf_p = yyg->yy_hold_char; + + if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) + /* This was really a NUL. */ + *yyg->yy_c_buf_p = '\0'; + + else + { /* need more input */ + yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr; + ++yyg->yy_c_buf_p; + + switch ( yy_get_next_buffer( yyscanner ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + cssrestart(yyin ,yyscanner); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( csswrap(yyscanner ) ) + return 0; + + if ( ! yyg->yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(yyscanner); +#else + return input(yyscanner); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yyg->yy_c_buf_p = yyg->yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */ + *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ + yyg->yy_hold_char = *++yyg->yy_c_buf_p; + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * @param yyscanner The scanner object. + * @note This function does not reset the start condition to @c INITIAL . + */ +void cssrestart (FILE * input_file , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if ( ! YY_CURRENT_BUFFER ){ + cssensure_buffer_stack (yyscanner); + YY_CURRENT_BUFFER_LVALUE = + css_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); + } + + css_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner); + css_load_buffer_state(yyscanner ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * @param yyscanner The scanner object. + */ +void css_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* TODO. We should be able to replace this entire function body + * with + * csspop_buffer_state(); + * csspush_buffer_state(new_buffer); + */ + cssensure_buffer_stack (yyscanner); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *yyg->yy_c_buf_p = yyg->yy_hold_char; + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + css_load_buffer_state(yyscanner ); + + /* We don't actually know whether we did this switch during + * EOF (csswrap()) processing, but the only time this flag + * is looked at is after csswrap() is called, so it's safe + * to go ahead and always set it. + */ + yyg->yy_did_buffer_switch_on_eof = 1; +} + +static void css_load_buffer_state (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + yyg->yy_hold_char = *yyg->yy_c_buf_p; +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * @param yyscanner The scanner object. + * @return the allocated buffer state. + */ +YY_BUFFER_STATE css_create_buffer (FILE * file, int size , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) cssalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in css_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) cssalloc(b->yy_buf_size + 2 ,yyscanner ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in css_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + css_init_buffer(b,file ,yyscanner); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with css_create_buffer() + * @param yyscanner The scanner object. + */ +void css_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + cssfree((void *) b->yy_ch_buf ,yyscanner ); + + cssfree((void *) b ,yyscanner ); +} + +#ifndef __cplusplus +extern int isatty (int ); +#endif /* __cplusplus */ + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a cssrestart() or at EOF. + */ +static void css_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) + +{ + int oerrno = errno; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + css_flush_buffer(b ,yyscanner); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then css_init_buffer was _probably_ + * called from cssrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * @param yyscanner The scanner object. + */ +void css_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + css_load_buffer_state(yyscanner ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * @param yyscanner The scanner object. + */ +void csspush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if (new_buffer == NULL) + return; + + cssensure_buffer_stack(yyscanner); + + /* This block is copied from css_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *yyg->yy_c_buf_p = yyg->yy_hold_char; + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + yyg->yy_buffer_stack_top++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from css_switch_to_buffer. */ + css_load_buffer_state(yyscanner ); + yyg->yy_did_buffer_switch_on_eof = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * @param yyscanner The scanner object. + */ +void csspop_buffer_state (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if (!YY_CURRENT_BUFFER) + return; + + css_delete_buffer(YY_CURRENT_BUFFER ,yyscanner); + YY_CURRENT_BUFFER_LVALUE = NULL; + if (yyg->yy_buffer_stack_top > 0) + --yyg->yy_buffer_stack_top; + + if (YY_CURRENT_BUFFER) { + css_load_buffer_state(yyscanner ); + yyg->yy_did_buffer_switch_on_eof = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void cssensure_buffer_stack (yyscan_t yyscanner) +{ + yy_size_t num_to_alloc; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (!yyg->yy_buffer_stack) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; + yyg->yy_buffer_stack = (struct yy_buffer_state**)cssalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + , yyscanner); + if ( ! yyg->yy_buffer_stack ) + YY_FATAL_ERROR( "out of dynamic memory in cssensure_buffer_stack()" ); + + memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + yyg->yy_buffer_stack_max = num_to_alloc; + yyg->yy_buffer_stack_top = 0; + return; + } + + if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + int grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = yyg->yy_buffer_stack_max + grow_size; + yyg->yy_buffer_stack = (struct yy_buffer_state**)cssrealloc + (yyg->yy_buffer_stack, + num_to_alloc * sizeof(struct yy_buffer_state*) + , yyscanner); + if ( ! yyg->yy_buffer_stack ) + YY_FATAL_ERROR( "out of dynamic memory in cssensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); + yyg->yy_buffer_stack_max = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE css_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) cssalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in css_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + css_switch_to_buffer(b ,yyscanner ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to csslex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * css_scan_bytes() instead. + */ +YY_BUFFER_STATE css_scan_string (yyconst char * yystr , yyscan_t yyscanner) +{ + + return css_scan_bytes(yystr,strlen(yystr) ,yyscanner); +} + +/** Setup the input buffer state to scan the given bytes. The next call to csslex() will + * scan from a @e copy of @a bytes. + * @param bytes the byte buffer to scan + * @param len the number of bytes in the buffer pointed to by @a bytes. + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE css_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n, i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = _yybytes_len + 2; + buf = (char *) cssalloc(n ,yyscanner ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in css_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = css_scan_buffer(buf,n ,yyscanner); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in css_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner) +{ + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ +do \ +{ \ +/* Undo effects of setting up yytext. */ \ +int yyless_macro_arg = (n); \ +YY_LESS_LINENO(yyless_macro_arg);\ +yytext[yyleng] = yyg->yy_hold_char; \ +yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ +yyg->yy_hold_char = *yyg->yy_c_buf_p; \ +*yyg->yy_c_buf_p = '\0'; \ +yyleng = yyless_macro_arg; \ +} \ +while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the user-defined data for this scanner. + * @param yyscanner The scanner object. + */ +YY_EXTRA_TYPE cssget_extra (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyextra; +} + +/** Get the current line number. + * @param yyscanner The scanner object. + */ +int cssget_lineno (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (! YY_CURRENT_BUFFER) + return 0; + + return yylineno; +} + +/** Get the current column number. + * @param yyscanner The scanner object. + */ +int cssget_column (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (! YY_CURRENT_BUFFER) + return 0; + + return yycolumn; +} + +/** Get the input stream. + * @param yyscanner The scanner object. + */ +FILE *cssget_in (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyin; +} + +/** Get the output stream. + * @param yyscanner The scanner object. + */ +FILE *cssget_out (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyout; +} + +/** Get the length of the current token. + * @param yyscanner The scanner object. + */ +yy_size_t cssget_leng (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyleng; +} + +/** Get the current token. + * @param yyscanner The scanner object. + */ + +char *cssget_text (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yytext; +} + +/** Set the user-defined data. This data is never touched by the scanner. + * @param user_defined The data to be associated with this scanner. + * @param yyscanner The scanner object. + */ +void cssset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyextra = user_defined ; +} + +/** Set the current line number. + * @param line_number + * @param yyscanner The scanner object. + */ +void cssset_lineno (int line_number , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* lineno is only valid if an input buffer exists. */ + if (! YY_CURRENT_BUFFER ) + yy_fatal_error( "cssset_lineno called with no buffer" , yyscanner); + + yylineno = line_number; +} + +/** Set the current column. + * @param line_number + * @param yyscanner The scanner object. + */ +void cssset_column (int column_no , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* column is only valid if an input buffer exists. */ + if (! YY_CURRENT_BUFFER ) + yy_fatal_error( "cssset_column called with no buffer" , yyscanner); + + yycolumn = column_no; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param in_str A readable stream. + * @param yyscanner The scanner object. + * @see css_switch_to_buffer + */ +void cssset_in (FILE * in_str , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyin = in_str ; +} + +void cssset_out (FILE * out_str , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyout = out_str ; +} + +int cssget_debug (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yy_flex_debug; +} + +void cssset_debug (int bdebug , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yy_flex_debug = bdebug ; +} + +/* Accessor methods for yylval and yylloc */ + +/* User-visible API */ + +/* csslex_init is special because it creates the scanner itself, so it is + * the ONLY reentrant function that doesn't take the scanner as the last argument. + * That's why we explicitly handle the declaration, instead of using our macros. + */ + +int csslex_init(yyscan_t* ptr_yy_globals) + +{ + if (ptr_yy_globals == NULL){ + errno = EINVAL; + return 1; + } + + *ptr_yy_globals = (yyscan_t) cssalloc ( sizeof( struct yyguts_t ), NULL ); + + if (*ptr_yy_globals == NULL){ + errno = ENOMEM; + return 1; + } + + /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ + memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); + + return yy_init_globals ( *ptr_yy_globals ); +} + +/* csslex_init_extra has the same functionality as csslex_init, but follows the + * convention of taking the scanner as the last argument. Note however, that + * this is a *pointer* to a scanner, as it will be allocated by this call (and + * is the reason, too, why this function also must handle its own declaration). + * The user defined value in the first argument will be available to cssalloc in + * the yyextra field. + */ + +int csslex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals ) + +{ + struct yyguts_t dummy_yyguts; + + cssset_extra (yy_user_defined, &dummy_yyguts); + + if (ptr_yy_globals == NULL){ + errno = EINVAL; + return 1; + } + + *ptr_yy_globals = (yyscan_t) cssalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); + + if (*ptr_yy_globals == NULL){ + errno = ENOMEM; + return 1; + } + + /* By setting to 0xAA, we expose bugs in + yy_init_globals. Leave at 0x00 for releases. */ + memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); + + cssset_extra (yy_user_defined, *ptr_yy_globals); + + return yy_init_globals ( *ptr_yy_globals ); +} + +static int yy_init_globals (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from csslex_destroy(), so don't allocate here. + */ + + yyg->yy_buffer_stack = 0; + yyg->yy_buffer_stack_top = 0; + yyg->yy_buffer_stack_max = 0; + yyg->yy_c_buf_p = (char *) 0; + yyg->yy_init = 0; + yyg->yy_start = 0; + + yyg->yy_start_stack_ptr = 0; + yyg->yy_start_stack_depth = 0; + yyg->yy_start_stack = NULL; + + /* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = (FILE *) 0; + yyout = (FILE *) 0; +#endif + + /* For future reference: Set errno on error, since we are called by + * csslex_init() + */ + return 0; +} + +/* csslex_destroy is for both reentrant and non-reentrant scanners. */ +int csslex_destroy (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + css_delete_buffer(YY_CURRENT_BUFFER ,yyscanner ); + YY_CURRENT_BUFFER_LVALUE = NULL; + csspop_buffer_state(yyscanner); + } + + /* Destroy the stack itself. */ + cssfree(yyg->yy_buffer_stack ,yyscanner); + yyg->yy_buffer_stack = NULL; + + /* Destroy the start condition stack. */ + cssfree(yyg->yy_start_stack ,yyscanner ); + yyg->yy_start_stack = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * csslex() is called, initialization will occur. */ + yy_init_globals( yyscanner); + + /* Destroy the main struct (reentrant only). */ + cssfree ( yyscanner , yyscanner ); + yyscanner = NULL; + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner) +{ + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) +{ + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *cssalloc (yy_size_t size , yyscan_t yyscanner) +{ + return (void *) malloc( size ); +} + +void *cssrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) +{ + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); +} + +void cssfree (void * ptr , yyscan_t yyscanner) +{ + free( (char *) ptr ); /* see cssrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" diff --git a/HTMLKit/CSSLexer.h b/HTMLKit/CSSLexer.h new file mode 100644 index 0000000..7e85d1d --- /dev/null +++ b/HTMLKit/CSSLexer.h @@ -0,0 +1,329 @@ +#ifndef cssHEADER_H +#define cssHEADER_H 1 +#define cssIN_HEADER 1 + +#line 6 "CSSLexer.h" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 +#define YY_FLEX_SUBMINOR_VERSION 35 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +typedef uint64_t flex_uint64_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; +#endif /* ! C99 */ + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#endif /* ! FLEXINT_H */ + +#ifdef __cplusplus + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +/* C99 requires __STDC__ to be defined as 1. */ +#if defined (__STDC__) + +#define YY_USE_CONST + +#endif /* defined (__STDC__) */ +#endif /* ! __cplusplus */ + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + +/* An opaque pointer. */ +#ifndef YY_TYPEDEF_YY_SCANNER_T +#define YY_TYPEDEF_YY_SCANNER_T +typedef void* yyscan_t; +#endif + +/* For convenience, these vars (plus the bison vars far below) + are macros in the reentrant scanner. */ +#define yyin yyg->yyin_r +#define yyout yyg->yyout_r +#define yyextra yyg->yyextra_r +#define yyleng yyg->yyleng_r +#define yytext yyg->yytext_r +#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) +#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) +#define yy_flex_debug yyg->yy_flex_debug_r + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#define YY_BUF_SIZE 16384 +#endif + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state +{ + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + yy_size_t yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +}; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +void cssrestart (FILE *input_file ,yyscan_t yyscanner ); +void css_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); +YY_BUFFER_STATE css_create_buffer (FILE *file,int size ,yyscan_t yyscanner ); +void css_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); +void css_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); +void csspush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); +void csspop_buffer_state (yyscan_t yyscanner ); + +YY_BUFFER_STATE css_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); +YY_BUFFER_STATE css_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); +YY_BUFFER_STATE css_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner ); + +void *cssalloc (yy_size_t ,yyscan_t yyscanner ); +void *cssrealloc (void *,yy_size_t ,yyscan_t yyscanner ); +void cssfree (void * ,yyscan_t yyscanner ); + +#define csswrap(n) 1 +#define YY_SKIP_YYWRAP + +#define yytext_ptr yytext_r + +#ifdef YY_HEADER_EXPORT_START_CONDITIONS +#define INITIAL 0 + +#endif + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +int csslex_init (yyscan_t* scanner); + +int csslex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int csslex_destroy (yyscan_t yyscanner ); + +int cssget_debug (yyscan_t yyscanner ); + +void cssset_debug (int debug_flag ,yyscan_t yyscanner ); + +YY_EXTRA_TYPE cssget_extra (yyscan_t yyscanner ); + +void cssset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); + +FILE *cssget_in (yyscan_t yyscanner ); + +void cssset_in (FILE * in_str ,yyscan_t yyscanner ); + +FILE *cssget_out (yyscan_t yyscanner ); + +void cssset_out (FILE * out_str ,yyscan_t yyscanner ); + +yy_size_t cssget_leng (yyscan_t yyscanner ); + +char *cssget_text (yyscan_t yyscanner ); + +int cssget_lineno (yyscan_t yyscanner ); + +void cssset_lineno (int line_number ,yyscan_t yyscanner ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int csswrap (yyscan_t yyscanner ); +#else +extern int csswrap (yyscan_t yyscanner ); +#endif +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner); +#endif + +#ifndef YY_NO_INPUT + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int csslex (yyscan_t yyscanner); + +#define YY_DECL int csslex (yyscan_t yyscanner) +#endif /* !YY_DECL */ + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +#undef YY_NEW_FILE +#undef YY_FLUSH_BUFFER +#undef yy_set_bol +#undef yy_new_buffer +#undef yy_set_interactive +#undef YY_DO_BEFORE_ACTION + +#ifdef YY_DECL_IS_OURS +#undef YY_DECL_IS_OURS +#undef YY_DECL +#endif + +#line 328 "CSSLexer.h" +#undef cssIN_HEADER +#endif /* cssHEADER_H */ diff --git a/HTMLKit/CSSTokenizer.h b/HTMLKit/CSSTokenizer.h new file mode 100644 index 0000000..2913093 --- /dev/null +++ b/HTMLKit/CSSTokenizer.h @@ -0,0 +1,44 @@ +// +// CSSTokenizer.h +// HTMLKit +// +// Created by Iska on 07/05/15. +// Copyright (c) 2015 BrainCookie. All rights reserved. +// + +#import + +typedef NS_ENUM(int, CSSToken) +{ + CSSTokenSpace = 1, + CSSTokenIncludes, + CSSTokenDashMatch, + CSSTokenPrefixMatch, + CSSTokenSuffixMatch, + CSSTokenSubstringMatch, + CSSTokenIdent, + CSSTokenString, + CSSTokenFunction, + CSSTokenNumber, + CSSTokenHash, + CSSTokenPlus, + CSSTokenGreater, + CSSTokenComma, + CSSTokenTilde, + CSSTokenNot, + CSSTokenAtKeyword, + CSSTokenInvalid, + CSSTokenPercentage, + CSSTokenDimension, + CSSTokenCDO, + CSSTokenCDC +}; + +@interface CSSTokenizer : NSObject + +- (instancetype)initWithString:(NSString *)string; + +- (CSSToken)nextToken; +- (NSString *)currentTokenText; + +@end diff --git a/HTMLKit/CSSTokenizer.m b/HTMLKit/CSSTokenizer.m new file mode 100644 index 0000000..edb87b6 --- /dev/null +++ b/HTMLKit/CSSTokenizer.m @@ -0,0 +1,56 @@ +// +// CSSTokenizer.m +// HTMLKit +// +// Created by Iska on 07/05/15. +// Copyright (c) 2015 BrainCookie. All rights reserved. +// + +#import "CSSTokenizer.h" +#import "CSSLexer.h" + +@interface CSSTokenizer () +{ + yyscan_t _scanner; + CSSToken _currentToken; + size_t _currentPosition; + size_t _tokenPosition; +} +@end + +@implementation CSSTokenizer + +- (instancetype)initWithString:(NSString *)string +{ + self = [super init]; + if (self) { + csslex_init(&_scanner); + css_scan_string(string.UTF8String, _scanner); + _currentToken = 0; + _currentPosition = 0; + _tokenPosition = 0; + } + return self; +} + +- (CSSToken)nextToken +{ + _currentToken = csslex(_scanner); + _tokenPosition += _currentPosition; + _currentPosition += cssget_leng(_scanner); + + return _currentToken; +} + +- (NSString *)currentTokenText +{ + if (_currentToken == 0) { + return nil; + } + + char *content = NULL; + content = cssget_text(_scanner); + return [NSString stringWithCString:content encoding:NSUTF8StringEncoding]; +} + +@end