#line 2 "ael_lex.c"#line 4 "ael_lex.c"#define  YY_INT_ALIGNED short int/* A lexical scanner generated by flex */#define FLEX_SCANNER#define YY_FLEX_MAJOR_VERSION 2#define YY_FLEX_MINOR_VERSION 5#define YY_FLEX_SUBMINOR_VERSION 35#if YY_FLEX_SUBMINOR_VERSION > 0#define FLEX_BETA#endif/* First, we deal with  platform-specific or compiler-specific issues. */#include "asterisk.h"/* 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;/* 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 /* ! C99 */#endif /* ! FLEXINT_H */#ifdef __cplusplus/* The "const" storage-class-modifier is valid. */#define YY_USE_CONST#else	/* ! __cplusplus *//* C99 requires __STDC__ to be defined as 1. */#if defined (__STDC__)#define YY_USE_CONST#endif	/* defined (__STDC__) */#endif	/* ! __cplusplus */#ifdef YY_USE_CONST#define yyconst const#else#define yyconst#endif/* Returned upon end-of-file. */#define YY_NULL 0/* Promotes a possibly negative, possibly signed char to an unsigned * integer for use as an array index.  If the signed char is negative, * we want to instead treat it as an 8-bit unsigned char, hence the * double cast. */#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)/* An opaque pointer. */#ifndef YY_TYPEDEF_YY_SCANNER_T#define YY_TYPEDEF_YY_SCANNER_Ttypedef void* yyscan_t;#endif/* For convenience, these vars (plus the bison vars far below)   are macros in the reentrant scanner. */#define yyin yyg->yyin_r#define yyout yyg->yyout_r#define yyextra yyg->yyextra_r#define yyleng yyg->yyleng_r#define yytext yyg->yytext_r#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)#define yy_flex_debug yyg->yy_flex_debug_r/* Enter a start condition.  This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN. */#define BEGIN yyg->yy_start = 1 + 2 */* Translate the current start state into a value that can be later handed * to BEGIN to return to the state.  The YYSTATE alias is for lex * compatibility. */#define YY_START ((yyg->yy_start - 1) / 2)#define YYSTATE YY_START/* Action number for EOF rule of a given start state. */#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)/* Special action meaning "start processing a new file". */#define YY_NEW_FILE ael_yyrestart(yyin ,yyscanner )#define YY_END_OF_BUFFER_CHAR 0/* Size of default input buffer. */#ifndef YY_BUF_SIZE#define YY_BUF_SIZE 16384#endif/* The state buf must be large enough to hold one state per character in the main buffer. */#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))#ifndef YY_TYPEDEF_YY_BUFFER_STATE#define YY_TYPEDEF_YY_BUFFER_STATEtypedef struct 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    #define YY_LESS_LINENO(n)    /* Return all but the first "n" matched characters back to the input stream. */#define yyless(n) \	do \		{ \		/* Undo effects of setting up yytext. */ \        int yyless_macro_arg = (n); \        YY_LESS_LINENO(yyless_macro_arg);\		*yy_cp = yyg->yy_hold_char; \		YY_RESTORE_YY_MORE_OFFSET \		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \		YY_DO_BEFORE_ACTION; /* set up yytext again */ \		} \	while ( 0 )#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )#ifndef YY_TYPEDEF_YY_SIZE_T#define YY_TYPEDEF_YY_SIZE_Ttypedef size_t yy_size_t;#endif#ifndef YY_STRUCT_YY_BUFFER_STATE#define YY_STRUCT_YY_BUFFER_STATEstruct yy_buffer_state	{	FILE *yy_input_file;	char *yy_ch_buf;		/* input buffer */	char *yy_buf_pos;		/* current position in input buffer */	/* Size of input buffer in bytes, not including room for EOB	 * characters.	 */	yy_size_t yy_buf_size;	/* Number of characters read into yy_ch_buf, not including EOB	 * characters.	 */	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 ael_yyrestart()), so that the user can continue scanning by	 * just pointing yyin at a new input file.	 */#define YY_BUFFER_EOF_PENDING 2	};#endif /* !YY_STRUCT_YY_BUFFER_STATE *//* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general * "scanner state". * * Returns the top of the stack, or NULL. */#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \                          : NULL)/* Same as previous macro, but useful when we know that the buffer stack is not * NULL or when we need an lvalue. For internal use only. */#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]void ael_yyrestart (FILE *input_file ,yyscan_t yyscanner );void ael_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );YY_BUFFER_STATE ael_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );void ael_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );void ael_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );void ael_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );void ael_yypop_buffer_state (yyscan_t yyscanner );static void ael_yyensure_buffer_stack (yyscan_t yyscanner );static void ael_yy_load_buffer_state (yyscan_t yyscanner );static void ael_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );#define YY_FLUSH_BUFFER ael_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)YY_BUFFER_STATE ael_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );YY_BUFFER_STATE ael_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );YY_BUFFER_STATE ael_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );void *ael_yyalloc (yy_size_t ,yyscan_t yyscanner );void *ael_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );void ael_yyfree (void * ,yyscan_t yyscanner );#define yy_new_buffer ael_yy_create_buffer#define yy_set_interactive(is_interactive) \	{ \	if ( ! YY_CURRENT_BUFFER ){ \        ael_yyensure_buffer_stack (yyscanner); \		YY_CURRENT_BUFFER_LVALUE =    \            ael_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \	} \	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \	}#define yy_set_bol(at_bol) \	{ \	if ( ! YY_CURRENT_BUFFER ){\        ael_yyensure_buffer_stack (yyscanner); \		YY_CURRENT_BUFFER_LVALUE =    \            ael_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \	} \	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \	}#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)/* Begin user sect3 */#define ael_yywrap(n) 1#define YY_SKIP_YYWRAPtypedef unsigned char YY_CHAR;typedef int yy_state_type;#define yytext_ptr yytext_rstatic yy_state_type yy_get_previous_state (yyscan_t yyscanner );static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);static int yy_get_next_buffer (yyscan_t yyscanner );static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );/* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */#define YY_DO_BEFORE_ACTION \	yyg->yytext_ptr = yy_bp; \	yyg->yytext_ptr -= yyg->yy_more_len; \	yyleng = (size_t) (yy_cp - yyg->yytext_ptr); \	yyg->yy_hold_char = *yy_cp; \	*yy_cp = '\0'; \	yyg->yy_c_buf_p = yy_cp;#define YY_NUM_RULES 76#define YY_END_OF_BUFFER 77/* 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[285] =    {   0,        0,    0,    0,    0,    0,    0,    0,    0,   43,   43,        0,    0,    0,    0,    0,    0,   77,   75,   50,   48,       49,   51,   51,   51,    9,    3,    4,    7,   51,    8,        5,    6,   12,   75,   51,   51,   51,   51,   51,   51,       51,   51,   51,   51,   51,   51,   51,   51,   51,   51,        1,   10,    2,   75,   65,   64,   75,   66,   75,   71,       72,   73,   75,   75,   67,   68,   69,   75,   70,   43,       44,   45,   75,   59,   60,   75,   58,   57,   52,   52,       57,   53,   75,   62,   63,   75,   61,   50,   49,    0,       51,   42,   13,   11,    0,    0,    0,    0,    0,    0,        0,    0,    0,    0,    0,    0,   22,    0,    0,    0,        0,    0,    0,    0,    0,    0,    0,    0,   65,   64,        0,   66,   65,   64,   66,    0,   71,   72,   73,    0,       71,   72,   73,    0,   67,   68,   69,    0,   70,   67,       68,   69,   70,   43,   44,   45,   46,   45,   47,    0,       59,   60,    0,   58,   59,   60,   58,   56,   55,   54,        0,   62,   63,    0,   61,   62,   63,   61,    0,   13,        0,    0,    0,    0,    0,    0,    0,    0,    0,   33,        0,    0,    0,   51,    0,    0,    0,    0,    0,    0,        0,    0,    0,    0,    0,    0,    0,    0,   35,    0,        0,    0,   27,    0,    0,    0,   28,   26,    0,    0,        0,   29,    0,    0,    0,    0,    0,    0,    0,    0,        0,    0,   31,   38,    0,    0,    0,    0,    0,    0,        0,    0,    0,   19,   17,    0,    0,    0,    0,    0,       34,    0,    0,    0,    0,    0,    0,   16,    0,   23,        0,    0,    0,   24,    0,   30,   21,    0,    0,   14,        0,   36,    0,   18,    0,    0,   37,    0,   51,    0,       15,   32,    0,    0,   41,   25,   39,    0,   40,   20,        0,    0,   74,    0    } ;static yyconst flex_int32_t yy_ec[256] =    {   0,        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,        1,    4,    5,    6,    7,    8,    1,    9,    5,   10,       11,   12,    5,   13,    5,    5,   14,    5,    5,    5,        5,    5,    5,    5,    5,    5,    5,   15,   16,    5,       17,   18,    1,   19,    5,    5,    5,    5,    5,    5,        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,        5,    5,    5,   20,    5,    5,    5,    5,    5,    5,       21,   22,   23,    1,    5,    1,   24,   25,   26,   27,       28,   29,   30,   31,   32,   33,   34,   35,   36,   37,       38,   39,    5,   40,   41,   42,   43,    5,   44,   45,        5,    5,   46,   47,   48,    1,    1,   49,   49,   49,       49,   49,   49,   49,   49,   49,   49,   49,   49,   49,       49,   49,   49,   49,   49,   49,   49,   49,   49,   49,       49,   49,   49,   49,   49,   49,   49,   49,   49,   49,       49,   49,   49,   49,   49,   49,   49,   49,   49,   49,