Version in base suite: 4.10.0-5.1+etch2 Version in overlay suite: (not present) Base version: mapserver_4.10.0-5.1+etch2 Target version: mapserver_4.10.0-5.1+etch4 Base file: /org/ftp.debian.org/ftp/pool/main/m/mapserver/mapserver_4.10.0-5.1+etch2.dsc Target file: /org/ftp.debian.org/queue/o-p-u-new/mapserver_4.10.0-5.1+etch4.dsc debian/patches/82_CVE-2009-0839.dpatch | 138 debian/patches/83_CVE-2009-0840-CVE-2009-2281.dpatch | 88 debian/patches/84_CVE-2009-0841.dpatch | 32 debian/patches/85_CVE-2009-0842.dpatch | 269 debian/patches/86_CVE-2009-0843.dpatch | 22 debian/patches/87_urlpatch.dpatch | 5597 +++++++++++++++++++ mapserver-4.10.0/debian/changelog | 17 mapserver-4.10.0/debian/patches/00list | 6 8 files changed, 6169 insertions(+) diff -u mapserver-4.10.0/debian/changelog mapserver-4.10.0/debian/changelog --- mapserver-4.10.0/debian/changelog +++ mapserver-4.10.0/debian/changelog @@ -1,3 +1,20 @@ +mapserver (4.10.0-5.1+etch4) oldstable-security; urgency=high + + * Fix paths specified in url vulnerabilities. + [http://trac.osgeo.org/mapserver/ticket/1836] + + -- Alan Boudreault Fri, 24 Jul 2009 14:06:34 -0400 + +mapserver (4.10.0-5.1+etch3) oldstable-security; urgency=high + + * Fix stack-based buffer overflow (CVE-2009-0839). + * Fix heap-based buffer underflow (CVE-2009-0840, CVE-2009-2281). + * Fix relative file path writing (CVE-2009-0841). + * Fix file data leakage (CVE-2009-0842). + * Fix file existence leakage (CVE-2009-0843). + + -- Alan Boudreault Tue, 14 Jul 2009 10:00:12 -0400 + mapserver (4.10.0-5.1+etch2) stable-security; urgency=high * Non-maintainer upload by the Security Team. diff -u mapserver-4.10.0/debian/patches/00list mapserver-4.10.0/debian/patches/00list --- mapserver-4.10.0/debian/patches/00list +++ mapserver-4.10.0/debian/patches/00list @@ -5,0 +6,6 @@ +82_CVE-2009-0839 +83_CVE-2009-0840-CVE-2009-2281 +84_CVE-2009-0841 +85_CVE-2009-0842 +86_CVE-2009-0843 +87_urlpatch only in patch2: unchanged: --- mapserver-4.10.0.orig/debian/patches/82_CVE-2009-0839.dpatch +++ mapserver-4.10.0/debian/patches/82_CVE-2009-0839.dpatch @@ -0,0 +1,138 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## 82_CVE-2009-0839.dpatch by Alan Boudreault +## +## All lines beginning with `## DP:' are a description of the patch. +## DP: No description. + +@DPATCH@ +diff -urNad mapserver-4.10.0~/mapserv.c mapserver-4.10.0/mapserv.c +--- mapserver-4.10.0~/mapserv.c 2006-08-28 21:56:53.000000000 -0400 ++++ mapserver-4.10.0/mapserv.c 2009-07-14 13:06:22.521857713 -0400 +@@ -278,8 +278,21 @@ + } else { + if(getenv(msObj->request->ParamValues[i])) /* an environment references the actual file to use */ + map = msLoadMap(getenv(msObj->request->ParamValues[i]), NULL); +- else ++ else { ++ /* by here we know the request isn't for something in an environment variable */ ++ if(getenv("MS_MAP_NO_PATH")) { ++ msSetError(MS_WEBERR, "Mapfile not found in environment variables and this server is not configured for full paths.", "loadMap()"); ++ writeError(); ++ } ++ ++ if(getenv("MS_MAP_PATTERN") && msEvalRegex(getenv("MS_MAP_PATTERN"), msObj->request->ParamValues[i]) != MS_TRUE) { ++ msSetError(MS_WEBERR, "Parameter 'map' value fails to validate.", "loadMap()"); ++ writeError(); ++ } ++ ++ /* ok to try to load now */ + map = msLoadMap(msObj->request->ParamValues[i], NULL); ++ } + } + + if(!map) writeError(); +@@ -1238,7 +1255,7 @@ + loadForm(); + + if(msObj->SaveMap) { +- sprintf(buffer, "%s%s%s.map", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id); ++ snprintf(buffer, sizeof(buffer), "%s%s%s.map", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id); + if(msSaveMap(msObj->Map, buffer) == -1) writeError(); + } + +@@ -1595,7 +1595,7 @@ + if (msReturnTemplateQuery(msObj, msObj->Map->web.queryformat, NULL) != MS_SUCCESS) writeError(); + + if(msObj->SaveQuery) { +- sprintf(buffer, "%s%s%s%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_QUERY_EXTENSION); ++ snprintf(buffer, sizeof(buffer), "%s%s%s%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_QUERY_EXTENSION); + if((status = msSaveQuery(msObj->Map, buffer)) != MS_SUCCESS) return status; + } + } +diff -urNad mapserver-4.10.0~/maptemplate.c mapserver-4.10.0/maptemplate.c +--- mapserver-4.10.0~/maptemplate.c 2006-09-29 16:52:05.000000000 -0400 ++++ mapserver-4.10.0/maptemplate.c 2009-07-14 13:06:22.521857713 -0400 +@@ -293,7 +307,7 @@ + img = msDrawQueryMap(msObj->Map); + if(!img) return MS_FAILURE; + +- snprintf(buffer, 1024, "%s%s%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); ++ snprintf(buffer, sizeof(buffer), "%s%s%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); + + status = msSaveImage(msObj->Map, img, buffer); + if(status != MS_SUCCESS) return status; +@@ -304,7 +318,7 @@ + { + img = msDrawLegend(msObj->Map, MS_FALSE); + if(!img) return MS_FAILURE; +- snprintf(buffer, 1024, "%s%sleg%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); ++ snprintf(buffer, sizeof(buffer), "%s%sleg%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); + status = msSaveImage(msObj->Map, img, buffer); + if(status != MS_SUCCESS) return status; + msFreeImage(img); +@@ -314,7 +328,7 @@ + { + img = msDrawScalebar(msObj->Map); + if(!img) return MS_FAILURE; +- snprintf(buffer, 1024, "%s%ssb%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); ++ snprintf(buffer, sizeof(buffer), "%s%ssb%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); + status = msSaveImage( msObj->Map, img, buffer); + if(status != MS_SUCCESS) return status; + msFreeImage(img); +@@ -324,7 +338,7 @@ + { + img = msDrawReferenceMap(msObj->Map); + if(!img) return MS_FAILURE; +- snprintf(buffer, 1024, "%s%sref%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); ++ snprintf(buffer, sizeof(buffer), "%s%sref%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); + status = msSaveImage(msObj->Map, img, buffer); + if(status != MS_SUCCESS) return status; + msFreeImage(img); +@@ -3411,7 +3446,7 @@ + image = msDrawMap(msObj->Map); + + if(image) { +- sprintf(buffer, "%s%s%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); ++ snprintf(buffer, sizeof(buffer), "%s%s%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); + + if(msSaveImage(msObj->Map, image, buffer) != MS_SUCCESS && bReturnOnError) { + msFreeImage(image); +@@ -3429,7 +3464,7 @@ + imageObj *image = NULL; + image = msDrawLegend(msObj->Map, MS_FALSE); + if(image) { +- sprintf(buffer, "%s%sleg%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); ++ snprintf(buffer, sizeof(buffer), "%s%sleg%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); + + if(msSaveImage(msObj->Map, image, buffer) != MS_SUCCESS && bReturnOnError) { + msFreeImage(image); +@@ -3447,7 +3482,7 @@ + imageObj *image = NULL; + image = msDrawScalebar(msObj->Map); + if(image) { +- sprintf(buffer, "%s%ssb%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); ++ snprintf(buffer, sizeof(buffer), "%s%ssb%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); + if(msSaveImage(msObj->Map, image, buffer) != MS_SUCCESS && bReturnOnError) { + msFreeImage(image); + return MS_FALSE; +@@ -3464,7 +3499,7 @@ + imageObj *image; + image = msDrawReferenceMap(msObj->Map); + if(image) { +- sprintf(buffer, "%s%sref%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); ++ snprintf(buffer, sizeof(buffer), "%s%sref%s.%s", msObj->Map->web.imagepath, msObj->Map->name, msObj->Id, MS_IMAGE_EXTENSION(msObj->Map->outputformat)); + if(msSaveImage(msObj->Map, image, buffer) != MS_SUCCESS && bReturnOnError) { + msFreeImage(image); + return MS_FALSE; +diff -urNad mapserver-4.10.0~/maptemplate.h mapserver-4.10.0/maptemplate.h +--- mapserver-4.10.0~/maptemplate.h 2005-06-14 12:03:35.000000000 -0400 ++++ mapserver-4.10.0/maptemplate.h 2009-07-14 13:06:22.521857713 -0400 +@@ -45,7 +45,7 @@ + #include "map.h" + #include "maphash.h" + +-#define IDSIZE 128 ++#define IDSIZE 64 + #define TEMPLATE_TYPE(s) (((strncmp("http://", s, 7) == 0) || (strncmp("https://", s, 8) == 0) || (strncmp("ftp://", s, 6)) == 0) ? MS_URL : MS_FILE) + #define MAXZOOM 25 + #define MINZOOM -25 only in patch2: unchanged: --- mapserver-4.10.0.orig/debian/patches/86_CVE-2009-0843.dpatch +++ mapserver-4.10.0/debian/patches/86_CVE-2009-0843.dpatch @@ -0,0 +1,22 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## 86_CVE-2009-0843.dpatch by Alan Boudreault +## +## All lines beginning with `## DP:' are a description of the patch. +## DP: No description. + +@DPATCH@ +diff -urNad mapserver-4.10.0~/mapquery.c mapserver-4.10.0/mapquery.c +--- mapserver-4.10.0~/mapquery.c 2006-02-01 20:00:11.000000000 -0500 ++++ mapserver-4.10.0/mapquery.c 2009-07-14 13:12:34.260614243 -0400 +@@ -153,6 +153,11 @@ + return(MS_FAILURE); + } + ++ /* ++ ** Make sure the file at least has the right extension. ++ */ ++ if(msEvalRegex("\\.qy$", filename) != MS_TRUE) return MS_FAILURE; ++ + stream = fopen(filename, "rb"); + if(!stream) { + msSetError(MS_IOERR, "(%s)", "msLoadQuery()", filename); only in patch2: unchanged: --- mapserver-4.10.0.orig/debian/patches/85_CVE-2009-0842.dpatch +++ mapserver-4.10.0/debian/patches/85_CVE-2009-0842.dpatch @@ -0,0 +1,269 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## 85_CVE-2009-0842.dpatch by Alan Boudreault +## +## All lines beginning with `## DP:' are a description of the patch. +## DP: No description. + +@DPATCH@ +diff -urNad mapserver-4.10.0~/map.h mapserver-4.10.0/map.h +--- mapserver-4.10.0~/map.h 2006-10-04 10:54:49.000000000 -0400 ++++ mapserver-4.10.0/map.h 2009-07-14 13:06:22.521857713 -0400 +@@ -242,7 +242,9 @@ + /* General defines, not wrapable */ + #ifndef SWIG + #define MS_DEFAULT_MAPFILE_PATTERN "\\.map$" +-#define MS_TEMPLATE_EXPR "\\.(jsp|asp|cfm|xml|wml|html|htm|shtml|phtml|php|svg)$" ++ ++#define MS_TEMPLATE_MAGIC_STRING "MapServer Template" ++#define MS_TEMPLATE_EXPR "\\.(xml|wml|html|htm|svg|kml|gml|js|tmpl)$" + + #define MS_INDEX_EXTENSION ".qix" + #define MS_QUERY_EXTENSION ".qy" +@@ -1482,6 +1484,7 @@ + MS_DLL_EXPORT char *msJoinStrings(char **array, int arrayLength, const char *delimeter); + MS_DLL_EXPORT char *msHashString(const char *pszStr); + MS_DLL_EXPORT char *msCommifyString(char *str); ++MS_DLL_EXPORT const char *msCaseFindSubstring(const char *haystack, const char *needle); + + #ifdef NEED_STRDUP + MS_DLL_EXPORT char *strdup(char *s); +diff -urNad mapserver-4.10.0~/mapstring.c mapserver-4.10.0/mapstring.c +--- mapserver-4.10.0~/mapstring.c 2006-08-16 10:05:07.000000000 -0400 ++++ mapserver-4.10.0/mapstring.c 2009-07-14 13:06:22.521857713 -0400 +@@ -933,3 +933,34 @@ + + return str; + } ++ ++/************************************************************************/ ++/* case incensitive equivalent of strstr */ ++/************************************************************************/ ++const char *msCaseFindSubstring(const char *haystack, const char *needle) ++{ ++ if ( !*needle ) ++ { ++ return haystack; ++ } ++ for ( ; *haystack; ++haystack ) ++ { ++ if ( toupper(*haystack) == toupper(*needle) ) ++ { ++ /* * Matched starting char -- loop through remaining chars. */ ++ const char *h, *n; ++ for ( h = haystack, n = needle; *h && *n; ++h, ++n ) ++ { ++ if ( toupper(*h) != toupper(*n) ) ++ { ++ break; ++ } ++ } ++ if ( !*n ) /* matched all of 'needle' to null termination */ ++ { ++ return haystack; /* return the start of the match */ ++ } ++ } ++ } ++ return 0; ++} +diff -urNad mapserver-4.10.0~/maptemplate.c mapserver-4.10.0/maptemplate.c +--- mapserver-4.10.0~/maptemplate.c 2006-09-29 16:52:05.000000000 -0400 ++++ mapserver-4.10.0/maptemplate.c 2009-07-14 13:06:22.521857713 -0400 +@@ -130,6 +130,20 @@ + + char *processLine(mapservObj* msObj, char* instr, int mode); + ++static int isValidTemplate(FILE *stream, const char *filename) ++{ ++ char buffer[MS_BUFFER_LENGTH]; ++ ++ if(fgets(buffer, MS_BUFFER_LENGTH, stream) != NULL) { ++ if(!msCaseFindSubstring(buffer, MS_TEMPLATE_MAGIC_STRING)) { ++ msSetError(MS_WEBERR, "Missing magic string, %s doesn't look like a MapServer template.", "isValidTemplate()", filename); ++ return MS_FALSE; ++ } ++ } ++ ++ return MS_TRUE; ++} ++ + /* + * Redirect to (only use in CGI) + * +@@ -2446,6 +2460,11 @@ + return(NULL); + } + ++ if(isValidTemplate(stream, join->header) != MS_TRUE) { ++ fclose(stream); ++ return NULL; ++ } ++ + /* echo file to the output buffer, no substitutions */ + while(fgets(line, MS_BUFFER_LENGTH, stream) != NULL) outbuf = strcatalloc(outbuf, line); + +@@ -2455,8 +2474,13 @@ + if((stream = fopen(msBuildPath(szPath, msObj->Map->mappath, join->template), "r")) == NULL) { + msSetError(MS_IOERR, "Error while opening join template file %s.", "processOneToManyJoin()", join->template); + return(NULL); +- } ++ } + ++ if(isValidTemplate(stream, join->header) != MS_TRUE) { ++ fclose(stream); ++ return NULL; ++ } ++ + records = MS_TRUE; + } + +@@ -2471,6 +2495,7 @@ + } + + rewind(stream); ++ fgets(line, MS_BUFFER_LENGTH, stream); /* skip the first line since it's the magic string */ + } /* next record */ + + if(records==MS_TRUE && join->footer) { +@@ -2479,6 +2504,11 @@ + return(NULL); + } + ++ if(isValidTemplate(stream, join->footer) != MS_TRUE) { ++ fclose(stream); ++ return NULL; ++ } ++ + /* echo file to the output buffer, no substitutions */ + while(fgets(line, MS_BUFFER_LENGTH, stream) != NULL) outbuf = strcatalloc(outbuf, line); + +@@ -3007,6 +3037,11 @@ + return MS_FAILURE; + } + ++ if(isValidTemplate(stream, html) != MS_TRUE) { ++ fclose(stream); ++ return MS_FAILURE; ++ } ++ + if (papszBuffer) + { + if ((*papszBuffer) == NULL) +diff -urNad mapserver-4.10.0~/mapfile.c mapserver-4.10.0/mapfile.c +--- mapserver-4.10.0~/mapfile.c 2006-08-31 22:30:15.000000000 -0400 ++++ mapserver-4.10.0/mapfile.c 2009-07-14 13:11:33.301856800 -0400 +@@ -4543,6 +4543,9 @@ + int i,j,k; + char szPath[MS_MAXPATHLEN], szCWDPath[MS_MAXPATHLEN]; + ++ int foundMapToken=MS_FALSE; ++ int token; ++ + if(!filename) { + msSetError(MS_MISCERR, "Filename is undefined.", "msLoadMap()"); + return(NULL); +@@ -4592,7 +4595,14 @@ + + for(;;) { + +- switch(msyylex()) { ++ token = msyylex(); ++ ++ if(!foundMapToken && token != MAP) { ++ msSetError(MS_IDENTERR, "First token must be MAP, this doesn't look like a mapfile.", "msLoadMap()"); ++ return(NULL); ++ } ++ ++ switch(token) { + + case(CONFIG): + { +@@ -4717,7 +4727,8 @@ + if(loadLegend(&(map->legend), map) == -1) return(NULL); + break; + case(MAP): +- break; ++ foundMapToken = MS_TRUE; ++ break; + case(MAXSIZE): + if(getInteger(&(map->maxsize)) == -1) return(NULL); + break; +diff -urNad mapserver-4.10.0~/mapsymbol.c mapserver-4.10.0/mapsymbol.c +--- mapserver-4.10.0~/mapsymbol.c 2006-07-22 23:28:45.000000000 -0400 ++++ mapserver-4.10.0/mapsymbol.c 2009-07-14 13:11:33.301856800 -0400 +@@ -632,7 +632,7 @@ + int msLoadSymbolSet(symbolSetObj *symbolset, mapObj *map) + { + int retval = MS_FAILURE; +- ++ + msAcquireLock( TLOCK_PARSER ); + retval = loadSymbolSet( symbolset, map ); + msReleaseLock( TLOCK_PARSER ); +@@ -647,6 +647,9 @@ + int status=1; + char szPath[MS_MAXPATHLEN], *pszSymbolPath=NULL; + ++ int foundSymbolSetToken=MS_FALSE; ++ int token; ++ + if(!symbolset) { + msSetError(MS_SYMERR, "Symbol structure unallocated.", "loadSymbolSet()"); + return(-1); +@@ -673,7 +676,15 @@ + ** Read the symbol file + */ + for(;;) { +- switch(msyylex()) { ++ ++ token = msyylex(); ++ ++ if(!foundSymbolSetToken && token != SYMBOLSET) { ++ msSetError(MS_IDENTERR, "First token must be SYMBOLSET, this doesn't look like a symbol file.", "msLoadSymbolSet()"); ++ return(-1); ++ } ++ ++ switch(token) { + case(END): + case(EOF): + status = 0; +@@ -688,6 +699,7 @@ + symbolset->numsymbols++; + break; + case(SYMBOLSET): ++ foundSymbolSetToken = MS_TRUE; + break; + default: + msSetError(MS_IDENTERR, "Parsing error near (%s):(line %d)", "loadSymbolSet()", msyytext, msyylineno); +diff -urNad mapserver-4.10.0~/tests/symbols.txt mapserver-4.10.0/tests/symbols.txt +--- mapserver-4.10.0~/tests/symbols.txt 2004-11-18 10:07:36.000000000 -0500 ++++ mapserver-4.10.0/tests/symbols.txt 2009-07-14 13:11:33.311860683 -0400 +@@ -1,22 +1,23 @@ +- +-SYMBOL ++SYMBOLSET ++ SYMBOL + NAME 'circle' + TYPE ellipse + FILLED true + POINTS + 1 1 + END +-END ++ END + +-SYMBOL ++ SYMBOL + NAME 'xmarks-png' + TYPE PIXMAP + IMAGE 'xmarks.png' +-END ++ END + +-SYMBOL ++ SYMBOL + NAME 'home-png' + TYPE PIXMAP + IMAGE 'home.png' ++ END + END + only in patch2: unchanged: --- mapserver-4.10.0.orig/debian/patches/84_CVE-2009-0841.dpatch +++ mapserver-4.10.0/debian/patches/84_CVE-2009-0841.dpatch @@ -0,0 +1,32 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## 84_CVE-2009-0841.dpatch by Alan Boudreault +## +## All lines beginning with `## DP:' are a description of the patch. +## DP: No description. + +@DPATCH@ +diff -urNad mapserver-4.10.0~/mapserv.c mapserver-4.10.0/mapserv.c +--- mapserver-4.10.0~/mapserv.c 2006-08-28 21:56:53.000000000 -0400 ++++ mapserver-4.10.0/mapserv.c 2009-07-14 13:10:06.254163494 -0400 +@@ -415,6 +428,10 @@ + } + + if(strcasecmp(msObj->request->ParamNames[i],"id") == 0) { ++ if(msEvalRegex(IDPATTERN, msObj->request->ParamValues[i]) == MS_FALSE) { ++ msSetError(MS_WEBERR, "Parameter 'id' value fails to validate.", "loadMap()"); ++ writeError(); ++ } + strncpy(msObj->Id, msObj->request->ParamValues[i], IDSIZE); + continue; + } +diff -urNad mapserver-4.10.0~/maptemplate.h mapserver-4.10.0/maptemplate.h +--- mapserver-4.10.0~/maptemplate.h 2005-06-14 12:03:35.000000000 -0400 ++++ mapserver-4.10.0/maptemplate.h 2009-07-14 13:06:22.521857713 -0400 +@@ -46,7 +46,8 @@ + #include "maphash.h" + + #define IDSIZE 64 ++#define IDPATTERN "^[0-9A-Za-z]{1,63}$" + #define TEMPLATE_TYPE(s) (((strncmp("http://", s, 7) == 0) || (strncmp("https://", s, 8) == 0) || (strncmp("ftp://", s, 6)) == 0) ? MS_URL : MS_FILE) + #define MAXZOOM 25 + #define MINZOOM -25 only in patch2: unchanged: --- mapserver-4.10.0.orig/debian/patches/87_urlpatch.dpatch +++ mapserver-4.10.0/debian/patches/87_urlpatch.dpatch @@ -0,0 +1,5597 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## 87_urlpatch.dpatch by Alan Boudreault +## +## All lines beginning with `## DP:' are a description of the patch. +## DP: No description. + +@DPATCH@ +diff -urNad mapserver-4.10.0~/mapfile.c mapserver-4.10.0/mapfile.c +--- mapserver-4.10.0~/mapfile.c 2006-08-31 22:30:15.000000000 -0400 ++++ mapserver-4.10.0/mapfile.c 2009-07-24 15:14:36.150608258 -0400 +@@ -4255,14 +4255,6 @@ + msFree(web->header); + web->header = strdup(value); + break; +- case(IMAGEPATH): +- msFree(web->imagepath); +- web->imagepath = strdup(value); +- break; +- case(IMAGEURL): +- msFree(web->imageurl); +- web->imageurl = strdup(value); +- break; + case(LEGENDFORMAT): + msFree(web->legendformat); + web->legendformat = strdup(value); +diff -urNad mapserver-4.10.0~/maplexer.c mapserver-4.10.0/maplexer.c +--- mapserver-4.10.0~/maplexer.c 2006-10-05 11:49:51.000000000 -0400 ++++ mapserver-4.10.0/maplexer.c 2009-07-24 15:14:47.960604827 -0400 +@@ -1,8 +1,13 @@ ++#line 2 "maplexer.c" ++ ++#line 4 "maplexer.c" ++ ++#define YY_INT_ALIGNED short int ++ ++/* A lexical scanner generated by flex */ ++ + #define yy_create_buffer msyy_create_buffer + #define yy_delete_buffer msyy_delete_buffer +-#define yy_scan_buffer msyy_scan_buffer +-#define yy_scan_string msyy_scan_string +-#define yy_scan_bytes msyy_scan_bytes + #define yy_flex_debug msyy_flex_debug + #define yy_init_buffer msyy_init_buffer + #define yy_flush_buffer msyy_flush_buffer +@@ -11,76 +16,118 @@ + #define yyin msyyin + #define yyleng msyyleng + #define yylex msyylex ++#define yylineno msyylineno + #define yyout msyyout + #define yyrestart msyyrestart + #define yytext msyytext + #define yywrap msyywrap +- +-#line 20 "maplexer.c" +-/* A lexical scanner generated by flex */ +- +-/* Scanner skeleton version: +- * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $ +- */ ++#define yyalloc msyyalloc ++#define yyrealloc msyyrealloc ++#define yyfree msyyfree + + #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. */ + +-/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +-#ifdef c_plusplus +-#ifndef __cplusplus +-#define __cplusplus +-#endif ++/* 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; ++#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; + +-#ifdef __cplusplus ++/* 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 + +-#include +-#include ++#endif /* ! C99 */ + +-/* Use prototypes in function declarations. */ +-#define YY_USE_PROTOS ++#endif /* ! FLEXINT_H */ ++ ++#ifdef __cplusplus + + /* The "const" storage-class-modifier is valid. */ + #define YY_USE_CONST + + #else /* ! __cplusplus */ + +-#if __STDC__ ++/* C99 requires __STDC__ to be defined as 1. */ ++#if defined (__STDC__) + +-#define YY_USE_PROTOS + #define YY_USE_CONST + +-#endif /* __STDC__ */ ++#endif /* defined (__STDC__) */ + #endif /* ! __cplusplus */ + +-#ifdef __TURBOC__ +- #pragma warn -rch +- #pragma warn -use +-#include +-#include +-#define YY_USE_CONST +-#define YY_USE_PROTOS +-#endif +- + #ifdef YY_USE_CONST + #define yyconst const + #else + #define yyconst + #endif + +- +-#ifdef YY_USE_PROTOS +-#define YY_PROTO(proto) proto +-#else +-#define YY_PROTO(proto) () +-#endif +- + /* Returned upon end-of-file. */ + #define YY_NULL 0 + +@@ -95,71 +142,70 @@ + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +-#define BEGIN yy_start = 1 + 2 * ++#define BEGIN (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 ((yy_start - 1) / 2) ++#define YY_START (((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 yyrestart( yyin ) ++#define YY_NEW_FILE msyyrestart(msyyin ) + + #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 + +-extern int yyleng; +-extern FILE *yyin, *yyout; ++extern int msyyleng; ++ ++extern FILE *msyyin, *msyyout; + + #define EOB_ACT_CONTINUE_SCAN 0 + #define EOB_ACT_END_OF_FILE 1 + #define EOB_ACT_LAST_MATCH 2 + +-/* The funky do-while in the following #define is used to turn the definition +- * int a single C statement (which needs a semi-colon terminator). This +- * avoids problems with code like: +- * +- * if ( condition_holds ) +- * yyless( 5 ); +- * else +- * do_something_else(); +- * +- * Prior to using the do-while the compiler would get upset at the +- * "else" because it interpreted the "if" statement as being all +- * done when it reached the ';' after the yyless() call. +- */ +- +-/* Return all but the first 'n' matched characters back to the input stream. */ +- ++ #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. */ \ +- *yy_cp = yy_hold_char; \ ++ /* Undo effects of setting up msyytext. */ \ ++ int yyless_macro_arg = (n); \ ++ YY_LESS_LINENO(yyless_macro_arg);\ ++ *yy_cp = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ +- yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ +- YY_DO_BEFORE_ACTION; /* set up yytext again */ \ ++ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ ++ YY_DO_BEFORE_ACTION; /* set up msyytext again */ \ + } \ + while ( 0 ) + +-#define unput(c) yyunput( c, yytext_ptr ) +- +-/* The following is because we cannot portably get our hands on size_t +- * (without autoconf's help, which isn't available because we want +- * flex-generated scanners to compile on their own). +- */ +-typedef unsigned int yy_size_t; ++#define unput(c) yyunput( c, (yytext_ptr) ) + ++#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; +@@ -196,12 +242,16 @@ + */ + 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 +@@ -211,108 +261,144 @@ + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" +- * (via yyrestart()), so that the user can continue scanning by +- * just pointing yyin at a new input file. ++ * (via msyyrestart()), so that the user can continue scanning by ++ * just pointing msyyin at a new input file. + */ + #define YY_BUFFER_EOF_PENDING 2 ++ + }; ++#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +-static YY_BUFFER_STATE yy_current_buffer = 0; ++/* Stack of input buffers. */ ++static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ ++static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ ++static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ + + /* 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 yy_current_buffer ++#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ ++ ? (yy_buffer_stack)[(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 (yy_buffer_stack)[(yy_buffer_stack_top)] + +-/* yy_hold_char holds the character lost when yytext is formed. */ ++/* yy_hold_char holds the character lost when msyytext is formed. */ + static char yy_hold_char; +- + static int yy_n_chars; /* number of characters read into yy_ch_buf */ +- +- +-int yyleng; ++int msyyleng; + + /* Points to current character in buffer. */ + static char *yy_c_buf_p = (char *) 0; +-static int yy_init = 1; /* whether we need to initialize */ ++static int yy_init = 0; /* whether we need to initialize */ + static int yy_start = 0; /* start state number */ + +-/* Flag which is used to allow yywrap()'s to do buffer switches +- * instead of setting up a fresh yyin. A bit of a hack ... ++/* Flag which is used to allow msyywrap()'s to do buffer switches ++ * instead of setting up a fresh msyyin. A bit of a hack ... + */ + static int yy_did_buffer_switch_on_eof; + +-void yyrestart YY_PROTO(( FILE *input_file )); ++void msyyrestart (FILE *input_file ); ++void msyy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); ++YY_BUFFER_STATE msyy_create_buffer (FILE *file,int size ); ++void msyy_delete_buffer (YY_BUFFER_STATE b ); ++void msyy_flush_buffer (YY_BUFFER_STATE b ); ++void msyypush_buffer_state (YY_BUFFER_STATE new_buffer ); ++void msyypop_buffer_state (void ); + +-void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +-void yy_load_buffer_state YY_PROTO(( void )); +-YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +-void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +-void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +-void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +-#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) ++static void msyyensure_buffer_stack (void ); ++static void msyy_load_buffer_state (void ); ++static void msyy_init_buffer (YY_BUFFER_STATE b,FILE *file ); + +-YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +-YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +-YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); ++#define YY_FLUSH_BUFFER msyy_flush_buffer(YY_CURRENT_BUFFER ) + +-static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +-static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +-static void yy_flex_free YY_PROTO(( void * )); ++YY_BUFFER_STATE msyy_scan_buffer (char *base,yy_size_t size ); ++YY_BUFFER_STATE msyy_scan_string (yyconst char *yy_str ); ++YY_BUFFER_STATE msyy_scan_bytes (yyconst char *bytes,int len ); + +-#define yy_new_buffer yy_create_buffer ++void *msyyalloc (yy_size_t ); ++void *msyyrealloc (void *,yy_size_t ); ++void msyyfree (void * ); ++ ++#define yy_new_buffer msyy_create_buffer + + #define yy_set_interactive(is_interactive) \ + { \ +- if ( ! yy_current_buffer ) \ +- yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ +- yy_current_buffer->yy_is_interactive = is_interactive; \ ++ if ( ! YY_CURRENT_BUFFER ){ \ ++ msyyensure_buffer_stack (); \ ++ YY_CURRENT_BUFFER_LVALUE = \ ++ msyy_create_buffer(msyyin,YY_BUF_SIZE ); \ ++ } \ ++ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } + + #define yy_set_bol(at_bol) \ + { \ +- if ( ! yy_current_buffer ) \ +- yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ +- yy_current_buffer->yy_at_bol = at_bol; \ ++ if ( ! YY_CURRENT_BUFFER ){\ ++ msyyensure_buffer_stack (); \ ++ YY_CURRENT_BUFFER_LVALUE = \ ++ msyy_create_buffer(msyyin,YY_BUF_SIZE ); \ ++ } \ ++ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } + +-#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) ++#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) ++ ++/* Begin user sect3 */ + + typedef unsigned char YY_CHAR; +-FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; ++ ++FILE *msyyin = (FILE *) 0, *msyyout = (FILE *) 0; ++ + typedef int yy_state_type; +-extern char *yytext; +-#define yytext_ptr yytext + +-static yy_state_type yy_get_previous_state YY_PROTO(( void )); +-static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +-static int yy_get_next_buffer YY_PROTO(( void )); +-static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); ++extern int msyylineno; ++ ++int msyylineno = 1; ++ ++extern char *msyytext; ++#define yytext_ptr msyytext ++ ++static yy_state_type yy_get_previous_state (void ); ++static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); ++static int yy_get_next_buffer (void ); ++static void yy_fatal_error (yyconst char msg[] ); + + /* Done after the current pattern has been matched and before the +- * corresponding action - sets up yytext. ++ * corresponding action - sets up msyytext. + */ + #define YY_DO_BEFORE_ACTION \ +- yytext_ptr = yy_bp; \ +- yyleng = (int) (yy_cp - yy_bp); \ +- yy_hold_char = *yy_cp; \ ++ (yytext_ptr) = yy_bp; \ ++ msyyleng = (size_t) (yy_cp - yy_bp); \ ++ (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ +- yy_c_buf_p = yy_cp; ++ (yy_c_buf_p) = yy_cp; + + #define YY_NUM_RULES 271 + #define YY_END_OF_BUFFER 272 +-static yyconst short int yy_accept[2463] = ++/* This struct is not used in this scanner, ++ but its presence is necessary. */ ++struct yy_trans_info ++ { ++ flex_int32_t yy_verify; ++ flex_int32_t yy_nxt; ++ }; ++static yyconst flex_int16_t yy_accept[2458] = + { 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 272, 269, 1, 267, 269, 2, 269, 269, 269, 251, + 264, 251, 264, 264, 264, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 268, 268, 265, 250, +- 3, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, +- 265, 265, 265, 1, 251, 266, 266, 266, 266, 266, ++ 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, ++ 265, 265, 3, 1, 251, 266, 266, 266, 266, 266, + 266, 266, 266, 266, 266, 266, 266, 266, 266, 266, + 266, 266, 266, 266, 266, 266, 266, 270, 1, 1, + +@@ -331,12 +417,12 @@ + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 264, 167, 264, 264, + 243, 244, 264, 245, 264, 264, 264, 264, 264, 264, +- 264, 265, 250, 3, 265, 265, 265, 265, 265, 265, ++ 264, 265, 250, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, +- 265, 265, 167, 265, 265, 265, 265, 265, 265, 265, ++ 265, 167, 265, 265, 265, 265, 265, 265, 265, 3, + + 266, 251, 266, 266, 256, 266, 266, 266, 185, 266, + 187, 188, 266, 193, 266, 266, 266, 266, 266, 266, +@@ -345,118 +431,118 @@ + 266, 266, 266, 266, 266, 266, 266, 266, 266, 266, + 266, 243, 244, 245, 266, 266, 7, 0, 263, 5, + 0, 263, 252, 252, 252, 0, 0, 257, 252, 0, +- 11, 6, 12, 10, 0, 253, 0, 8, 0, 13, +- 11, 9, 0, 4, 0, 260, 0, 259, 251, 0, +- 0, 264, 251, 256, 254, 251, 0, 0, 251, 264, ++ 11, 6, 12, 10, 0, 8, 0, 13, 11, 9, ++ 0, 4, 0, 253, 0, 260, 0, 259, 259, 251, ++ 0, 0, 264, 251, 256, 254, 251, 0, 0, 251, + + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 264, 264, 264, 264, 264, 189, 264, 264, +- 264, 264, 264, 264, 264, 264, 264, 45, 264, 264, ++ 264, 264, 264, 264, 264, 264, 264, 264, 189, 264, ++ 264, 264, 264, 264, 264, 264, 264, 264, 45, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, +- 60, 264, 264, 264, 264, 264, 264, 264, 264, 264, ++ 264, 60, 264, 264, 264, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, +- 264, 96, 97, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 264, 264, 264, 264, 264, 216, 217, 264, ++ 264, 264, 96, 97, 264, 264, 264, 264, 264, 264, ++ 264, 264, 264, 264, 264, 264, 264, 264, 216, 217, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, + +- 233, 264, 264, 264, 264, 264, 264, 264, 264, 264, ++ 264, 233, 264, 264, 264, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 264, 264, 175, 247, 264, 177, 248, 264, +- 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, ++ 264, 264, 264, 264, 264, 175, 247, 264, 177, 248, ++ 264, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, +- 265, 265, 265, 265, 265, 265, 265, 265, 97, 265, ++ 265, 265, 265, 265, 265, 265, 265, 265, 265, 97, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + +- 265, 265, 265, 175, 265, 177, 265, 266, 251, 254, +- 266, 266, 266, 266, 189, 266, 266, 266, 266, 266, ++ 265, 265, 265, 265, 175, 265, 177, 265, 266, 251, ++ 254, 266, 266, 266, 266, 189, 266, 266, 266, 266, + 266, 266, 266, 266, 266, 266, 266, 266, 266, 266, +- 266, 266, 266, 266, 216, 217, 266, 266, 266, 266, +- 266, 266, 266, 266, 266, 266, 266, 233, 266, 266, +- 266, 266, 266, 266, 266, 266, 247, 248, 262, 0, +- 252, 255, 252, 0, 0, 252, 16, 0, 14, 251, +- 254, 0, 251, 264, 264, 264, 264, 180, 264, 264, +- 264, 264, 264, 264, 183, 264, 264, 264, 264, 264, +- 264, 264, 38, 264, 264, 264, 42, 264, 264, 264, ++ 266, 266, 266, 266, 266, 216, 217, 266, 266, 266, ++ 266, 266, 266, 266, 266, 266, 266, 266, 233, 266, ++ 266, 266, 266, 266, 266, 266, 266, 247, 248, 262, ++ 262, 0, 252, 255, 252, 0, 0, 252, 16, 0, ++ 14, 251, 254, 0, 251, 264, 264, 264, 264, 180, ++ 264, 264, 264, 264, 264, 264, 183, 264, 264, 264, ++ 264, 264, 264, 264, 38, 264, 264, 264, 42, 264, + +- 264, 264, 264, 264, 264, 264, 197, 264, 264, 264, +- 55, 264, 264, 264, 59, 264, 264, 61, 264, 264, +- 264, 264, 264, 264, 264, 264, 264, 76, 264, 264, +- 264, 264, 264, 264, 264, 264, 206, 264, 264, 264, ++ 264, 264, 264, 264, 264, 264, 264, 264, 197, 264, ++ 264, 264, 55, 264, 264, 264, 59, 264, 264, 61, ++ 264, 264, 264, 264, 264, 264, 264, 264, 264, 76, ++ 264, 264, 264, 264, 264, 264, 264, 264, 206, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 121, 214, 264, 264, 264, 264, 264, 264, ++ 264, 264, 264, 264, 121, 214, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 264, 264, 264, 264, 150, 264, 264, 264, ++ 264, 264, 264, 264, 264, 264, 264, 264, 150, 264, + +- 264, 264, 264, 264, 162, 264, 239, 264, 264, 264, +- 264, 241, 173, 264, 264, 264, 178, 265, 265, 265, +- 265, 265, 265, 265, 265, 265, 265, 265, 38, 265, +- 265, 42, 265, 265, 265, 265, 265, 265, 265, 55, +- 265, 265, 265, 59, 265, 61, 265, 265, 265, 265, +- 265, 76, 265, 265, 265, 265, 265, 265, 265, 265, ++ 264, 264, 264, 264, 264, 264, 162, 264, 239, 264, ++ 264, 264, 264, 241, 173, 264, 264, 264, 178, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, +- 265, 265, 265, 265, 265, 265, 121, 265, 265, 265, ++ 38, 265, 265, 42, 265, 265, 265, 265, 265, 265, ++ 265, 55, 265, 265, 265, 59, 265, 61, 265, 265, ++ 265, 265, 265, 76, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, +- 265, 265, 265, 265, 265, 265, 150, 265, 265, 265, ++ 265, 265, 265, 265, 265, 265, 265, 265, 121, 265, ++ 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, ++ 265, 265, 265, 265, 265, 265, 265, 265, 150, 265, + +- 265, 265, 162, 265, 265, 265, 265, 173, 265, 265, +- 178, 266, 266, 180, 266, 266, 266, 266, 197, 266, +- 266, 266, 266, 266, 266, 206, 266, 266, 266, 266, ++ 265, 265, 265, 265, 162, 265, 265, 265, 265, 173, ++ 265, 265, 178, 266, 266, 180, 266, 266, 266, 266, ++ 197, 266, 266, 266, 266, 266, 266, 206, 266, 266, + 266, 266, 266, 266, 266, 266, 266, 266, 266, 266, + 266, 266, 266, 266, 266, 266, 266, 266, 266, 266, +- 239, 266, 241, 0, 252, 0, 249, 22, 264, 264, +- 264, 264, 181, 264, 264, 264, 264, 264, 264, 32, +- 34, 264, 264, 264, 264, 40, 264, 264, 264, 195, +- 43, 264, 46, 264, 264, 196, 264, 264, 264, 264, +- 264, 264, 57, 264, 199, 264, 63, 200, 264, 264, ++ 266, 266, 239, 266, 241, 0, 252, 0, 249, 22, ++ 264, 264, 264, 264, 181, 264, 264, 264, 264, 264, ++ 264, 32, 34, 264, 264, 264, 264, 40, 264, 264, ++ 264, 195, 43, 264, 46, 264, 264, 196, 264, 264, ++ 264, 264, 264, 264, 57, 264, 199, 264, 63, 200, + +- 65, 264, 264, 73, 264, 264, 264, 264, 264, 80, +- 204, 264, 90, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 264, 264, 264, 264, 264, 264, 264, 211, ++ 264, 264, 65, 264, 264, 73, 264, 264, 264, 264, ++ 264, 80, 204, 264, 90, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, +- 264, 212, 264, 228, 190, 264, 264, 264, 264, 264, +- 264, 264, 264, 264, 264, 264, 264, 264, 225, 264, +- 264, 264, 264, 264, 264, 230, 264, 264, 264, 264, +- 264, 264, 232, 145, 264, 264, 264, 264, 264, 264, +- 264, 237, 264, 264, 154, 264, 159, 264, 264, 166, +- 264, 264, 264, 264, 174, 264, 176, 265, 22, 265, ++ 264, 211, 264, 264, 264, 264, 264, 264, 264, 264, ++ 264, 264, 264, 212, 264, 228, 190, 264, 264, 264, ++ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, ++ 225, 264, 264, 264, 264, 264, 264, 230, 264, 264, ++ 264, 264, 264, 264, 232, 145, 264, 264, 264, 264, ++ 264, 264, 264, 237, 264, 264, 154, 264, 159, 264, ++ 264, 166, 264, 264, 264, 264, 174, 264, 176, 265, + +- 265, 265, 265, 265, 32, 34, 265, 265, 265, 265, +- 40, 265, 43, 265, 46, 265, 265, 265, 265, 265, +- 57, 265, 265, 63, 265, 65, 73, 265, 265, 265, +- 265, 80, 265, 90, 265, 265, 265, 265, 265, 265, ++ 22, 265, 265, 265, 265, 265, 32, 34, 265, 265, ++ 265, 265, 40, 265, 43, 265, 46, 265, 265, 265, ++ 265, 265, 57, 265, 265, 63, 265, 65, 73, 265, ++ 265, 265, 265, 80, 265, 90, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, +- 265, 265, 265, 265, 145, 265, 265, 265, 265, 265, +- 154, 265, 159, 265, 265, 166, 265, 265, 174, 176, +- 249, 266, 266, 266, 195, 196, 266, 199, 266, 266, ++ 265, 265, 265, 265, 265, 265, 145, 265, 265, 265, ++ 265, 265, 154, 265, 159, 265, 265, 166, 265, 265, ++ 174, 176, 249, 266, 266, 266, 195, 196, 266, 199, + +- 266, 204, 266, 266, 211, 212, 266, 228, 190, 266, +- 266, 266, 266, 266, 266, 225, 266, 266, 230, 266, +- 232, 266, 266, 237, 266, 266, 266, 266, 0, 264, +- 264, 264, 264, 264, 264, 182, 264, 30, 264, 264, +- 186, 264, 264, 35, 264, 264, 264, 264, 41, 264, +- 264, 264, 264, 48, 264, 51, 52, 198, 264, 54, +- 264, 264, 64, 201, 264, 264, 264, 264, 264, 264, +- 202, 264, 264, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 264, 264, 264, 89, 91, 264, 264, 98, +- 264, 264, 264, 264, 264, 264, 264, 264, 264, 209, ++ 266, 266, 266, 204, 266, 266, 211, 212, 266, 228, ++ 190, 266, 266, 266, 266, 266, 266, 225, 266, 266, ++ 230, 266, 232, 266, 266, 237, 266, 266, 266, 266, ++ 0, 264, 264, 264, 264, 264, 264, 182, 264, 30, ++ 264, 264, 186, 264, 264, 35, 264, 264, 264, 264, ++ 41, 264, 264, 264, 264, 48, 264, 51, 52, 198, ++ 264, 54, 264, 264, 64, 201, 264, 264, 264, 264, ++ 264, 264, 202, 264, 264, 264, 264, 264, 264, 264, ++ 264, 264, 264, 264, 264, 264, 264, 89, 91, 264, ++ 264, 98, 264, 264, 264, 264, 264, 264, 264, 264, + +- 264, 210, 264, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 264, 264, 215, 122, 264, 264, 264, 264, +- 264, 264, 264, 264, 224, 223, 229, 134, 264, 264, +- 264, 264, 264, 264, 264, 264, 264, 264, 231, 264, +- 264, 264, 264, 264, 264, 264, 264, 235, 236, 264, +- 264, 238, 153, 264, 156, 264, 264, 264, 264, 264, +- 264, 264, 264, 246, 265, 265, 265, 265, 265, 265, +- 30, 265, 265, 35, 265, 265, 265, 41, 265, 265, +- 265, 48, 265, 52, 54, 265, 265, 64, 265, 265, ++ 264, 209, 264, 210, 264, 264, 264, 264, 264, 264, ++ 264, 264, 264, 264, 264, 264, 215, 122, 264, 264, ++ 264, 264, 264, 264, 264, 264, 224, 223, 229, 134, ++ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, ++ 231, 264, 264, 264, 264, 264, 264, 264, 264, 235, ++ 236, 264, 264, 238, 153, 264, 156, 264, 264, 264, ++ 264, 264, 264, 264, 264, 246, 265, 265, 265, 265, ++ 265, 265, 30, 265, 265, 35, 265, 265, 265, 41, ++ 265, 265, 265, 48, 265, 52, 54, 265, 265, 64, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + + 265, 265, 265, 265, 265, 265, 89, 91, 98, 265, +@@ -483,102 +569,101 @@ + + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 50, 265, 265, 265, 265, 265, 265, +- 265, 265, 265, 265, 265, 265, 78, 265, 265, 265, +- 265, 265, 265, 265, 265, 265, 265, 265, 100, 265, +- 265, 265, 265, 105, 265, 265, 265, 265, 265, 111, +- 265, 265, 265, 265, 265, 117, 265, 265, 265, 123, ++ 265, 265, 265, 265, 78, 265, 265, 265, 265, 265, ++ 265, 265, 265, 265, 265, 265, 100, 265, 265, 265, ++ 265, 105, 265, 265, 265, 265, 265, 111, 265, 265, ++ 265, 265, 265, 117, 265, 265, 265, 123, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, +- 265, 265, 265, 265, 265, 265, 265, 265, 265, 266, +- 192, 266, 266, 266, 266, 266, 226, 227, 266, 266, ++ 265, 265, 265, 265, 265, 265, 265, 266, 192, 266, ++ 266, 266, 266, 266, 226, 227, 266, 266, 266, 266, + +- 266, 266, 266, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 264, 264, 264, 264, 264, 44, 264, 264, +- 264, 264, 264, 264, 264, 264, 264, 264, 71, 264, +- 264, 77, 264, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 264, 94, 264, 264, 264, 264, 104, 264, +- 264, 108, 109, 110, 264, 264, 264, 264, 116, 264, +- 264, 120, 213, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 264, 133, 264, 135, 264, 264, 264, 264, +- 264, 140, 264, 264, 264, 143, 264, 146, 234, 264, +- 264, 264, 151, 264, 264, 264, 264, 160, 264, 165, ++ 266, 264, 264, 264, 264, 264, 264, 264, 264, 264, ++ 264, 264, 264, 264, 264, 44, 264, 264, 264, 264, ++ 264, 264, 264, 264, 264, 264, 71, 264, 264, 77, ++ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, ++ 264, 94, 264, 264, 264, 264, 104, 264, 264, 108, ++ 109, 110, 264, 264, 264, 264, 116, 264, 264, 120, ++ 213, 264, 264, 264, 264, 264, 264, 264, 264, 264, ++ 264, 133, 264, 135, 264, 264, 264, 264, 264, 140, ++ 264, 264, 264, 143, 264, 146, 234, 264, 264, 264, ++ 151, 264, 264, 264, 264, 160, 264, 165, 264, 264, + +- 264, 264, 264, 240, 242, 265, 265, 265, 265, 265, +- 265, 265, 265, 265, 265, 265, 44, 265, 265, 265, +- 265, 265, 265, 265, 265, 265, 265, 71, 265, 265, +- 77, 265, 265, 265, 265, 265, 265, 265, 265, 265, +- 265, 265, 265, 265, 265, 104, 265, 265, 108, 109, +- 110, 265, 265, 265, 265, 116, 265, 265, 120, 265, +- 265, 265, 265, 265, 265, 265, 133, 135, 265, 265, +- 265, 265, 140, 265, 265, 265, 143, 265, 146, 265, +- 265, 265, 151, 265, 265, 265, 265, 160, 265, 165, +- 265, 265, 265, 266, 266, 213, 266, 266, 266, 266, ++ 264, 240, 242, 265, 265, 265, 265, 265, 265, 265, ++ 265, 265, 265, 265, 44, 265, 265, 265, 265, 265, ++ 265, 265, 265, 265, 265, 265, 77, 265, 265, 265, ++ 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, ++ 265, 104, 265, 265, 108, 109, 110, 265, 265, 265, ++ 265, 116, 265, 265, 120, 265, 265, 265, 265, 265, ++ 265, 265, 133, 135, 265, 265, 265, 265, 140, 265, ++ 265, 265, 143, 265, 146, 265, 265, 265, 151, 265, ++ 265, 265, 265, 160, 265, 165, 265, 265, 265, 266, ++ 266, 213, 266, 266, 266, 266, 266, 234, 266, 240, + +- 266, 234, 266, 240, 242, 264, 23, 264, 24, 264, +- 28, 264, 184, 31, 33, 264, 264, 264, 19, 264, +- 49, 264, 264, 62, 264, 69, 70, 264, 67, 74, +- 75, 264, 264, 264, 264, 264, 84, 264, 264, 264, +- 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, ++ 242, 264, 23, 264, 24, 264, 28, 264, 184, 31, ++ 33, 264, 264, 264, 19, 264, 49, 264, 264, 62, ++ 264, 69, 70, 264, 67, 74, 75, 264, 264, 264, ++ 264, 264, 84, 264, 264, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, + 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, +- 264, 264, 264, 20, 141, 264, 264, 264, 264, 149, +- 152, 155, 264, 158, 264, 163, 168, 172, 264, 265, +- 23, 24, 265, 28, 265, 33, 265, 265, 265, 19, ++ 264, 264, 264, 264, 264, 264, 264, 264, 264, 20, ++ 141, 264, 264, 264, 264, 149, 152, 155, 264, 158, ++ 264, 163, 168, 172, 264, 265, 23, 24, 265, 28, ++ 265, 33, 265, 265, 265, 19, 265, 49, 265, 265, + +- 265, 49, 265, 265, 62, 265, 69, 70, 265, 67, +- 74, 75, 265, 265, 265, 265, 84, 265, 265, 265, ++ 62, 265, 69, 265, 67, 74, 75, 265, 265, 265, ++ 265, 84, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, + 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, +- 265, 265, 265, 265, 265, 265, 265, 20, 141, 265, +- 265, 265, 265, 149, 152, 155, 265, 158, 265, 163, +- 168, 172, 265, 266, 266, 266, 266, 266, 266, 266, +- 164, 21, 179, 264, 264, 17, 36, 264, 47, 53, +- 264, 66, 264, 79, 203, 264, 82, 264, 264, 264, +- 264, 264, 264, 264, 99, 101, 264, 264, 264, 264, ++ 265, 265, 20, 141, 265, 265, 265, 265, 149, 152, ++ 155, 265, 158, 265, 163, 168, 172, 265, 266, 266, ++ 266, 266, 266, 266, 266, 164, 21, 179, 264, 264, ++ 17, 36, 264, 47, 53, 264, 66, 264, 79, 203, ++ 264, 82, 264, 264, 264, 264, 264, 264, 264, 99, ++ 101, 264, 264, 264, 264, 112, 264, 264, 264, 264, + +- 112, 264, 264, 264, 264, 264, 264, 219, 264, 264, +- 264, 264, 264, 264, 264, 264, 264, 264, 264, 191, +- 264, 137, 138, 264, 142, 144, 264, 148, 264, 264, +- 264, 264, 21, 265, 265, 17, 36, 265, 47, 53, +- 265, 66, 265, 79, 265, 82, 265, 265, 265, 265, +- 265, 265, 99, 101, 265, 265, 265, 265, 112, 265, +- 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, +- 265, 265, 265, 265, 137, 138, 265, 142, 144, 265, +- 148, 265, 265, 265, 265, 179, 203, 266, 219, 266, +- 266, 191, 264, 264, 264, 264, 264, 39, 264, 264, ++ 264, 264, 219, 264, 264, 264, 264, 264, 264, 264, ++ 264, 264, 264, 264, 191, 264, 137, 138, 264, 142, ++ 144, 264, 148, 264, 264, 264, 264, 21, 265, 265, ++ 17, 36, 265, 47, 53, 265, 66, 265, 79, 265, ++ 82, 265, 265, 265, 265, 265, 265, 99, 101, 265, ++ 265, 265, 265, 112, 265, 265, 265, 265, 265, 265, ++ 265, 265, 265, 265, 265, 265, 265, 265, 265, 137, ++ 138, 265, 142, 144, 265, 148, 265, 265, 265, 265, ++ 179, 203, 266, 219, 266, 266, 191, 264, 264, 264, ++ 264, 264, 39, 264, 264, 264, 83, 264, 264, 264, + +- 264, 83, 264, 264, 264, 264, 264, 264, 102, 103, +- 264, 107, 113, 264, 115, 264, 119, 220, 264, 264, +- 264, 264, 264, 264, 264, 264, 131, 264, 222, 264, +- 139, 147, 157, 264, 264, 264, 171, 265, 265, 265, +- 265, 265, 39, 265, 265, 265, 83, 265, 265, 265, +- 265, 265, 102, 103, 265, 107, 113, 265, 115, 265, +- 119, 265, 265, 265, 265, 265, 265, 265, 131, 265, +- 265, 139, 147, 157, 265, 265, 265, 171, 220, 266, +- 222, 264, 264, 264, 29, 264, 58, 68, 264, 264, +- 264, 264, 264, 92, 264, 106, 264, 118, 264, 124, ++ 264, 264, 264, 102, 103, 264, 107, 113, 264, 115, ++ 264, 119, 220, 264, 264, 264, 264, 264, 264, 264, ++ 264, 131, 264, 222, 264, 139, 147, 157, 264, 264, ++ 264, 171, 265, 265, 265, 265, 265, 39, 265, 265, ++ 265, 83, 265, 265, 265, 265, 265, 102, 103, 265, ++ 107, 113, 265, 115, 265, 119, 265, 265, 265, 265, ++ 265, 265, 265, 131, 265, 265, 139, 147, 157, 265, ++ 265, 265, 171, 220, 266, 222, 264, 264, 264, 29, ++ 264, 58, 68, 264, 264, 264, 264, 264, 92, 264, ++ 106, 264, 118, 264, 124, 125, 264, 127, 264, 264, + +- 125, 264, 127, 264, 264, 264, 264, 264, 264, 264, +- 170, 265, 265, 265, 29, 265, 58, 68, 265, 265, +- 265, 265, 265, 92, 106, 265, 118, 124, 125, 265, +- 127, 265, 265, 265, 265, 265, 265, 265, 170, 266, +- 264, 264, 264, 264, 264, 85, 86, 87, 88, 264, +- 264, 221, 264, 264, 264, 264, 132, 264, 264, 264, +- 265, 265, 265, 265, 265, 85, 86, 87, 88, 265, +- 265, 265, 265, 265, 132, 265, 265, 265, 221, 264, +- 264, 264, 37, 81, 264, 114, 264, 128, 129, 264, +- 136, 264, 169, 265, 265, 265, 37, 81, 114, 265, ++ 264, 264, 264, 264, 264, 170, 265, 265, 265, 29, ++ 265, 58, 68, 265, 265, 265, 265, 265, 92, 106, ++ 265, 118, 124, 125, 265, 127, 265, 265, 265, 265, ++ 265, 265, 265, 170, 266, 264, 264, 264, 264, 264, ++ 85, 86, 87, 88, 264, 264, 221, 264, 264, 264, ++ 264, 132, 264, 264, 264, 265, 265, 265, 265, 265, ++ 85, 86, 87, 88, 265, 265, 265, 265, 265, 132, ++ 265, 265, 265, 221, 264, 264, 264, 37, 81, 264, ++ 114, 264, 128, 129, 264, 136, 264, 169, 265, 265, ++ 265, 37, 81, 114, 265, 128, 129, 265, 136, 265, + +- 128, 129, 265, 136, 265, 169, 18, 25, 264, 95, +- 264, 264, 161, 18, 25, 265, 265, 265, 161, 264, +- 264, 264, 265, 265, 265, 264, 264, 264, 264, 265, +- 265, 265, 265, 264, 264, 264, 264, 265, 265, 265, +- 265, 264, 264, 264, 130, 265, 265, 265, 130, 264, +- 27, 264, 265, 27, 265, 26, 264, 26, 265, 126, +- 126, 0 ++ 169, 18, 25, 264, 95, 264, 264, 161, 18, 25, ++ 265, 265, 265, 161, 264, 264, 264, 265, 265, 265, ++ 264, 264, 264, 264, 265, 265, 265, 265, 264, 264, ++ 264, 264, 265, 265, 265, 265, 264, 264, 264, 130, ++ 265, 265, 265, 130, 264, 27, 264, 265, 27, 265, ++ 26, 264, 26, 265, 126, 126, 0 + } ; + +-static yyconst int yy_ec[256] = ++static yyconst flex_int32_t yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, +@@ -586,14 +671,14 @@ + 1, 5, 6, 7, 8, 1, 1, 9, 10, 11, + 12, 1, 13, 1, 14, 15, 16, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 1, 1, 18, +- 19, 20, 1, 1, 23, 24, 25, 26, 27, 28, +- 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, +- 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, +- 1, 1, 1, 1, 21, 22, 23, 24, 25, 26, +- ++ 19, 20, 1, 1, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, +- 47, 48, 1, 49, 1, 50, 1, 1, 1, 1, ++ 1, 1, 1, 1, 47, 48, 49, 50, 51, 52, ++ ++ 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, ++ 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, ++ 73, 74, 1, 75, 1, 76, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +@@ -610,1201 +695,1746 @@ + 1, 1, 1, 1, 1 + } ; + +-static yyconst int yy_meta[52] = ++static yyconst flex_int32_t yy_meta[78] = + { 0, + 1, 1, 2, 1, 3, 1, 1, 1, 1, 1, + 1, 1, 1, 4, 4, 4, 4, 1, 4, 1, +- 5, 1, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +- 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, +- 1 ++ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, ++ 4, 4, 4, 4, 4, 4, 5, 1, 4, 4, ++ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, ++ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, ++ 4, 4, 4, 4, 1, 1, 1 + } ; + +-static yyconst short int yy_base[2480] = ++static yyconst flex_int16_t yy_base[2475] = + { 0, +- 0, 0, 51, 0, 102, 0, 153, 0, 203, 207, +- 2769, 2770, 214, 2770, 2761, 0, 2757, 2754, 205, 198, +- 225, 225, 210, 227, 254, 238, 262, 232, 226, 259, +- 188, 2728, 229, 276, 288, 225, 289, 303, 2721, 277, +- 319, 325, 287, 2736, 336, 0, 2770, 2770, 0, 2745, +- 2740, 237, 266, 246, 330, 339, 350, 2720, 2732, 257, +- 2721, 2730, 297, 324, 2733, 340, 299, 2712, 315, 361, +- 370, 2718, 369, 409, 361, 417, 346, 0, 409, 333, +- 2718, 409, 2721, 2720, 2714, 2718, 422, 417, 2711, 376, +- 424, 2704, 434, 443, 375, 447, 424, 2770, 471, 475, ++ 0, 0, 77, 0, 154, 0, 231, 0, 307, 311, ++ 914, 5207, 318, 5207, 902, 0, 858, 850, 309, 302, ++ 355, 316, 310, 353, 412, 359, 354, 417, 416, 356, ++ 356, 275, 370, 463, 464, 408, 512, 562, 284, 469, ++ 606, 659, 468, 323, 708, 0, 5207, 5207, 0, 815, ++ 402, 486, 361, 519, 415, 551, 401, 472, 508, 468, ++ 483, 522, 584, 524, 523, 589, 510, 591, 625, 754, ++ 522, 658, 755, 330, 573, 827, 658, 0, 706, 625, ++ 562, 705, 603, 607, 611, 618, 755, 819, 637, 815, ++ 756, 644, 693, 826, 714, 829, 744, 5207, 335, 341, + +- 2727, 2738, 2735, 2733, 448, 414, 2726, 468, 2722, 465, +- 2721, 2717, 2702, 2698, 179, 461, 459, 462, 2696, 2686, +- 2770, 2770, 488, 2727, 2723, 498, 2725, 2700, 0, 2720, +- 2698, 2716, 2715, 477, 481, 0, 489, 381, 2710, 516, +- 2694, 513, 496, 2686, 506, 2681, 508, 2678, 2679, 2683, +- 463, 2679, 0, 2695, 2677, 2693, 478, 0, 2671, 2672, +- 0, 483, 2682, 2677, 2677, 507, 521, 2670, 499, 2675, +- 516, 2674, 515, 2670, 2668, 2682, 527, 2662, 2680, 2668, +- 2678, 528, 2669, 2652, 2664, 532, 0, 2668, 2660, 0, +- 2666, 0, 522, 531, 541, 2660, 210, 2658, 523, 2664, ++ 782, 793, 781, 772, 313, 678, 744, 793, 740, 328, ++ 736, 657, 684, 831, 761, 833, 865, 685, 705, 675, ++ 5207, 5207, 557, 741, 737, 597, 702, 707, 0, 676, ++ 765, 657, 656, 840, 881, 0, 880, 688, 650, 934, ++ 767, 895, 693, 761, 922, 786, 930, 824, 842, 850, ++ 925, 889, 0, 908, 892, 910, 929, 0, 890, 926, ++ 0, 945, 939, 936, 938, 950, 950, 937, 940, 946, ++ 991, 953, 983, 970, 971, 998, 999, 982, 1002, 992, ++ 1004, 1014, 998, 984, 998, 1038, 0, 1004, 1002, 0, ++ 1012, 0, 1025, 1044, 1039, 1010, 1047, 1042, 1043, 1054, + +- 2651, 2663, 2666, 2646, 2660, 2646, 2645, 2638, 2640, 547, +- 2645, 2654, 544, 556, 2637, 2656, 2651, 2643, 2653, 551, +- 2652, 2631, 546, 2638, 2648, 536, 558, 2637, 573, 2632, +- 0, 0, 2638, 0, 2643, 2643, 2625, 2639, 2622, 2622, +- 2639, 0, 2644, 2639, 2621, 299, 566, 2621, 2629, 2633, +- 567, 2613, 2630, 2622, 2617, 2613, 2625, 2609, 567, 2625, +- 2613, 570, 2609, 588, 2622, 2621, 572, 2612, 2595, 584, +- 2612, 575, 2598, 582, 2604, 2610, 2595, 2609, 2595, 581, +- 2597, 2606, 2596, 595, 2608, 2607, 2581, 597, 2593, 2603, +- 589, 596, 2592, 2602, 2586, 2592, 2598, 2595, 2578, 2596, ++ 1047, 1062, 1069, 1052, 1068, 1056, 1057, 1054, 1069, 1095, ++ 1081, 1092, 1091, 1103, 1078, 1107, 1106, 1100, 1112, 1103, ++ 1118, 1100, 1127, 1110, 1124, 1140, 1146, 1119, 1154, 1118, ++ 0, 0, 1137, 0, 1158, 1163, 1148, 1164, 1149, 1151, ++ 1170, 0, 644, 1156, 1170, 1170, 1161, 1172, 1178, 1173, ++ 1162, 1200, 1199, 1196, 1195, 1211, 1198, 1201, 1218, 1208, ++ 1208, 1209, 1226, 1224, 1227, 1239, 1220, 1207, 1256, 1226, ++ 1222, 1214, 1251, 1254, 1264, 1252, 1268, 1257, 1269, 1262, ++ 1274, 1266, 1277, 1281, 1283, 1259, 1289, 1278, 1295, 1302, ++ 1308, 1287, 1301, 1305, 1314, 1327, 1327, 1312, 1332, 609, + +- 0, 610, 626, 644, 2587, 2579, 2580, 2573, 0, 2574, +- 0, 0, 2569, 0, 2584, 2587, 2576, 2582, 2574, 2584, +- 2572, 2580, 2570, 2563, 0, 2566, 0, 0, 607, 625, +- 2567, 413, 2560, 2571, 2558, 2570, 2573, 2555, 2548, 2550, +- 627, 2565, 2550, 2547, 2562, 2554, 2551, 2563, 2542, 635, +- 632, 0, 0, 0, 2543, 2542, 2770, 2575, 2550, 2770, +- 2570, 2548, 615, 655, 656, 663, 2562, 2546, 657, 672, +- 2770, 2770, 2770, 2770, 2554, 2770, 2549, 2770, 2535, 2770, +- 2537, 2770, 2530, 2770, 2564, 2770, 2560, 2770, 661, 683, +- 2552, 2551, 2550, 2535, 0, 664, 685, 2548, 2547, 2533, ++ 0, 1339, 894, 1392, 1325, 1319, 1323, 1318, 0, 1321, ++ 0, 0, 1318, 0, 1335, 1356, 1358, 1366, 1365, 1386, ++ 1377, 1390, 1382, 1377, 0, 1382, 0, 0, 1393, 1388, ++ 1389, 1395, 1385, 1398, 1388, 1402, 1408, 1392, 1387, 1391, ++ 1434, 1411, 1407, 1406, 1428, 1433, 1436, 1450, 1431, 1444, ++ 1448, 0, 0, 0, 1440, 1441, 5207, 635, 1453, 5207, ++ 611, 1454, 1467, 1470, 1471, 902, 604, 1457, 1496, 908, ++ 5207, 5207, 5207, 5207, 1466, 5207, 1460, 5207, 1468, 5207, ++ 1463, 5207, 570, 5207, 600, 5207, 596, 5207, 5207, 1502, ++ 1353, 586, 579, 546, 1480, 0, 1509, 1515, 541, 531, + +- 2528, 2524, 2529, 2522, 2525, 2531, 2529, 2520, 2509, 2525, +- 2510, 2509, 2510, 2524, 2507, 2510, 651, 0, 2523, 2502, +- 2521, 2499, 2504, 2510, 2513, 2497, 2501, 0, 2500, 2496, +- 2508, 2493, 2491, 2490, 667, 2497, 2488, 2487, 678, 2493, +- 0, 2491, 2484, 2499, 2481, 2498, 2496, 2490, 2491, 674, +- 2492, 2491, 2481, 674, 2479, 2488, 2485, 2479, 2485, 2484, +- 2483, 0, 0, 2476, 683, 2477, 689, 2480, 2479, 706, +- 2478, 2462, 2472, 2463, 2474, 2473, 2464, 2457, 0, 2483, +- 2471, 683, 2455, 2452, 2468, 683, 2463, 2455, 2443, 689, +- 694, 2449, 2459, 2445, 2459, 2462, 2441, 2446, 2446, 2447, ++ 1484, 1483, 1481, 1493, 1498, 1504, 1512, 1513, 1506, 1498, ++ 1516, 1505, 1506, 1509, 1525, 1512, 1517, 1531, 0, 1532, ++ 1513, 1535, 1516, 1523, 1531, 1543, 1531, 1537, 0, 1542, ++ 1540, 1558, 1550, 1550, 1551, 1562, 1560, 1555, 1557, 1575, ++ 1568, 0, 1569, 1564, 1583, 1568, 1587, 1588, 1584, 1587, ++ 1596, 1590, 1591, 1587, 1616, 1598, 1609, 1612, 1614, 1622, ++ 1623, 1625, 0, 0, 1620, 1663, 1624, 1633, 1634, 1635, ++ 1714, 1638, 1625, 1637, 1631, 1644, 1645, 1638, 1633, 0, ++ 501, 1654, 1682, 1642, 1655, 1678, 1686, 1677, 1675, 1671, ++ 1693, 1698, 1686, 1700, 1701, 1720, 1727, 1710, 1723, 1725, + +- 0, 2453, 697, 2441, 2449, 2450, 2442, 2452, 2432, 2439, +- 2448, 2437, 2432, 2427, 2441, 2420, 2432, 2438, 2428, 2440, +- 2435, 2434, 2418, 2417, 0, 0, 2416, 0, 0, 2419, +- 2426, 2421, 2423, 2420, 2426, 2406, 2422, 2408, 2411, 705, +- 2424, 2403, 2401, 2406, 2401, 2405, 2404, 2400, 2412, 2396, +- 2395, 2394, 2393, 711, 2399, 2391, 2406, 2388, 2404, 2400, +- 2401, 2400, 2390, 708, 2398, 2390, 2396, 2395, 0, 2388, +- 729, 2397, 2392, 752, 2391, 2376, 704, 2376, 2373, 2378, +- 712, 730, 2373, 2383, 2384, 2387, 2366, 2371, 2373, 718, +- 2379, 2363, 2370, 2379, 2368, 2363, 2358, 2372, 2364, 2370, ++ 1728, 0, 1737, 1741, 1731, 1743, 1747, 1742, 1754, 1738, ++ 1748, 1761, 1752, 1753, 1751, 1767, 1749, 1764, 1772, 1765, ++ 1780, 1779, 1782, 1769, 1770, 0, 0, 1773, 0, 0, ++ 1778, 1787, 1784, 1789, 1790, 1799, 1783, 1802, 1791, 1796, ++ 1813, 1812, 1793, 1794, 1804, 1805, 1813, 1815, 1814, 1828, ++ 1815, 1817, 1820, 1823, 1846, 1832, 1826, 1846, 1830, 1848, ++ 1847, 1852, 1857, 1850, 1857, 1862, 1857, 1865, 1867, 0, ++ 1864, 1904, 1880, 1878, 1955, 1879, 1867, 1877, 1870, 1871, ++ 1887, 1898, 1905, 1884, 1913, 1917, 1924, 1905, 1917, 1925, ++ 1954, 1934, 1920, 1932, 1943, 1937, 1946, 1943, 1961, 1957, + +- 2360, 2368, 2352, 0, 2351, 0, 2354, 2374, 2373, 0, +- 2359, 2351, 2350, 2361, 0, 2362, 2357, 2342, 2340, 2347, +- 2344, 2348, 2348, 2340, 2347, 2348, 2343, 2346, 2345, 2344, +- 2328, 2338, 2329, 2332, 0, 0, 2352, 2340, 2339, 2336, +- 2333, 2325, 2313, 2317, 2318, 2315, 2320, 0, 2328, 2325, +- 2319, 2329, 2324, 2303, 2326, 2321, 0, 0, 2770, 2330, +- 2329, 2770, 723, 750, 2328, 2327, 2770, 2314, 2770, 2325, +- 2770, 2324, 2323, 2316, 2311, 2295, 2313, 0, 2306, 2293, +- 2299, 2309, 2290, 2303, 0, 2292, 2305, 2293, 2285, 2285, +- 2293, 2296, 652, 2293, 2278, 2293, 0, 2281, 2292, 2270, ++ 1966, 1962, 1974, 1960, 0, 1961, 0, 1966, 494, 493, ++ 0, 1975, 1973, 1978, 1992, 0, 1995, 1995, 1982, 1985, ++ 2000, 1999, 2005, 2007, 2002, 2011, 2014, 2011, 2017, 2020, ++ 2021, 2007, 2021, 2014, 2019, 0, 0, 485, 2031, 2032, ++ 2031, 2030, 2024, 2014, 2024, 2031, 2031, 2038, 0, 2051, ++ 2050, 2049, 2067, 2064, 2045, 2070, 2068, 0, 0, 5207, ++ 5207, 479, 443, 5207, 2077, 2093, 441, 439, 5207, 2068, ++ 5207, 390, 5207, 384, 337, 2075, 2073, 2061, 2082, 0, ++ 2081, 2072, 2080, 2092, 2075, 2090, 0, 2085, 2101, 2093, ++ 2088, 2090, 2103, 2108, 2099, 2107, 2097, 2119, 0, 2109, + +- 2290, 2275, 2287, 2277, 2285, 2268, 0, 2283, 2282, 2271, +- 2266, 2279, 2278, 2281, 0, 2261, 2271, 0, 2263, 2270, +- 2272, 2256, 2270, 2269, 2252, 2248, 2253, 0, 2257, 727, +- 2256, 2256, 2262, 2251, 2247, 2250, 734, 2258, 2244, 2246, +- 2255, 2245, 748, 2253, 2248, 2235, 2251, 2236, 2234, 2232, +- 2233, 2235, 2188, 241, 251, 756, 278, 368, 382, 530, +- 548, 594, 0, 0, 618, 741, 680, 693, 714, 718, +- 735, 746, 755, 750, 762, 755, 746, 760, 748, 766, +- 765, 769, 751, 774, 775, 763, 762, 774, 772, 781, +- 781, 784, 773, 784, 778, 779, 783, 781, 776, 774, ++ 2122, 2102, 2125, 2113, 2127, 2120, 2132, 2117, 0, 2134, ++ 2139, 2132, 2129, 2144, 2145, 2150, 0, 2136, 2149, 0, ++ 2145, 2155, 2159, 2148, 2164, 2165, 2150, 2149, 2156, 0, ++ 2167, 2172, 2169, 2171, 2180, 2172, 2172, 2179, 2197, 2189, ++ 2177, 2188, 2199, 2191, 2203, 2209, 2208, 2198, 2216, 2207, ++ 2207, 2207, 2211, 2215, 2227, 2232, 2224, 2240, 2234, 2232, ++ 2226, 2237, 2231, 2239, 0, 0, 2255, 2254, 2240, 2250, ++ 2259, 2249, 2261, 2266, 2271, 2268, 2280, 2273, 2263, 2278, ++ 2266, 2285, 2288, 2289, 2270, 2294, 2295, 2284, 2285, 2297, ++ 2295, 2308, 2310, 2313, 2302, 2313, 2307, 2312, 2317, 2317, + +- 791, 782, 793, 787, 0, 791, 0, 796, 784, 784, +- 791, 786, 0, 788, 793, 801, 0, 809, 806, 811, +- 806, 795, 796, 811, 798, 800, 810, 815, 805, 815, +- 819, 0, 800, 822, 809, 823, 815, 809, 826, 0, +- 827, 828, 833, 0, 826, 0, 820, 832, 833, 815, +- 822, 0, 828, 833, 831, 829, 827, 832, 842, 830, +- 835, 846, 838, 850, 849, 846, 852, 837, 840, 845, +- 852, 857, 849, 861, 860, 857, 0, 863, 858, 848, +- 861, 865, 855, 856, 865, 873, 874, 855, 876, 865, +- 864, 876, 874, 882, 873, 884, 881, 870, 887, 878, ++ 2313, 2311, 2331, 2322, 2334, 2329, 0, 2333, 0, 2343, ++ 2331, 2331, 2337, 2333, 0, 2336, 2341, 2350, 0, 2360, ++ 2357, 2362, 2361, 2352, 2353, 2368, 2355, 2357, 2371, 2377, ++ 2369, 2381, 2387, 0, 2368, 2390, 2377, 2392, 2384, 2383, ++ 2400, 0, 2401, 2402, 2408, 0, 2402, 0, 2396, 2409, ++ 2412, 2394, 2401, 0, 2411, 2420, 2415, 2413, 2412, 2417, ++ 2433, 2423, 2428, 2439, 2434, 2458, 2444, 2441, 2449, 2434, ++ 2442, 2447, 2454, 2460, 2454, 2471, 2465, 2464, 0, 2478, ++ 2466, 2463, 2473, 2477, 2474, 2477, 2487, 2495, 2499, 2480, ++ 2501, 2491, 2490, 2507, 2505, 2513, 2504, 2516, 2514, 2503, + +- 889, 883, 0, 887, 892, 880, 880, 0, 881, 893, +- 0, 902, 884, 0, 893, 885, 903, 903, 0, 894, +- 890, 891, 907, 900, 909, 0, 894, 898, 898, 900, +- 910, 901, 909, 921, 903, 912, 920, 914, 918, 908, +- 922, 923, 906, 927, 929, 931, 923, 924, 919, 929, +- 0, 925, 920, 946, 947, 923, 941, 936, 945, 935, +- 930, 940, 0, 934, 946, 934, 941, 951, 950, 947, +- 939, 951, 956, 959, 960, 0, 950, 945, 945, 0, +- 0, 956, 0, 947, 948, 0, 951, 966, 953, 949, +- 968, 956, 0, 955, 0, 973, 0, 0, 959, 973, ++ 2521, 2514, 2525, 2519, 0, 2527, 2534, 2522, 2522, 0, ++ 2523, 2535, 0, 2547, 2530, 0, 2541, 2534, 2552, 2555, ++ 0, 2546, 2542, 2545, 2561, 2559, 2568, 0, 2553, 2557, ++ 2558, 2561, 2571, 2563, 2573, 2585, 2567, 2579, 2587, 2583, ++ 2587, 2577, 2591, 2592, 2579, 2601, 2605, 2608, 2600, 2604, ++ 2599, 2609, 0, 2607, 2602, 335, 333, 2608, 2626, 2621, ++ 2630, 2621, 2617, 2627, 0, 2622, 2636, 2624, 2631, 2644, ++ 2643, 2642, 2634, 2646, 2651, 2654, 2659, 0, 2650, 2647, ++ 2648, 0, 0, 2659, 0, 2653, 2654, 0, 2659, 2674, ++ 2666, 2662, 2681, 2669, 0, 2669, 0, 2688, 0, 0, + +- 976, 961, 977, 0, 972, 981, 957, 984, 981, 997, +- 0, 973, 0, 984, 989, 976, 977, 996, 977, 1001, +- 984, 1004, 981, 1006, 996, 1007, 999, 1012, 995, 0, +- 992, 1015, 995, 1001, 1020, 1002, 1022, 998, 1023, 1013, +- 1023, 0, 1012, 0, 0, 1017, 1010, 1011, 1017, 1028, +- 1020, 1015, 1035, 1036, 1024, 1020, 1024, 1027, 1023, 1028, +- 1035, 1036, 1045, 1028, 1045, 1043, 1041, 1033, 1047, 1044, +- 1037, 1036, 0, 1056, 1039, 1037, 1045, 1057, 1058, 1044, +- 1051, 0, 1061, 1048, 1059, 1057, 0, 1069, 1057, 0, +- 1071, 1067, 1067, 1050, 0, 1058, 0, 1075, 1070, 1068, ++ 2674, 2689, 2720, 2678, 2694, 0, 2699, 2698, 2677, 2703, ++ 2702, 2769, 0, 2696, 0, 2712, 2717, 2709, 2710, 2726, ++ 2706, 2733, 2723, 2744, 2722, 2751, 2742, 2759, 2753, 2766, ++ 2755, 0, 2752, 2776, 2756, 2765, 2784, 2766, 2788, 2764, ++ 2790, 2780, 2792, 0, 2781, 0, 0, 2787, 2781, 2784, ++ 2794, 2806, 2805, 2802, 2822, 2825, 2814, 2811, 2815, 2819, ++ 2815, 2820, 2827, 2831, 2837, 2822, 2839, 2839, 2834, 2826, ++ 2841, 2839, 2835, 2834, 0, 2855, 2840, 2842, 2851, 2870, ++ 2873, 2859, 2868, 0, 2879, 2867, 2878, 2877, 0, 2889, ++ 2877, 0, 2891, 2888, 2889, 2873, 0, 2881, 0, 2897, + +- 1063, 1073, 1079, 1067, 1077, 1069, 1081, 1086, 1089, 1090, +- 0, 1074, 0, 1084, 0, 1075, 1076, 1079, 1080, 1081, +- 0, 1080, 1098, 0, 1084, 1100, 0, 1092, 1104, 1080, +- 1106, 1109, 1094, 0, 1105, 1093, 1116, 1099, 1123, 1105, +- 1125, 1103, 1128, 1118, 1128, 1132, 1109, 1132, 1112, 1118, +- 1137, 1119, 1139, 1115, 1140, 1130, 1140, 1125, 1126, 1133, +- 1128, 1148, 1149, 1132, 1143, 1152, 1135, 1152, 1150, 1148, +- 1153, 1150, 1142, 1140, 1160, 1141, 1149, 1146, 1153, 1149, +- 1160, 1158, 0, 1170, 1158, 0, 1172, 1168, 0, 0, +- 0, 1174, 1171, 1165, 0, 0, 1156, 0, 1175, 1162, ++ 2892, 2890, 2887, 2899, 2904, 2893, 2904, 2898, 2914, 2920, ++ 2930, 2933, 0, 2917, 0, 2929, 0, 2921, 2923, 2927, ++ 2928, 2929, 0, 2928, 2947, 0, 2934, 2952, 0, 2942, ++ 2952, 2930, 2956, 3000, 2944, 0, 2956, 2943, 2964, 2953, ++ 2978, 2967, 2993, 2970, 2996, 2986, 2998, 3003, 2983, 3007, ++ 2987, 2993, 3013, 2996, 3016, 2994, 3019, 3010, 3021, 3008, ++ 3013, 3021, 3023, 3049, 3051, 3035, 3046, 3056, 3039, 3056, ++ 3054, 3053, 3059, 3056, 3048, 3047, 3067, 3047, 3056, 3053, ++ 3060, 3056, 3067, 3065, 0, 3078, 3092, 0, 3080, 3083, ++ 0, 0, 0, 3090, 3103, 3098, 0, 0, 3088, 0, + +- 1177, 0, 1170, 1166, 0, 0, 1170, 0, 0, 1175, +- 1173, 1184, 1176, 1172, 1178, 0, 1178, 1185, 0, 1177, +- 0, 1176, 1192, 0, 1193, 1185, 1193, 1176, 1194, 1189, +- 1185, 1186, 1198, 1193, 1189, 0, 1204, 0, 1202, 1192, +- 0, 1193, 1213, 0, 1195, 1196, 1203, 1198, 0, 1214, +- 1206, 1202, 1213, 0, 1218, 0, 1215, 0, 1205, 0, +- 1211, 1206, 0, 0, 1213, 1214, 1229, 1210, 1207, 1215, +- 0, 1229, 1234, 1235, 1230, 1233, 1236, 1220, 1227, 1241, +- 1228, 1224, 1244, 1241, 1238, 0, 1242, 1233, 1241, 1232, +- 1233, 1235, 1235, 1251, 1245, 1253, 1255, 1244, 1241, 0, ++ 3108, 3095, 3110, 0, 3103, 3099, 0, 0, 3104, 0, ++ 0, 3109, 3107, 3118, 3110, 3106, 3112, 0, 3113, 3146, ++ 0, 3111, 0, 3110, 3126, 0, 3127, 3119, 3128, 3112, ++ 3137, 3132, 3142, 3146, 3158, 3153, 3149, 0, 3164, 0, ++ 3162, 3152, 0, 3154, 3175, 0, 3157, 3158, 3165, 3160, ++ 0, 3176, 3168, 3165, 3176, 0, 3181, 0, 3178, 0, ++ 3168, 0, 3174, 3170, 0, 0, 3178, 3186, 3202, 3190, ++ 3193, 3202, 0, 3217, 3222, 3223, 3218, 3221, 3224, 3208, ++ 3216, 3231, 3218, 3214, 3234, 3231, 3228, 0, 3232, 3224, ++ 3232, 3223, 3225, 3226, 3227, 3244, 3245, 3254, 3263, 3258, + +- 1242, 0, 1247, 1245, 1246, 1246, 1247, 1263, 1257, 1265, +- 1267, 1256, 1253, 1262, 0, 0, 1270, 1284, 1258, 1273, +- 1273, 1255, 1269, 1262, 0, 0, 0, 0, 1269, 1269, +- 1266, 1281, 1285, 1269, 1269, 1275, 1290, 1272, 0, 1279, +- 1272, 1290, 1276, 1296, 1293, 1296, 1299, 0, 0, 1296, +- 1293, 0, 0, 1283, 1285, 1285, 1302, 1302, 1294, 1294, +- 1309, 1299, 1296, 0, 1298, 1294, 1307, 1302, 1298, 1313, +- 0, 1300, 1320, 0, 1302, 1303, 1310, 0, 1311, 1307, +- 1318, 0, 1323, 1320, 0, 1315, 1310, 0, 1317, 1318, +- 1333, 1314, 1311, 1319, 1337, 1338, 1333, 1336, 1339, 1329, ++ 3256, 0, 3258, 0, 3263, 3261, 3262, 3262, 3263, 3279, ++ 3274, 3283, 3285, 3274, 3271, 3280, 0, 0, 3288, 335, ++ 3275, 3291, 3291, 3273, 3287, 3280, 0, 0, 0, 0, ++ 3287, 3288, 3286, 3308, 3313, 3304, 3310, 3317, 3333, 3315, ++ 0, 3322, 3315, 3333, 3319, 3339, 3337, 3342, 3343, 0, ++ 0, 3341, 3338, 0, 0, 3328, 3330, 3330, 3348, 3348, ++ 3340, 3340, 3355, 3345, 3343, 0, 3354, 3351, 3370, 3371, ++ 3368, 3384, 0, 3371, 3391, 0, 3373, 3374, 3381, 0, ++ 3382, 3379, 3391, 0, 3396, 3393, 0, 3388, 3383, 0, ++ 3390, 3391, 3387, 3384, 3409, 3410, 3405, 3408, 3412, 3403, + +- 1343, 1330, 1326, 1346, 1343, 1340, 0, 1344, 1332, 1333, +- 1334, 1334, 1351, 1345, 1353, 1355, 1344, 1341, 1342, 1347, +- 1345, 1346, 1346, 1347, 1363, 1357, 1365, 1367, 1356, 1353, +- 0, 1369, 1370, 1370, 1352, 1366, 0, 1364, 1378, 1362, +- 1362, 1368, 1383, 1365, 1372, 1365, 1383, 1369, 1389, 1388, +- 1391, 1388, 1385, 0, 1375, 1377, 1377, 1394, 1394, 1386, +- 1386, 1401, 1383, 0, 1384, 0, 0, 0, 1385, 0, +- 0, 1394, 0, 1416, 1390, 1390, 0, 0, 1397, 1393, +- 1408, 0, 1409, 0, 0, 1411, 1404, 1401, 2770, 1406, +- 1414, 1411, 1420, 1401, 1418, 1409, 1411, 1421, 1422, 1414, ++ 3424, 3412, 3415, 3441, 3439, 3437, 0, 3441, 3429, 3430, ++ 3432, 3432, 3449, 3444, 3452, 3454, 3443, 3440, 3441, 3446, ++ 3445, 3446, 3446, 3447, 3463, 3457, 3466, 3469, 3465, 3463, ++ 0, 3486, 3493, 3494, 3477, 3491, 0, 3489, 3503, 3487, ++ 3487, 3493, 3509, 3492, 3499, 3492, 3510, 3496, 3516, 3518, ++ 3517, 3515, 3513, 0, 3503, 3505, 3505, 3523, 3524, 3525, ++ 3532, 3553, 3536, 0, 3538, 0, 0, 0, 3539, 0, ++ 0, 3548, 0, 322, 3542, 3542, 0, 0, 3549, 3545, ++ 3561, 0, 3563, 0, 0, 3565, 3558, 3555, 5207, 3560, ++ 3568, 3565, 3575, 3556, 3573, 3564, 3566, 3576, 3578, 3571, + +- 1420, 1410, 1424, 0, 0, 1425, 1424, 1419, 0, 1415, +- 0, 1420, 1425, 1426, 1435, 1420, 1440, 1426, 1431, 0, +- 1441, 1433, 1441, 0, 1438, 1443, 1442, 1447, 1433, 1447, +- 1429, 1440, 1438, 1430, 1442, 0, 1444, 1450, 0, 1451, +- 1440, 1444, 1458, 0, 1455, 1453, 1458, 1466, 1463, 0, +- 1460, 1469, 1450, 1454, 1468, 0, 1465, 1463, 1468, 1472, +- 0, 1465, 1463, 1478, 1467, 1481, 1466, 1485, 0, 1473, +- 0, 1469, 1484, 1481, 1482, 1474, 1477, 1490, 1494, 1493, +- 1480, 1492, 1484, 1499, 1489, 1496, 1486, 1494, 1488, 1504, +- 1507, 1506, 1508, 1501, 1512, 1498, 1499, 1513, 1514, 1508, ++ 3584, 3575, 3596, 0, 0, 3603, 3603, 3599, 0, 3595, ++ 0, 3600, 3605, 3606, 3615, 3600, 3621, 3608, 3613, 0, ++ 3623, 3615, 3623, 0, 3620, 3625, 3625, 3630, 3616, 3630, ++ 3612, 3623, 3622, 3615, 3634, 0, 3637, 3650, 0, 3657, ++ 3647, 3652, 3666, 0, 3663, 3661, 3666, 3674, 3671, 0, ++ 3669, 3679, 3660, 3664, 3678, 0, 3675, 3673, 3678, 3683, ++ 0, 3676, 3674, 3689, 3678, 3720, 3678, 3714, 0, 3710, ++ 0, 3707, 3722, 3719, 3720, 3712, 3715, 3727, 3731, 3731, ++ 3718, 3729, 3722, 3737, 3727, 3735, 3725, 3733, 3727, 3743, ++ 3774, 3748, 3766, 3765, 3777, 3764, 3765, 3779, 3780, 3774, + +- 1516, 1521, 1502, 1519, 1510, 1521, 1513, 1519, 1509, 1523, +- 1524, 1523, 1518, 0, 1514, 1519, 1524, 1525, 1534, 1519, +- 1539, 1525, 1530, 1540, 1532, 1540, 0, 1537, 1540, 1545, +- 1531, 1545, 1527, 1538, 1536, 1528, 1540, 1547, 0, 1548, +- 1537, 1541, 1555, 0, 1552, 1550, 1555, 1563, 1560, 0, +- 1557, 1566, 1547, 1551, 1565, 0, 1562, 1560, 1565, 0, +- 1571, 1560, 1574, 1559, 1565, 1575, 1572, 1573, 1565, 1568, +- 1580, 1583, 1583, 1571, 1582, 1574, 1579, 1586, 1576, 1584, +- 1578, 1594, 1597, 1596, 1598, 1591, 1602, 1588, 1589, 1599, +- 0, 1604, 1605, 1598, 1596, 1613, 0, 0, 1596, 1612, ++ 3782, 3787, 3768, 3785, 3776, 3787, 3779, 3785, 3775, 3789, ++ 3790, 3789, 3785, 0, 3781, 3786, 3791, 3792, 3805, 3826, ++ 3817, 3831, 3823, 3831, 0, 3829, 3832, 3837, 3823, 3837, ++ 3819, 3830, 3828, 3820, 3832, 3839, 0, 3840, 3829, 3833, ++ 3847, 0, 3844, 3842, 3848, 3856, 3853, 0, 3850, 3859, ++ 3844, 3865, 3884, 0, 3881, 3879, 3884, 0, 3891, 3880, ++ 3894, 3879, 3885, 3895, 3892, 3893, 3885, 3888, 3900, 3903, ++ 3903, 3891, 3903, 3896, 3900, 3907, 3901, 3926, 3925, 3941, ++ 3945, 3942, 3946, 3939, 3950, 3936, 3937, 3947, 0, 3952, ++ 3953, 3946, 3944, 3961, 0, 0, 3944, 3960, 3960, 3961, + +- 1612, 1613, 1614, 1605, 1608, 1607, 1604, 1610, 1612, 1608, +- 1622, 1610, 1616, 1623, 1616, 1627, 1628, 0, 1619, 1621, +- 1631, 1617, 1633, 1624, 1635, 1633, 1630, 1638, 0, 1639, +- 1626, 0, 1632, 1629, 1636, 1641, 1637, 1638, 1633, 1634, +- 1633, 1650, 1638, 1644, 1632, 1633, 1642, 1639, 0, 1640, +- 1662, 0, 0, 0, 1638, 1651, 1648, 1645, 0, 1646, +- 1668, 0, 0, 1669, 1657, 1671, 1658, 1656, 1674, 1661, +- 1676, 1657, 1670, 0, 1673, 0, 1664, 1670, 1669, 1669, +- 1673, 0, 1674, 1683, 1669, 0, 1675, 0, 0, 1679, +- 1666, 1685, 0, 1675, 1683, 1696, 1678, 1683, 1676, 0, ++ 3963, 3954, 3957, 3956, 3953, 3963, 3982, 3983, 3997, 3985, ++ 3991, 3999, 3992, 4003, 4004, 0, 3995, 3997, 4007, 3993, ++ 4009, 4000, 4011, 4009, 4006, 4014, 0, 4015, 4002, 0, ++ 4008, 4006, 4013, 4018, 4014, 4015, 4014, 4032, 4036, 4053, ++ 4041, 4047, 4036, 4037, 4046, 4043, 0, 4044, 4066, 0, ++ 0, 0, 4042, 4055, 4052, 4049, 0, 4050, 4072, 0, ++ 0, 4073, 4061, 4075, 4062, 4060, 4079, 4066, 4106, 4061, ++ 4102, 0, 4077, 0, 4072, 4101, 4100, 4101, 4105, 0, ++ 4106, 4115, 4101, 0, 4107, 0, 0, 4111, 4098, 4117, ++ 0, 4107, 4115, 4128, 4110, 4115, 4108, 0, 4128, 4121, + +- 1696, 1689, 1698, 0, 0, 1689, 1692, 1687, 1693, 1695, +- 1691, 1697, 1704, 1697, 1708, 1709, 0, 1700, 1702, 1712, +- 1698, 1714, 1705, 1716, 1714, 1711, 1719, 0, 1720, 1707, +- 0, 1713, 1716, 1721, 1717, 1718, 1713, 1714, 1713, 1730, +- 1718, 1711, 1712, 1721, 1718, 0, 1719, 1741, 0, 0, +- 0, 1717, 1730, 1727, 1724, 0, 1725, 1747, 0, 1734, +- 1732, 1750, 1737, 1752, 1733, 1746, 0, 0, 1744, 1743, +- 1743, 1746, 0, 1747, 1757, 1743, 0, 1749, 0, 1753, +- 1740, 1759, 0, 1749, 1756, 1769, 1752, 1757, 1750, 0, +- 1770, 1763, 1772, 1763, 1761, 0, 1779, 1767, 1781, 1776, ++ 4131, 0, 0, 4122, 4125, 4121, 4131, 4150, 4149, 4156, ++ 4163, 4156, 4167, 4169, 0, 4160, 4162, 4172, 4158, 4174, ++ 4165, 4176, 4170, 4178, 4179, 4166, 0, 4172, 4175, 4180, ++ 4176, 4177, 4173, 4174, 4173, 4191, 4183, 4193, 4197, 4207, ++ 4204, 0, 4205, 4227, 0, 0, 0, 4204, 4217, 4214, ++ 4211, 0, 4212, 4234, 0, 4221, 4219, 4237, 4224, 4239, ++ 4220, 4248, 0, 0, 4230, 4229, 4229, 4233, 0, 4236, ++ 4245, 4232, 0, 4260, 0, 4267, 4255, 4274, 0, 4264, ++ 4271, 4285, 4267, 4272, 4265, 0, 4285, 4278, 4287, 4278, ++ 4276, 0, 4294, 4282, 4296, 4291, 4282, 0, 4276, 0, + +- 1767, 0, 1761, 0, 0, 1768, 0, 1773, 0, 1784, +- 0, 1776, 0, 0, 0, 1785, 1777, 1774, 0, 1779, +- 0, 1781, 1786, 0, 1778, 0, 0, 1788, 0, 0, +- 0, 1791, 1780, 1795, 1796, 1801, 0, 1800, 1801, 1796, +- 1797, 1794, 1807, 1804, 1805, 1806, 1811, 1804, 1794, 1810, +- 1813, 1812, 1817, 1810, 1800, 1807, 1817, 1803, 1812, 1812, +- 1823, 1815, 1804, 1815, 1810, 1805, 1819, 1828, 1822, 1832, +- 1829, 1823, 1837, 0, 0, 1824, 1826, 1826, 1837, 0, +- 0, 0, 1831, 0, 1843, 0, 1824, 0, 1832, 1829, +- 0, 0, 1844, 0, 1836, 0, 1845, 1837, 1834, 0, ++ 0, 4284, 0, 4290, 0, 4301, 0, 4293, 0, 0, ++ 0, 4303, 4299, 4311, 0, 4317, 0, 4322, 4328, 0, ++ 4320, 0, 0, 4330, 0, 0, 0, 4333, 4323, 4338, ++ 4339, 4344, 0, 4343, 4344, 4339, 4340, 4337, 4350, 4347, ++ 4348, 4349, 4354, 4347, 4338, 4355, 4358, 4357, 4363, 4360, ++ 4365, 4373, 4386, 4373, 4382, 4382, 4393, 4386, 4375, 4386, ++ 4381, 4376, 4390, 4399, 4393, 4403, 4400, 4394, 4408, 0, ++ 0, 4395, 4397, 4397, 4409, 0, 0, 0, 4404, 0, ++ 4416, 0, 4397, 0, 4406, 4407, 0, 0, 4437, 0, ++ 4430, 0, 4442, 4435, 4432, 0, 4437, 0, 4439, 4445, + +- 1839, 0, 1841, 1846, 0, 1838, 0, 0, 1848, 0, +- 0, 0, 1851, 1854, 1855, 1860, 0, 1859, 1860, 1855, +- 1856, 1853, 1862, 1863, 1864, 1869, 1862, 1852, 1868, 1871, +- 1870, 1875, 1868, 1858, 1867, 1867, 1878, 1870, 1859, 1870, +- 1865, 1860, 1874, 1885, 1882, 1876, 1890, 0, 0, 1877, +- 1879, 1879, 1890, 0, 0, 0, 1884, 0, 1896, 0, +- 1877, 0, 1885, 1886, 1882, 1888, 1898, 1884, 1900, 1894, +- 0, 1889, 0, 1905, 1908, 0, 1890, 1897, 0, 0, +- 1897, 0, 1893, 0, 0, 1905, 0, 1895, 1915, 1916, +- 1900, 1899, 1919, 1897, 0, 0, 1903, 1911, 1921, 1921, ++ 0, 4437, 0, 4447, 0, 0, 0, 4450, 4453, 4454, ++ 4459, 0, 4458, 4459, 4454, 4455, 4452, 4461, 4462, 4463, ++ 4469, 4463, 4453, 4469, 4473, 4476, 4496, 4490, 4483, 4493, ++ 4493, 4504, 4496, 4486, 4497, 4492, 4487, 4501, 4512, 4509, ++ 4503, 4517, 0, 0, 4504, 4506, 4506, 4517, 0, 0, ++ 0, 4511, 0, 4523, 0, 4505, 0, 4514, 4515, 4511, ++ 4518, 4532, 4533, 4550, 4547, 0, 4543, 0, 4559, 4562, ++ 0, 4544, 4552, 0, 0, 4552, 0, 4548, 0, 0, ++ 4560, 0, 4550, 4570, 4571, 4555, 4554, 4574, 4552, 0, ++ 0, 4558, 4567, 4576, 4577, 0, 4579, 4566, 4574, 4584, + +- 0, 1922, 1909, 1917, 1926, 1926, 1907, 0, 1924, 1919, +- 1934, 1925, 1922, 1919, 1920, 1928, 1936, 1940, 1924, 0, +- 1943, 0, 0, 1925, 0, 0, 1928, 0, 1942, 1928, +- 1935, 1947, 1933, 1949, 1952, 0, 1934, 1941, 0, 0, +- 1941, 0, 1937, 0, 1949, 0, 1939, 1959, 1960, 1944, +- 1943, 1963, 0, 0, 1946, 1954, 1965, 1965, 0, 1966, +- 1953, 1961, 1970, 1970, 1961, 1976, 1967, 1964, 1961, 1962, +- 1970, 1978, 1982, 1984, 0, 0, 1966, 0, 0, 1969, +- 0, 1983, 1969, 1976, 1988, 0, 0, 1967, 0, 1984, +- 1975, 0, 1994, 1981, 1989, 1978, 1974, 0, 1986, 1976, ++ 4588, 4584, 0, 4602, 4600, 4616, 4607, 4604, 4601, 4603, ++ 4611, 4619, 4623, 4607, 0, 4626, 0, 0, 4608, 0, ++ 0, 4611, 0, 4625, 4611, 4618, 4641, 4616, 4646, 4634, ++ 0, 4616, 4624, 0, 0, 4625, 0, 4621, 0, 4633, ++ 0, 4647, 4670, 4672, 4656, 4655, 4675, 0, 0, 4659, ++ 4667, 4676, 4676, 0, 4677, 4664, 4672, 4681, 4681, 4672, ++ 4687, 4679, 4676, 4673, 4675, 4684, 4692, 4696, 4699, 0, ++ 0, 4685, 0, 0, 4699, 0, 4716, 4703, 4713, 4726, ++ 0, 0, 4705, 0, 4722, 4713, 0, 4733, 4720, 4728, ++ 4717, 4713, 0, 4725, 4715, 4721, 0, 4730, 4731, 4739, + +- 1982, 0, 1991, 1992, 2000, 2001, 1987, 1990, 0, 0, +- 2005, 0, 0, 2002, 0, 2007, 0, 0, 2012, 1996, +- 1995, 2009, 1999, 2009, 2010, 2011, 0, 2006, 0, 2019, +- 0, 0, 0, 2003, 2015, 2000, 0, 2025, 2012, 2020, +- 2009, 2005, 0, 2017, 2007, 2013, 0, 2022, 2023, 2031, +- 2032, 2018, 0, 0, 2034, 0, 0, 2031, 0, 2036, +- 0, 2024, 2023, 2037, 2027, 2037, 2038, 2039, 0, 2034, +- 2047, 0, 0, 0, 2031, 2043, 2028, 0, 0, 2053, +- 0, 2041, 2044, 2056, 0, 2042, 0, 0, 2054, 2055, +- 2056, 2043, 2050, 0, 2055, 0, 2039, 0, 2054, 0, ++ 4742, 4728, 4731, 0, 0, 4747, 0, 0, 4744, 0, ++ 4749, 0, 0, 4755, 4743, 4753, 4770, 4761, 4774, 4776, ++ 4777, 0, 4772, 0, 4785, 0, 0, 0, 4770, 4782, ++ 4767, 0, 4792, 4779, 4787, 4776, 4772, 0, 4784, 4774, ++ 4780, 0, 4790, 4791, 4799, 4801, 4788, 0, 0, 4804, ++ 0, 0, 4801, 0, 4807, 0, 4799, 4809, 4826, 4817, ++ 4830, 4832, 4833, 0, 4828, 4841, 0, 0, 0, 4826, ++ 4838, 4823, 0, 0, 4848, 0, 4836, 4839, 4851, 0, ++ 4837, 0, 0, 4849, 4850, 4851, 4839, 4846, 0, 4851, ++ 0, 4836, 0, 4852, 0, 0, 4847, 0, 4840, 4842, + +- 0, 2049, 0, 2042, 2043, 2056, 2059, 2064, 2068, 2054, +- 0, 2061, 2064, 2076, 0, 2062, 0, 0, 2074, 2075, +- 2076, 2063, 2070, 0, 0, 2058, 0, 0, 0, 2067, +- 0, 2060, 2061, 2074, 2077, 2082, 2086, 2072, 0, 2081, +- 2087, 2080, 2092, 2092, 2085, 0, 0, 0, 0, 2073, +- 2095, 0, 2086, 2097, 2098, 2099, 0, 2100, 2088, 2088, +- 2101, 2094, 2106, 2106, 2099, 0, 0, 0, 0, 2108, +- 2099, 2110, 2111, 2112, 0, 2113, 2101, 2101, 0, 2116, +- 2104, 2108, 0, 0, 2119, 0, 2104, 0, 0, 2123, +- 0, 2113, 0, 2123, 2111, 2115, 0, 0, 0, 2110, ++ 4859, 4873, 4881, 4886, 4875, 0, 4883, 4886, 4898, 0, ++ 4884, 0, 0, 4897, 4898, 4899, 4886, 4893, 0, 0, ++ 4881, 0, 0, 0, 4890, 0, 4883, 4884, 4897, 4900, ++ 4906, 4910, 4896, 0, 4906, 4913, 4906, 4918, 4919, 4916, ++ 0, 0, 0, 0, 4915, 4940, 0, 4932, 4946, 4948, ++ 4949, 0, 4950, 4938, 4939, 4952, 4945, 4957, 4957, 4950, ++ 0, 0, 0, 0, 4959, 4950, 4961, 4962, 4963, 0, ++ 4965, 4953, 4953, 0, 4969, 4958, 4962, 0, 0, 4973, ++ 0, 4959, 0, 0, 4982, 0, 4983, 0, 4996, 4985, ++ 4992, 0, 0, 0, 4988, 0, 0, 5007, 0, 4997, + +- 0, 0, 2129, 0, 2119, 0, 0, 0, 2111, 0, +- 2121, 2121, 0, 0, 0, 2114, 2124, 2124, 0, 2137, +- 2137, 2130, 2140, 2140, 2133, 2131, 2138, 2145, 2134, 2135, +- 2142, 2149, 2138, 2142, 2129, 2142, 2140, 2148, 2135, 2147, +- 2145, 2149, 2160, 2154, 0, 2152, 2163, 2157, 0, 2152, +- 0, 2156, 2154, 0, 2158, 0, 2156, 0, 2157, 0, +- 0, 2770, 2197, 2202, 2207, 2212, 2217, 2219, 2224, 2205, +- 2227, 2231, 2236, 2241, 2246, 2251, 2256, 2261, 2266 ++ 0, 0, 0, 4989, 0, 5000, 5000, 0, 0, 0, ++ 4993, 5003, 5003, 0, 5017, 5015, 5009, 5031, 5019, 5012, ++ 5011, 5018, 5025, 5015, 5017, 5024, 5038, 5038, 5045, 5033, ++ 5048, 5047, 5054, 5041, 5053, 5052, 5056, 5067, 5061, 0, ++ 5059, 5070, 5064, 0, 5059, 0, 5064, 5062, 0, 5067, ++ 0, 5065, 0, 5066, 0, 0, 5207, 5132, 5137, 5142, ++ 5147, 5152, 5154, 5159, 325, 5162, 5166, 5171, 5176, 5181, ++ 5186, 5191, 5196, 5201 + } ; + +-static yyconst short int yy_def[2480] = ++static yyconst flex_int16_t yy_def[2475] = + { 0, +- 2462, 1, 2462, 3, 2462, 5, 2462, 7, 2463, 2463, +- 2462, 2462, 2462, 2462, 2464, 2465, 2466, 2467, 2462, 2468, +- 2469, 2462, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2462, 2462, 2470, 2462, +- 2462, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2462, 2471, 2472, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2462, 2462, 2462, ++ 2457, 1, 2457, 3, 2457, 5, 2457, 7, 2458, 2458, ++ 2457, 2457, 2457, 2457, 2459, 2460, 2461, 2462, 2457, 2463, ++ 2464, 2457, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2457, 2457, 2465, 2457, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2457, 2457, 2466, 2467, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2457, 2457, 2457, + +- 2462, 2473, 2462, 2474, 2462, 2462, 2475, 2462, 2462, 2462, +- 2462, 2476, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, +- 2462, 2462, 2462, 2477, 2478, 2462, 2464, 2462, 2465, 2466, +- 2462, 2467, 2467, 2462, 2462, 2468, 2468, 2468, 2479, 2469, +- 2468, 2462, 2462, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, ++ 2457, 2468, 2457, 2469, 2457, 2457, 2470, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2471, 2457, ++ 2457, 2457, 2457, 2472, 2473, 2457, 2459, 2457, 2460, 2461, ++ 2457, 2462, 2462, 2457, 2457, 2463, 2463, 2463, 2474, 2464, ++ 2463, 2457, 2457, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, + +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2470, 2462, 2462, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2465, 2457, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2457, + +- 2471, 2471, 2471, 2472, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2462, 2473, 2462, 2462, +- 2474, 2462, 2462, 2462, 2462, 2462, 2475, 2462, 2462, 2462, +- 2462, 2462, 2462, 2462, 2476, 2462, 2462, 2462, 2462, 2462, +- 2462, 2462, 2462, 2462, 2477, 2462, 2478, 2462, 2462, 2462, +- 2462, 2468, 2468, 2462, 2468, 2462, 2462, 2462, 2462, 2468, ++ 2466, 2466, 2466, 2467, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2457, 2468, 2457, 2457, ++ 2469, 2457, 2457, 2457, 2457, 2457, 2470, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2471, 2457, 2472, 2457, 2473, 2457, 2457, 2457, ++ 2457, 2457, 2463, 2463, 2457, 2463, 2457, 2457, 2457, 2457, + +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, + +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, + +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2462, 2462, +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, +- 2462, 2462, 2462, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, + +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, + +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, + +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2462, 2462, 2462, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2457, 2457, 2457, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, + +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2470, 2470, 2470, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2465, + +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, + +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2462, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2457, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, + +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, + +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2462, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2457, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, + +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2470, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2465, + +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2471, +- 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, 2471, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2466, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, + +- 2471, 2471, 2471, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, ++ 2466, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, + +- 2468, 2468, 2468, 2468, 2468, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2471, 2471, 2471, 2471, 2471, 2471, 2471, ++ 2463, 2463, 2463, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2466, + +- 2471, 2471, 2471, 2471, 2471, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, ++ 2466, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, + +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2471, 2471, 2471, 2471, 2471, 2471, 2471, +- 2471, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2466, 2466, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, + +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2471, 2471, 2471, 2471, 2471, +- 2471, 2471, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2466, 2466, 2466, 2466, 2466, 2466, 2466, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, + +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2471, 2471, +- 2471, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2466, 2466, 2466, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, + +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2471, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, +- 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2470, 2471, 2468, +- 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2470, 2470, 2470, 2470, 2470, 2470, 2470, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2466, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, ++ 2465, 2465, 2465, 2466, 2463, 2463, 2463, 2463, 2463, 2463, ++ 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, 2465, + +- 2470, 2470, 2470, 2470, 2470, 2470, 2468, 2468, 2468, 2468, +- 2468, 2468, 2468, 2470, 2470, 2470, 2470, 2470, 2470, 2468, +- 2468, 2468, 2470, 2470, 2470, 2468, 2468, 2468, 2468, 2470, +- 2470, 2470, 2470, 2468, 2468, 2468, 2468, 2470, 2470, 2470, +- 2470, 2468, 2468, 2468, 2468, 2470, 2470, 2470, 2470, 2468, +- 2468, 2468, 2470, 2470, 2470, 2468, 2468, 2470, 2470, 2468, +- 2470, 0, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462 ++ 2465, 2463, 2463, 2463, 2463, 2463, 2463, 2463, 2465, 2465, ++ 2465, 2465, 2465, 2465, 2463, 2463, 2463, 2465, 2465, 2465, ++ 2463, 2463, 2463, 2463, 2465, 2465, 2465, 2465, 2463, 2463, ++ 2463, 2463, 2465, 2465, 2465, 2465, 2463, 2463, 2463, 2463, ++ 2465, 2465, 2465, 2465, 2463, 2463, 2463, 2465, 2465, 2465, ++ 2463, 2463, 2465, 2465, 2463, 2465, 0, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457 + } ; + +-static yyconst short int yy_nxt[2822] = ++static yyconst flex_int16_t yy_nxt[5285] = + { 0, + 12, 13, 14, 13, 13, 12, 15, 16, 12, 17, + 18, 12, 12, 19, 20, 21, 22, 12, 12, 12, +- 12, 12, 23, 24, 25, 26, 27, 28, 29, 30, +- 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, +- 41, 42, 43, 44, 45, 46, 46, 46, 12, 12, +- 12, 12, 12, 47, 48, 12, 12, 12, 12, 12, +- 12, 12, 12, 12, 12, 49, 49, 50, 12, 12, +- 12, 51, 12, 52, 53, 54, 55, 56, 57, 58, +- 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, +- 69, 70, 71, 72, 49, 73, 49, 49, 49, 48, ++ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, ++ 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, ++ 43, 44, 45, 46, 46, 46, 12, 12, 23, 24, ++ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, ++ 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, ++ 45, 46, 46, 46, 12, 12, 12, 12, 12, 47, ++ 48, 12, 12, 12, 12, 12, 12, 12, 12, 12, ++ 12, 49, 49, 50, 12, 12, 12, 51, 52, 53, + +- 12, 48, 12, 13, 47, 74, 13, 12, 15, 12, +- 12, 17, 18, 12, 12, 19, 75, 76, 22, 12, +- 12, 12, 12, 12, 77, 78, 79, 80, 81, 82, ++ 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, ++ 64, 65, 66, 67, 68, 69, 70, 71, 49, 72, ++ 49, 49, 49, 73, 12, 51, 52, 53, 54, 55, ++ 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, ++ 66, 67, 68, 69, 70, 71, 49, 72, 49, 49, ++ 49, 48, 12, 48, 12, 13, 47, 74, 13, 12, ++ 15, 12, 12, 17, 18, 12, 12, 19, 75, 76, ++ 22, 12, 12, 12, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 78, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 78, 97, 78, 78, 78, +- 48, 12, 48, 98, 99, 47, 100, 99, 101, 102, +- 98, 103, 104, 98, 98, 98, 105, 106, 107, 108, +- 109, 110, 111, 98, 112, 113, 98, 98, 98, 114, +- 98, 115, 98, 116, 98, 98, 117, 98, 118, 119, +- 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, + +- 98, 120, 98, 121, 123, 374, 123, 123, 123, 124, +- 123, 123, 125, 124, 137, 126, 125, 126, 126, 134, +- 378, 135, 181, 182, 138, 139, 139, 139, 139, 139, +- 139, 139, 139, 139, 139, 139, 139, 139, 473, 142, +- 141, 135, 139, 144, 139, 145, 139, 198, 175, 147, +- 474, 143, 146, 148, 170, 184, 176, 149, 171, 185, +- 160, 199, 172, 161, 162, 177, 150, 1035, 173, 151, +- 245, 174, 246, 139, 139, 139, 152, 163, 153, 250, +- 164, 178, 251, 154, 155, 179, 1036, 156, 247, 180, +- 157, 266, 267, 158, 159, 165, 166, 167, 186, 213, ++ 12, 12, 77, 78, 79, 80, 81, 82, 83, 84, ++ 85, 78, 86, 87, 88, 89, 90, 91, 92, 93, ++ 94, 95, 96, 78, 97, 78, 78, 78, 48, 12, ++ 48, 98, 99, 47, 100, 99, 101, 102, 98, 103, ++ 104, 98, 98, 98, 105, 106, 107, 108, 109, 110, ++ 111, 112, 98, 98, 98, 113, 98, 114, 98, 115, ++ 98, 98, 116, 98, 117, 118, 98, 98, 98, 98, ++ 98, 98, 98, 98, 98, 98, 98, 98, 119, 112, ++ 98, 98, 98, 113, 98, 114, 98, 115, 98, 98, ++ 116, 98, 117, 118, 98, 98, 98, 98, 98, 98, + +- 187, 168, 188, 214, 1040, 248, 189, 169, 249, 190, +- 193, 231, 191, 215, 194, 192, 200, 201, 195, 270, +- 232, 279, 233, 271, 202, 206, 234, 532, 203, 207, +- 196, 204, 205, 208, 197, 280, 209, 283, 281, 210, +- 533, 284, 211, 216, 217, 218, 272, 225, 219, 220, +- 273, 226, 252, 221, 274, 227, 253, 222, 314, 315, +- 223, 228, 236, 237, 229, 224, 238, 276, 239, 254, +- 240, 230, 255, 256, 257, 241, 260, 302, 258, 306, +- 261, 307, 277, 278, 259, 285, 262, 303, 308, 263, +- 286, 287, 290, 391, 392, 297, 291, 393, 1041, 298, ++ 98, 98, 98, 98, 98, 120, 98, 121, 123, 183, ++ 123, 123, 123, 124, 123, 123, 125, 124, 137, 126, ++ 125, 126, 126, 134, 212, 135, 138, 363, 242, 364, ++ 142, 126, 135, 126, 126, 1692, 126, 183, 126, 126, ++ 143, 144, 126, 145, 126, 126, 372, 235, 1562, 957, ++ 146, 957, 212, 675, 138, 139, 139, 139, 139, 139, ++ 139, 139, 139, 139, 139, 139, 139, 139, 143, 144, ++ 141, 145, 139, 147, 139, 235, 178, 148, 146, 160, ++ 179, 149, 161, 162, 180, 165, 166, 167, 181, 182, ++ 150, 168, 249, 151, 184, 250, 163, 169, 185, 164, + +- 292, 299, 288, 334, 335, 350, 293, 289, 300, 294, +- 126, 336, 126, 126, 351, 337, 295, 139, 139, 139, +- 139, 1042, 139, 139, 139, 139, 139, 139, 139, 139, +- 365, 317, 305, 309, 139, 318, 139, 139, 139, 310, +- 366, 632, 311, 329, 324, 319, 325, 330, 312, 313, +- 338, 355, 326, 633, 339, 327, 343, 340, 356, 331, +- 341, 328, 363, 332, 364, 139, 139, 139, 345, 346, +- 344, 352, 126, 347, 126, 126, 126, 348, 126, 126, +- 353, 349, 369, 372, 364, 381, 354, 379, 357, 126, +- 410, 126, 126, 389, 370, 142, 380, 135, 383, 126, ++ 675, 147, 139, 373, 178, 148, 672, 160, 179, 149, ++ 161, 162, 180, 165, 166, 167, 181, 182, 150, 168, ++ 249, 151, 184, 250, 163, 169, 185, 164, 198, 139, ++ 139, 139, 152, 244, 153, 245, 175, 170, 263, 154, ++ 155, 171, 199, 156, 176, 172, 157, 255, 256, 158, ++ 159, 173, 257, 177, 174, 668, 198, 668, 258, 663, ++ 152, 244, 153, 245, 175, 170, 263, 154, 155, 171, ++ 199, 156, 176, 172, 157, 255, 256, 158, 159, 173, ++ 257, 177, 174, 186, 193, 187, 258, 188, 194, 213, ++ 231, 189, 195, 214, 190, 663, 264, 191, 937, 232, + +- 382, 126, 126, 390, 411, 137, 420, 143, 398, 398, +- 421, 416, 399, 417, 373, 138, 139, 139, 139, 139, +- 139, 139, 139, 139, 139, 139, 139, 139, 139, 396, +- 425, 141, 405, 139, 401, 139, 430, 139, 433, 397, +- 431, 402, 434, 406, 426, 427, 428, 403, 436, 443, +- 437, 438, 450, 451, 439, 456, 466, 444, 476, 463, +- 1043, 464, 477, 445, 139, 139, 139, 465, 509, 452, +- 513, 457, 467, 458, 468, 469, 470, 488, 459, 493, +- 489, 514, 471, 495, 494, 504, 505, 490, 1044, 496, +- 534, 515, 510, 516, 497, 519, 498, 561, 506, 517, ++ 192, 233, 267, 215, 196, 234, 246, 268, 197, 610, ++ 610, 186, 193, 187, 769, 188, 194, 213, 231, 189, ++ 195, 214, 190, 247, 264, 191, 248, 232, 192, 233, ++ 267, 215, 196, 234, 246, 268, 197, 200, 201, 251, ++ 265, 266, 269, 252, 274, 202, 270, 400, 275, 203, ++ 281, 247, 204, 205, 248, 295, 253, 400, 126, 254, ++ 126, 126, 394, 276, 277, 200, 201, 251, 265, 266, ++ 269, 252, 274, 202, 270, 259, 275, 203, 281, 260, ++ 204, 205, 206, 295, 253, 261, 207, 254, 262, 302, ++ 208, 276, 277, 209, 316, 394, 210, 303, 126, 211, + +- 539, 535, 540, 520, 548, 552, 553, 565, 549, 554, +- 556, 580, 569, 562, 570, 521, 573, 574, 557, 592, +- 571, 581, 585, 596, 558, 566, 302, 1045, 586, 598, +- 567, 365, 627, 587, 597, 588, 303, 599, 391, 608, +- 1046, 366, 609, 593, 139, 139, 139, 139, 628, 139, +- 139, 139, 139, 139, 139, 139, 139, 642, 629, 305, +- 643, 139, 655, 139, 139, 139, 630, 644, 653, 369, +- 654, 364, 365, 663, 656, 660, 660, 389, 691, 661, +- 396, 370, 366, 664, 665, 665, 692, 390, 666, 974, +- 397, 975, 139, 139, 139, 391, 391, 672, 672, 670, ++ 126, 126, 672, 259, 271, 386, 386, 260, 272, 278, ++ 206, 282, 273, 261, 207, 283, 262, 384, 208, 368, ++ 362, 209, 316, 279, 210, 303, 280, 211, 216, 217, ++ 218, 320, 271, 219, 220, 321, 272, 278, 221, 282, ++ 273, 359, 222, 283, 322, 223, 323, 284, 314, 315, ++ 224, 279, 285, 286, 280, 300, 216, 217, 218, 320, ++ 243, 219, 220, 321, 287, 395, 221, 133, 133, 288, ++ 222, 333, 322, 223, 323, 284, 314, 315, 224, 225, ++ 285, 286, 296, 226, 342, 131, 297, 227, 298, 306, ++ 375, 307, 287, 228, 365, 299, 229, 288, 308, 333, + +- 708, 673, 713, 724, 729, 739, 740, 725, 709, 774, +- 741, 747, 714, 742, 730, 748, 769, 775, 781, 779, +- 770, 1049, 793, 743, 744, 782, 1050, 745, 751, 752, +- 780, 753, 827, 754, 794, 842, 755, 879, 853, 663, +- 828, 880, 884, 895, 1051, 843, 756, 757, 854, 664, +- 758, 860, 861, 885, 886, 896, 862, 1007, 1015, 863, +- 1052, 887, 954, 954, 1008, 1016, 955, 1047, 1053, 864, +- 865, 1048, 1022, 866, 869, 870, 1054, 871, 1023, 872, +- 1037, 1055, 873, 1056, 1057, 1058, 1038, 1059, 1060, 1061, +- 1024, 1064, 874, 875, 1062, 1065, 876, 1066, 1039, 1063, ++ 392, 393, 366, 230, 394, 399, 399, 225, 128, 400, ++ 296, 226, 342, 343, 297, 227, 298, 306, 375, 307, ++ 372, 228, 382, 299, 229, 317, 308, 344, 309, 318, ++ 366, 230, 236, 237, 310, 388, 238, 311, 239, 319, ++ 240, 343, 350, 312, 313, 241, 386, 386, 372, 382, ++ 382, 351, 384, 317, 374, 344, 309, 318, 371, 368, ++ 236, 237, 310, 388, 238, 311, 239, 319, 240, 355, ++ 350, 312, 313, 241, 289, 324, 356, 325, 290, 351, ++ 338, 362, 291, 326, 339, 377, 327, 340, 292, 360, ++ 341, 293, 328, 389, 378, 396, 401, 355, 294, 359, + +- 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, +- 1077, 1078, 1079, 1080, 1082, 1083, 1084, 1085, 1086, 1087, +- 1088, 1089, 1090, 1091, 1092, 1081, 1093, 1094, 1095, 1096, +- 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, +- 1107, 1108, 1109, 1111, 1110, 1112, 1113, 1114, 1115, 1116, +- 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, +- 1127, 1128, 1129, 1130, 1132, 1133, 1134, 1135, 1136, 1137, +- 1131, 1138, 1139, 1140, 1141, 1144, 1145, 1146, 1147, 1148, +- 1142, 1149, 1150, 1151, 1152, 1153, 1156, 1157, 1160, 1158, +- 1161, 1154, 1143, 1159, 1162, 1163, 1164, 1165, 1166, 1167, ++ 357, 300, 289, 324, 356, 325, 290, 369, 338, 364, ++ 291, 326, 339, 377, 327, 340, 292, 370, 341, 293, ++ 328, 389, 378, 396, 401, 405, 294, 139, 139, 139, ++ 139, 243, 139, 139, 139, 139, 139, 139, 139, 139, ++ 334, 335, 305, 329, 139, 370, 139, 330, 336, 345, ++ 346, 352, 337, 405, 347, 374, 390, 379, 348, 331, ++ 353, 133, 349, 332, 391, 408, 354, 131, 334, 335, ++ 376, 329, 380, 139, 139, 330, 336, 345, 346, 352, ++ 337, 409, 347, 374, 410, 379, 348, 331, 353, 357, ++ 349, 332, 391, 408, 354, 142, 137, 135, 376, 381, + +- 1168, 1169, 1170, 1155, 1171, 1172, 1173, 1174, 1175, 1176, +- 1177, 1178, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, +- 1188, 1189, 1190, 1179, 1191, 1192, 1193, 1194, 1195, 1196, +- 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, +- 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, 1216, +- 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, 1226, +- 1227, 1228, 955, 955, 1229, 1230, 1231, 1232, 1233, 1234, +- 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, +- 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, +- 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, ++ 380, 139, 139, 139, 138, 143, 392, 609, 128, 409, ++ 610, 397, 410, 2457, 662, 662, 2457, 357, 663, 398, ++ 667, 667, 2457, 2457, 668, 2457, 413, 381, 414, 415, ++ 416, 419, 138, 143, 139, 139, 139, 139, 139, 139, ++ 139, 139, 139, 139, 139, 139, 139, 398, 402, 141, ++ 411, 139, 406, 139, 413, 403, 414, 415, 416, 419, ++ 417, 404, 418, 407, 412, 420, 421, 423, 424, 425, ++ 422, 426, 428, 429, 430, 431, 402, 433, 411, 432, ++ 406, 139, 2457, 403, 436, 427, 2457, 2457, 417, 404, ++ 418, 407, 412, 420, 421, 423, 424, 425, 422, 426, + +- 1265, 1271, 1272, 1275, 1276, 1273, 1277, 1278, 1286, 1287, +- 1266, 1288, 1289, 1267, 1268, 1274, 1290, 1269, 1270, 1279, +- 1291, 1280, 1292, 1293, 1281, 1294, 1295, 1282, 1296, 1297, +- 1298, 1283, 1299, 1300, 1301, 1302, 1284, 1285, 1303, 1304, +- 1305, 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, +- 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, +- 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1333, 1334, 1335, +- 1336, 1338, 1339, 1340, 1341, 1332, 1342, 1337, 1343, 1344, +- 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, 1354, +- 1355, 1356, 1357, 1359, 1360, 1362, 1363, 1364, 1358, 1365, ++ 428, 429, 430, 431, 441, 433, 442, 432, 139, 139, ++ 139, 434, 436, 427, 437, 435, 438, 439, 443, 444, ++ 440, 447, 448, 449, 450, 2457, 454, 445, 455, 456, ++ 461, 2457, 441, 446, 442, 462, 451, 452, 463, 434, ++ 2457, 473, 437, 435, 438, 439, 443, 444, 440, 447, ++ 448, 449, 450, 453, 454, 445, 455, 456, 461, 457, ++ 464, 446, 465, 462, 451, 452, 463, 467, 466, 473, ++ 469, 470, 471, 474, 476, 458, 477, 459, 472, 479, ++ 478, 453, 460, 468, 480, 475, 481, 457, 464, 482, ++ 465, 483, 484, 485, 486, 467, 466, 487, 469, 470, + +- 1366, 1367, 1368, 1369, 1361, 1370, 1371, 1372, 1373, 1374, +- 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, +- 1385, 1386, 1387, 1388, 1389, 1395, 1397, 1398, 1399, 1407, +- 1408, 1400, 1409, 1401, 1390, 1396, 1402, 1391, 1392, 1403, +- 1410, 1393, 1394, 1404, 1411, 1412, 1413, 1414, 1405, 1406, +- 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, +- 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, +- 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1444, 1445, +- 1446, 1447, 1448, 1449, 1443, 1450, 1451, 1452, 1453, 1454, +- 1455, 1456, 1457, 1458, 1460, 1461, 1463, 1464, 1465, 1459, ++ 471, 474, 476, 458, 477, 459, 472, 479, 478, 488, ++ 460, 468, 480, 475, 481, 492, 493, 482, 500, 483, ++ 484, 485, 486, 489, 494, 487, 490, 501, 496, 495, ++ 502, 503, 504, 491, 497, 505, 506, 488, 508, 498, ++ 509, 499, 512, 492, 493, 513, 500, 510, 507, 2457, ++ 519, 489, 494, 523, 490, 501, 496, 495, 502, 503, ++ 504, 491, 497, 505, 506, 524, 508, 498, 509, 499, ++ 512, 511, 514, 513, 520, 510, 507, 516, 519, 517, ++ 525, 523, 521, 515, 526, 518, 527, 528, 529, 530, ++ 531, 532, 535, 524, 522, 537, 533, 538, 539, 511, + +- 1466, 1467, 1468, 1469, 1470, 1462, 1471, 1472, 1473, 1474, +- 1475, 1476, 1477, 1478, 1479, 1480, 1482, 1483, 1484, 1485, +- 1486, 1487, 1488, 1489, 1481, 1490, 1491, 1492, 1493, 1494, +- 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, +- 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, +- 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, +- 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1533, 1534, 1535, +- 1536, 1537, 1538, 1539, 1532, 1540, 1541, 1542, 1543, 1544, +- 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, +- 1555, 1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, ++ 514, 542, 520, 536, 540, 516, 541, 517, 525, 534, ++ 521, 515, 526, 518, 527, 528, 529, 530, 531, 532, ++ 535, 543, 522, 537, 533, 538, 539, 544, 545, 542, ++ 546, 536, 540, 547, 541, 548, 549, 534, 551, 552, ++ 550, 553, 554, 556, 560, 555, 557, 561, 564, 543, ++ 2457, 565, 569, 573, 558, 544, 545, 570, 546, 571, ++ 559, 547, 562, 548, 549, 572, 551, 552, 550, 553, ++ 554, 556, 560, 555, 557, 561, 564, 566, 563, 565, ++ 569, 573, 558, 574, 575, 570, 576, 571, 559, 577, ++ 562, 578, 579, 572, 580, 567, 583, 581, 584, 585, + +- 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, +- 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, +- 1585, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595, +- 1596, 1597, 1598, 1599, 1600, 1601, 1586, 1602, 1603, 1604, +- 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, +- 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, +- 1625, 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1635, +- 1636, 1637, 1638, 1639, 1640, 1641, 1634, 1642, 1643, 1644, +- 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, +- 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, ++ 568, 590, 586, 591, 592, 566, 563, 582, 587, 593, ++ 595, 574, 575, 588, 576, 589, 596, 577, 601, 578, ++ 579, 602, 580, 567, 583, 581, 584, 585, 568, 590, ++ 586, 591, 592, 594, 597, 582, 587, 593, 595, 599, ++ 603, 588, 604, 589, 596, 598, 601, 600, 605, 602, ++ 606, 607, 608, 611, 612, 302, 613, 614, 615, 616, ++ 617, 594, 597, 303, 2457, 392, 392, 599, 603, 672, ++ 604, 2457, 2457, 598, 2457, 600, 605, 618, 606, 607, ++ 608, 611, 612, 2457, 613, 614, 615, 616, 617, 619, ++ 620, 303, 139, 139, 139, 139, 621, 139, 139, 139, + +- 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, +- 1675, 1676, 1677, 1679, 1680, 1681, 1682, 1683, 1684, 1685, +- 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1678, 1694, +- 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, +- 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, +- 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, +- 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, +- 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, +- 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, 1754, +- 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, ++ 139, 139, 139, 139, 139, 618, 622, 305, 623, 139, ++ 2457, 139, 624, 625, 626, 627, 628, 619, 620, 630, ++ 632, 633, 635, 636, 621, 637, 638, 631, 639, 640, ++ 641, 642, 629, 634, 622, 646, 623, 2457, 139, 139, ++ 624, 625, 626, 627, 628, 647, 648, 630, 632, 633, ++ 635, 636, 649, 637, 638, 631, 639, 640, 641, 642, ++ 629, 634, 643, 646, 650, 644, 139, 139, 139, 651, ++ 652, 653, 645, 647, 648, 654, 656, 655, 658, 659, ++ 649, 660, 661, 365, 369, 664, 364, 365, 657, 360, ++ 643, 366, 650, 644, 370, 366, 669, 651, 652, 653, + +- 1766, 1765, 1767, 1768, 1769, 1770, 1774, 1775, 1776, 1777, +- 1778, 1779, 1780, 1781, 1782, 1771, 1783, 1772, 1784, 1785, +- 1786, 1773, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, +- 1795, 1796, 1798, 1797, 1799, 1800, 1801, 1802, 1803, 1804, +- 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, +- 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, +- 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, +- 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, 1843, 1844, +- 1845, 1846, 1847, 1848, 1849, 1850, 1851, 1852, 1853, 1854, +- 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1867, ++ 645, 670, 671, 654, 656, 655, 658, 659, 673, 660, ++ 661, 676, 665, 664, 677, 678, 657, 360, 390, 366, ++ 666, 679, 370, 366, 669, 397, 391, 674, 674, 670, ++ 671, 675, 680, 398, 681, 682, 673, 683, 684, 676, ++ 685, 686, 677, 678, 687, 688, 689, 690, 666, 679, ++ 691, 692, 695, 696, 391, 697, 693, 698, 699, 700, ++ 680, 398, 681, 682, 694, 683, 684, 701, 685, 686, ++ 702, 703, 687, 688, 689, 690, 704, 705, 691, 692, ++ 695, 696, 706, 697, 693, 698, 699, 700, 707, 708, ++ 709, 712, 694, 710, 713, 701, 714, 715, 702, 703, + +- 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1864, 1876, +- 1865, 1877, 1878, 1879, 1866, 1880, 1881, 1882, 1883, 1884, +- 1885, 1886, 1888, 1887, 1889, 1890, 1891, 1892, 1893, 1894, +- 1895, 1896, 1897, 1899, 1898, 1900, 1901, 1902, 1903, 1904, +- 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, +- 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, +- 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, +- 1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, 1943, 1944, +- 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, +- 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1965, ++ 717, 711, 718, 719, 704, 705, 720, 716, 721, 722, ++ 706, 723, 724, 725, 728, 729, 707, 708, 709, 712, ++ 730, 710, 713, 726, 714, 715, 2457, 727, 717, 711, ++ 718, 719, 733, 734, 720, 716, 721, 722, 735, 723, ++ 724, 725, 728, 729, 731, 736, 737, 738, 730, 739, ++ 740, 726, 748, 749, 732, 727, 2457, 750, 751, 752, ++ 733, 734, 761, 2457, 762, 763, 735, 764, 765, 766, ++ 767, 768, 731, 736, 737, 738, 770, 739, 740, 773, ++ 748, 749, 732, 741, 742, 750, 751, 752, 743, 2457, ++ 761, 744, 762, 763, 774, 764, 765, 766, 767, 768, + +- 1966, 1968, 1969, 1970, 1971, 1972, 1964, 1973, 1974, 1975, +- 1976, 1977, 1978, 1979, 1980, 1981, 1967, 1982, 1983, 1984, +- 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, +- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, +- 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, +- 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, +- 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, +- 2035, 2036, 2037, 2038, 2039, 2041, 2042, 2044, 2045, 2046, +- 2047, 2048, 2040, 2049, 2050, 2051, 2052, 2053, 2054, 2055, +- 2056, 2057, 2043, 2058, 2059, 2060, 2061, 2062, 2063, 2064, ++ 775, 745, 746, 778, 770, 747, 2457, 773, 779, 2457, ++ 776, 741, 742, 771, 2457, 780, 743, 772, 777, 744, ++ 783, 781, 774, 785, 2457, 2457, 786, 784, 775, 745, ++ 746, 778, 782, 747, 753, 754, 779, 755, 776, 756, ++ 787, 771, 757, 780, 788, 772, 777, 789, 783, 781, ++ 790, 785, 758, 759, 786, 784, 760, 791, 792, 793, ++ 782, 794, 753, 754, 795, 755, 797, 756, 787, 798, ++ 757, 799, 788, 800, 801, 789, 796, 802, 790, 803, ++ 758, 759, 804, 805, 760, 791, 792, 793, 806, 794, ++ 807, 808, 795, 809, 797, 810, 811, 798, 812, 799, + +- 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, +- 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, +- 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093, 2094, +- 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, +- 2105, 2106, 2107, 2108, 2109, 2110, 2111, 2112, 2113, 2114, +- 2115, 2116, 2117, 2118, 2119, 2120, 2121, 2122, 2123, 2124, +- 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, +- 2135, 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, +- 2145, 2146, 2147, 2148, 2149, 2150, 2151, 2152, 2153, 2154, +- 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, ++ 813, 800, 801, 814, 796, 802, 815, 803, 816, 817, ++ 804, 805, 818, 819, 820, 821, 806, 822, 807, 808, ++ 823, 809, 824, 810, 811, 825, 812, 826, 813, 827, ++ 828, 814, 831, 832, 815, 833, 816, 817, 829, 834, ++ 818, 819, 820, 821, 835, 822, 830, 836, 823, 837, ++ 824, 838, 839, 825, 840, 826, 841, 827, 828, 842, ++ 831, 832, 843, 833, 846, 847, 829, 834, 844, 848, ++ 849, 850, 835, 851, 830, 836, 852, 837, 845, 838, ++ 839, 853, 840, 854, 841, 855, 857, 842, 858, 859, ++ 843, 860, 846, 847, 861, 856, 844, 848, 849, 850, + +- 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2174, +- 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, 2184, +- 2185, 2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, +- 2196, 2197, 2198, 2199, 2200, 2201, 2202, 2203, 2204, 2205, +- 2206, 2207, 2208, 2209, 2210, 2195, 2211, 2212, 2213, 2214, +- 2215, 2216, 2217, 2218, 2219, 2220, 2221, 2222, 2223, 2224, +- 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233, 2234, +- 2235, 2236, 2238, 2239, 2241, 2242, 2243, 2244, 2245, 2246, +- 2247, 2248, 2249, 2250, 2251, 2252, 2253, 2254, 2237, 2240, +- 2255, 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, ++ 869, 851, 870, 879, 852, 880, 845, 883, 881, 853, ++ 884, 854, 882, 855, 857, 2457, 858, 859, 2457, 860, ++ 885, 890, 861, 856, 862, 863, 886, 888, 869, 864, ++ 870, 879, 865, 880, 889, 883, 881, 887, 884, 891, ++ 882, 892, 866, 867, 893, 894, 868, 2457, 885, 890, ++ 2457, 895, 862, 863, 886, 888, 896, 864, 899, 900, ++ 865, 2457, 889, 901, 902, 887, 2457, 891, 903, 892, ++ 866, 867, 893, 894, 868, 871, 872, 897, 873, 895, ++ 874, 904, 905, 875, 896, 906, 899, 900, 907, 898, ++ 908, 901, 902, 876, 877, 909, 903, 878, 910, 911, + +- 2265, 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, +- 2275, 2276, 2277, 2279, 2280, 2281, 2282, 2283, 2284, 2285, +- 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2278, +- 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 2303, 2304, +- 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, +- 2315, 2316, 2317, 2318, 2319, 2320, 2321, 2322, 2323, 2324, +- 2325, 2326, 2327, 2328, 2329, 2330, 2331, 2332, 2333, 2334, +- 2335, 2336, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, +- 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, +- 2355, 2356, 2357, 2358, 2359, 2360, 2361, 2362, 2363, 2364, ++ 912, 913, 914, 871, 872, 897, 873, 915, 874, 904, ++ 905, 875, 916, 906, 917, 918, 907, 898, 908, 919, ++ 920, 876, 877, 909, 921, 878, 910, 911, 912, 913, ++ 914, 922, 923, 924, 925, 915, 926, 927, 928, 929, ++ 916, 930, 917, 918, 931, 932, 933, 919, 920, 934, ++ 935, 936, 921, 938, 939, 940, 941, 942, 943, 922, ++ 923, 924, 925, 944, 926, 927, 928, 929, 945, 930, ++ 946, 947, 931, 932, 933, 948, 949, 934, 935, 936, ++ 950, 938, 939, 940, 941, 942, 943, 951, 952, 953, ++ 954, 944, 955, 665, 958, 959, 945, 960, 946, 947, + +- 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, +- 2375, 2376, 2377, 2378, 2379, 2380, 2381, 2382, 2383, 2384, +- 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392, 2393, 2394, +- 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 2404, +- 2405, 2406, 2407, 2408, 2409, 2410, 2411, 2412, 2413, 2414, +- 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, +- 2425, 2426, 2428, 2429, 2430, 2432, 2433, 2434, 2435, 2436, +- 2437, 2438, 2439, 2440, 2441, 2442, 2443, 2427, 2444, 2445, +- 2431, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, +- 2455, 2456, 2457, 2458, 2459, 2460, 2461, 122, 122, 122, ++ 961, 666, 962, 948, 949, 956, 956, 963, 950, 957, ++ 964, 965, 966, 967, 968, 951, 952, 953, 954, 969, ++ 955, 970, 958, 959, 971, 960, 972, 973, 961, 666, ++ 962, 974, 975, 978, 976, 963, 977, 979, 964, 965, ++ 966, 967, 968, 980, 981, 982, 983, 969, 984, 970, ++ 985, 986, 971, 987, 972, 973, 988, 989, 990, 974, ++ 975, 978, 976, 991, 977, 979, 992, 993, 994, 995, ++ 996, 980, 981, 982, 983, 997, 984, 998, 985, 986, ++ 999, 987, 1000, 1001, 988, 989, 990, 1002, 1003, 1004, ++ 1005, 991, 1006, 1007, 992, 993, 994, 995, 996, 1008, + +- 122, 122, 127, 127, 127, 127, 127, 129, 242, 129, +- 129, 129, 130, 130, 130, 130, 130, 132, 1034, 132, +- 132, 132, 136, 136, 140, 140, 140, 140, 140, 301, +- 301, 304, 304, 304, 304, 304, 358, 358, 358, 358, +- 358, 361, 361, 361, 361, 361, 367, 367, 367, 367, +- 367, 375, 375, 375, 375, 375, 385, 385, 385, 385, +- 385, 387, 387, 387, 387, 387, 139, 139, 139, 139, +- 139, 1033, 1032, 1031, 1030, 1029, 1028, 1027, 1026, 1025, +- 1021, 1020, 1019, 1018, 1017, 1014, 1013, 1012, 1011, 1010, +- 1009, 1006, 1005, 1004, 1003, 1002, 1001, 1000, 999, 998, ++ 1009, 1011, 1012, 997, 1013, 998, 1014, 1010, 999, 1015, ++ 1000, 1001, 1016, 1019, 1020, 1002, 1003, 1004, 1005, 1017, ++ 1006, 1007, 1021, 1022, 1023, 1024, 1018, 1008, 1009, 1011, ++ 1012, 1025, 1013, 1027, 1014, 1010, 1028, 1015, 1029, 1030, ++ 1016, 1019, 1020, 1026, 1031, 1032, 1033, 1017, 1034, 1035, ++ 1021, 1022, 1023, 1024, 1018, 1036, 1037, 1038, 1042, 1025, ++ 1043, 1027, 1039, 1044, 1028, 1045, 1029, 1030, 1040, 1046, ++ 1047, 1026, 1031, 1032, 1033, 1048, 1034, 1035, 1049, 1051, ++ 1041, 1052, 1050, 1036, 1037, 1038, 1042, 1053, 1043, 1054, ++ 1039, 1044, 1055, 1045, 1056, 1057, 1040, 1046, 1047, 1058, + +- 997, 996, 995, 994, 993, 992, 991, 990, 989, 988, +- 987, 986, 985, 984, 983, 982, 981, 980, 979, 978, +- 977, 976, 973, 972, 971, 970, 969, 968, 967, 966, +- 965, 964, 963, 962, 961, 960, 959, 958, 957, 673, +- 673, 670, 956, 666, 666, 661, 661, 953, 952, 951, +- 950, 949, 948, 947, 946, 945, 944, 943, 942, 941, +- 940, 939, 938, 937, 936, 935, 934, 933, 932, 931, +- 930, 929, 928, 927, 926, 925, 924, 923, 922, 921, +- 920, 919, 918, 917, 916, 915, 914, 913, 912, 609, +- 609, 911, 910, 909, 908, 907, 906, 905, 904, 903, ++ 1059, 1060, 1061, 1048, 1062, 1063, 1049, 1051, 1041, 1052, ++ 1050, 1064, 1066, 1067, 1068, 1053, 1065, 1054, 1069, 1070, ++ 1055, 1071, 1056, 1057, 1072, 1073, 1074, 1058, 1059, 1060, ++ 1061, 1075, 1062, 1063, 1076, 1077, 1078, 1079, 1080, 1064, ++ 1066, 1067, 1068, 1081, 1065, 1082, 1069, 1070, 1084, 1071, ++ 1085, 1086, 1072, 1073, 1074, 1087, 1088, 1083, 1089, 1075, ++ 1090, 1091, 1076, 1077, 1078, 1079, 1080, 1092, 1093, 1094, ++ 1095, 1081, 1096, 1082, 1097, 1098, 1084, 1099, 1085, 1086, ++ 1100, 1101, 1102, 1087, 1088, 1083, 1089, 1103, 1090, 1091, ++ 1104, 1105, 1106, 1107, 1108, 1092, 1093, 1094, 1095, 1109, + +- 902, 901, 900, 899, 898, 897, 894, 893, 892, 891, +- 890, 889, 888, 883, 882, 881, 878, 877, 868, 867, +- 859, 858, 857, 856, 855, 852, 851, 850, 849, 848, +- 847, 846, 845, 844, 841, 840, 839, 838, 837, 836, +- 835, 834, 833, 832, 831, 830, 829, 826, 825, 824, +- 823, 822, 821, 820, 819, 818, 817, 816, 815, 814, +- 813, 812, 811, 810, 809, 808, 807, 806, 805, 804, +- 803, 802, 801, 800, 799, 798, 797, 796, 795, 792, +- 791, 790, 789, 788, 787, 786, 785, 784, 783, 778, +- 777, 776, 773, 772, 771, 768, 767, 766, 765, 764, ++ 1096, 1110, 1097, 1098, 1111, 1099, 1112, 1113, 1100, 1101, ++ 1102, 1114, 1115, 1116, 1117, 1103, 1118, 1119, 1104, 1105, ++ 1106, 1107, 1108, 1120, 1121, 1122, 1123, 1109, 1124, 1110, ++ 1125, 1126, 1111, 1127, 1112, 1113, 1128, 1129, 1130, 1114, ++ 1115, 1116, 1117, 1131, 1118, 1119, 1134, 1135, 1132, 1136, ++ 1137, 1120, 1121, 1122, 1123, 1133, 1124, 1138, 1125, 1126, ++ 1139, 1127, 1140, 1141, 1128, 1129, 1130, 1142, 1146, 1147, ++ 2457, 1131, 1148, 1149, 1134, 1135, 1132, 1136, 1137, 1150, ++ 1143, 1151, 1152, 1133, 1153, 1138, 1144, 1154, 1139, 1158, ++ 1140, 1141, 1159, 1155, 1162, 1142, 1146, 1147, 1145, 1156, + +- 763, 762, 761, 760, 759, 750, 749, 746, 738, 737, +- 736, 735, 734, 733, 732, 731, 728, 727, 726, 723, +- 722, 721, 720, 719, 718, 717, 716, 715, 712, 711, +- 710, 707, 706, 705, 704, 703, 702, 701, 700, 699, +- 698, 697, 696, 695, 694, 693, 690, 689, 688, 687, +- 686, 685, 684, 683, 682, 681, 680, 679, 678, 677, +- 676, 675, 674, 399, 399, 671, 393, 393, 670, 386, +- 386, 669, 668, 667, 360, 376, 662, 368, 659, 362, +- 659, 359, 658, 657, 652, 651, 650, 649, 648, 647, +- 646, 645, 641, 640, 639, 638, 637, 636, 635, 634, ++ 1148, 1149, 1160, 1163, 1164, 1165, 1161, 1150, 1143, 1151, ++ 1152, 1157, 1153, 1166, 1144, 1154, 1167, 1158, 1168, 1169, ++ 1159, 1155, 1162, 1170, 1171, 1172, 1145, 1156, 1173, 1174, ++ 1160, 1163, 1164, 1165, 1161, 1175, 1176, 1177, 1178, 1157, ++ 1179, 1166, 1180, 1182, 1167, 1183, 1168, 1169, 1184, 1185, ++ 1186, 1170, 1171, 1172, 1181, 1187, 1173, 1174, 1188, 1189, ++ 1190, 1191, 1192, 1175, 1176, 1177, 1178, 1193, 1179, 1194, ++ 1180, 1182, 1195, 1183, 1196, 1197, 1184, 1185, 1186, 1198, ++ 1199, 1200, 1181, 1187, 1201, 1202, 1188, 1189, 1190, 1191, ++ 1192, 1203, 1204, 1205, 1206, 1193, 1207, 1194, 1208, 1209, + +- 631, 626, 625, 624, 623, 622, 621, 620, 619, 618, +- 617, 616, 615, 614, 613, 612, 611, 610, 607, 606, +- 605, 604, 603, 602, 601, 600, 595, 594, 591, 590, +- 589, 584, 583, 582, 579, 578, 577, 576, 575, 572, +- 568, 564, 563, 560, 559, 555, 551, 550, 547, 546, +- 545, 544, 543, 542, 541, 538, 537, 536, 531, 244, +- 243, 530, 529, 528, 527, 526, 525, 524, 523, 522, +- 518, 512, 511, 508, 507, 503, 502, 501, 500, 499, +- 492, 491, 487, 486, 485, 484, 483, 482, 481, 480, +- 479, 478, 475, 472, 462, 461, 460, 455, 454, 453, ++ 1195, 1210, 1196, 1197, 1211, 1212, 1213, 1198, 1199, 1200, ++ 1214, 1215, 1201, 1202, 1216, 1217, 1218, 1219, 1220, 1203, ++ 1204, 1205, 1206, 1221, 1207, 1222, 1208, 1209, 1223, 1210, ++ 1224, 1225, 1211, 1212, 1213, 1226, 1227, 1228, 1214, 1215, ++ 1229, 1230, 1216, 1217, 1218, 1219, 1220, 1231, 1232, 1233, ++ 1234, 1221, 1235, 1222, 1236, 1237, 1223, 1238, 1224, 1225, ++ 1239, 1240, 1241, 1226, 1227, 1228, 1242, 1243, 1229, 1230, ++ 1244, 1245, 1246, 1247, 1248, 1231, 1232, 1233, 1234, 1249, ++ 1235, 1250, 1236, 1237, 1251, 1238, 1252, 1253, 1239, 1240, ++ 1241, 1254, 1255, 1256, 1242, 1243, 1257, 1258, 1244, 1245, + +- 449, 448, 447, 446, 442, 441, 440, 435, 432, 429, +- 424, 423, 422, 419, 418, 415, 414, 413, 412, 409, +- 408, 407, 404, 400, 395, 394, 133, 133, 388, 131, +- 388, 128, 386, 386, 384, 384, 372, 377, 376, 374, +- 371, 368, 362, 360, 359, 357, 342, 333, 323, 322, +- 321, 320, 316, 296, 282, 275, 269, 268, 265, 264, +- 244, 243, 235, 212, 183, 133, 131, 128, 2462, 11, +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, ++ 1246, 1247, 1248, 1259, 1260, 1261, 1262, 1249, 1263, 1250, ++ 1264, 1265, 1251, 1266, 1252, 1253, 1273, 1274, 1277, 1254, ++ 1255, 1256, 1278, 1279, 1257, 1258, 1280, 2457, 2457, 1288, ++ 1275, 1259, 1260, 1261, 1262, 1289, 1263, 1290, 1264, 1265, ++ 1276, 1266, 1267, 1291, 1273, 1274, 1277, 1292, 1293, 1294, ++ 1278, 1279, 1268, 1295, 1280, 1269, 1270, 1288, 1275, 1271, ++ 1272, 2457, 1296, 1289, 1297, 1290, 2457, 1298, 1276, 2457, ++ 1267, 1291, 1299, 2457, 1300, 1292, 1293, 1294, 2457, 2457, ++ 1268, 1295, 1301, 1269, 1270, 1302, 1303, 1271, 1272, 1281, ++ 1296, 1282, 1297, 1304, 1283, 1298, 1305, 1284, 1306, 1307, + +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, +- 2462 ++ 1299, 1285, 1300, 1308, 1309, 1310, 1286, 1287, 1311, 1312, ++ 1301, 1313, 1314, 1302, 1303, 1315, 1316, 1281, 1317, 1282, ++ 1318, 1304, 1283, 1319, 1305, 1284, 1306, 1307, 1320, 1285, ++ 1321, 1308, 1309, 1310, 1286, 1287, 1311, 1312, 1322, 1313, ++ 1314, 1323, 1324, 1315, 1316, 1325, 1317, 1326, 1318, 1327, ++ 1328, 1319, 1329, 1330, 1331, 1332, 1320, 1335, 1321, 1333, ++ 1336, 1337, 1340, 1341, 1338, 1342, 1322, 1343, 1334, 1323, ++ 1324, 1339, 1344, 1325, 1345, 1326, 1346, 1327, 1328, 1347, ++ 1329, 1330, 1331, 1332, 1348, 1335, 1349, 1333, 1336, 1337, ++ 1340, 1341, 1338, 1342, 1350, 1343, 1334, 1351, 1352, 1339, ++ ++ 1344, 1353, 1345, 1354, 1346, 1355, 1356, 1347, 1357, 1358, ++ 1359, 1361, 1348, 1362, 1349, 1364, 1360, 1365, 1366, 1367, ++ 1368, 1369, 1350, 1363, 1370, 1351, 1352, 1371, 1372, 1353, ++ 1373, 1354, 1374, 1355, 1356, 1375, 1357, 1358, 1359, 1361, ++ 1376, 1362, 1377, 1364, 1360, 1365, 1366, 1367, 1368, 1369, ++ 1378, 1363, 1370, 1379, 1380, 1371, 1372, 1381, 1373, 1382, ++ 1374, 1383, 1384, 1375, 1385, 1386, 1387, 1388, 1376, 1389, ++ 1377, 1390, 1397, 1395, 1391, 1398, 1399, 1407, 1378, 1408, ++ 1409, 1379, 1380, 1396, 1392, 1381, 1410, 1382, 1393, 1383, ++ 1384, 1394, 1385, 1386, 1387, 1388, 1411, 1389, 1412, 1390, ++ ++ 1397, 1395, 1391, 1398, 1399, 1407, 1413, 1408, 1409, 2457, ++ 2457, 1396, 1392, 1414, 1410, 1415, 1393, 1416, 1417, 1394, ++ 1400, 1418, 1401, 1419, 1411, 1402, 1412, 1420, 1403, 1421, ++ 1422, 1423, 1404, 1424, 1413, 1425, 1426, 1405, 1406, 1427, ++ 1428, 1414, 1429, 1415, 1430, 1416, 1417, 1431, 1400, 1418, ++ 1401, 1419, 1432, 1402, 1433, 1420, 1403, 1421, 1422, 1423, ++ 1404, 1424, 1434, 1425, 1426, 1405, 1406, 1427, 1428, 1435, ++ 1429, 1436, 1430, 1437, 1438, 1431, 1439, 1440, 1441, 1442, ++ 1432, 1444, 1433, 1445, 1446, 1447, 1443, 1448, 1449, 1450, ++ 1434, 1451, 1452, 1453, 1454, 1455, 1456, 1435, 1457, 1436, ++ ++ 1460, 1437, 1438, 2457, 1439, 1440, 1441, 1442, 1461, 1444, ++ 1463, 1445, 1446, 1447, 1443, 1448, 1449, 1450, 1462, 1451, ++ 1452, 1453, 1454, 1455, 1456, 1458, 1457, 1464, 1460, 1465, ++ 1466, 1459, 1467, 1468, 1469, 1470, 1461, 1471, 1463, 1472, ++ 1473, 1474, 1475, 1476, 1477, 1478, 1462, 1479, 1482, 1483, ++ 1484, 1485, 1486, 1458, 1487, 1464, 1488, 1465, 1466, 1459, ++ 1467, 1468, 1469, 1470, 1489, 1471, 1490, 1472, 1473, 1474, ++ 1475, 1476, 1477, 1478, 1480, 1479, 1482, 1483, 1484, 1485, ++ 1486, 1491, 1487, 1481, 1488, 1492, 1493, 1494, 1495, 1496, ++ 1497, 1498, 1489, 1499, 1490, 1500, 1501, 1502, 1503, 1504, ++ ++ 1505, 1506, 1480, 1507, 1508, 1509, 1510, 1511, 1512, 1491, ++ 1513, 1481, 1514, 1492, 1493, 1494, 1495, 1496, 1497, 1498, ++ 1515, 1499, 1516, 1500, 1501, 1502, 1503, 1504, 1505, 1506, ++ 1517, 1507, 1508, 1509, 1510, 1511, 1512, 1518, 1513, 1519, ++ 1514, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1515, 1527, ++ 1516, 1528, 1529, 1530, 1531, 1533, 1534, 1535, 1517, 1536, ++ 1537, 1538, 1532, 1539, 1540, 1518, 1541, 1519, 1542, 1520, ++ 1521, 1522, 1523, 1524, 1525, 1526, 1543, 1527, 1544, 1528, ++ 1529, 1530, 1531, 1533, 1534, 1535, 1545, 1536, 1537, 1538, ++ 1532, 1539, 1540, 1546, 1541, 1547, 1542, 1548, 1549, 1550, ++ ++ 1551, 1552, 1553, 1554, 1543, 1555, 1544, 1556, 1557, 1558, ++ 1559, 1560, 1561, 1563, 1545, 1564, 1565, 1566, 1567, 1568, ++ 1569, 1546, 1570, 1547, 1571, 1548, 1549, 1550, 1551, 1552, ++ 1553, 1554, 1572, 1555, 1573, 1556, 1557, 1558, 1559, 1560, ++ 1561, 1563, 1574, 1564, 1565, 1566, 1567, 1568, 1569, 1575, ++ 1570, 1576, 1571, 1577, 1578, 1579, 1580, 1581, 1582, 1583, ++ 1572, 1584, 1573, 1587, 1585, 1588, 1589, 1590, 1591, 1592, ++ 1574, 1593, 1594, 1595, 1596, 1597, 1598, 1575, 1599, 1576, ++ 1586, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1600, 1584, ++ 1601, 1587, 1585, 1588, 1589, 1590, 1591, 1592, 1602, 1593, ++ ++ 1594, 1595, 1596, 1597, 1598, 1603, 1599, 1604, 1586, 1605, ++ 1606, 1607, 1608, 1609, 1610, 1611, 1600, 1612, 1601, 1613, ++ 1614, 1615, 1616, 1617, 1618, 1619, 1602, 1620, 1621, 1622, ++ 1623, 1624, 1625, 1603, 1626, 1604, 1627, 1605, 1606, 1607, ++ 1608, 1609, 1610, 1611, 1628, 1612, 1629, 1613, 1614, 1615, ++ 1616, 1617, 1618, 1619, 1630, 1620, 1621, 1622, 1623, 1624, ++ 1625, 1631, 1626, 1633, 1627, 1634, 1635, 1636, 1637, 1632, ++ 1638, 1639, 1628, 1640, 1629, 1641, 1642, 1643, 1644, 1645, ++ 1646, 1647, 1630, 1648, 1649, 1650, 1651, 1652, 1653, 1631, ++ 1654, 1633, 1655, 1634, 1635, 1636, 1637, 1632, 1638, 1639, ++ ++ 1656, 1640, 1657, 1641, 1642, 1643, 1644, 1645, 1646, 1647, ++ 1658, 1648, 1649, 1650, 1651, 1652, 1653, 1659, 1654, 1660, ++ 1655, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1656, 1668, ++ 1657, 1669, 1670, 1671, 1672, 1673, 1674, 1677, 1658, 1678, ++ 1675, 1679, 1680, 1681, 1682, 1659, 1683, 1660, 1684, 1661, ++ 1662, 1663, 1664, 1665, 1666, 1667, 1676, 1668, 1685, 1669, ++ 1670, 1671, 1672, 1673, 1674, 1677, 1686, 1678, 1675, 1679, ++ 1680, 1681, 1682, 1687, 1683, 1688, 1684, 1689, 1690, 1691, ++ 1693, 1694, 1695, 1696, 1676, 1697, 1685, 1698, 1699, 1700, ++ 1701, 1702, 1703, 1704, 1686, 1705, 1706, 1707, 1708, 1709, ++ ++ 1710, 1687, 1711, 1688, 1712, 1689, 1690, 1691, 1693, 1694, ++ 1695, 1696, 1713, 1697, 1714, 1698, 1699, 1700, 1701, 1702, ++ 1703, 1704, 1715, 1705, 1706, 1707, 1708, 1709, 1710, 1716, ++ 1711, 1717, 1712, 1718, 1719, 1720, 1721, 1722, 1723, 1724, ++ 1713, 1725, 1714, 1726, 1727, 1728, 1729, 1730, 1731, 1732, ++ 1715, 1733, 1734, 1735, 1736, 1737, 1738, 1716, 1739, 1717, ++ 1740, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1741, 1725, ++ 1742, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1743, 1733, ++ 1734, 1735, 1736, 1737, 1738, 1744, 1739, 1745, 1740, 1746, ++ 1747, 1748, 1749, 1750, 1751, 1752, 1741, 1753, 1742, 1754, ++ ++ 1755, 1756, 1757, 1758, 1759, 1760, 1743, 1761, 1762, 1764, ++ 1763, 1765, 1766, 1744, 2457, 1745, 1772, 1746, 1747, 1748, ++ 1749, 1750, 1751, 1752, 2457, 1753, 2457, 1754, 1755, 1756, ++ 1757, 1758, 1759, 1760, 1773, 1761, 1762, 1764, 1763, 1765, ++ 1766, 1767, 1768, 1774, 1772, 1775, 1776, 1777, 1778, 1779, ++ 1780, 1781, 1769, 1782, 1770, 1783, 1784, 1785, 1771, 1786, ++ 1787, 1788, 1773, 1789, 1790, 1791, 1792, 1793, 2457, 1767, ++ 1768, 1774, 1796, 1775, 1776, 1777, 1778, 1779, 1780, 1781, ++ 1769, 1782, 1770, 1783, 1784, 1785, 1771, 1786, 1787, 1788, ++ 1797, 1789, 1790, 1791, 1792, 1793, 1794, 1798, 1795, 1799, ++ ++ 1796, 1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, ++ 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1797, 1817, ++ 1818, 1819, 1820, 1821, 1794, 1798, 1795, 1799, 1822, 1800, ++ 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, ++ 1811, 1812, 1813, 1814, 1815, 1816, 1823, 1817, 1818, 1819, ++ 1820, 1821, 1824, 1825, 1826, 1827, 1822, 1828, 1829, 1830, ++ 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, ++ 1841, 1842, 1843, 1844, 1823, 1845, 1846, 1847, 1848, 1849, ++ 1824, 1825, 1826, 1827, 1850, 1828, 1829, 1830, 1831, 1832, ++ 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, ++ ++ 1843, 1844, 1851, 1845, 1846, 1847, 1848, 1849, 1852, 1853, ++ 1854, 1855, 1850, 1856, 1857, 1858, 1859, 1863, 1864, 1865, ++ 1866, 1867, 1868, 1869, 1870, 1871, 1860, 1872, 1861, 1873, ++ 1851, 1874, 1862, 1875, 1876, 1877, 1852, 1853, 1854, 1855, ++ 1878, 1856, 1857, 1858, 1859, 1863, 1864, 1865, 1866, 1867, ++ 1868, 1869, 1870, 1871, 1860, 1872, 1861, 1873, 1879, 1874, ++ 1862, 1875, 1876, 1877, 1880, 1881, 1884, 1882, 1878, 1883, ++ 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1895, ++ 1894, 1896, 1897, 1898, 1899, 1900, 1879, 1901, 1902, 1903, ++ 1904, 1905, 1880, 1881, 1884, 1882, 1906, 1883, 1885, 1886, ++ ++ 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1895, 1894, 1896, ++ 1897, 1898, 1899, 1900, 1907, 1901, 1902, 1903, 1904, 1905, ++ 1908, 1909, 1910, 1911, 1906, 1912, 1913, 1914, 1915, 1916, ++ 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, ++ 1927, 1928, 1907, 1929, 1930, 1931, 1932, 1933, 1908, 1909, ++ 1910, 1911, 1934, 1912, 1913, 1914, 1915, 1916, 1917, 1918, ++ 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, ++ 1935, 1929, 1930, 1931, 1932, 1933, 1936, 1937, 1938, 1939, ++ 1934, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, ++ 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1935, 1957, ++ ++ 1958, 1961, 2457, 1964, 1936, 1937, 1938, 1939, 1965, 1940, ++ 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, ++ 1951, 1952, 1953, 1954, 1955, 1956, 1959, 1957, 1958, 1961, ++ 1962, 1964, 1966, 1967, 1960, 1968, 1965, 1969, 1970, 1971, ++ 1972, 1973, 1974, 1975, 1976, 1977, 1963, 1978, 1979, 1980, ++ 1981, 1982, 1983, 1984, 1959, 1985, 1986, 1987, 1962, 1988, ++ 1966, 1967, 1960, 1968, 1989, 1969, 1970, 1971, 1972, 1973, ++ 1974, 1975, 1976, 1977, 1963, 1978, 1979, 1980, 1981, 1982, ++ 1983, 1984, 1990, 1985, 1986, 1987, 1991, 1988, 1992, 1993, ++ 1994, 1995, 1989, 1996, 1997, 1998, 1999, 2000, 2001, 2002, ++ ++ 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, ++ 1990, 2013, 2014, 2015, 1991, 2016, 1992, 1993, 1994, 1995, ++ 2017, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, ++ 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2018, 2013, ++ 2014, 2015, 2019, 2016, 2020, 2021, 2022, 2023, 2017, 2024, ++ 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, ++ 2036, 2039, 2040, 2041, 2457, 2042, 2018, 2035, 2043, 2044, ++ 2019, 2045, 2020, 2021, 2022, 2023, 2037, 2024, 2025, 2026, ++ 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2036, 2039, ++ 2040, 2041, 2038, 2042, 2046, 2035, 2043, 2044, 2047, 2045, ++ ++ 2048, 2049, 2050, 2051, 2037, 2052, 2053, 2054, 2055, 2056, ++ 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, ++ 2038, 2067, 2046, 2068, 2069, 2070, 2047, 2071, 2048, 2049, ++ 2050, 2051, 2072, 2052, 2053, 2054, 2055, 2056, 2057, 2058, ++ 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2073, 2067, ++ 2074, 2068, 2069, 2070, 2075, 2071, 2076, 2077, 2078, 2079, ++ 2072, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, ++ 2089, 2090, 2091, 2092, 2093, 2094, 2073, 2095, 2074, 2096, ++ 2097, 2098, 2075, 2099, 2076, 2077, 2078, 2079, 2100, 2080, ++ 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, ++ ++ 2091, 2092, 2093, 2094, 2101, 2095, 2102, 2096, 2097, 2098, ++ 2103, 2099, 2104, 2105, 2106, 2107, 2100, 2108, 2109, 2110, ++ 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, ++ 2121, 2122, 2101, 2123, 2102, 2124, 2125, 2126, 2103, 2127, ++ 2104, 2105, 2106, 2107, 2128, 2108, 2109, 2110, 2111, 2112, ++ 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121, 2122, ++ 2129, 2123, 2130, 2124, 2125, 2126, 2131, 2127, 2132, 2133, ++ 2134, 2135, 2128, 2136, 2137, 2138, 2139, 2140, 2141, 2142, ++ 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2129, 2151, ++ 2130, 2152, 2153, 2154, 2131, 2155, 2132, 2133, 2134, 2135, ++ ++ 2156, 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, ++ 2145, 2146, 2147, 2148, 2149, 2150, 2157, 2151, 2158, 2152, ++ 2153, 2154, 2159, 2155, 2160, 2161, 2162, 2163, 2156, 2164, ++ 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2174, ++ 2175, 2176, 2177, 2178, 2157, 2179, 2158, 2180, 2181, 2182, ++ 2159, 2183, 2160, 2161, 2162, 2163, 2184, 2164, 2165, 2166, ++ 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, 2176, ++ 2177, 2178, 2185, 2179, 2186, 2180, 2181, 2182, 2187, 2183, ++ 2188, 2189, 2191, 2192, 2184, 2193, 2194, 2195, 2196, 2197, ++ 2198, 2199, 2200, 2201, 2202, 2203, 2204, 2190, 2205, 2206, ++ ++ 2185, 2207, 2186, 2208, 2209, 2210, 2187, 2211, 2188, 2189, ++ 2191, 2192, 2212, 2193, 2194, 2195, 2196, 2197, 2198, 2199, ++ 2200, 2201, 2202, 2203, 2204, 2190, 2205, 2206, 2213, 2207, ++ 2214, 2208, 2209, 2210, 2215, 2211, 2216, 2217, 2218, 2219, ++ 2212, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, ++ 2229, 2230, 2457, 2233, 2236, 2237, 2213, 2238, 2214, 2239, ++ 2240, 2241, 2215, 2231, 2216, 2217, 2218, 2219, 2234, 2220, ++ 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, ++ 2232, 2233, 2236, 2237, 2235, 2238, 2242, 2239, 2240, 2241, ++ 2243, 2231, 2244, 2245, 2246, 2247, 2234, 2248, 2249, 2250, ++ ++ 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2232, 2259, ++ 2260, 2261, 2235, 2262, 2242, 2263, 2264, 2265, 2243, 2266, ++ 2244, 2245, 2246, 2247, 2267, 2248, 2249, 2250, 2251, 2252, ++ 2253, 2254, 2255, 2256, 2257, 2258, 2268, 2259, 2260, 2261, ++ 2269, 2262, 2270, 2263, 2264, 2265, 2271, 2266, 2272, 2274, ++ 2275, 2276, 2267, 2277, 2278, 2279, 2280, 2281, 2282, 2283, ++ 2284, 2285, 2286, 2287, 2268, 2273, 2288, 2289, 2269, 2290, ++ 2270, 2291, 2292, 2293, 2271, 2294, 2272, 2274, 2275, 2276, ++ 2295, 2277, 2278, 2279, 2280, 2281, 2282, 2283, 2284, 2285, ++ 2286, 2287, 2296, 2273, 2288, 2289, 2297, 2290, 2298, 2291, ++ ++ 2292, 2293, 2299, 2294, 2300, 2301, 2302, 2303, 2295, 2304, ++ 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, ++ 2296, 2315, 2316, 2317, 2297, 2318, 2298, 2319, 2320, 2321, ++ 2299, 2322, 2300, 2301, 2302, 2303, 2323, 2304, 2305, 2306, ++ 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2324, 2315, ++ 2316, 2317, 2325, 2318, 2326, 2319, 2320, 2321, 2327, 2322, ++ 2328, 2329, 2330, 2331, 2323, 2332, 2333, 2334, 2335, 2336, ++ 2337, 2338, 2339, 2340, 2341, 2342, 2324, 2343, 2344, 2345, ++ 2325, 2346, 2326, 2347, 2348, 2349, 2327, 2350, 2328, 2329, ++ 2330, 2331, 2351, 2332, 2333, 2334, 2335, 2336, 2337, 2338, ++ ++ 2339, 2340, 2341, 2342, 2352, 2343, 2344, 2345, 2353, 2346, ++ 2354, 2347, 2348, 2349, 2355, 2350, 2356, 2357, 2358, 2359, ++ 2351, 2360, 2361, 2362, 2363, 2364, 2365, 2366, 2367, 2368, ++ 2369, 2370, 2352, 2371, 2372, 2373, 2353, 2374, 2354, 2375, ++ 2376, 2377, 2355, 2378, 2356, 2357, 2358, 2359, 2379, 2360, ++ 2361, 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, ++ 2380, 2371, 2372, 2373, 2381, 2374, 2382, 2375, 2376, 2377, ++ 2383, 2378, 2384, 2385, 2386, 2387, 2379, 2388, 2389, 2390, ++ 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2380, 2399, ++ 2400, 2401, 2381, 2402, 2382, 2403, 2404, 2405, 2383, 2406, ++ ++ 2384, 2385, 2386, 2387, 2407, 2388, 2389, 2390, 2391, 2392, ++ 2393, 2394, 2395, 2396, 2397, 2398, 2408, 2399, 2400, 2401, ++ 2409, 2402, 2410, 2403, 2404, 2405, 2411, 2406, 2412, 2413, ++ 2414, 2415, 2407, 2416, 2417, 2418, 2419, 2420, 2423, 2421, ++ 2424, 2457, 2427, 2428, 2408, 2429, 2430, 2431, 2409, 2432, ++ 2410, 2433, 2434, 2425, 2411, 2422, 2412, 2413, 2414, 2415, ++ 2435, 2416, 2417, 2418, 2419, 2420, 2423, 2421, 2424, 2426, ++ 2427, 2428, 2436, 2429, 2430, 2431, 2437, 2432, 2438, 2433, ++ 2434, 2425, 2439, 2422, 2440, 2441, 2442, 2443, 2435, 2444, ++ 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2426, 2452, 2453, ++ ++ 2436, 2454, 2455, 2456, 2437, 2457, 2438, 2457, 2457, 2457, ++ 2439, 2457, 2440, 2441, 2442, 2443, 2457, 2444, 2445, 2446, ++ 2447, 2448, 2449, 2450, 2451, 2457, 2452, 2453, 2457, 2454, ++ 2455, 2456, 122, 122, 122, 122, 122, 127, 127, 127, ++ 127, 127, 129, 2457, 129, 129, 129, 130, 130, 130, ++ 130, 130, 132, 2457, 132, 132, 132, 136, 136, 140, ++ 140, 140, 140, 140, 301, 301, 304, 304, 304, 304, ++ 304, 358, 358, 358, 358, 358, 361, 361, 361, 361, ++ 361, 367, 367, 367, 367, 367, 383, 383, 383, 383, ++ 383, 385, 385, 385, 385, 385, 387, 387, 387, 387, ++ ++ 387, 139, 139, 139, 139, 139, 11, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457 + } ; + +-static yyconst short int yy_chk[2822] = ++static yyconst flex_int16_t yy_chk[5285] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +- 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +- +- 3, 3, 5, 5, 5, 5, 5, 5, 5, 5, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, +- 5, 5, 5, 7, 7, 7, 7, 7, 7, 7, ++ ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, ++ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, ++ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + +- 7, 7, 7, 7, 9, 115, 9, 9, 10, 9, +- 10, 10, 9, 10, 20, 13, 10, 13, 13, 19, +- 115, 19, 31, 31, 20, 21, 21, 21, 21, 21, +- 21, 21, 21, 21, 21, 21, 21, 21, 197, 22, +- 21, 22, 21, 23, 21, 23, 21, 36, 29, 24, +- 197, 22, 23, 24, 28, 33, 29, 24, 28, 33, +- 26, 36, 28, 26, 26, 29, 24, 754, 28, 24, +- 52, 28, 52, 21, 21, 21, 25, 26, 25, 54, +- 26, 30, 54, 25, 25, 30, 755, 25, 53, 30, +- 25, 60, 60, 25, 25, 27, 27, 27, 34, 40, ++ 7, 7, 7, 7, 7, 7, 7, 7, 9, 32, ++ 9, 9, 10, 9, 10, 10, 9, 10, 20, 13, ++ 10, 13, 13, 19, 39, 19, 20, 105, 2465, 105, ++ 22, 74, 22, 74, 74, 1474, 99, 32, 99, 99, ++ 22, 23, 100, 23, 100, 100, 110, 44, 1320, 957, ++ 23, 956, 39, 675, 20, 21, 21, 21, 21, 21, ++ 21, 21, 21, 21, 21, 21, 21, 21, 22, 23, ++ 21, 23, 21, 24, 21, 44, 30, 24, 23, 26, ++ 30, 24, 26, 26, 30, 27, 27, 27, 31, 31, ++ 24, 27, 53, 24, 33, 53, 26, 27, 33, 26, + +- 34, 27, 34, 40, 757, 53, 34, 27, 53, 34, +- 35, 43, 34, 40, 35, 34, 37, 37, 35, 63, +- 43, 67, 43, 63, 37, 38, 43, 246, 37, 38, +- 35, 37, 37, 38, 35, 67, 38, 69, 67, 38, +- 246, 69, 38, 41, 41, 41, 64, 42, 41, 41, +- 64, 42, 55, 41, 64, 42, 55, 41, 80, 80, +- 41, 42, 45, 45, 42, 41, 45, 66, 45, 55, +- 45, 42, 55, 56, 56, 45, 57, 75, 56, 77, +- 57, 77, 66, 66, 56, 70, 57, 75, 77, 57, +- 70, 70, 71, 138, 138, 73, 71, 138, 758, 73, ++ 674, 24, 21, 110, 30, 24, 672, 26, 30, 24, ++ 26, 26, 30, 27, 27, 27, 31, 31, 24, 27, ++ 53, 24, 33, 53, 26, 27, 33, 26, 36, 21, ++ 21, 21, 25, 51, 25, 51, 29, 28, 57, 25, ++ 25, 28, 36, 25, 29, 28, 25, 55, 55, 25, ++ 25, 28, 55, 29, 28, 668, 36, 667, 55, 663, ++ 25, 51, 25, 51, 29, 28, 57, 25, 25, 28, ++ 36, 25, 29, 28, 25, 55, 55, 25, 25, 28, ++ 55, 29, 28, 34, 35, 34, 55, 34, 35, 40, ++ 43, 34, 35, 40, 34, 662, 58, 34, 638, 43, + +- 71, 73, 70, 90, 90, 95, 71, 70, 73, 71, +- 74, 90, 74, 74, 95, 90, 71, 76, 76, 76, +- 76, 759, 76, 76, 76, 76, 76, 76, 76, 76, +- 106, 82, 76, 79, 76, 82, 76, 76, 76, 79, +- 106, 332, 79, 88, 87, 82, 87, 88, 79, 79, +- 91, 97, 87, 332, 91, 87, 93, 91, 97, 88, +- 91, 87, 105, 88, 105, 76, 76, 76, 94, 94, +- 93, 96, 99, 94, 99, 99, 100, 94, 100, 100, +- 96, 94, 108, 110, 108, 117, 96, 116, 118, 123, +- 151, 123, 123, 134, 108, 135, 116, 135, 118, 126, ++ 34, 43, 60, 40, 35, 43, 52, 61, 35, 610, ++ 609, 34, 35, 34, 481, 34, 35, 40, 43, 34, ++ 35, 40, 34, 52, 58, 34, 52, 43, 34, 43, ++ 60, 40, 35, 43, 52, 61, 35, 37, 37, 54, ++ 59, 59, 62, 54, 64, 37, 62, 400, 65, 37, ++ 67, 52, 37, 37, 52, 71, 54, 399, 123, 54, ++ 123, 123, 394, 65, 65, 37, 37, 54, 59, 59, ++ 62, 54, 64, 37, 62, 56, 65, 37, 67, 56, ++ 37, 37, 38, 71, 54, 56, 38, 54, 56, 75, ++ 38, 65, 65, 38, 81, 393, 38, 75, 126, 38, + +- 117, 126, 126, 134, 151, 137, 162, 135, 143, 143, +- 162, 157, 143, 157, 110, 137, 140, 140, 140, 140, +- 140, 140, 140, 140, 140, 140, 140, 140, 140, 142, +- 166, 140, 147, 140, 145, 140, 169, 140, 171, 142, +- 169, 145, 171, 147, 166, 167, 167, 145, 173, 177, +- 173, 173, 182, 182, 173, 186, 194, 177, 199, 193, +- 760, 193, 199, 177, 140, 140, 140, 193, 223, 182, +- 226, 186, 194, 186, 195, 195, 195, 210, 186, 213, +- 210, 226, 195, 214, 213, 220, 220, 210, 761, 214, +- 247, 227, 223, 227, 214, 229, 214, 267, 220, 227, ++ 126, 126, 392, 56, 63, 387, 385, 56, 63, 66, ++ 38, 68, 63, 56, 38, 68, 56, 383, 38, 367, ++ 361, 38, 81, 66, 38, 75, 66, 38, 41, 41, ++ 41, 83, 63, 41, 41, 84, 63, 66, 41, 68, ++ 63, 358, 41, 68, 85, 41, 86, 69, 80, 80, ++ 41, 66, 69, 69, 66, 300, 41, 41, 41, 83, ++ 243, 41, 41, 84, 69, 139, 41, 133, 132, 69, ++ 41, 89, 85, 41, 86, 69, 80, 80, 41, 42, ++ 69, 69, 72, 42, 92, 130, 72, 42, 72, 77, ++ 112, 77, 69, 42, 106, 72, 42, 69, 77, 89, + +- 251, 247, 251, 229, 259, 262, 262, 270, 259, 262, +- 264, 280, 272, 267, 272, 229, 274, 274, 264, 288, +- 272, 280, 284, 291, 264, 270, 302, 762, 284, 292, +- 270, 363, 329, 284, 291, 284, 302, 292, 303, 303, +- 765, 363, 303, 288, 304, 304, 304, 304, 329, 304, +- 304, 304, 304, 304, 304, 304, 304, 341, 330, 304, +- 341, 304, 351, 304, 304, 304, 330, 341, 350, 364, +- 350, 364, 365, 369, 351, 366, 366, 389, 417, 366, +- 396, 364, 365, 369, 370, 370, 417, 389, 370, 693, +- 396, 693, 304, 304, 304, 390, 390, 397, 397, 390, ++ 138, 138, 106, 42, 138, 143, 143, 42, 127, 143, ++ 72, 42, 92, 93, 72, 42, 72, 77, 112, 77, ++ 113, 42, 118, 72, 42, 82, 77, 93, 79, 82, ++ 106, 42, 45, 45, 79, 128, 45, 79, 45, 82, ++ 45, 93, 95, 79, 79, 45, 125, 124, 113, 120, ++ 118, 95, 119, 82, 111, 93, 79, 82, 109, 107, ++ 45, 45, 79, 128, 45, 79, 45, 82, 45, 97, ++ 95, 79, 79, 45, 70, 87, 97, 87, 70, 95, ++ 91, 104, 70, 87, 91, 115, 87, 91, 70, 103, ++ 91, 70, 87, 131, 115, 141, 144, 97, 70, 102, + +- 435, 397, 439, 450, 454, 465, 465, 450, 435, 486, +- 465, 467, 439, 465, 454, 467, 482, 486, 491, 490, +- 482, 767, 503, 465, 465, 491, 768, 465, 470, 470, +- 490, 470, 540, 470, 503, 554, 470, 577, 564, 663, +- 540, 577, 581, 590, 769, 554, 470, 470, 564, 663, +- 470, 571, 571, 581, 582, 590, 571, 730, 737, 571, +- 770, 582, 664, 664, 730, 737, 664, 766, 771, 571, +- 571, 766, 743, 571, 574, 574, 772, 574, 743, 574, +- 756, 773, 574, 774, 775, 776, 756, 777, 778, 779, +- 743, 781, 574, 574, 780, 782, 574, 783, 756, 780, ++ 101, 73, 70, 87, 97, 87, 70, 108, 91, 108, ++ 70, 87, 91, 115, 87, 91, 70, 108, 91, 70, ++ 87, 131, 115, 141, 144, 146, 70, 76, 76, 76, ++ 76, 50, 76, 76, 76, 76, 76, 76, 76, 76, ++ 90, 90, 76, 88, 76, 108, 76, 88, 90, 94, ++ 94, 96, 90, 146, 94, 114, 134, 116, 94, 88, ++ 96, 18, 94, 88, 134, 148, 96, 17, 90, 90, ++ 114, 88, 116, 76, 76, 88, 90, 94, 94, 96, ++ 90, 149, 94, 114, 150, 116, 94, 88, 96, 117, ++ 94, 88, 134, 148, 96, 135, 137, 135, 114, 117, + +- 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, +- 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, +- 804, 806, 808, 809, 810, 797, 811, 812, 814, 815, +- 816, 818, 819, 820, 821, 822, 823, 824, 825, 826, +- 827, 828, 829, 830, 829, 831, 833, 834, 835, 836, +- 837, 838, 839, 841, 842, 843, 845, 847, 848, 849, +- 850, 851, 853, 854, 855, 856, 857, 858, 859, 860, +- 854, 861, 862, 863, 864, 865, 866, 867, 868, 869, +- 864, 870, 871, 872, 873, 874, 875, 876, 879, 878, +- 880, 874, 864, 878, 881, 882, 883, 884, 885, 886, ++ 116, 76, 76, 76, 137, 135, 303, 303, 15, 149, ++ 303, 142, 150, 11, 366, 366, 0, 117, 366, 142, ++ 370, 370, 0, 0, 370, 0, 152, 117, 154, 155, ++ 156, 159, 137, 135, 140, 140, 140, 140, 140, 140, ++ 140, 140, 140, 140, 140, 140, 140, 142, 145, 140, ++ 151, 140, 147, 140, 152, 145, 154, 155, 156, 159, ++ 157, 145, 157, 147, 151, 160, 162, 163, 164, 165, ++ 162, 166, 167, 167, 168, 169, 145, 170, 151, 169, ++ 147, 140, 0, 145, 172, 166, 0, 0, 157, 145, ++ 157, 147, 151, 160, 162, 163, 164, 165, 162, 166, + +- 887, 888, 889, 874, 890, 891, 892, 893, 894, 895, +- 896, 897, 898, 899, 900, 901, 902, 904, 905, 906, +- 907, 909, 910, 897, 912, 913, 915, 916, 917, 918, +- 920, 921, 922, 923, 924, 925, 927, 928, 929, 930, +- 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, +- 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, +- 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, +- 962, 964, 965, 966, 967, 968, 969, 970, 971, 972, +- 973, 974, 975, 977, 978, 979, 982, 984, 985, 985, +- 987, 988, 989, 990, 991, 992, 994, 996, 999, 1000, ++ 167, 167, 168, 169, 174, 170, 175, 169, 140, 140, ++ 140, 171, 172, 166, 173, 171, 173, 173, 176, 177, ++ 173, 178, 179, 180, 181, 0, 183, 177, 184, 185, ++ 188, 0, 174, 177, 175, 189, 182, 182, 191, 171, ++ 0, 196, 173, 171, 173, 173, 176, 177, 173, 178, ++ 179, 180, 181, 182, 183, 177, 184, 185, 188, 186, ++ 193, 177, 193, 189, 182, 182, 191, 194, 193, 196, ++ 195, 195, 195, 197, 198, 186, 199, 186, 195, 200, ++ 199, 182, 186, 194, 201, 197, 202, 186, 193, 203, ++ 193, 204, 205, 206, 207, 194, 193, 208, 195, 195, + +- 1001, 1002, 1003, 1006, 1007, 1005, 1008, 1009, 1012, 1014, +- 1001, 1015, 1016, 1001, 1001, 1005, 1017, 1001, 1001, 1010, +- 1018, 1010, 1019, 1020, 1010, 1021, 1022, 1010, 1023, 1024, +- 1025, 1010, 1026, 1027, 1028, 1029, 1010, 1010, 1031, 1032, +- 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1043, +- 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, +- 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, +- 1066, 1067, 1068, 1069, 1070, 1062, 1071, 1066, 1072, 1074, +- 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1083, 1084, 1085, +- 1086, 1088, 1089, 1091, 1092, 1093, 1094, 1096, 1089, 1098, ++ 195, 197, 198, 186, 199, 186, 195, 200, 199, 209, ++ 186, 194, 201, 197, 202, 211, 212, 203, 215, 204, ++ 205, 206, 207, 210, 213, 208, 210, 216, 214, 213, ++ 217, 218, 219, 210, 214, 220, 220, 209, 221, 214, ++ 222, 214, 224, 211, 212, 225, 215, 223, 220, 0, ++ 228, 210, 213, 230, 210, 216, 214, 213, 217, 218, ++ 219, 210, 214, 220, 220, 233, 221, 214, 222, 214, ++ 224, 223, 226, 225, 229, 223, 220, 227, 228, 227, ++ 235, 230, 229, 226, 236, 227, 237, 238, 239, 240, ++ 241, 244, 246, 233, 229, 247, 245, 248, 249, 223, + +- 1099, 1100, 1101, 1102, 1092, 1103, 1104, 1105, 1106, 1107, +- 1108, 1109, 1110, 1112, 1114, 1116, 1117, 1117, 1118, 1119, +- 1120, 1122, 1123, 1125, 1126, 1128, 1129, 1130, 1131, 1133, +- 1135, 1132, 1136, 1132, 1126, 1128, 1132, 1126, 1126, 1132, +- 1137, 1126, 1126, 1132, 1138, 1139, 1140, 1141, 1132, 1132, +- 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, +- 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, +- 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, +- 1172, 1173, 1174, 1175, 1169, 1176, 1177, 1178, 1179, 1180, +- 1181, 1182, 1184, 1185, 1187, 1188, 1192, 1193, 1194, 1185, ++ 226, 251, 229, 246, 250, 227, 250, 227, 235, 245, ++ 229, 226, 236, 227, 237, 238, 239, 240, 241, 244, ++ 246, 252, 229, 247, 245, 248, 249, 253, 254, 251, ++ 255, 246, 250, 256, 250, 257, 258, 245, 259, 260, ++ 258, 261, 261, 262, 264, 261, 263, 265, 267, 252, ++ 0, 268, 270, 272, 263, 253, 254, 271, 255, 271, ++ 263, 256, 266, 257, 258, 271, 259, 260, 258, 261, ++ 261, 262, 264, 261, 263, 265, 267, 269, 266, 268, ++ 270, 272, 263, 273, 273, 271, 274, 271, 263, 275, ++ 266, 276, 277, 271, 278, 269, 280, 279, 281, 282, + +- 1197, 1199, 1200, 1201, 1203, 1188, 1204, 1207, 1210, 1211, +- 1212, 1213, 1214, 1215, 1217, 1218, 1220, 1222, 1223, 1225, +- 1226, 1227, 1228, 1229, 1218, 1230, 1231, 1232, 1233, 1234, +- 1235, 1237, 1239, 1240, 1242, 1243, 1245, 1246, 1247, 1248, +- 1250, 1251, 1252, 1253, 1255, 1257, 1259, 1261, 1262, 1265, +- 1266, 1267, 1268, 1269, 1270, 1272, 1273, 1274, 1275, 1276, +- 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1287, +- 1288, 1289, 1290, 1291, 1283, 1292, 1293, 1294, 1295, 1296, +- 1297, 1298, 1299, 1301, 1303, 1304, 1305, 1306, 1307, 1308, +- 1309, 1310, 1311, 1312, 1313, 1314, 1317, 1318, 1319, 1320, ++ 269, 284, 283, 285, 286, 269, 266, 279, 283, 287, ++ 288, 273, 273, 283, 274, 283, 289, 275, 292, 276, ++ 277, 293, 278, 269, 280, 279, 281, 282, 269, 284, ++ 283, 285, 286, 287, 290, 279, 283, 287, 288, 291, ++ 294, 283, 295, 283, 289, 290, 292, 291, 296, 293, ++ 297, 298, 299, 305, 306, 302, 307, 308, 310, 313, ++ 315, 287, 290, 302, 0, 391, 391, 291, 294, 391, ++ 295, 0, 0, 290, 0, 291, 296, 316, 297, 298, ++ 299, 305, 306, 0, 307, 308, 310, 313, 315, 317, ++ 318, 302, 304, 304, 304, 304, 319, 304, 304, 304, + +- 1321, 1322, 1323, 1324, 1329, 1330, 1331, 1332, 1333, 1334, +- 1335, 1336, 1337, 1338, 1340, 1341, 1342, 1343, 1344, 1345, +- 1346, 1347, 1350, 1351, 1354, 1355, 1356, 1357, 1358, 1359, +- 1360, 1361, 1362, 1363, 1365, 1366, 1346, 1367, 1368, 1369, +- 1370, 1372, 1373, 1375, 1376, 1377, 1379, 1380, 1381, 1383, +- 1384, 1386, 1387, 1389, 1390, 1391, 1392, 1393, 1394, 1395, +- 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, +- 1406, 1408, 1409, 1410, 1411, 1412, 1404, 1413, 1414, 1415, +- 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, +- 1426, 1427, 1428, 1429, 1430, 1432, 1433, 1434, 1435, 1436, ++ 304, 304, 304, 304, 304, 316, 320, 304, 321, 304, ++ 0, 304, 322, 323, 324, 326, 329, 317, 318, 330, ++ 331, 332, 333, 334, 319, 335, 336, 330, 337, 338, ++ 339, 340, 329, 332, 320, 342, 321, 0, 304, 304, ++ 322, 323, 324, 326, 329, 343, 344, 330, 331, 332, ++ 333, 334, 345, 335, 336, 330, 337, 338, 339, 340, ++ 329, 332, 341, 342, 346, 341, 304, 304, 304, 347, ++ 348, 349, 341, 343, 344, 350, 351, 350, 355, 356, ++ 345, 359, 362, 363, 364, 368, 364, 365, 351, 375, ++ 341, 363, 346, 341, 364, 365, 377, 347, 348, 349, + +- 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, +- 1448, 1449, 1450, 1451, 1452, 1453, 1455, 1456, 1457, 1458, +- 1459, 1460, 1461, 1462, 1463, 1465, 1469, 1472, 1450, 1474, +- 1475, 1476, 1479, 1480, 1481, 1483, 1486, 1487, 1488, 1490, +- 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, +- 1501, 1502, 1503, 1506, 1507, 1508, 1510, 1512, 1513, 1514, +- 1515, 1516, 1517, 1518, 1519, 1521, 1522, 1523, 1525, 1526, +- 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535, 1537, +- 1538, 1540, 1541, 1542, 1543, 1545, 1546, 1547, 1548, 1549, +- 1551, 1552, 1553, 1554, 1555, 1557, 1558, 1559, 1560, 1562, ++ 341, 379, 381, 350, 351, 350, 355, 356, 395, 359, ++ 362, 401, 369, 368, 402, 403, 351, 375, 390, 363, ++ 369, 404, 364, 365, 377, 397, 390, 398, 398, 379, ++ 381, 398, 405, 397, 406, 407, 395, 408, 409, 401, ++ 410, 411, 402, 403, 412, 413, 414, 415, 369, 404, ++ 416, 417, 420, 421, 390, 422, 418, 423, 424, 425, ++ 405, 397, 406, 407, 418, 408, 409, 426, 410, 411, ++ 427, 428, 412, 413, 414, 415, 430, 431, 416, 417, ++ 420, 421, 432, 422, 418, 423, 424, 425, 433, 434, ++ 435, 437, 418, 436, 438, 426, 439, 440, 427, 428, + +- 1563, 1562, 1564, 1565, 1566, 1566, 1567, 1568, 1570, 1572, +- 1573, 1574, 1575, 1576, 1577, 1566, 1578, 1566, 1579, 1580, +- 1581, 1566, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, +- 1590, 1591, 1592, 1591, 1593, 1594, 1595, 1596, 1597, 1598, +- 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, +- 1609, 1610, 1611, 1612, 1613, 1615, 1616, 1617, 1618, 1619, +- 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1628, 1629, 1630, +- 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1640, 1641, +- 1642, 1643, 1645, 1646, 1647, 1648, 1649, 1651, 1652, 1653, +- 1654, 1655, 1657, 1658, 1659, 1661, 1662, 1663, 1663, 1664, ++ 441, 436, 443, 444, 430, 431, 445, 440, 446, 447, ++ 432, 448, 449, 450, 452, 453, 433, 434, 435, 437, ++ 454, 436, 438, 451, 439, 440, 0, 451, 441, 436, ++ 443, 444, 456, 457, 445, 440, 446, 447, 458, 448, ++ 449, 450, 452, 453, 455, 459, 460, 461, 454, 462, ++ 465, 451, 467, 468, 455, 451, 0, 468, 469, 470, ++ 456, 457, 472, 0, 473, 474, 458, 475, 476, 477, ++ 478, 479, 455, 459, 460, 461, 482, 462, 465, 484, ++ 467, 468, 455, 466, 466, 468, 469, 470, 466, 0, ++ 472, 466, 473, 474, 485, 475, 476, 477, 478, 479, + +- 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1663, 1673, +- 1663, 1674, 1675, 1676, 1663, 1677, 1678, 1679, 1680, 1681, +- 1682, 1683, 1684, 1683, 1685, 1686, 1687, 1688, 1689, 1690, +- 1692, 1693, 1694, 1695, 1694, 1696, 1699, 1700, 1701, 1702, +- 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, +- 1713, 1714, 1715, 1716, 1717, 1719, 1720, 1721, 1722, 1723, +- 1724, 1725, 1726, 1727, 1728, 1730, 1731, 1733, 1734, 1735, +- 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, +- 1746, 1747, 1748, 1750, 1751, 1755, 1756, 1757, 1758, 1760, +- 1761, 1764, 1765, 1766, 1767, 1768, 1769, 1770, 1771, 1772, ++ 486, 466, 466, 488, 482, 466, 0, 484, 489, 0, ++ 487, 466, 466, 483, 0, 490, 466, 483, 487, 466, ++ 492, 491, 485, 493, 0, 0, 494, 492, 486, 466, ++ 466, 488, 491, 466, 471, 471, 489, 471, 487, 471, ++ 495, 483, 471, 490, 496, 483, 487, 497, 492, 491, ++ 498, 493, 471, 471, 494, 492, 471, 499, 500, 501, ++ 491, 503, 471, 471, 504, 471, 505, 471, 495, 506, ++ 471, 507, 496, 508, 509, 497, 504, 510, 498, 511, ++ 471, 471, 512, 513, 471, 499, 500, 501, 514, 503, ++ 515, 516, 504, 517, 505, 518, 519, 506, 520, 507, + +- 1773, 1775, 1777, 1778, 1779, 1780, 1771, 1781, 1783, 1784, +- 1785, 1787, 1790, 1791, 1792, 1794, 1773, 1795, 1796, 1797, +- 1798, 1799, 1801, 1802, 1803, 1806, 1807, 1808, 1809, 1810, +- 1811, 1812, 1813, 1814, 1815, 1816, 1818, 1819, 1820, 1821, +- 1822, 1823, 1824, 1825, 1826, 1827, 1829, 1830, 1832, 1833, +- 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, 1843, +- 1844, 1845, 1847, 1848, 1852, 1853, 1854, 1855, 1857, 1858, +- 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1869, 1870, 1871, +- 1872, 1874, 1864, 1875, 1876, 1878, 1880, 1881, 1882, 1884, +- 1885, 1886, 1866, 1887, 1888, 1889, 1891, 1892, 1893, 1894, ++ 521, 508, 509, 522, 504, 510, 523, 511, 524, 525, ++ 512, 513, 528, 531, 532, 533, 514, 534, 515, 516, ++ 535, 517, 536, 518, 519, 537, 520, 538, 521, 539, ++ 540, 522, 542, 543, 523, 544, 524, 525, 541, 545, ++ 528, 531, 532, 533, 546, 534, 541, 547, 535, 548, ++ 536, 549, 550, 537, 551, 538, 552, 539, 540, 553, ++ 542, 543, 554, 544, 556, 557, 541, 545, 555, 558, ++ 559, 560, 546, 561, 541, 547, 562, 548, 555, 549, ++ 550, 563, 551, 564, 552, 565, 566, 553, 567, 568, ++ 554, 569, 556, 557, 571, 565, 555, 558, 559, 560, + +- 1895, 1897, 1898, 1899, 1900, 1901, 1903, 1906, 1908, 1910, +- 1912, 1916, 1917, 1918, 1920, 1922, 1923, 1925, 1928, 1932, +- 1933, 1934, 1935, 1936, 1938, 1939, 1940, 1941, 1942, 1943, +- 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, +- 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, +- 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, +- 1976, 1977, 1978, 1979, 1983, 1985, 1987, 1989, 1990, 1993, +- 1995, 1997, 1998, 1999, 2001, 2003, 2004, 2006, 2009, 2013, +- 2014, 2015, 2016, 2018, 2019, 2020, 2021, 2022, 2023, 2024, +- 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, ++ 573, 561, 574, 576, 562, 577, 555, 579, 578, 563, ++ 580, 564, 578, 565, 566, 0, 567, 568, 0, 569, ++ 581, 584, 571, 565, 572, 572, 582, 583, 573, 572, ++ 574, 576, 572, 577, 583, 579, 578, 582, 580, 585, ++ 578, 586, 572, 572, 587, 588, 572, 0, 581, 584, ++ 0, 589, 572, 572, 582, 583, 590, 572, 592, 593, ++ 572, 0, 583, 594, 595, 582, 0, 585, 596, 586, ++ 572, 572, 587, 588, 572, 575, 575, 591, 575, 589, ++ 575, 597, 598, 575, 590, 599, 592, 593, 600, 591, ++ 601, 594, 595, 575, 575, 602, 596, 575, 603, 604, + +- 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, +- 2045, 2046, 2047, 2050, 2051, 2052, 2053, 2057, 2059, 2061, +- 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2072, 2074, +- 2075, 2077, 2078, 2081, 2083, 2086, 2088, 2089, 2090, 2091, +- 2092, 2093, 2094, 2097, 2098, 2074, 2099, 2100, 2102, 2103, +- 2104, 2105, 2106, 2107, 2109, 2110, 2111, 2112, 2113, 2114, +- 2115, 2116, 2117, 2118, 2119, 2121, 2124, 2127, 2129, 2130, +- 2131, 2132, 2133, 2134, 2135, 2137, 2138, 2141, 2143, 2145, +- 2147, 2148, 2149, 2150, 2151, 2152, 2155, 2156, 2132, 2134, +- 2157, 2158, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, ++ 606, 608, 612, 575, 575, 591, 575, 613, 575, 597, ++ 598, 575, 614, 599, 615, 617, 600, 591, 601, 618, ++ 619, 575, 575, 602, 620, 575, 603, 604, 606, 608, ++ 612, 621, 622, 623, 624, 613, 625, 626, 627, 628, ++ 614, 629, 615, 617, 630, 631, 632, 618, 619, 633, ++ 634, 635, 620, 639, 640, 641, 642, 643, 644, 621, ++ 622, 623, 624, 645, 625, 626, 627, 628, 646, 629, ++ 647, 648, 630, 631, 632, 650, 651, 633, 634, 635, ++ 652, 639, 640, 641, 642, 643, 644, 653, 654, 655, ++ 656, 645, 657, 665, 670, 676, 646, 677, 647, 648, + +- 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2177, 2180, 2182, +- 2183, 2184, 2185, 2188, 2190, 2191, 2193, 2194, 2195, 2196, +- 2197, 2199, 2200, 2201, 2203, 2204, 2205, 2206, 2207, 2185, +- 2208, 2211, 2214, 2216, 2219, 2220, 2221, 2222, 2223, 2224, +- 2225, 2226, 2228, 2230, 2234, 2235, 2236, 2238, 2239, 2240, +- 2241, 2242, 2244, 2245, 2246, 2248, 2249, 2250, 2251, 2252, +- 2255, 2258, 2260, 2262, 2263, 2264, 2265, 2266, 2267, 2268, +- 2270, 2271, 2275, 2276, 2277, 2280, 2282, 2283, 2284, 2286, +- 2289, 2290, 2291, 2292, 2293, 2295, 2297, 2299, 2302, 2304, +- 2305, 2306, 2307, 2308, 2309, 2310, 2312, 2313, 2314, 2316, ++ 678, 665, 679, 650, 651, 666, 666, 681, 652, 666, ++ 682, 683, 684, 685, 686, 653, 654, 655, 656, 688, ++ 657, 689, 670, 676, 690, 677, 691, 692, 678, 665, ++ 679, 693, 694, 696, 695, 681, 695, 697, 682, 683, ++ 684, 685, 686, 698, 700, 701, 702, 688, 703, 689, ++ 704, 705, 690, 706, 691, 692, 707, 708, 710, 693, ++ 694, 696, 695, 711, 695, 697, 712, 713, 714, 715, ++ 716, 698, 700, 701, 702, 718, 703, 719, 704, 705, ++ 721, 706, 722, 723, 707, 708, 710, 724, 725, 726, ++ 727, 711, 728, 729, 712, 713, 714, 715, 716, 731, + +- 2319, 2320, 2321, 2322, 2323, 2326, 2330, 2332, 2333, 2334, +- 2335, 2336, 2337, 2338, 2340, 2341, 2342, 2343, 2344, 2345, +- 2350, 2351, 2353, 2354, 2355, 2356, 2358, 2359, 2360, 2361, +- 2362, 2363, 2364, 2365, 2370, 2371, 2372, 2373, 2374, 2376, +- 2377, 2378, 2380, 2381, 2382, 2385, 2387, 2390, 2392, 2394, +- 2395, 2396, 2400, 2403, 2405, 2409, 2411, 2412, 2416, 2417, +- 2418, 2420, 2421, 2422, 2423, 2424, 2425, 2426, 2427, 2428, +- 2429, 2430, 2431, 2432, 2433, 2434, 2435, 2420, 2436, 2437, +- 2423, 2438, 2439, 2440, 2441, 2442, 2443, 2444, 2446, 2447, +- 2448, 2450, 2452, 2453, 2455, 2457, 2459, 2463, 2463, 2463, ++ 732, 733, 734, 718, 735, 719, 736, 732, 721, 737, ++ 722, 723, 738, 740, 741, 724, 725, 726, 727, 739, ++ 728, 729, 742, 743, 744, 745, 739, 731, 732, 733, ++ 734, 745, 735, 746, 736, 732, 747, 737, 748, 749, ++ 738, 740, 741, 745, 750, 751, 752, 739, 753, 754, ++ 742, 743, 744, 745, 739, 755, 756, 757, 759, 745, ++ 760, 746, 758, 761, 747, 762, 748, 749, 758, 763, ++ 764, 745, 750, 751, 752, 767, 753, 754, 768, 769, ++ 758, 770, 768, 755, 756, 757, 759, 771, 760, 772, ++ 758, 761, 773, 762, 774, 775, 758, 763, 764, 776, + +- 2463, 2463, 2464, 2464, 2464, 2464, 2464, 2465, 2470, 2465, +- 2465, 2465, 2466, 2466, 2466, 2466, 2466, 2467, 753, 2467, +- 2467, 2467, 2468, 2468, 2469, 2469, 2469, 2469, 2469, 2471, +- 2471, 2472, 2472, 2472, 2472, 2472, 2473, 2473, 2473, 2473, +- 2473, 2474, 2474, 2474, 2474, 2474, 2475, 2475, 2475, 2475, +- 2475, 2476, 2476, 2476, 2476, 2476, 2477, 2477, 2477, 2477, +- 2477, 2478, 2478, 2478, 2478, 2478, 2479, 2479, 2479, 2479, +- 2479, 752, 751, 750, 749, 748, 747, 746, 745, 744, +- 742, 741, 740, 739, 738, 736, 735, 734, 733, 732, +- 731, 729, 727, 726, 725, 724, 723, 722, 721, 720, ++ 777, 778, 779, 767, 780, 781, 768, 769, 758, 770, ++ 768, 782, 783, 784, 785, 771, 782, 772, 786, 787, ++ 773, 788, 774, 775, 789, 790, 791, 776, 777, 778, ++ 779, 792, 780, 781, 793, 794, 795, 796, 797, 782, ++ 783, 784, 785, 798, 782, 799, 786, 787, 800, 788, ++ 801, 802, 789, 790, 791, 803, 804, 799, 805, 792, ++ 806, 808, 793, 794, 795, 796, 797, 810, 811, 812, ++ 813, 798, 814, 799, 816, 817, 800, 818, 801, 802, ++ 820, 821, 822, 803, 804, 799, 805, 823, 806, 808, ++ 824, 825, 826, 827, 828, 810, 811, 812, 813, 829, + +- 719, 717, 716, 714, 713, 712, 711, 710, 709, 708, +- 706, 705, 704, 703, 702, 701, 700, 699, 698, 696, +- 695, 694, 692, 691, 690, 689, 688, 687, 686, 684, +- 683, 682, 681, 680, 679, 677, 676, 675, 674, 673, +- 672, 670, 668, 666, 665, 661, 660, 656, 655, 654, +- 653, 652, 651, 650, 649, 647, 646, 645, 644, 643, +- 642, 641, 640, 639, 638, 637, 634, 633, 632, 631, +- 630, 629, 628, 627, 626, 625, 624, 623, 622, 621, +- 620, 619, 618, 617, 616, 614, 613, 612, 611, 609, +- 608, 607, 605, 603, 602, 601, 600, 599, 598, 597, ++ 814, 830, 816, 817, 831, 818, 831, 832, 820, 821, ++ 822, 833, 835, 836, 837, 823, 838, 839, 824, 825, ++ 826, 827, 828, 840, 841, 843, 844, 829, 845, 830, ++ 847, 849, 831, 850, 831, 832, 851, 852, 853, 833, ++ 835, 836, 837, 855, 838, 839, 857, 858, 856, 859, ++ 860, 840, 841, 843, 844, 856, 845, 861, 847, 849, ++ 862, 850, 863, 864, 851, 852, 853, 865, 867, 868, ++ 0, 855, 869, 870, 857, 858, 856, 859, 860, 871, ++ 866, 872, 873, 856, 874, 861, 866, 875, 862, 877, ++ 863, 864, 878, 876, 881, 865, 867, 868, 866, 876, + +- 596, 595, 594, 593, 592, 591, 589, 588, 587, 586, +- 585, 584, 583, 580, 579, 578, 576, 575, 573, 572, +- 570, 568, 567, 566, 565, 563, 562, 561, 560, 559, +- 558, 557, 556, 555, 553, 552, 551, 550, 549, 548, +- 547, 546, 545, 544, 543, 542, 541, 539, 538, 537, +- 536, 535, 534, 533, 532, 531, 530, 527, 524, 523, +- 522, 521, 520, 519, 518, 517, 516, 515, 514, 513, +- 512, 511, 510, 509, 508, 507, 506, 505, 504, 502, +- 500, 499, 498, 497, 496, 495, 494, 493, 492, 489, +- 488, 487, 485, 484, 483, 481, 480, 478, 477, 476, ++ 869, 870, 880, 882, 883, 884, 880, 871, 866, 872, ++ 873, 876, 874, 885, 866, 875, 886, 877, 887, 888, ++ 878, 876, 881, 889, 890, 891, 866, 876, 892, 893, ++ 880, 882, 883, 884, 880, 894, 895, 896, 897, 876, ++ 898, 885, 899, 900, 886, 901, 887, 888, 902, 903, ++ 904, 889, 890, 891, 899, 906, 892, 893, 907, 908, ++ 909, 911, 912, 894, 895, 896, 897, 914, 898, 915, ++ 899, 900, 917, 901, 918, 919, 902, 903, 904, 920, ++ 922, 923, 899, 906, 924, 925, 907, 908, 909, 911, ++ 912, 926, 927, 929, 930, 914, 931, 915, 932, 933, + +- 475, 474, 473, 472, 471, 469, 468, 466, 464, 461, +- 460, 459, 458, 457, 456, 455, 453, 452, 451, 449, +- 448, 447, 446, 445, 444, 443, 442, 440, 438, 437, +- 436, 434, 433, 432, 431, 430, 429, 427, 426, 425, +- 424, 423, 422, 421, 420, 419, 416, 415, 414, 413, +- 412, 411, 410, 409, 408, 407, 406, 405, 404, 403, +- 402, 401, 400, 399, 398, 394, 393, 392, 391, 387, +- 385, 383, 381, 379, 377, 375, 368, 367, 362, 361, +- 359, 358, 356, 355, 349, 348, 347, 346, 345, 344, +- 343, 342, 340, 339, 338, 337, 336, 335, 334, 333, ++ 917, 934, 918, 919, 935, 936, 937, 920, 922, 923, ++ 938, 939, 924, 925, 940, 941, 942, 943, 944, 926, ++ 927, 929, 930, 945, 931, 946, 932, 933, 947, 934, ++ 948, 949, 935, 936, 937, 950, 951, 952, 938, 939, ++ 954, 955, 940, 941, 942, 943, 944, 958, 959, 960, ++ 961, 945, 962, 946, 963, 964, 947, 966, 948, 949, ++ 967, 968, 969, 950, 951, 952, 970, 971, 954, 955, ++ 972, 973, 974, 975, 976, 958, 959, 960, 961, 977, ++ 962, 979, 963, 964, 980, 966, 981, 984, 967, 968, ++ 969, 986, 987, 987, 970, 971, 989, 990, 972, 973, + +- 331, 326, 324, 323, 322, 321, 320, 319, 318, 317, +- 316, 315, 313, 310, 308, 307, 306, 305, 300, 299, +- 298, 297, 296, 295, 294, 293, 290, 289, 287, 286, +- 285, 283, 282, 281, 279, 278, 277, 276, 275, 273, +- 271, 269, 268, 266, 265, 263, 261, 260, 258, 257, +- 256, 255, 254, 253, 252, 250, 249, 248, 245, 244, +- 243, 241, 240, 239, 238, 237, 236, 235, 233, 230, +- 228, 225, 224, 222, 221, 219, 218, 217, 216, 215, +- 212, 211, 209, 208, 207, 206, 205, 204, 203, 202, +- 201, 200, 198, 196, 191, 189, 188, 185, 184, 183, ++ 974, 975, 976, 991, 992, 993, 994, 977, 996, 979, ++ 998, 1001, 980, 1002, 981, 984, 1004, 1005, 1008, 986, ++ 987, 987, 1009, 1010, 989, 990, 1011, 0, 0, 1014, ++ 1007, 991, 992, 993, 994, 1016, 996, 1017, 998, 1001, ++ 1007, 1002, 1003, 1018, 1004, 1005, 1008, 1019, 1020, 1021, ++ 1009, 1010, 1003, 1022, 1011, 1003, 1003, 1014, 1007, 1003, ++ 1003, 0, 1023, 1016, 1024, 1017, 0, 1025, 1007, 0, ++ 1003, 1018, 1026, 0, 1027, 1019, 1020, 1021, 0, 0, ++ 1003, 1022, 1028, 1003, 1003, 1029, 1030, 1003, 1003, 1012, ++ 1023, 1012, 1024, 1031, 1012, 1025, 1033, 1012, 1034, 1035, + +- 181, 180, 179, 178, 176, 175, 174, 172, 170, 168, +- 165, 164, 163, 160, 159, 156, 155, 154, 152, 150, +- 149, 148, 146, 144, 141, 139, 133, 132, 131, 130, +- 128, 127, 125, 124, 120, 119, 114, 113, 112, 111, +- 109, 107, 104, 103, 102, 101, 92, 89, 86, 85, +- 84, 83, 81, 72, 68, 65, 62, 61, 59, 58, +- 51, 50, 44, 39, 32, 18, 17, 15, 11, 2462, +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, ++ 1026, 1012, 1027, 1036, 1037, 1038, 1012, 1012, 1039, 1040, ++ 1028, 1041, 1042, 1029, 1030, 1043, 1045, 1012, 1048, 1012, ++ 1049, 1031, 1012, 1050, 1033, 1012, 1034, 1035, 1051, 1012, ++ 1052, 1036, 1037, 1038, 1012, 1012, 1039, 1040, 1053, 1041, ++ 1042, 1054, 1055, 1043, 1045, 1056, 1048, 1057, 1049, 1058, ++ 1059, 1050, 1060, 1061, 1062, 1063, 1051, 1065, 1052, 1064, ++ 1066, 1067, 1069, 1070, 1068, 1071, 1053, 1072, 1064, 1054, ++ 1055, 1068, 1073, 1056, 1074, 1057, 1076, 1058, 1059, 1077, ++ 1060, 1061, 1062, 1063, 1078, 1065, 1079, 1064, 1066, 1067, ++ 1069, 1070, 1068, 1071, 1080, 1072, 1064, 1081, 1082, 1068, + +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, +- 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, 2462, +- 2462 ++ 1073, 1083, 1074, 1085, 1076, 1086, 1087, 1077, 1088, 1090, ++ 1091, 1093, 1078, 1094, 1079, 1095, 1091, 1096, 1098, 1100, ++ 1101, 1102, 1080, 1094, 1103, 1081, 1082, 1104, 1105, 1083, ++ 1106, 1085, 1107, 1086, 1087, 1108, 1088, 1090, 1091, 1093, ++ 1109, 1094, 1110, 1095, 1091, 1096, 1098, 1100, 1101, 1102, ++ 1111, 1094, 1103, 1112, 1114, 1104, 1105, 1116, 1106, 1118, ++ 1107, 1119, 1119, 1108, 1120, 1121, 1122, 1124, 1109, 1125, ++ 1110, 1127, 1131, 1130, 1128, 1132, 1133, 1135, 1111, 1137, ++ 1138, 1112, 1114, 1130, 1128, 1116, 1139, 1118, 1128, 1119, ++ 1119, 1128, 1120, 1121, 1122, 1124, 1140, 1125, 1141, 1127, ++ ++ 1131, 1130, 1128, 1132, 1133, 1135, 1142, 1137, 1138, 0, ++ 0, 1130, 1128, 1143, 1139, 1144, 1128, 1145, 1146, 1128, ++ 1134, 1147, 1134, 1148, 1140, 1134, 1141, 1149, 1134, 1150, ++ 1151, 1152, 1134, 1153, 1142, 1154, 1155, 1134, 1134, 1156, ++ 1157, 1143, 1158, 1144, 1159, 1145, 1146, 1160, 1134, 1147, ++ 1134, 1148, 1161, 1134, 1162, 1149, 1134, 1150, 1151, 1152, ++ 1134, 1153, 1163, 1154, 1155, 1134, 1134, 1156, 1157, 1164, ++ 1158, 1165, 1159, 1166, 1167, 1160, 1168, 1169, 1170, 1171, ++ 1161, 1172, 1162, 1173, 1174, 1175, 1171, 1176, 1177, 1178, ++ 1163, 1179, 1180, 1181, 1182, 1183, 1184, 1164, 1186, 1165, ++ ++ 1189, 1166, 1167, 0, 1168, 1169, 1170, 1171, 1190, 1172, ++ 1194, 1173, 1174, 1175, 1171, 1176, 1177, 1178, 1190, 1179, ++ 1180, 1181, 1182, 1183, 1184, 1187, 1186, 1195, 1189, 1196, ++ 1199, 1187, 1201, 1202, 1203, 1205, 1190, 1206, 1194, 1209, ++ 1212, 1213, 1214, 1215, 1216, 1217, 1190, 1219, 1222, 1224, ++ 1225, 1227, 1228, 1187, 1229, 1195, 1230, 1196, 1199, 1187, ++ 1201, 1202, 1203, 1205, 1231, 1206, 1232, 1209, 1212, 1213, ++ 1214, 1215, 1216, 1217, 1220, 1219, 1222, 1224, 1225, 1227, ++ 1228, 1233, 1229, 1220, 1230, 1234, 1235, 1236, 1237, 1239, ++ 1241, 1242, 1231, 1244, 1232, 1245, 1247, 1248, 1249, 1250, ++ ++ 1252, 1253, 1220, 1254, 1255, 1257, 1259, 1261, 1263, 1233, ++ 1264, 1220, 1267, 1234, 1235, 1236, 1237, 1239, 1241, 1242, ++ 1268, 1244, 1269, 1245, 1247, 1248, 1249, 1250, 1252, 1253, ++ 1270, 1254, 1255, 1257, 1259, 1261, 1263, 1271, 1264, 1272, ++ 1267, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1268, 1281, ++ 1269, 1282, 1283, 1284, 1285, 1286, 1287, 1289, 1270, 1290, ++ 1291, 1292, 1285, 1293, 1294, 1271, 1295, 1272, 1296, 1274, ++ 1275, 1276, 1277, 1278, 1279, 1280, 1297, 1281, 1298, 1282, ++ 1283, 1284, 1285, 1286, 1287, 1289, 1299, 1290, 1291, 1292, ++ 1285, 1293, 1294, 1300, 1295, 1301, 1296, 1303, 1305, 1306, ++ ++ 1307, 1308, 1309, 1310, 1297, 1311, 1298, 1312, 1313, 1314, ++ 1315, 1316, 1319, 1321, 1299, 1322, 1323, 1324, 1325, 1326, ++ 1331, 1300, 1332, 1301, 1333, 1303, 1305, 1306, 1307, 1308, ++ 1309, 1310, 1334, 1311, 1335, 1312, 1313, 1314, 1315, 1316, ++ 1319, 1321, 1336, 1322, 1323, 1324, 1325, 1326, 1331, 1337, ++ 1332, 1338, 1333, 1339, 1340, 1342, 1343, 1344, 1345, 1346, ++ 1334, 1347, 1335, 1349, 1348, 1352, 1353, 1356, 1357, 1358, ++ 1336, 1359, 1360, 1361, 1362, 1363, 1364, 1337, 1365, 1338, ++ 1348, 1339, 1340, 1342, 1343, 1344, 1345, 1346, 1367, 1347, ++ 1368, 1349, 1348, 1352, 1353, 1356, 1357, 1358, 1369, 1359, ++ ++ 1360, 1361, 1362, 1363, 1364, 1370, 1365, 1371, 1348, 1372, ++ 1374, 1375, 1377, 1378, 1379, 1381, 1367, 1382, 1368, 1383, ++ 1385, 1386, 1388, 1389, 1391, 1392, 1369, 1393, 1394, 1395, ++ 1396, 1397, 1398, 1370, 1399, 1371, 1400, 1372, 1374, 1375, ++ 1377, 1378, 1379, 1381, 1401, 1382, 1402, 1383, 1385, 1386, ++ 1388, 1389, 1391, 1392, 1403, 1393, 1394, 1395, 1396, 1397, ++ 1398, 1404, 1399, 1405, 1400, 1406, 1408, 1409, 1410, 1404, ++ 1411, 1412, 1401, 1413, 1402, 1414, 1415, 1416, 1417, 1418, ++ 1419, 1420, 1403, 1421, 1422, 1423, 1424, 1425, 1426, 1404, ++ 1427, 1405, 1428, 1406, 1408, 1409, 1410, 1404, 1411, 1412, ++ ++ 1429, 1413, 1430, 1414, 1415, 1416, 1417, 1418, 1419, 1420, ++ 1432, 1421, 1422, 1423, 1424, 1425, 1426, 1433, 1427, 1434, ++ 1428, 1435, 1436, 1438, 1439, 1440, 1441, 1442, 1429, 1443, ++ 1430, 1444, 1445, 1446, 1447, 1448, 1449, 1451, 1432, 1452, ++ 1450, 1453, 1455, 1456, 1457, 1433, 1458, 1434, 1459, 1435, ++ 1436, 1438, 1439, 1440, 1441, 1442, 1450, 1443, 1460, 1444, ++ 1445, 1446, 1447, 1448, 1449, 1451, 1461, 1452, 1450, 1453, ++ 1455, 1456, 1457, 1462, 1458, 1463, 1459, 1465, 1469, 1472, ++ 1475, 1476, 1479, 1480, 1450, 1481, 1460, 1483, 1486, 1487, ++ 1488, 1490, 1491, 1492, 1461, 1493, 1494, 1495, 1496, 1497, ++ ++ 1498, 1462, 1499, 1463, 1500, 1465, 1469, 1472, 1475, 1476, ++ 1479, 1480, 1501, 1481, 1502, 1483, 1486, 1487, 1488, 1490, ++ 1491, 1492, 1503, 1493, 1494, 1495, 1496, 1497, 1498, 1506, ++ 1499, 1507, 1500, 1508, 1510, 1512, 1513, 1514, 1515, 1516, ++ 1501, 1517, 1502, 1518, 1519, 1521, 1522, 1523, 1525, 1526, ++ 1503, 1527, 1528, 1529, 1530, 1531, 1532, 1506, 1533, 1507, ++ 1534, 1508, 1510, 1512, 1513, 1514, 1515, 1516, 1535, 1517, ++ 1537, 1518, 1519, 1521, 1522, 1523, 1525, 1526, 1538, 1527, ++ 1528, 1529, 1530, 1531, 1532, 1540, 1533, 1541, 1534, 1542, ++ 1543, 1545, 1546, 1547, 1548, 1549, 1535, 1551, 1537, 1552, ++ ++ 1553, 1554, 1555, 1557, 1558, 1559, 1538, 1560, 1562, 1563, ++ 1562, 1564, 1565, 1540, 0, 1541, 1567, 1542, 1543, 1545, ++ 1546, 1547, 1548, 1549, 0, 1551, 0, 1552, 1553, 1554, ++ 1555, 1557, 1558, 1559, 1568, 1560, 1562, 1563, 1562, 1564, ++ 1565, 1566, 1566, 1570, 1567, 1572, 1573, 1574, 1575, 1576, ++ 1577, 1578, 1566, 1579, 1566, 1580, 1581, 1582, 1566, 1583, ++ 1584, 1585, 1568, 1586, 1587, 1588, 1589, 1590, 0, 1566, ++ 1566, 1570, 1592, 1572, 1573, 1574, 1575, 1576, 1577, 1578, ++ 1566, 1579, 1566, 1580, 1581, 1582, 1566, 1583, 1584, 1585, ++ 1593, 1586, 1587, 1588, 1589, 1590, 1591, 1594, 1591, 1595, ++ ++ 1592, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, ++ 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1593, 1613, ++ 1615, 1616, 1617, 1618, 1591, 1594, 1591, 1595, 1619, 1596, ++ 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, ++ 1607, 1608, 1609, 1610, 1611, 1612, 1620, 1613, 1615, 1616, ++ 1617, 1618, 1621, 1622, 1623, 1624, 1619, 1626, 1627, 1628, ++ 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1638, 1639, ++ 1640, 1641, 1643, 1644, 1620, 1645, 1646, 1647, 1649, 1650, ++ 1621, 1622, 1623, 1624, 1651, 1626, 1627, 1628, 1629, 1630, ++ 1631, 1632, 1633, 1634, 1635, 1636, 1638, 1639, 1640, 1641, ++ ++ 1643, 1644, 1652, 1645, 1646, 1647, 1649, 1650, 1653, 1655, ++ 1656, 1657, 1651, 1659, 1660, 1661, 1661, 1662, 1663, 1664, ++ 1665, 1666, 1667, 1668, 1669, 1670, 1661, 1671, 1661, 1672, ++ 1652, 1673, 1661, 1674, 1675, 1676, 1653, 1655, 1656, 1657, ++ 1677, 1659, 1660, 1661, 1661, 1662, 1663, 1664, 1665, 1666, ++ 1667, 1668, 1669, 1670, 1661, 1671, 1661, 1672, 1678, 1673, ++ 1661, 1674, 1675, 1676, 1679, 1680, 1682, 1681, 1677, 1681, ++ 1683, 1684, 1685, 1686, 1687, 1688, 1690, 1691, 1692, 1693, ++ 1692, 1694, 1697, 1698, 1699, 1700, 1678, 1701, 1702, 1703, ++ 1704, 1705, 1679, 1680, 1682, 1681, 1706, 1681, 1683, 1684, ++ ++ 1685, 1686, 1687, 1688, 1690, 1691, 1692, 1693, 1692, 1694, ++ 1697, 1698, 1699, 1700, 1707, 1701, 1702, 1703, 1704, 1705, ++ 1708, 1709, 1710, 1711, 1706, 1712, 1713, 1714, 1715, 1717, ++ 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1728, ++ 1729, 1731, 1707, 1732, 1733, 1734, 1735, 1736, 1708, 1709, ++ 1710, 1711, 1737, 1712, 1713, 1714, 1715, 1717, 1718, 1719, ++ 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1728, 1729, 1731, ++ 1738, 1732, 1733, 1734, 1735, 1736, 1739, 1740, 1741, 1742, ++ 1737, 1743, 1744, 1745, 1746, 1748, 1749, 1753, 1754, 1755, ++ 1756, 1758, 1759, 1762, 1763, 1764, 1765, 1766, 1738, 1767, ++ ++ 1768, 1770, 0, 1773, 1739, 1740, 1741, 1742, 1775, 1743, ++ 1744, 1745, 1746, 1748, 1749, 1753, 1754, 1755, 1756, 1758, ++ 1759, 1762, 1763, 1764, 1765, 1766, 1769, 1767, 1768, 1770, ++ 1771, 1773, 1776, 1777, 1769, 1778, 1775, 1779, 1781, 1782, ++ 1783, 1785, 1788, 1789, 1790, 1792, 1771, 1793, 1794, 1795, ++ 1796, 1797, 1799, 1800, 1769, 1801, 1804, 1805, 1771, 1806, ++ 1776, 1777, 1769, 1778, 1807, 1779, 1781, 1782, 1783, 1785, ++ 1788, 1789, 1790, 1792, 1771, 1793, 1794, 1795, 1796, 1797, ++ 1799, 1800, 1808, 1801, 1804, 1805, 1809, 1806, 1810, 1811, ++ 1812, 1813, 1807, 1814, 1816, 1817, 1818, 1819, 1820, 1821, ++ ++ 1822, 1823, 1824, 1825, 1826, 1828, 1829, 1830, 1831, 1832, ++ 1808, 1833, 1834, 1835, 1809, 1836, 1810, 1811, 1812, 1813, ++ 1837, 1814, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, ++ 1824, 1825, 1826, 1828, 1829, 1830, 1831, 1832, 1838, 1833, ++ 1834, 1835, 1839, 1836, 1840, 1841, 1843, 1844, 1837, 1848, ++ 1849, 1850, 1851, 1853, 1854, 1856, 1857, 1858, 1859, 1860, ++ 1861, 1865, 1866, 1867, 0, 1868, 1838, 1860, 1870, 1871, ++ 1839, 1872, 1840, 1841, 1843, 1844, 1862, 1848, 1849, 1850, ++ 1851, 1853, 1854, 1856, 1857, 1858, 1859, 1860, 1861, 1865, ++ 1866, 1867, 1862, 1868, 1874, 1860, 1870, 1871, 1876, 1872, ++ ++ 1877, 1878, 1880, 1881, 1862, 1882, 1883, 1884, 1885, 1887, ++ 1888, 1889, 1890, 1891, 1893, 1894, 1895, 1896, 1897, 1899, ++ 1862, 1902, 1874, 1904, 1906, 1908, 1876, 1912, 1877, 1878, ++ 1880, 1881, 1913, 1882, 1883, 1884, 1885, 1887, 1888, 1889, ++ 1890, 1891, 1893, 1894, 1895, 1896, 1897, 1899, 1914, 1902, ++ 1916, 1904, 1906, 1908, 1918, 1912, 1919, 1921, 1924, 1928, ++ 1913, 1929, 1930, 1931, 1932, 1934, 1935, 1936, 1937, 1938, ++ 1939, 1940, 1941, 1942, 1943, 1944, 1914, 1945, 1916, 1946, ++ 1947, 1948, 1918, 1949, 1919, 1921, 1924, 1928, 1950, 1929, ++ 1930, 1931, 1932, 1934, 1935, 1936, 1937, 1938, 1939, 1940, ++ ++ 1941, 1942, 1943, 1944, 1951, 1945, 1952, 1946, 1947, 1948, ++ 1953, 1949, 1954, 1955, 1956, 1957, 1950, 1958, 1959, 1960, ++ 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1972, ++ 1973, 1974, 1951, 1975, 1952, 1979, 1981, 1983, 1953, 1985, ++ 1954, 1955, 1956, 1957, 1986, 1958, 1959, 1960, 1961, 1962, ++ 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1972, 1973, 1974, ++ 1989, 1975, 1991, 1979, 1981, 1983, 1993, 1985, 1994, 1995, ++ 1997, 1999, 1986, 2000, 2002, 2004, 2008, 2009, 2010, 2011, ++ 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 1989, 2021, ++ 1991, 2022, 2023, 2024, 1993, 2025, 1994, 1995, 1997, 1999, ++ ++ 2026, 2000, 2002, 2004, 2008, 2009, 2010, 2011, 2013, 2014, ++ 2015, 2016, 2017, 2018, 2019, 2020, 2027, 2021, 2028, 2022, ++ 2023, 2024, 2029, 2025, 2030, 2031, 2032, 2033, 2026, 2034, ++ 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2045, 2046, ++ 2047, 2048, 2052, 2054, 2027, 2056, 2028, 2058, 2059, 2060, ++ 2029, 2061, 2030, 2031, 2032, 2033, 2062, 2034, 2035, 2036, ++ 2037, 2038, 2039, 2040, 2041, 2042, 2045, 2046, 2047, 2048, ++ 2052, 2054, 2063, 2056, 2064, 2058, 2059, 2060, 2065, 2061, ++ 2067, 2069, 2070, 2072, 2062, 2073, 2076, 2078, 2081, 2083, ++ 2084, 2085, 2086, 2087, 2088, 2089, 2092, 2069, 2093, 2094, ++ ++ 2063, 2095, 2064, 2097, 2098, 2099, 2065, 2100, 2067, 2069, ++ 2070, 2072, 2101, 2073, 2076, 2078, 2081, 2083, 2084, 2085, ++ 2086, 2087, 2088, 2089, 2092, 2069, 2093, 2094, 2102, 2095, ++ 2104, 2097, 2098, 2099, 2105, 2100, 2106, 2107, 2108, 2109, ++ 2101, 2110, 2111, 2112, 2113, 2114, 2116, 2119, 2122, 2124, ++ 2125, 2126, 0, 2128, 2130, 2132, 2102, 2133, 2104, 2136, ++ 2138, 2140, 2105, 2127, 2106, 2107, 2108, 2109, 2129, 2110, ++ 2111, 2112, 2113, 2114, 2116, 2119, 2122, 2124, 2125, 2126, ++ 2127, 2128, 2130, 2132, 2129, 2133, 2142, 2136, 2138, 2140, ++ 2143, 2127, 2144, 2145, 2146, 2147, 2129, 2150, 2151, 2152, ++ ++ 2153, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2127, 2162, ++ 2163, 2164, 2129, 2165, 2142, 2166, 2167, 2168, 2143, 2169, ++ 2144, 2145, 2146, 2147, 2172, 2150, 2151, 2152, 2153, 2155, ++ 2156, 2157, 2158, 2159, 2160, 2161, 2175, 2162, 2163, 2164, ++ 2177, 2165, 2178, 2166, 2167, 2168, 2179, 2169, 2180, 2183, ++ 2185, 2186, 2172, 2188, 2189, 2190, 2191, 2192, 2194, 2195, ++ 2196, 2198, 2199, 2200, 2175, 2180, 2201, 2202, 2177, 2203, ++ 2178, 2206, 2209, 2211, 2179, 2214, 2180, 2183, 2185, 2186, ++ 2215, 2188, 2189, 2190, 2191, 2192, 2194, 2195, 2196, 2198, ++ 2199, 2200, 2216, 2180, 2201, 2202, 2217, 2203, 2218, 2206, ++ ++ 2209, 2211, 2219, 2214, 2220, 2221, 2223, 2225, 2215, 2229, ++ 2230, 2231, 2233, 2234, 2235, 2236, 2237, 2239, 2240, 2241, ++ 2216, 2243, 2244, 2245, 2217, 2246, 2218, 2247, 2250, 2253, ++ 2219, 2255, 2220, 2221, 2223, 2225, 2257, 2229, 2230, 2231, ++ 2233, 2234, 2235, 2236, 2237, 2239, 2240, 2241, 2258, 2243, ++ 2244, 2245, 2259, 2246, 2260, 2247, 2250, 2253, 2261, 2255, ++ 2262, 2263, 2265, 2266, 2257, 2270, 2271, 2272, 2275, 2277, ++ 2278, 2279, 2281, 2284, 2285, 2286, 2258, 2287, 2288, 2290, ++ 2259, 2292, 2260, 2294, 2297, 2299, 2261, 2300, 2262, 2263, ++ 2265, 2266, 2301, 2270, 2271, 2272, 2275, 2277, 2278, 2279, ++ ++ 2281, 2284, 2285, 2286, 2302, 2287, 2288, 2290, 2303, 2292, ++ 2304, 2294, 2297, 2299, 2305, 2300, 2307, 2308, 2309, 2311, ++ 2301, 2314, 2315, 2316, 2317, 2318, 2321, 2325, 2327, 2328, ++ 2329, 2330, 2302, 2331, 2332, 2333, 2303, 2335, 2304, 2336, ++ 2337, 2338, 2305, 2339, 2307, 2308, 2309, 2311, 2340, 2314, ++ 2315, 2316, 2317, 2318, 2321, 2325, 2327, 2328, 2329, 2330, ++ 2345, 2331, 2332, 2333, 2346, 2335, 2348, 2336, 2337, 2338, ++ 2349, 2339, 2350, 2351, 2353, 2354, 2340, 2355, 2356, 2357, ++ 2358, 2359, 2360, 2365, 2366, 2367, 2368, 2369, 2345, 2371, ++ 2372, 2373, 2346, 2375, 2348, 2376, 2377, 2380, 2349, 2382, ++ ++ 2350, 2351, 2353, 2354, 2385, 2355, 2356, 2357, 2358, 2359, ++ 2360, 2365, 2366, 2367, 2368, 2369, 2387, 2371, 2372, 2373, ++ 2389, 2375, 2390, 2376, 2377, 2380, 2391, 2382, 2395, 2398, ++ 2400, 2404, 2385, 2406, 2407, 2411, 2412, 2413, 2416, 2415, ++ 2417, 0, 2419, 2420, 2387, 2421, 2422, 2423, 2389, 2424, ++ 2390, 2425, 2426, 2418, 2391, 2415, 2395, 2398, 2400, 2404, ++ 2427, 2406, 2407, 2411, 2412, 2413, 2416, 2415, 2417, 2418, ++ 2419, 2420, 2428, 2421, 2422, 2423, 2429, 2424, 2430, 2425, ++ 2426, 2418, 2431, 2415, 2432, 2433, 2434, 2435, 2427, 2436, ++ 2437, 2438, 2439, 2441, 2442, 2443, 2445, 2418, 2447, 2448, ++ ++ 2428, 2450, 2452, 2454, 2429, 0, 2430, 0, 0, 0, ++ 2431, 0, 2432, 2433, 2434, 2435, 0, 2436, 2437, 2438, ++ 2439, 2441, 2442, 2443, 2445, 0, 2447, 2448, 0, 2450, ++ 2452, 2454, 2458, 2458, 2458, 2458, 2458, 2459, 2459, 2459, ++ 2459, 2459, 2460, 0, 2460, 2460, 2460, 2461, 2461, 2461, ++ 2461, 2461, 2462, 0, 2462, 2462, 2462, 2463, 2463, 2464, ++ 2464, 2464, 2464, 2464, 2466, 2466, 2467, 2467, 2467, 2467, ++ 2467, 2468, 2468, 2468, 2468, 2468, 2469, 2469, 2469, 2469, ++ 2469, 2470, 2470, 2470, 2470, 2470, 2471, 2471, 2471, 2471, ++ 2471, 2472, 2472, 2472, 2472, 2472, 2473, 2473, 2473, 2473, ++ ++ 2473, 2474, 2474, 2474, 2474, 2474, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, 2457, ++ 2457, 2457, 2457, 2457 + } ; + + static yy_state_type yy_last_accepting_state; + static char *yy_last_accepting_cpos; + ++extern int msyy_flex_debug; ++int msyy_flex_debug = 0; ++ + /* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +@@ -1812,9 +2442,8 @@ + #define yymore() yymore_used_but_not_detected + #define YY_MORE_ADJ 0 + #define YY_RESTORE_YY_MORE_OFFSET +-char *yytext; ++char *msyytext; + #line 1 "maplexer.l" +-#define INITIAL 0 + #line 2 "maplexer.l" + /* C declarations */ + #include +@@ -1856,7 +2485,7 @@ + */ + if( yy_current_buffer != NULL ) + { +- yy_delete_buffer( yy_current_buffer ); ++ msyy_delete_buffer(yy_current_buffer ); + yy_current_buffer = 0; + } + #endif +@@ -1865,15 +2494,60 @@ + #define MAX_INCLUDE_DEPTH 5 + YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH]; + int include_stack_ptr = 0; +-#define OBJECT_STRING 1 + +-#define VALUE_STRING 2 + +-#define EXPRESSION_STRING 3 + ++ ++#line 2502 "maplexer.c" ++ ++#define INITIAL 0 ++#define OBJECT_STRING 1 ++#define VALUE_STRING 2 ++#define EXPRESSION_STRING 3 + #define INCLUDE 4 + +-#line 1877 "maplexer.c" ++#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 ++ ++static int yy_init_globals (void ); ++ ++/* Accessor methods to globals. ++ These are made visible to non-reentrant scanners for convenience. */ ++ ++int msyylex_destroy (void ); ++ ++int msyyget_debug (void ); ++ ++void msyyset_debug (int debug_flag ); ++ ++YY_EXTRA_TYPE msyyget_extra (void ); ++ ++void msyyset_extra (YY_EXTRA_TYPE user_defined ); ++ ++FILE *msyyget_in (void ); ++ ++void msyyset_in (FILE * in_str ); ++ ++FILE *msyyget_out (void ); ++ ++void msyyset_out (FILE * out_str ); ++ ++int msyyget_leng (void ); ++ ++char *msyyget_text (void ); ++ ++int msyyget_lineno (void ); ++ ++void msyyset_lineno (int line_number ); + + /* Macros after this point can all be overridden by user definitions in + * section 1. +@@ -1881,65 +2555,30 @@ + + #ifndef YY_SKIP_YYWRAP + #ifdef __cplusplus +-extern "C" int yywrap YY_PROTO(( void )); ++extern "C" int msyywrap (void ); + #else +-extern int yywrap YY_PROTO(( void )); +-#endif ++extern int msyywrap (void ); + #endif +- +-#ifndef YY_NO_UNPUT +-static void yyunput YY_PROTO(( int c, char *buf_ptr )); + #endif + ++ static void yyunput (int c,char *buf_ptr ); ++ + #ifndef yytext_ptr +-static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); ++static void yy_flex_strncpy (char *,yyconst char *,int ); + #endif + + #ifdef YY_NEED_STRLEN +-static int yy_flex_strlen YY_PROTO(( yyconst char * )); ++static int yy_flex_strlen (yyconst char * ); + #endif + + #ifndef YY_NO_INPUT ++ + #ifdef __cplusplus +-static int yyinput YY_PROTO(( void )); ++static int yyinput (void ); + #else +-static int input YY_PROTO(( void )); +-#endif +-#endif +- +-#if YY_STACK_USED +-static int yy_start_stack_ptr = 0; +-static int yy_start_stack_depth = 0; +-static int *yy_start_stack = 0; +-#ifndef YY_NO_PUSH_STATE +-static void yy_push_state YY_PROTO(( int new_state )); +-#endif +-#ifndef YY_NO_POP_STATE +-static void yy_pop_state YY_PROTO(( void )); +-#endif +-#ifndef YY_NO_TOP_STATE +-static int yy_top_state YY_PROTO(( void )); ++static int input (void ); + #endif + +-#else +-#define YY_NO_PUSH_STATE 1 +-#define YY_NO_POP_STATE 1 +-#define YY_NO_TOP_STATE 1 +-#endif +- +-#ifdef YY_MALLOC_DECL +-YY_MALLOC_DECL +-#else +-#if __STDC__ +-#ifndef __cplusplus +-#include +-#endif +-#else +-/* Just try to get by without declaring the routines. This will fail +- * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) +- * or sizeof(void*) != sizeof(int). +- */ +-#endif + #endif + + /* Amount of stuff to slurp up with each read. */ +@@ -1948,12 +2587,11 @@ + #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 (void) fwrite( yytext, yyleng, 1, yyout ) ++#define ECHO do { if (fwrite( msyytext, msyyleng, 1, msyyout )) {} } while (0) + #endif + + /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, +@@ -1961,21 +2599,35 @@ + */ + #ifndef YY_INPUT + #define YY_INPUT(buf,result,max_size) \ +- if ( yy_current_buffer->yy_is_interactive ) \ ++ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ +- int c = '*', n; \ ++ int c = '*'; \ ++ size_t n; \ + for ( n = 0; n < max_size && \ +- (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ ++ (c = getc( msyyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ +- if ( c == EOF && ferror( yyin ) ) \ ++ if ( c == EOF && ferror( msyyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ +- else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ +- && ferror( yyin ) ) \ +- YY_FATAL_ERROR( "input in flex scanner failed" ); ++ else \ ++ { \ ++ errno=0; \ ++ while ( (result = fread(buf, 1, max_size, msyyin))==0 && ferror(msyyin)) \ ++ { \ ++ if( errno != EINTR) \ ++ { \ ++ YY_FATAL_ERROR( "input in flex scanner failed" ); \ ++ break; \ ++ } \ ++ errno=0; \ ++ clearerr(msyyin); \ ++ } \ ++ }\ ++\ ++ + #endif + + /* No semi-colon after return; correct usage is to write "yyterminate();" - +@@ -1996,14 +2648,20 @@ + #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) + #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 int yylex YY_PROTO(( void )) +-#endif ++#define YY_DECL_IS_OURS 1 + +-/* Code executed at the beginning of each rule, after yytext and yyleng ++extern int msyylex (void); ++ ++#define YY_DECL int msyylex (void) ++#endif /* !YY_DECL */ ++ ++/* Code executed at the beginning of each rule, after msyytext and msyyleng + * have been set up. + */ + #ifndef YY_USER_ACTION +@@ -2018,12 +2676,14 @@ + #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; +- ++ + #line 58 "maplexer.l" + + switch(msyystate) { +@@ -2076,87 +2736,87 @@ + break; + } + +-#line 2080 "maplexer.c" ++#line 2740 "maplexer.c" + +- if ( yy_init ) ++ if ( !(yy_init) ) + { +- yy_init = 0; ++ (yy_init) = 1; + + #ifdef YY_USER_INIT + YY_USER_INIT; + #endif + +- if ( ! yy_start ) +- yy_start = 1; /* first start state */ ++ if ( ! (yy_start) ) ++ (yy_start) = 1; /* first start state */ + +- if ( ! yyin ) +- yyin = stdin; ++ if ( ! msyyin ) ++ msyyin = stdin; + +- if ( ! yyout ) +- yyout = stdout; ++ if ( ! msyyout ) ++ msyyout = stdout; + +- if ( ! yy_current_buffer ) +- yy_current_buffer = +- yy_create_buffer( yyin, YY_BUF_SIZE ); ++ if ( ! YY_CURRENT_BUFFER ) { ++ msyyensure_buffer_stack (); ++ YY_CURRENT_BUFFER_LVALUE = ++ msyy_create_buffer(msyyin,YY_BUF_SIZE ); ++ } + +- yy_load_buffer_state(); ++ msyy_load_buffer_state( ); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { +- yy_cp = yy_c_buf_p; ++ yy_cp = (yy_c_buf_p); + +- /* Support of yytext. */ +- *yy_cp = yy_hold_char; ++ /* Support of msyytext. */ ++ *yy_cp = (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; ++ yy_current_state = (yy_start); + yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { +- yy_last_accepting_state = yy_current_state; +- yy_last_accepting_cpos = yy_cp; ++ (yy_last_accepting_state) = yy_current_state; ++ (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; +- if ( yy_current_state >= 2463 ) ++ if ( yy_current_state >= 2458 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } +- while ( yy_base[yy_current_state] != 2770 ); ++ while ( yy_base[yy_current_state] != 5207 ); + + yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ +- yy_cp = yy_last_accepting_cpos; +- yy_current_state = yy_last_accepting_state; ++ yy_cp = (yy_last_accepting_cpos); ++ yy_current_state = (yy_last_accepting_state); + yy_act = yy_accept[yy_current_state]; + } + + 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 = yy_hold_char; +- yy_cp = yy_last_accepting_cpos; +- yy_current_state = yy_last_accepting_state; ++ *yy_cp = (yy_hold_char); ++ yy_cp = (yy_last_accepting_cpos); ++ yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + + case 1: +@@ -3429,6 +4089,7 @@ + } + YY_BREAK + case 253: ++/* rule 253 can match eol */ + YY_RULE_SETUP + #line 383 "maplexer.l" + { +@@ -3441,6 +4102,7 @@ + } + YY_BREAK + case 254: ++/* rule 254 can match eol */ + YY_RULE_SETUP + #line 392 "maplexer.l" + { +@@ -3450,6 +4112,7 @@ + } + YY_BREAK + case 255: ++/* rule 255 can match eol */ + YY_RULE_SETUP + #line 398 "maplexer.l" + { +@@ -3460,6 +4123,7 @@ + } + YY_BREAK + case 256: ++/* rule 256 can match eol */ + YY_RULE_SETUP + #line 405 "maplexer.l" + { +@@ -3469,6 +4133,7 @@ + } + YY_BREAK + case 257: ++/* rule 257 can match eol */ + YY_RULE_SETUP + #line 411 "maplexer.l" + { +@@ -3488,6 +4153,7 @@ + } + YY_BREAK + case 259: ++/* rule 259 can match eol */ + YY_RULE_SETUP + #line 424 "maplexer.l" + { +@@ -3497,6 +4163,7 @@ + } + YY_BREAK + case 260: ++/* rule 260 can match eol */ + YY_RULE_SETUP + #line 430 "maplexer.l" + { +@@ -3522,6 +4189,7 @@ + } + YY_BREAK + case 261: ++/* rule 261 can match eol */ + YY_RULE_SETUP + #line 452 "maplexer.l" + { +@@ -3531,6 +4199,7 @@ + } + YY_BREAK + case 262: ++/* rule 262 can match eol */ + YY_RULE_SETUP + #line 458 "maplexer.l" + { +@@ -3542,6 +4211,7 @@ + } + YY_BREAK + case 263: ++/* rule 263 can match eol */ + YY_RULE_SETUP + #line 466 "maplexer.l" + { +@@ -3568,6 +4238,7 @@ + { return(MS_STRING); } + YY_BREAK + case 267: ++/* rule 267 can match eol */ + YY_RULE_SETUP + #line 478 "maplexer.l" + { msyylineno++; } +@@ -3584,6 +4255,7 @@ + } + YY_BREAK + case 268: ++/* rule 268 can match eol */ + YY_RULE_SETUP + #line 489 "maplexer.l" + { return(0); } +@@ -3603,7 +4275,7 @@ + #line 493 "maplexer.l" + ECHO; + YY_BREAK +-#line 3607 "maplexer.c" ++#line 4279 "maplexer.c" + case YY_STATE_EOF(OBJECT_STRING): + case YY_STATE_EOF(VALUE_STRING): + case YY_STATE_EOF(EXPRESSION_STRING): +@@ -3613,26 +4285,26 @@ + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ +- int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; ++ int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ +- *yy_cp = yy_hold_char; ++ *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + +- if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) ++ 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 +- * yylex(). If so, then we have to assure +- * consistency between yy_current_buffer and our ++ * just pointed msyyin at a new source and called ++ * msyylex(). 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. + */ +- yy_n_chars = yy_current_buffer->yy_n_chars; +- yy_current_buffer->yy_input_file = yyin; +- yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; ++ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ++ YY_CURRENT_BUFFER_LVALUE->yy_input_file = msyyin; ++ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position +@@ -3642,13 +4314,13 @@ + * end-of-buffer state). Contrast this with the test + * in input(). + */ +- if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) ++ if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + +- yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; ++ (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + +- yy_current_state = yy_get_previous_state(); ++ yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have +@@ -3661,41 +4333,41 @@ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + +- yy_bp = yytext_ptr + YY_MORE_ADJ; ++ yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ +- yy_cp = ++yy_c_buf_p; ++ yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { +- yy_cp = yy_c_buf_p; ++ yy_cp = (yy_c_buf_p); + goto yy_find_action; + } + } + +- else switch ( yy_get_next_buffer() ) ++ else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { +- yy_did_buffer_switch_on_eof = 0; ++ (yy_did_buffer_switch_on_eof) = 0; + +- if ( yywrap() ) ++ if ( msyywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up +- * yytext, we can now set up ++ * msyytext, 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. + */ +- yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; ++ (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; +@@ -3703,30 +4375,30 @@ + + else + { +- if ( ! yy_did_buffer_switch_on_eof ) ++ if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: +- yy_c_buf_p = +- yytext_ptr + yy_amount_of_matched_text; ++ (yy_c_buf_p) = ++ (yytext_ptr) + yy_amount_of_matched_text; + +- yy_current_state = yy_get_previous_state(); ++ yy_current_state = yy_get_previous_state( ); + +- yy_cp = yy_c_buf_p; +- yy_bp = yytext_ptr + YY_MORE_ADJ; ++ yy_cp = (yy_c_buf_p); ++ yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: +- yy_c_buf_p = +- &yy_current_buffer->yy_ch_buf[yy_n_chars]; ++ (yy_c_buf_p) = ++ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + +- yy_current_state = yy_get_previous_state(); ++ yy_current_state = yy_get_previous_state( ); + +- yy_cp = yy_c_buf_p; +- yy_bp = yytext_ptr + YY_MORE_ADJ; ++ yy_cp = (yy_c_buf_p); ++ yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; +@@ -3737,8 +4409,7 @@ + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ +- } /* end of yylex */ +- ++} /* end of msyylex */ + + /* yy_get_next_buffer - try to read in a new buffer + * +@@ -3747,21 +4418,20 @@ + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +- +-static int yy_get_next_buffer() +- { +- register char *dest = yy_current_buffer->yy_ch_buf; +- register char *source = yytext_ptr; ++static int yy_get_next_buffer (void) ++{ ++ register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ++ register char *source = (yytext_ptr); + register int number_to_move, i; + int ret_val; + +- if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) ++ if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + +- if ( yy_current_buffer->yy_fill_buffer == 0 ) ++ if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ +- if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) ++ if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. +@@ -3781,34 +4451,30 @@ + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ +- number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; ++ number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + +- if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ++ 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->yy_n_chars = yy_n_chars = 0; ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { +- int num_to_read = +- yy_current_buffer->yy_buf_size - number_to_move - 1; ++ int 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. */ +-#ifdef YY_USES_REJECT +- YY_FATAL_ERROR( +-"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +-#else + + /* just a shorter name for the current buffer */ +- YY_BUFFER_STATE b = yy_current_buffer; ++ YY_BUFFER_STATE b = YY_CURRENT_BUFFER; + + int yy_c_buf_p_offset = +- (int) (yy_c_buf_p - b->yy_ch_buf); ++ (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { +@@ -3821,8 +4487,7 @@ + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ +- yy_flex_realloc( (void *) b->yy_ch_buf, +- b->yy_buf_size + 2 ); ++ msyyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ +@@ -3832,35 +4497,35 @@ + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + +- yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; ++ (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + +- num_to_read = yy_current_buffer->yy_buf_size - ++ num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; +-#endif ++ + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ +- YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), +- yy_n_chars, num_to_read ); ++ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ++ (yy_n_chars), (size_t) num_to_read ); + +- yy_current_buffer->yy_n_chars = yy_n_chars; ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + +- if ( yy_n_chars == 0 ) ++ if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; +- yyrestart( yyin ); ++ msyyrestart(msyyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; +- yy_current_buffer->yy_buffer_status = ++ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } +@@ -3868,152 +4533,145 @@ + else + ret_val = EOB_ACT_CONTINUE_SCAN; + +- yy_n_chars += number_to_move; +- yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; +- yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ++ if ((yy_size_t) ((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 = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); ++ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) msyyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); ++ if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ++ YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ++ } + +- yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; ++ (yy_n_chars) += number_to_move; ++ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; ++ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + +- return ret_val; +- } ++ (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() +- { ++ static yy_state_type yy_get_previous_state (void) ++{ + register yy_state_type yy_current_state; + register char *yy_cp; ++ ++ yy_current_state = (yy_start); + +- yy_current_state = yy_start; +- +- for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) ++ for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { +- register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 51); ++ register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 77); + if ( yy_accept[yy_current_state] ) + { +- yy_last_accepting_state = yy_current_state; +- yy_last_accepting_cpos = yy_cp; ++ (yy_last_accepting_state) = yy_current_state; ++ (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; +- if ( yy_current_state >= 2463 ) ++ if ( yy_current_state >= 2458 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + 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 ); + */ +- +-#ifdef YY_USE_PROTOS +-static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +-#else +-static yy_state_type yy_try_NUL_trans( yy_current_state ) +-yy_state_type yy_current_state; +-#endif +- { ++ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) ++{ + register int yy_is_jam; +- register char *yy_cp = yy_c_buf_p; ++ register char *yy_cp = (yy_c_buf_p); + +- register YY_CHAR yy_c = 51; ++ register YY_CHAR yy_c = 77; + if ( yy_accept[yy_current_state] ) + { +- yy_last_accepting_state = yy_current_state; +- yy_last_accepting_cpos = yy_cp; ++ (yy_last_accepting_state) = yy_current_state; ++ (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; +- if ( yy_current_state >= 2463 ) ++ if ( yy_current_state >= 2458 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; +- yy_is_jam = (yy_current_state == 2462); ++ yy_is_jam = (yy_current_state == 2457); + + return yy_is_jam ? 0 : yy_current_state; +- } +- ++} + +-#ifndef YY_NO_UNPUT +-#ifdef YY_USE_PROTOS +-static void yyunput( int c, register char *yy_bp ) +-#else +-static void yyunput( c, yy_bp ) +-int c; +-register char *yy_bp; +-#endif +- { +- register char *yy_cp = yy_c_buf_p; ++ static void yyunput (int c, register char * yy_bp ) ++{ ++ register char *yy_cp; ++ ++ yy_cp = (yy_c_buf_p); + +- /* undo effects of setting up yytext */ +- *yy_cp = yy_hold_char; ++ /* undo effects of setting up msyytext */ ++ *yy_cp = (yy_hold_char); + +- if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) ++ if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ +- register int number_to_move = yy_n_chars + 2; +- register char *dest = &yy_current_buffer->yy_ch_buf[ +- yy_current_buffer->yy_buf_size + 2]; ++ register int number_to_move = (yy_n_chars) + 2; ++ register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ ++ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + register char *source = +- &yy_current_buffer->yy_ch_buf[number_to_move]; ++ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + +- while ( source > yy_current_buffer->yy_ch_buf ) ++ while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); +- yy_current_buffer->yy_n_chars = +- yy_n_chars = yy_current_buffer->yy_buf_size; ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = ++ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + +- if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) ++ if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + ++ (yytext_ptr) = yy_bp; ++ (yy_hold_char) = *yy_cp; ++ (yy_c_buf_p) = yy_cp; ++} + +- yytext_ptr = yy_bp; +- yy_hold_char = *yy_cp; +- yy_c_buf_p = yy_cp; +- } +-#endif /* ifndef YY_NO_UNPUT */ +- +- ++#ifndef YY_NO_INPUT + #ifdef __cplusplus +-static int yyinput() ++ static int yyinput (void) + #else +-static int input() ++ static int input (void) + #endif +- { +- int c; + +- *yy_c_buf_p = yy_hold_char; ++{ ++ int c; ++ ++ *(yy_c_buf_p) = (yy_hold_char); + +- if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) ++ if ( *(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 ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) ++ if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ +- *yy_c_buf_p = '\0'; ++ *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ +- int offset = yy_c_buf_p - yytext_ptr; +- ++yy_c_buf_p; ++ int offset = (yy_c_buf_p) - (yytext_ptr); ++ ++(yy_c_buf_p); + +- switch ( yy_get_next_buffer() ) ++ switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() +@@ -4027,16 +4685,16 @@ + */ + + /* Reset buffer status. */ +- yyrestart( yyin ); ++ msyyrestart(msyyin ); + +- /* fall through */ ++ /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { +- if ( yywrap() ) ++ if ( msyywrap( ) ) + return EOF; + +- if ( ! yy_did_buffer_switch_on_eof ) ++ if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + #ifdef __cplusplus + return yyinput(); +@@ -4046,172 +4704,169 @@ + } + + case EOB_ACT_CONTINUE_SCAN: +- yy_c_buf_p = yytext_ptr + offset; ++ (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + +- c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ +- *yy_c_buf_p = '\0'; /* preserve yytext */ +- yy_hold_char = *++yy_c_buf_p; +- ++ c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ ++ *(yy_c_buf_p) = '\0'; /* preserve msyytext */ ++ (yy_hold_char) = *++(yy_c_buf_p); + + return c; +- } +- +- +-#ifdef YY_USE_PROTOS +-void yyrestart( FILE *input_file ) +-#else +-void yyrestart( input_file ) +-FILE *input_file; +-#endif +- { +- if ( ! yy_current_buffer ) +- yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); ++} ++#endif /* ifndef YY_NO_INPUT */ + +- yy_init_buffer( yy_current_buffer, input_file ); +- yy_load_buffer_state(); ++/** Immediately switch to a different input stream. ++ * @param input_file A readable stream. ++ * ++ * @note This function does not reset the start condition to @c INITIAL . ++ */ ++ void msyyrestart (FILE * input_file ) ++{ ++ ++ if ( ! YY_CURRENT_BUFFER ){ ++ msyyensure_buffer_stack (); ++ YY_CURRENT_BUFFER_LVALUE = ++ msyy_create_buffer(msyyin,YY_BUF_SIZE ); + } + ++ msyy_init_buffer(YY_CURRENT_BUFFER,input_file ); ++ msyy_load_buffer_state( ); ++} + +-#ifdef YY_USE_PROTOS +-void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +-#else +-void yy_switch_to_buffer( new_buffer ) +-YY_BUFFER_STATE new_buffer; +-#endif +- { +- if ( yy_current_buffer == new_buffer ) ++/** Switch to a different input buffer. ++ * @param new_buffer The new input buffer. ++ * ++ */ ++ void msyy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) ++{ ++ ++ /* TODO. We should be able to replace this entire function body ++ * with ++ * msyypop_buffer_state(); ++ * msyypush_buffer_state(new_buffer); ++ */ ++ msyyensure_buffer_stack (); ++ if ( YY_CURRENT_BUFFER == new_buffer ) + return; + +- if ( yy_current_buffer ) ++ if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ +- *yy_c_buf_p = yy_hold_char; +- yy_current_buffer->yy_buf_pos = yy_c_buf_p; +- yy_current_buffer->yy_n_chars = yy_n_chars; ++ *(yy_c_buf_p) = (yy_hold_char); ++ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + +- yy_current_buffer = new_buffer; +- yy_load_buffer_state(); ++ YY_CURRENT_BUFFER_LVALUE = new_buffer; ++ msyy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during +- * EOF (yywrap()) processing, but the only time this flag +- * is looked at is after yywrap() is called, so it's safe ++ * EOF (msyywrap()) processing, but the only time this flag ++ * is looked at is after msyywrap() is called, so it's safe + * to go ahead and always set it. + */ +- yy_did_buffer_switch_on_eof = 1; +- } +- +- +-#ifdef YY_USE_PROTOS +-void yy_load_buffer_state( void ) +-#else +-void yy_load_buffer_state() +-#endif +- { +- yy_n_chars = yy_current_buffer->yy_n_chars; +- yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; +- yyin = yy_current_buffer->yy_input_file; +- yy_hold_char = *yy_c_buf_p; +- } ++ (yy_did_buffer_switch_on_eof) = 1; ++} + ++static void msyy_load_buffer_state (void) ++{ ++ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ++ (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ++ msyyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ++ (yy_hold_char) = *(yy_c_buf_p); ++} + +-#ifdef YY_USE_PROTOS +-YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +-#else +-YY_BUFFER_STATE yy_create_buffer( file, size ) +-FILE *file; +-int size; +-#endif +- { ++/** 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. ++ * ++ * @return the allocated buffer state. ++ */ ++ YY_BUFFER_STATE msyy_create_buffer (FILE * file, int size ) ++{ + YY_BUFFER_STATE b; +- +- b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); ++ ++ b = (YY_BUFFER_STATE) msyyalloc(sizeof( struct yy_buffer_state ) ); + if ( ! b ) +- YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ++ YY_FATAL_ERROR( "out of dynamic memory in msyy_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 *) yy_flex_alloc( b->yy_buf_size + 2 ); ++ b->yy_ch_buf = (char *) msyyalloc(b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) +- YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ++ YY_FATAL_ERROR( "out of dynamic memory in msyy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + +- yy_init_buffer( b, file ); ++ msyy_init_buffer(b,file ); + + return b; +- } +- ++} + +-#ifdef YY_USE_PROTOS +-void yy_delete_buffer( YY_BUFFER_STATE b ) +-#else +-void yy_delete_buffer( b ) +-YY_BUFFER_STATE b; +-#endif +- { ++/** Destroy the buffer. ++ * @param b a buffer created with msyy_create_buffer() ++ * ++ */ ++ void msyy_delete_buffer (YY_BUFFER_STATE b ) ++{ ++ + if ( ! b ) + return; + +- if ( b == yy_current_buffer ) +- yy_current_buffer = (YY_BUFFER_STATE) 0; ++ 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 ) +- yy_flex_free( (void *) b->yy_ch_buf ); +- +- yy_flex_free( (void *) b ); +- } +- +- +-#ifndef YY_ALWAYS_INTERACTIVE +-#ifndef YY_NEVER_INTERACTIVE +-extern int isatty YY_PROTO(( int )); +-#endif +-#endif ++ msyyfree((void *) b->yy_ch_buf ); + +-#ifdef YY_USE_PROTOS +-void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +-#else +-void yy_init_buffer( b, file ) +-YY_BUFFER_STATE b; +-FILE *file; +-#endif ++ msyyfree((void *) b ); ++} + ++#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 msyyrestart() or at EOF. ++ */ ++ static void msyy_init_buffer (YY_BUFFER_STATE b, FILE * file ) + +- { +- yy_flush_buffer( b ); ++{ ++ int oerrno = errno; ++ ++ msyy_flush_buffer(b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +-#if YY_ALWAYS_INTERACTIVE +- b->yy_is_interactive = 1; +-#else +-#if YY_NEVER_INTERACTIVE +- b->yy_is_interactive = 0; +-#else +- b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +-#endif +-#endif +- } +- ++ /* If b is the current buffer, then msyy_init_buffer was _probably_ ++ * called from msyyrestart() 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; ++ } + +-#ifdef YY_USE_PROTOS +-void yy_flush_buffer( YY_BUFFER_STATE b ) +-#else +-void yy_flush_buffer( b ) +-YY_BUFFER_STATE b; +-#endif ++ b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ++ ++ errno = oerrno; ++} + +- { +- if ( ! b ) ++/** 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. ++ * ++ */ ++ void msyy_flush_buffer (YY_BUFFER_STATE b ) ++{ ++ if ( ! b ) + return; + + b->yy_n_chars = 0; +@@ -4228,31 +4883,127 @@ + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + +- if ( b == yy_current_buffer ) +- yy_load_buffer_state(); ++ if ( b == YY_CURRENT_BUFFER ) ++ msyy_load_buffer_state( ); ++} ++ ++/** 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. ++ * ++ */ ++void msyypush_buffer_state (YY_BUFFER_STATE new_buffer ) ++{ ++ if (new_buffer == NULL) ++ return; ++ ++ msyyensure_buffer_stack(); ++ ++ /* This block is copied from msyy_switch_to_buffer. */ ++ if ( YY_CURRENT_BUFFER ) ++ { ++ /* Flush out information for old buffer. */ ++ *(yy_c_buf_p) = (yy_hold_char); ++ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); ++ } ++ ++ /* Only push if top exists. Otherwise, replace top. */ ++ if (YY_CURRENT_BUFFER) ++ (yy_buffer_stack_top)++; ++ YY_CURRENT_BUFFER_LVALUE = new_buffer; ++ ++ /* copied from msyy_switch_to_buffer. */ ++ msyy_load_buffer_state( ); ++ (yy_did_buffer_switch_on_eof) = 1; ++} ++ ++/** Removes and deletes the top of the stack, if present. ++ * The next element becomes the new top. ++ * ++ */ ++void msyypop_buffer_state (void) ++{ ++ if (!YY_CURRENT_BUFFER) ++ return; ++ ++ msyy_delete_buffer(YY_CURRENT_BUFFER ); ++ YY_CURRENT_BUFFER_LVALUE = NULL; ++ if ((yy_buffer_stack_top) > 0) ++ --(yy_buffer_stack_top); ++ ++ if (YY_CURRENT_BUFFER) { ++ msyy_load_buffer_state( ); ++ (yy_did_buffer_switch_on_eof) = 1; + } ++} + ++/* Allocates the stack if it does not exist. ++ * Guarantees space for at least one push. ++ */ ++static void msyyensure_buffer_stack (void) ++{ ++ int num_to_alloc; ++ ++ if (!(yy_buffer_stack)) { + +-#ifndef YY_NO_SCAN_BUFFER +-#ifdef YY_USE_PROTOS +-YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +-#else +-YY_BUFFER_STATE yy_scan_buffer( base, size ) +-char *base; +-yy_size_t size; +-#endif +- { +- YY_BUFFER_STATE b; ++ /* 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; ++ (yy_buffer_stack) = (struct yy_buffer_state**)msyyalloc ++ (num_to_alloc * sizeof(struct yy_buffer_state*) ++ ); ++ if ( ! (yy_buffer_stack) ) ++ YY_FATAL_ERROR( "out of dynamic memory in msyyensure_buffer_stack()" ); ++ ++ memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); ++ ++ (yy_buffer_stack_max) = num_to_alloc; ++ (yy_buffer_stack_top) = 0; ++ return; ++ } ++ ++ if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ ++ ++ /* Increase the buffer to prepare for a possible push. */ ++ int grow_size = 8 /* arbitrary grow size */; ++ ++ num_to_alloc = (yy_buffer_stack_max) + grow_size; ++ (yy_buffer_stack) = (struct yy_buffer_state**)msyyrealloc ++ ((yy_buffer_stack), ++ num_to_alloc * sizeof(struct yy_buffer_state*) ++ ); ++ if ( ! (yy_buffer_stack) ) ++ YY_FATAL_ERROR( "out of dynamic memory in msyyensure_buffer_stack()" ); + ++ /* zero only the new slots.*/ ++ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); ++ (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 ++ * ++ * @return the newly allocated buffer state object. ++ */ ++YY_BUFFER_STATE msyy_scan_buffer (char * base, yy_size_t size ) ++{ ++ 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) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); ++ b = (YY_BUFFER_STATE) msyyalloc(sizeof( struct yy_buffer_state ) ); + if ( ! b ) +- YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ++ YY_FATAL_ERROR( "out of dynamic memory in msyy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; +@@ -4264,58 +5015,53 @@ + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + +- yy_switch_to_buffer( b ); ++ msyy_switch_to_buffer(b ); + + return b; +- } +-#endif +- +- +-#ifndef YY_NO_SCAN_STRING +-#ifdef YY_USE_PROTOS +-YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +-#else +-YY_BUFFER_STATE yy_scan_string( yy_str ) +-yyconst char *yy_str; +-#endif +- { +- int len; +- for ( len = 0; yy_str[len]; ++len ) +- ; +- +- return yy_scan_bytes( yy_str, len ); +- } +-#endif ++} + ++/** Setup the input buffer state to scan a string. The next call to msyylex() will ++ * scan from a @e copy of @a str. ++ * @param yystr a NUL-terminated string to scan ++ * ++ * @return the newly allocated buffer state object. ++ * @note If you want to scan bytes that may contain NUL values, then use ++ * msyy_scan_bytes() instead. ++ */ ++YY_BUFFER_STATE msyy_scan_string (yyconst char * yystr ) ++{ ++ ++ return msyy_scan_bytes(yystr,strlen(yystr) ); ++} + +-#ifndef YY_NO_SCAN_BYTES +-#ifdef YY_USE_PROTOS +-YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +-#else +-YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +-yyconst char *bytes; +-int len; +-#endif +- { ++/** Setup the input buffer state to scan the given bytes. The next call to msyylex() 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. ++ * ++ * @return the newly allocated buffer state object. ++ */ ++YY_BUFFER_STATE msyy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) ++{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; +- ++ + /* Get memory for full buffer, including space for trailing EOB's. */ +- n = len + 2; +- buf = (char *) yy_flex_alloc( n ); ++ n = _yybytes_len + 2; ++ buf = (char *) msyyalloc(n ); + if ( ! buf ) +- YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ++ YY_FATAL_ERROR( "out of dynamic memory in msyy_scan_bytes()" ); + +- for ( i = 0; i < len; ++i ) +- buf[i] = bytes[i]; ++ for ( i = 0; i < _yybytes_len; ++i ) ++ buf[i] = yybytes[i]; + +- buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; ++ buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + +- b = yy_scan_buffer( buf, n ); ++ b = msyy_scan_buffer(buf,n ); + if ( ! b ) +- YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ++ YY_FATAL_ERROR( "bad buffer in msyy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. +@@ -4323,148 +5069,196 @@ + 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 ) ++{ ++ (void) fprintf( stderr, "%s\n", msg ); ++ exit( YY_EXIT_FAILURE ); ++} + +-#ifndef YY_NO_PUSH_STATE +-#ifdef YY_USE_PROTOS +-static void yy_push_state( int new_state ) +-#else +-static void yy_push_state( new_state ) +-int new_state; +-#endif +- { +- if ( yy_start_stack_ptr >= yy_start_stack_depth ) +- { +- yy_size_t new_size; ++/* Redefine yyless() so it works in section 3 code. */ + +- yy_start_stack_depth += YY_START_STACK_INCR; +- new_size = yy_start_stack_depth * sizeof( int ); ++#undef yyless ++#define yyless(n) \ ++ do \ ++ { \ ++ /* Undo effects of setting up msyytext. */ \ ++ int yyless_macro_arg = (n); \ ++ YY_LESS_LINENO(yyless_macro_arg);\ ++ msyytext[msyyleng] = (yy_hold_char); \ ++ (yy_c_buf_p) = msyytext + yyless_macro_arg; \ ++ (yy_hold_char) = *(yy_c_buf_p); \ ++ *(yy_c_buf_p) = '\0'; \ ++ msyyleng = yyless_macro_arg; \ ++ } \ ++ while ( 0 ) + +- if ( ! yy_start_stack ) +- yy_start_stack = (int *) yy_flex_alloc( new_size ); ++/* Accessor methods (get/set functions) to struct members. */ + +- else +- yy_start_stack = (int *) yy_flex_realloc( +- (void *) yy_start_stack, new_size ); ++/** Get the current line number. ++ * ++ */ ++int msyyget_lineno (void) ++{ ++ ++ return msyylineno; ++} + +- if ( ! yy_start_stack ) +- YY_FATAL_ERROR( +- "out of memory expanding start-condition stack" ); +- } ++/** Get the input stream. ++ * ++ */ ++FILE *msyyget_in (void) ++{ ++ return msyyin; ++} + +- yy_start_stack[yy_start_stack_ptr++] = YY_START; ++/** Get the output stream. ++ * ++ */ ++FILE *msyyget_out (void) ++{ ++ return msyyout; ++} + +- BEGIN(new_state); +- } +-#endif ++/** Get the length of the current token. ++ * ++ */ ++int msyyget_leng (void) ++{ ++ return msyyleng; ++} + ++/** Get the current token. ++ * ++ */ + +-#ifndef YY_NO_POP_STATE +-static void yy_pop_state() +- { +- if ( --yy_start_stack_ptr < 0 ) +- YY_FATAL_ERROR( "start-condition stack underflow" ); ++char *msyyget_text (void) ++{ ++ return msyytext; ++} + +- BEGIN(yy_start_stack[yy_start_stack_ptr]); +- } +-#endif ++/** Set the current line number. ++ * @param line_number ++ * ++ */ ++void msyyset_lineno (int line_number ) ++{ ++ ++ msyylineno = line_number; ++} + ++/** Set the input stream. This does not discard the current ++ * input buffer. ++ * @param in_str A readable stream. ++ * ++ * @see msyy_switch_to_buffer ++ */ ++void msyyset_in (FILE * in_str ) ++{ ++ msyyin = in_str ; ++} + +-#ifndef YY_NO_TOP_STATE +-static int yy_top_state() +- { +- return yy_start_stack[yy_start_stack_ptr - 1]; +- } +-#endif ++void msyyset_out (FILE * out_str ) ++{ ++ msyyout = out_str ; ++} + +-#ifndef YY_EXIT_FAILURE +-#define YY_EXIT_FAILURE 2 +-#endif ++int msyyget_debug (void) ++{ ++ return msyy_flex_debug; ++} + +-#ifdef YY_USE_PROTOS +-static void yy_fatal_error( yyconst char msg[] ) ++void msyyset_debug (int bdebug ) ++{ ++ msyy_flex_debug = bdebug ; ++} ++ ++static int yy_init_globals (void) ++{ ++ /* Initialization is the same as for the non-reentrant scanner. ++ * This function is called from msyylex_destroy(), so don't allocate here. ++ */ ++ ++ (yy_buffer_stack) = 0; ++ (yy_buffer_stack_top) = 0; ++ (yy_buffer_stack_max) = 0; ++ (yy_c_buf_p) = (char *) 0; ++ (yy_init) = 0; ++ (yy_start) = 0; ++ ++/* Defined in main.c */ ++#ifdef YY_STDINIT ++ msyyin = stdin; ++ msyyout = stdout; + #else +-static void yy_fatal_error( msg ) +-char msg[]; ++ msyyin = (FILE *) 0; ++ msyyout = (FILE *) 0; + #endif +- { +- (void) fprintf( stderr, "%s\n", msg ); +- exit( YY_EXIT_FAILURE ); +- } + ++ /* For future reference: Set errno on error, since we are called by ++ * msyylex_init() ++ */ ++ return 0; ++} + ++/* msyylex_destroy is for both reentrant and non-reentrant scanners. */ ++int msyylex_destroy (void) ++{ ++ ++ /* Pop the buffer stack, destroying each element. */ ++ while(YY_CURRENT_BUFFER){ ++ msyy_delete_buffer(YY_CURRENT_BUFFER ); ++ YY_CURRENT_BUFFER_LVALUE = NULL; ++ msyypop_buffer_state(); ++ } + +-/* Redefine yyless() so it works in section 3 code. */ ++ /* Destroy the stack itself. */ ++ msyyfree((yy_buffer_stack) ); ++ (yy_buffer_stack) = NULL; + +-#undef yyless +-#define yyless(n) \ +- do \ +- { \ +- /* Undo effects of setting up yytext. */ \ +- yytext[yyleng] = yy_hold_char; \ +- yy_c_buf_p = yytext + n; \ +- yy_hold_char = *yy_c_buf_p; \ +- *yy_c_buf_p = '\0'; \ +- yyleng = n; \ +- } \ +- while ( 0 ) ++ /* Reset the globals. This is important in a non-reentrant scanner so the next time ++ * msyylex() is called, initialization will occur. */ ++ yy_init_globals( ); + ++ return 0; ++} + +-/* Internal utility routines. */ ++/* ++ * Internal utility routines. ++ */ + + #ifndef yytext_ptr +-#ifdef YY_USE_PROTOS +-static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +-#else +-static void yy_flex_strncpy( s1, s2, n ) +-char *s1; +-yyconst char *s2; +-int n; +-#endif +- { ++static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) ++{ + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +- } ++} + #endif + + #ifdef YY_NEED_STRLEN +-#ifdef YY_USE_PROTOS +-static int yy_flex_strlen( yyconst char *s ) +-#else +-static int yy_flex_strlen( s ) +-yyconst char *s; +-#endif +- { ++static int yy_flex_strlen (yyconst char * s ) ++{ + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +- } ++} + #endif + +- +-#ifdef YY_USE_PROTOS +-static void *yy_flex_alloc( yy_size_t size ) +-#else +-static void *yy_flex_alloc( size ) +-yy_size_t size; +-#endif +- { ++void *msyyalloc (yy_size_t size ) ++{ + return (void *) malloc( size ); +- } ++} + +-#ifdef YY_USE_PROTOS +-static void *yy_flex_realloc( void *ptr, yy_size_t size ) +-#else +-static void *yy_flex_realloc( ptr, size ) +-void *ptr; +-yy_size_t size; +-#endif +- { ++void *msyyrealloc (void * ptr, yy_size_t size ) ++{ + /* 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 +@@ -4473,28 +5267,19 @@ + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); +- } ++} + +-#ifdef YY_USE_PROTOS +-static void yy_flex_free( void *ptr ) +-#else +-static void yy_flex_free( ptr ) +-void *ptr; +-#endif +- { +- free( ptr ); +- } ++void msyyfree (void * ptr ) ++{ ++ free( (char *) ptr ); /* see msyyrealloc() for (char *) cast */ ++} ++ ++#define YYTABLES_NAME "yytables" + +-#if YY_MAIN +-int main() +- { +- yylex(); +- return 0; +- } +-#endif + #line 493 "maplexer.l" + + ++ + /* + ** Any extra C functions + */ +@@ -4508,3 +5293,4 @@ + msSetError(MS_PARSEERR, s, "msyyparse()"); + return(0); + } ++ +diff -urNad mapserver-4.10.0~/maplexer.l mapserver-4.10.0/maplexer.l +--- mapserver-4.10.0~/maplexer.l 2006-08-15 02:18:49.000000000 -0400 ++++ mapserver-4.10.0/maplexer.l 2009-07-24 15:14:36.180606521 -0400 +@@ -182,8 +182,8 @@ + imagetype { return(IMAGETYPE); } + imagequality { return(IMAGEQUALITY); } + imagemode { return(IMAGEMODE); } +-imagepath { return(IMAGEPATH); } +-imageurl { return(IMAGEURL); } ++imagepath { return(IMAGEPATH); } ++imageurl { return(IMAGEURL); } + include { BEGIN(INCLUDE); } + index { return(INDEX); } + interlace { return(INTERLACE); } only in patch2: unchanged: --- mapserver-4.10.0.orig/debian/patches/83_CVE-2009-0840-CVE-2009-2281.dpatch +++ mapserver-4.10.0/debian/patches/83_CVE-2009-0840-CVE-2009-2281.dpatch @@ -0,0 +1,88 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## 83_CVE-2009-0840-CVE-2009-2281.dpatch by Alan Boudreault +## +## All lines beginning with `## DP:' are a description of the patch. +## DP: No description. + +@DPATCH@ +diff -urNad mapserver-4.10.0~/cgiutil.c mapserver-4.10.0/cgiutil.c +--- mapserver-4.10.0~/cgiutil.c 2006-08-28 21:56:53.000000000 -0400 ++++ mapserver-4.10.0/cgiutil.c 2009-07-14 13:08:18.430607176 -0400 +@@ -69,7 +69,8 @@ + static char *readPostBody( cgiRequestObj *request ) + { + char *data; +- int data_max, data_len, chunk_size; ++ size_t data_max, data_len; ++ int chunk_size; + + msIO_needBinaryStdin(); + +@@ -79,12 +80,19 @@ + if( getenv("CONTENT_LENGTH") != NULL ) + { + +- data_max = atoi(getenv("CONTENT_LENGTH")); ++ data_max = (size_t) atoi(getenv("CONTENT_LENGTH")); ++ /* Test for suspicious CONTENT_LENGTH (negative value or SIZE_MAX) */ ++ if( data_max >= SIZE_MAX ) ++ { ++ msIO_printf("Content-type: text/html%c%c",10,10); ++ msIO_printf("Suspicious Content-Length.\n"); ++ exit( 1 ); ++ } + data = (char *) malloc(data_max+1); + if( data == NULL ) + { + msIO_printf("Content-type: text/html%c%c",10,10); +- msIO_printf("malloc() failed, Content-Length: %d unreasonably large?\n", ++ msIO_printf("malloc() failed, Content-Length: %u unreasonably large?\n", + data_max ); + exit( 1 ); + } +@@ -101,7 +109,9 @@ + /* -------------------------------------------------------------------- */ + /* Otherwise read in chunks to the end. */ + /* -------------------------------------------------------------------- */ +- data_max = 10000; ++#define DATA_ALLOC_SIZE 10000 ++ ++ data_max = DATA_ALLOC_SIZE; + data_len = 0; + data = (char *) malloc(data_max+1); + +@@ -112,13 +122,21 @@ + + if( data_len == data_max ) + { +- data_max = data_max + 10000; ++ /* Realloc buffer, making sure we check for possible size_t overflow */ ++ if ( data_max > SIZE_MAX - (DATA_ALLOC_SIZE+1) ) ++ { ++ msIO_printf("Content-type: text/html%c%c",10,10); ++ msIO_printf("Possible size_t overflow, cannot reallocate input buffer, POST body too large?\n" ); ++ exit(1); ++ } ++ ++ data_max = data_max + DATA_ALLOC_SIZE; + data = (char *) realloc(data, data_max+1); + + if( data == NULL ) + { + msIO_printf("Content-type: text/html%c%c",10,10); +- msIO_printf("out of memory trying to allocate %d input buffer, POST body too large?\n", data_max+1 ); ++ msIO_printf("out of memory trying to allocate %u input buffer, POST body too large?\n", data_max+1 ); + exit(1); + } + } +diff -urNad mapserver-4.10.0~/map.h mapserver-4.10.0/map.h +--- mapserver-4.10.0~/map.h 2006-10-04 10:54:49.000000000 -0400 ++++ mapserver-4.10.0/map.h 2009-07-14 13:08:18.430607176 -0400 +@@ -153,6 +153,7 @@ + #include + #else + #include ++#include + #endif + + #ifndef DISABLE_CVSID