#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)# define YYSIZE_T __SIZE_TYPE__#endif#if ! defined (YYSIZE_T) && defined (size_t)# define YYSIZE_T size_t#endif#if ! defined (YYSIZE_T)# if defined (__STDC__) || defined (__cplusplus)#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */#  define YYSIZE_T size_t# endif#endif#if ! defined (YYSIZE_T)# define YYSIZE_T unsigned int#endif#define yyerrok		(yyerrstatus = 0)#define yyclearin	(yychar = YYEMPTY)#define YYEMPTY		(-2)#define YYEOF		0#define YYACCEPT	goto yyacceptlab#define YYABORT		goto yyabortlab#define YYERROR		goto yyerrorlab/* Like YYERROR except do call yyerror.  This remains here temporarily   to ease the transition to the new meaning of YYERROR, for GCC.   Once GCC version 2 has supplanted version 1, this can go.  */#define YYFAIL		goto yyerrlab#define YYRECOVERING()  (!!yyerrstatus)#define YYBACKUP(Token, Value)					\do								\  if (yychar == YYEMPTY && yylen == 1)				\    {								\      yychar = (Token);						\      yylval = (Value);						\      yytoken = YYTRANSLATE (yychar);				\      YYPOPSTACK;						\      goto yybackup;						\    }								\  else								\    { 								\      yyerror ("syntax error: cannot back up");\      YYERROR;							\    }								\while (0)#define YYTERROR	1#define YYERRCODE	256/* YYLLOC_DEFAULT -- Compute the default location (before the actions   are run).  */#ifndef YYLLOC_DEFAULT# define YYLLOC_DEFAULT(Current, Rhs, N)		\   ((Current).first_line   = (Rhs)[1].first_line,	\    (Current).first_column = (Rhs)[1].first_column,	\    (Current).last_line    = (Rhs)[N].last_line,	\    (Current).last_column  = (Rhs)[N].last_column)#endif/* YYLEX -- calling `yylex' with the right arguments.  */#ifdef YYLEX_PARAM# define YYLEX yylex (YYLEX_PARAM)#else# define YYLEX yylex ()#endif/* Enable debugging if requested.  */#if YYDEBUG# ifndef YYFPRINTF#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */#  define YYFPRINTF fprintf# endif# define YYDPRINTF(Args)			\do {						\  if (yydebug)					\    YYFPRINTF Args;				\} while (0)# define YYDSYMPRINT(Args)			\do {						\  if (yydebug)					\    yysymprint Args;				\} while (0)# define YYDSYMPRINTF(Title, Token, Value, Location)		\do {								\  if (yydebug)							\    {								\      YYFPRINTF (stderr, "%s ", Title);				\      yysymprint (stderr, 					\                  Token, Value);	\      YYFPRINTF (stderr, "\n");					\    }								\} while (0)/*------------------------------------------------------------------.| yy_stack_print -- Print the state stack from its BOTTOM up to its || TOP (included).                                                   |`------------------------------------------------------------------*/#if defined (__STDC__) || defined (__cplusplus)static voidyy_stack_print (short *bottom, short *top)#elsestatic voidyy_stack_print (bottom, top)    short *bottom;    short *top;#endif{  YYFPRINTF (stderr, "Stack now");  for (/* Nothing. */; bottom <= top; ++bottom)    YYFPRINTF (stderr, " %d", *bottom);  YYFPRINTF (stderr, "\n");}# define YY_STACK_PRINT(Bottom, Top)				\do {								\  if (yydebug)							\    yy_stack_print ((Bottom), (Top));				\} while (0)/*------------------------------------------------.| Report that the YYRULE is going to be reduced.  |`------------------------------------------------*/#if defined (__STDC__) || defined (__cplusplus)static voidyy_reduce_print (int yyrule)#elsestatic voidyy_reduce_print (yyrule)    int yyrule;#endif{  int yyi;  unsigned int yylno = yyrline[yyrule];  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",             yyrule - 1, yylno);  /* Print the symbols being reduced, and their result.  */  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);}# define YY_REDUCE_PRINT(Rule)		\do {					\  if (yydebug)				\    yy_reduce_print (Rule);		\} while (0)/* Nonzero means print parse trace.  It is left uninitialized so that   multiple parsers can coexist.  */int yydebug;#else /* !YYDEBUG */# define YYDPRINTF(Args)# define YYDSYMPRINT(Args)# define YYDSYMPRINTF(Title, Token, Value, Location)# define YY_STACK_PRINT(Bottom, Top)# define YY_REDUCE_PRINT(Rule)#endif /* !YYDEBUG *//* YYINITDEPTH -- initial size of the parser's stacks.  */#ifndef	YYINITDEPTH# define YYINITDEPTH 200#endif/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only   if the built-in stack extension method is used).   Do not make this value too large; the results are undefined if   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)   evaluated with infinite-precision integer arithmetic.  */#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0# undef YYMAXDEPTH#endif#ifndef YYMAXDEPTH# define YYMAXDEPTH 10000#endif#if YYERROR_VERBOSE# ifndef yystrlen#  if defined (__GLIBC__) && defined (_STRING_H)#   define yystrlen strlen#  else/* Return the length of YYSTR.  */static YYSIZE_T#   if defined (__STDC__) || defined (__cplusplus)yystrlen (const char *yystr)#   elseyystrlen (yystr)     const char *yystr;#   endif{  register const char *yys = yystr;  while (*yys++ != '\0')    continue;  return yys - yystr - 1;}#  endif# endif# ifndef yystpcpy#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)#   define yystpcpy stpcpy#  else/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in   YYDEST.  */static char *#   if defined (__STDC__) || defined (__cplusplus)yystpcpy (char *yydest, const char *yysrc)#   elseyystpcpy (yydest, yysrc)     char *yydest;     const char *yysrc;#   endif{  register char *yyd = yydest;  register const char *yys = yysrc;  while ((*yyd++ = *yys++) != '\0')    continue;  return yyd - 1;}#  endif# endif#endif /* !YYERROR_VERBOSE */#if YYDEBUG/*--------------------------------.| Print this symbol on YYOUTPUT.  |`--------------------------------*/#if defined (__STDC__) || defined (__cplusplus)static voidyysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)#elsestatic voidyysymprint (yyoutput, yytype, yyvaluep)    FILE *yyoutput;    int yytype;    YYSTYPE *yyvaluep;#endif{  /* Pacify ``unused variable'' warnings.  */  (void) yyvaluep;  if (yytype < YYNTOKENS)    {      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);# ifdef YYPRINT      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);# endif    }  else    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);  switch (yytype)    {      default:        break;    }  YYFPRINTF (yyoutput, ")");}#endif /* ! YYDEBUG *//*-----------------------------------------------.| Release the memory associated to this symbol.  |`-----------------------------------------------*/#if defined (__STDC__) || defined (__cplusplus)static voidyydestruct (int yytype, YYSTYPE *yyvaluep)#elsestatic voidyydestruct (yytype, yyvaluep)    int yytype;    YYSTYPE *yyvaluep;#endif{  /* Pacify ``unused variable'' warnings.  */  (void) yyvaluep;  switch (yytype)    {      default:        break;    }}/* Prevent warnings from -Wmissing-prototypes.  */#ifdef YYPARSE_PARAM# if defined (__STDC__) || defined (__cplusplus)int yyparse (void *YYPARSE_PARAM);# elseint yyparse ();# endif#else /* ! YYPARSE_PARAM */#if defined (__STDC__) || defined (__cplusplus)int yyparse (void);#elseint yyparse ();#endif#endif /* ! YYPARSE_PARAM *//* The lookahead symbol.  */int yychar;/* The semantic value of the lookahead symbol.  */YYSTYPE yylval;/* Number of syntax errors so far.  */int yynerrs;/*----------.| yyparse.  |`----------*/#ifdef YYPARSE_PARAM# if defined (__STDC__) || defined (__cplusplus)int yyparse (void *YYPARSE_PARAM)# elseint yyparse (YYPARSE_PARAM)  void *YYPARSE_PARAM;# endif#else /* ! YYPARSE_PARAM */#if defined (__STDC__) || defined (__cplusplus)intyyparse (void)#elseintyyparse ()#endif#endif{    register int yystate;  register int yyn;  int yyresult;  /* Number of tokens to shift before error messages enabled.  */  int yyerrstatus;  /* Lookahead token as an internal (translated) token number.  */  int yytoken = 0;  /* Three stacks and their tools:     `yyss': related to states,     `yyvs': related to semantic values,     `yyls': related to locations.     Refer to the stacks thru separate pointers, to allow yyoverflow     to reallocate them elsewhere.  */  /* The state stack.  */  short	yyssa[YYINITDEPTH];  short *yyss = yyssa;  register short *yyssp;  /* The semantic value stack.  */  YYSTYPE yyvsa[YYINITDEPTH];  YYSTYPE *yyvs = yyvsa;  register YYSTYPE *yyvsp;#define YYPOPSTACK   (yyvsp--, yyssp--)  YYSIZE_T yystacksize = YYINITDEPTH;  /* The variables used to return semantic value and location from the     action routines.  */  YYSTYPE yyval;  /* When reducing, the number of symbols on the RHS of the reduced     rule.  */  int yylen;  YYDPRINTF ((stderr, "Starting parse\n"));  yystate = 0;  yyerrstatus = 0;  yynerrs = 0;  yychar = YYEMPTY;		/* Cause a token to be read.  */  /* Initialize stack pointers.     Waste one element of value and location stack     so that they stay on the same level as the state stack.     The wasted elements are never initialized.  */  yyssp = yyss;  yyvsp = yyvs;  goto yysetstate;/*------------------------------------------------------------.| yynewstate -- Push a new state, which is found in yystate.  |`------------------------------------------------------------*/ yynewstate:  /* In all cases, when you get here, the value and location stacks     have just been pushed. so pushing a state here evens the stacks.     */  yyssp++; yysetstate:  *yyssp = yystate;  if (yyss + yystacksize - 1 <= yyssp)    {      /* Get the current used size of the three stacks, in elements.  */      YYSIZE_T yysize = yyssp - yyss + 1;#ifdef yyoverflow      {	/* Give user a chance to reallocate the stack. Use copies of	   these so that the &'s don't force the real ones into	   memory.  */	YYSTYPE *yyvs1 = yyvs;	short *yyss1 = yyss;	/* Each stack pointer address is followed by the size of the	   data in use in that stack, in bytes.  This used to be a	   conditional around just the two extra args, but that might	   be undefined if yyoverflow is a macro.  */	yyoverflow ("parser stack overflow",		    &yyss1, yysize * sizeof (*yyssp),		    &yyvs1, yysize * sizeof (*yyvsp),		    &yystacksize);	yyss = yyss1;	yyvs = yyvs1;      }#else /* no yyoverflow */# ifndef YYSTACK_RELOCATE      goto yyoverflowlab;# else      /* Extend the stack our own way.  */      if (YYMAXDEPTH <= yystacksize)	goto yyoverflowlab;      yystacksize *= 2;      if (YYMAXDEPTH < yystacksize)	yystacksize = YYMAXDEPTH;      {	short *yyss1 = yyss;	union yyalloc *yyptr =	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));	if (! yyptr)	  goto yyoverflowlab;	YYSTACK_RELOCATE (yyss);	YYSTACK_RELOCATE (yyvs);