#define  YY_INT_ALIGNED short int/* A lexical scanner generated by flex */#define FLEX_SCANNER#define YY_FLEX_MAJOR_VERSION 2#define YY_FLEX_MINOR_VERSION 5#define YY_FLEX_SUBMINOR_VERSION 35#if YY_FLEX_SUBMINOR_VERSION > 0#define FLEX_BETA#endif/* First, we deal with  platform-specific or compiler-specific issues. *//* begin standard C headers. */#include <stdio.h>#include <string.h>#include <errno.h>#include <stdlib.h>/* end standard C headers. *//* flex integer type definitions */#ifndef FLEXINT_H#define FLEXINT_H/* C99 systems have <inttypes.h>. 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 <inttypes.h>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;#elsetypedef signed char flex_int8_t;typedef short int flex_int16_t;typedef int flex_int32_t;typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t;typedef unsigned int flex_uint32_t;#endif /* ! C99 *//* Limits of integral types. */#ifndef INT8_MIN#define INT8_MIN               (-128)#endif#ifndef INT16_MIN#define INT16_MIN              (-32767-1)#endif#ifndef INT32_MIN#define INT32_MIN              (-2147483647-1)#endif#ifndef INT8_MAX#define INT8_MAX               (127)#endif#ifndef INT16_MAX#define INT16_MAX              (32767)#endif#ifndef INT32_MAX#define INT32_MAX              (2147483647)#endif#ifndef UINT8_MAX#define UINT8_MAX              (255U)#endif#ifndef UINT16_MAX#define UINT16_MAX             (65535U)#endif#ifndef UINT32_MAX#define UINT32_MAX             (4294967295U)#endif#endif /* ! FLEXINT_H */#ifdef __cplusplus/* The "const" storage-class-modifier is valid. */#define YY_USE_CONST#else	/* ! __cplusplus *//* C99 requires __STDC__ to be defined as 1. */#if defined (__STDC__)#define YY_USE_CONST#endif	/* defined (__STDC__) */#endif	/* ! __cplusplus */#ifdef YY_USE_CONST#define lpt_yyconst const#else#define lpt_yyconst#endif/* Returned upon end-of-file. */#define YY_NULL 0/* Promotes a possibly negative, possibly signed char to an unsigned * integer for use as an array index.  If the signed char is negative, * we want to instead treat it as an 8-bit unsigned char, hence the * double cast. */#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)/* An opaque pointer. */#ifndef YY_TYPEDEF_YY_SCANNER_T#define YY_TYPEDEF_YY_SCANNER_Ttypedef void* lpt_yyscan_t;#endif/* For convenience, these vars (plus the bison vars far below)   are macros in the reentrant scanner. */#define lpt_yyin lpt_yyg->lpt_yyin_r#define lpt_yyout lpt_yyg->lpt_yyout_r#define lpt_yyextra lpt_yyg->lpt_yyextra_r#define lpt_yyleng lpt_yyg->lpt_yyleng_r#define lpt_yytext lpt_yyg->lpt_yytext_r#define lpt_yylineno (YY_CURRENT_BUFFER_LVALUE->lpt_yy_bs_lineno)#define lpt_yycolumn (YY_CURRENT_BUFFER_LVALUE->lpt_yy_bs_column)#define lpt_yy_flex_debug lpt_yyg->lpt_yy_flex_debug_r/* Enter a start condition.  This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN. */#define BEGIN lpt_yyg->lpt_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 ((lpt_yyg->lpt_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 lpt_yyrestart(lpt_yyin ,lpt_yyscanner )#define YY_END_OF_BUFFER_CHAR 0/* Size of default input buffer. */#ifndef YY_BUF_SIZE#define YY_BUF_SIZE 16384#endif/* The state buf must be large enough to hold one state per character in the main buffer. */#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(lpt_yy_state_type))#ifndef YY_TYPEDEF_YY_BUFFER_STATE#define YY_TYPEDEF_YY_BUFFER_STATEtypedef struct lpt_yy_buffer_state *YY_BUFFER_STATE;#endif#define EOB_ACT_CONTINUE_SCAN 0#define EOB_ACT_END_OF_FILE 1#define EOB_ACT_LAST_MATCH 2    /* Note: We specifically omit the test for lpt_yy_rule_can_match_eol because it requires     *       access to the local variable lpt_yy_act. Since lpt_yyless() is a macro, it would break     *       existing scanners that call lpt_yyless() from OUTSIDE lpt_yylex.      *       One obvious solution it to make lpt_yy_act a global. I tried that, and saw     *       a 5% performance hit in a non-lpt_yylineno scanner, because lpt_yy_act is     *       normally declared as a register variable-- so it is not worth it.     */    #define  YY_LESS_LINENO(n) \            do { \                int lpt_yyl;\                for ( lpt_yyl = n; lpt_yyl < lpt_yyleng; ++lpt_yyl )\                    if ( lpt_yytext[lpt_yyl] == '\n' )\                        --lpt_yylineno;\            }while(0)    /* Return all but the first "n" matched characters back to the input stream. */#define lpt_yyless(n) \	do \		{ \		/* Undo effects of setting up lpt_yytext. */ \        int lpt_yyless_macro_arg = (n); \        YY_LESS_LINENO(lpt_yyless_macro_arg);\		*lpt_yy_cp = lpt_yyg->lpt_yy_hold_char; \		YY_RESTORE_YY_MORE_OFFSET \		lpt_yyg->lpt_yy_c_buf_p = lpt_yy_cp = lpt_yy_bp + lpt_yyless_macro_arg - YY_MORE_ADJ; \		YY_DO_BEFORE_ACTION; /* set up lpt_yytext again */ \		} \	while ( 0 )#define unput(c) lpt_yyunput( c, lpt_yyg->lpt_yytext_ptr , lpt_yyscanner )#ifndef YY_TYPEDEF_YY_SIZE_T#define YY_TYPEDEF_YY_SIZE_Ttypedef size_t lpt_yy_size_t;#endif#ifndef YY_STRUCT_YY_BUFFER_STATE#define YY_STRUCT_YY_BUFFER_STATEstruct lpt_yy_buffer_state	{	FILE *lpt_yy_input_file;	char *lpt_yy_ch_buf;		/* input buffer */	char *lpt_yy_buf_pos;		/* current position in input buffer */	/* Size of input buffer in bytes, not including room for EOB	 * characters.	 */	lpt_yy_size_t lpt_yy_buf_size;	/* Number of characters read into lpt_yy_ch_buf, not including EOB	 * characters.	 */	int lpt_yy_n_chars;	/* Whether we "own" the buffer - i.e., we know we created it,	 * and can realloc() it to grow it, and should free() it to	 * delete it.	 */	int lpt_yy_is_our_buffer;	/* Whether this is an "interactive" input source; if so, and	 * if we're using stdio for input, then we want to use getc()	 * instead of fread(), to make sure we stop fetching input after	 * each newline.	 */	int lpt_yy_is_interactive;	/* Whether we're considered to be at the beginning of a line.	 * If so, '^' rules will be active on the next match, otherwise	 * not.	 */	int lpt_yy_at_bol;    int lpt_yy_bs_lineno; /**< The line count. */    int lpt_yy_bs_column; /**< The column count. */    	/* Whether to try to fill the input buffer when we reach the	 * end of it.	 */	int lpt_yy_fill_buffer;	int lpt_yy_buffer_status;#define YY_BUFFER_NEW 0#define YY_BUFFER_NORMAL 1	/* When an EOF's been seen but there's still some text to process	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we	 * shouldn't try reading from the input source any more.  We might	 * still have a bunch of tokens to match, though, because of	 * possible backing-up.	 *	 * When we actually see the EOF, we change the status to "new"	 * (via lpt_yyrestart()), so that the user can continue scanning by	 * just pointing lpt_yyin at a new input file.	 */#define YY_BUFFER_EOF_PENDING 2	};#endif /* !YY_STRUCT_YY_BUFFER_STATE *//* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general * "scanner state". * * Returns the top of the stack, or NULL. */#define YY_CURRENT_BUFFER ( lpt_yyg->lpt_yy_buffer_stack \                          ? lpt_yyg->lpt_yy_buffer_stack[lpt_yyg->lpt_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 lpt_yyg->lpt_yy_buffer_stack[lpt_yyg->lpt_yy_buffer_stack_top]void lpt_yyrestart (FILE *input_file ,lpt_yyscan_t lpt_yyscanner );void lpt_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,lpt_yyscan_t lpt_yyscanner );YY_BUFFER_STATE lpt_yy_create_buffer (FILE *file,int size ,lpt_yyscan_t lpt_yyscanner );void lpt_yy_delete_buffer (YY_BUFFER_STATE b ,lpt_yyscan_t lpt_yyscanner );void lpt_yy_flush_buffer (YY_BUFFER_STATE b ,lpt_yyscan_t lpt_yyscanner );void lpt_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,lpt_yyscan_t lpt_yyscanner );void lpt_yypop_buffer_state (lpt_yyscan_t lpt_yyscanner );static void lpt_yyensure_buffer_stack (lpt_yyscan_t lpt_yyscanner );static void lpt_yy_load_buffer_state (lpt_yyscan_t lpt_yyscanner );static void lpt_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,lpt_yyscan_t lpt_yyscanner );#define YY_FLUSH_BUFFER lpt_yy_flush_buffer(YY_CURRENT_BUFFER ,lpt_yyscanner)YY_BUFFER_STATE lpt_yy_scan_buffer (char *base,lpt_yy_size_t size ,lpt_yyscan_t lpt_yyscanner );YY_BUFFER_STATE lpt_yy_scan_string (lpt_yyconst char *lpt_yy_str ,lpt_yyscan_t lpt_yyscanner );YY_BUFFER_STATE lpt_yy_scan_bytes (lpt_yyconst char *bytes,int len ,lpt_yyscan_t lpt_yyscanner );void *lpt_yyalloc (lpt_yy_size_t ,lpt_yyscan_t lpt_yyscanner );void *lpt_yyrealloc (void *,lpt_yy_size_t ,lpt_yyscan_t lpt_yyscanner );void lpt_yyfree (void * ,lpt_yyscan_t lpt_yyscanner );#define lpt_yy_new_buffer lpt_yy_create_buffer#define lpt_yy_set_interactive(is_interactive) \	{ \	if ( ! YY_CURRENT_BUFFER ){ \        lpt_yyensure_buffer_stack (lpt_yyscanner); \		YY_CURRENT_BUFFER_LVALUE =    \            lpt_yy_create_buffer(lpt_yyin,YY_BUF_SIZE ,lpt_yyscanner); \	} \	YY_CURRENT_BUFFER_LVALUE->lpt_yy_is_interactive = is_interactive; \	}#define lpt_yy_set_bol(at_bol) \	{ \	if ( ! YY_CURRENT_BUFFER ){\        lpt_yyensure_buffer_stack (lpt_yyscanner); \		YY_CURRENT_BUFFER_LVALUE =    \            lpt_yy_create_buffer(lpt_yyin,YY_BUF_SIZE ,lpt_yyscanner); \	} \	YY_CURRENT_BUFFER_LVALUE->lpt_yy_at_bol = at_bol; \	}#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->lpt_yy_at_bol)/* Begin user sect3 */#define lpt_yywrap(n) 1#define YY_SKIP_YYWRAPtypedef unsigned char YY_CHAR;typedef int lpt_yy_state_type;#define lpt_yytext_ptr lpt_yytext_rstatic lpt_yy_state_type lpt_yy_get_previous_state (lpt_yyscan_t lpt_yyscanner );static lpt_yy_state_type lpt_yy_try_NUL_trans (lpt_yy_state_type current_state  ,lpt_yyscan_t lpt_yyscanner);static int lpt_yy_get_next_buffer (lpt_yyscan_t lpt_yyscanner );static void lpt_yy_fatal_error (lpt_yyconst char msg[] ,lpt_yyscan_t lpt_yyscanner );/* Done after the current pattern has been matched and before the * corresponding action - sets up lpt_yytext. */#define YY_DO_BEFORE_ACTION \	lpt_yyg->lpt_yytext_ptr = lpt_yy_bp; \	lpt_yyleng = (size_t) (lpt_yy_cp - lpt_yy_bp); \	lpt_yyg->lpt_yy_hold_char = *lpt_yy_cp; \	*lpt_yy_cp = '\0'; \	lpt_yyg->lpt_yy_c_buf_p = lpt_yy_cp;#define YY_NUM_RULES 26#define YY_END_OF_BUFFER 27/* This struct is not used in this scanner,   but its presence is necessary. */struct lpt_yy_trans_info	{	flex_int32_t lpt_yy_verify;	flex_int32_t lpt_yy_nxt;	};static lpt_yyconst flex_int16_t lpt_yy_accept[174] =    {   0,        0,    0,    0,    0,   27,   25,   25,    5,    5,   21,       15,   25,   11,   23,   22,   24,   21,    1,   25,   21,       21,   21,   21,   21,   21,   21,   21,    4,    2,    3,        0,    5,   21,   15,    0,   11,   23,   22,   24,   21,        0,    0,    0,   21,   20,   15,    0,   12,   12,   11,        0,   23,   24,   21,    0,   21,   21,   21,   21,   21,       21,   21,   21,    0,   21,   20,   21,   21,   21,   21,       21,   21,   21,   21,   21,   21,   21,   21,    8,   21,        0,   12,    0,   12,   21,    0,    0,   16,   21,   10,       21,   16,   16,    7,    6,   21,    0,   20,   21,   18,        8,   21,   21,   13,   14,    0,   21,   21,   14,   21,       21,   21,   21,   19,   17,   21,   21,    0,    0,    0,       21,    9,   21,   21,   21,   21,    0,   17,   21,    0,        0,   21,   16,    9,   21,   21,   21,   21,   21,   21,        0,   21,    0,    0,   21,   16,   16,   21,    7,   21,        6,    0,   21,    0,    0,   16,   16,    7,    6,    0,        0,    0,   13,    0,    0,    8,    0,    0,    0,    0,        0,   17,    0    } ;static lpt_yyconst flex_int32_t lpt_yy_ec[256] =    {   0,        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,        1,    5,    6,    6,    6,    6,    6,    6,    6,    6,        6,    1,    7,    6,    8,    9,    6,   10,   11,   11,       10,   10,   10,   10,   10,   10,   10,   12,    6,   13,       14,   15,    6,    6,   16,   17,   18,   19,   20,   21,       22,   23,   24,   25,    6,   26,   27,   28,   29,    6,