#line 2 "scan-gram.c"#line 4 "scan-gram.c"#define  YY_INT_ALIGNED short int/* A lexical scanner generated by flex */#define FLEX_SCANNER#define YY_FLEX_MAJOR_VERSION 2#define YY_FLEX_MINOR_VERSION 5#define YY_FLEX_SUBMINOR_VERSION 31#if YY_FLEX_SUBMINOR_VERSION > 0#define FLEX_BETA#endif/* %if-c++-only *//* %endif *//* %if-c-only */    /* %endif *//* %if-c-only *//* %endif *//* First, we deal with  platform-specific or compiler-specific issues. *//* begin standard C headers. *//* %if-c-only */#include <stdio.h>#include <string.h>#include <errno.h>#include <stdlib.h>/* %endif *//* %if-tables-serialization *//* %endif *//* end standard C headers. *//* %if-c-or-c++ *//* 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#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 *//* %endif *//* %if-c++-only *//* %endif */#ifdef __cplusplus/* The "const" storage-class-modifier is valid. */#define YY_USE_CONST#else	/* ! __cplusplus */#if __STDC__#define YY_USE_CONST#endif	/* __STDC__ */#endif	/* ! __cplusplus */#ifdef YY_USE_CONST#define yyconst const#else#define yyconst#endif/* %not-for-header *//* Returned upon end-of-file. */#define YY_NULL 0/* %ok-for-header *//* %not-for-header *//* 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)/* %ok-for-header *//* %if-reentrant *//* %endif *//* %if-not-reentrant *//* %endif *//* 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 (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 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 gram_restart(gram_in  )#define YY_END_OF_BUFFER_CHAR 0/* Size of default input buffer. */#ifndef YY_BUF_SIZE#define YY_BUF_SIZE 16384#endif#ifndef YY_TYPEDEF_YY_BUFFER_STATE#define YY_TYPEDEF_YY_BUFFER_STATEtypedef struct yy_buffer_state *YY_BUFFER_STATE;#endif/* %if-not-reentrant */extern int gram_leng;/* %endif *//* %if-c-only *//* %if-not-reentrant */extern FILE *gram_in, *gram_out;/* %endif *//* %endif */#define EOB_ACT_CONTINUE_SCAN 0#define EOB_ACT_END_OF_FILE 1#define EOB_ACT_LAST_MATCH 2    #define YY_LESS_LINENO(n)    /* Return all but the first "n" matched characters back to the input stream. */#define yyless(n) \	do \		{ \		/* Undo effects of setting up gram_text. */ \        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 + yyless_macro_arg - YY_MORE_ADJ; \		YY_DO_BEFORE_ACTION; /* set up gram_text 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). */#ifndef YY_TYPEDEF_YY_SIZE_T#define YY_TYPEDEF_YY_SIZE_Ttypedef unsigned int yy_size_t;#endif#ifndef YY_STRUCT_YY_BUFFER_STATE#define YY_STRUCT_YY_BUFFER_STATEstruct yy_buffer_state	{/* %if-c-only */	FILE *yy_input_file;/* %endif *//* %if-c++-only *//* %endif */	char *yy_ch_buf;		/* input buffer */	char *yy_buf_pos;		/* current position in input buffer */	/* Size of input buffer in bytes, not including room for EOB	 * characters.	 */	yy_size_t yy_buf_size;	/* Number of characters read into yy_ch_buf, not including EOB	 * characters.	 */	int yy_n_chars;	/* Whether we "own" the buffer - i.e., we know we created it,	 * and can realloc() it to grow it, and should free() it to	 * delete it.	 */	int yy_is_our_buffer;	/* Whether this is an "interactive" input source; if so, and	 * if we're using stdio for input, then we want to use getc()	 * instead of fread(), to make sure we stop fetching input after	 * each newline.	 */	int yy_is_interactive;	/* Whether we're considered to be at the beginning of a line.	 * If so, '^' rules will be active on the next match, otherwise	 * not.	 */	int yy_at_bol;    int yy_bs_lineno; /**< The line count. */    int yy_bs_column; /**< The column count. */    	/* Whether to try to fill the input buffer when we reach the	 * end of it.	 */	int yy_fill_buffer;	int yy_buffer_status;#define YY_BUFFER_NEW 0#define YY_BUFFER_NORMAL 1	/* When an EOF's been seen but there's still some text to process	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we	 * shouldn't try reading from the input source any more.  We might	 * still have a bunch of tokens to match, though, because of	 * possible backing-up.	 *	 * When we actually see the EOF, we change the status to "new"	 * (via gram_restart()), so that the user can continue scanning by	 * just pointing gram_in at a new input file.	 */#define YY_BUFFER_EOF_PENDING 2	};#endif /* !YY_STRUCT_YY_BUFFER_STATE *//* %if-c-only Standard (non-C++) definition *//* %not-for-header *//* %if-not-reentrant *//* 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. *//* %endif *//* %ok-for-header *//* %endif *//* 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_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)]/* %if-c-only Standard (non-C++) definition *//* %if-not-reentrant *//* %not-for-header *//* yy_hold_char holds the character lost when gram_text is formed. */static char yy_hold_char;static int yy_n_chars;		/* number of characters read into yy_ch_buf */int gram_leng;/* 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_start = 0;	/* start state number *//* Flag which is used to allow gram_wrap()'s to do buffer switches * instead of setting up a fresh gram_in.  A bit of a hack ... */static int yy_did_buffer_switch_on_eof;/* %ok-for-header *//* %endif */void gram_restart (FILE *input_file  );void gram__switch_to_buffer (YY_BUFFER_STATE new_buffer  );YY_BUFFER_STATE gram__create_buffer (FILE *file,int size  );void gram__delete_buffer (YY_BUFFER_STATE b  );void gram__flush_buffer (YY_BUFFER_STATE b  );void gram_push_buffer_state (YY_BUFFER_STATE new_buffer  );void gram_pop_buffer_state (void );static void gram_ensure_buffer_stack (void );static void gram__load_buffer_state (void );static void gram__init_buffer (YY_BUFFER_STATE b,FILE *file  );#define YY_FLUSH_BUFFER gram__flush_buffer(YY_CURRENT_BUFFER )YY_BUFFER_STATE gram__scan_buffer (char *base,yy_size_t size  );YY_BUFFER_STATE gram__scan_string (yyconst char *yy_str  );YY_BUFFER_STATE gram__scan_bytes (yyconst char *bytes,int len  );/* %endif */void *gram_alloc (yy_size_t  );void *gram_realloc (void *,yy_size_t  );void gram_free (void *  );#define yy_new_buffer gram__create_buffer#define yy_set_interactive(is_interactive) \	{ \	if ( ! YY_CURRENT_BUFFER ){ \        gram_ensure_buffer_stack (); \		YY_CURRENT_BUFFER_LVALUE =    \            gram__create_buffer(gram_in,YY_BUF_SIZE ); \	} \	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \	}#define yy_set_bol(at_bol) \	{ \	if ( ! YY_CURRENT_BUFFER ){\        gram_ensure_buffer_stack (); \		YY_CURRENT_BUFFER_LVALUE =    \            gram__create_buffer(gram_in,YY_BUF_SIZE ); \	} \	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \	}#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)/* %% [1.0] gram_text/gram_in/gram_out/yy_state_type/gram_lineno etc. def's & init go here *//* Begin user sect3 */#define gram_wrap(n) 1#define YY_SKIP_YYWRAP#define FLEX_DEBUGtypedef unsigned char YY_CHAR;FILE *gram_in = (FILE *) 0, *gram_out = (FILE *) 0;typedef int yy_state_type;extern int gram_lineno;int gram_lineno = 1;extern char *gram_text;#define yytext_ptr gram_text/* %if-c-only Standard (non-C++) definition */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[]  );/* %endif *//* Done after the current pattern has been matched and before the * corresponding action - sets up gram_text. */#define YY_DO_BEFORE_ACTION \	(yytext_ptr) = yy_bp; \/* %% [2.0] code to fiddle gram_text and gram_leng for yymore() goes here \ */\	gram_leng = (size_t) (yy_cp - yy_bp); \	(yy_hold_char) = *yy_cp; \	*yy_cp = '\0'; \/* %% [3.0] code to copy yytext_ptr to gram_text[] goes here, if %array \ */\	(yy_c_buf_p) = yy_cp;/* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */#define YY_NUM_RULES 106#define YY_END_OF_BUFFER 107/* 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[455] =    {   0,