# 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 yyerrlab1/* 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);						\      yychar1 = 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.  */#define YYLEX	yylex ()/* 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)/* 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)#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 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 YYOUT.  |`-----------------------------*/static void#if defined (__STDC__) || defined (__cplusplus)yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue)#elseyysymprint (yyout, yytype, yyvalue)    FILE* yyout;    int yytype;    YYSTYPE yyvalue;#endif{  /* Pacify ``unused variable'' warnings.  */  (void) yyvalue;  if (yytype < YYNTOKENS)    {      YYFPRINTF (yyout, "token %s (", yytname[yytype]);# ifdef YYPRINT      YYPRINT (yyout, yytoknum[yytype], yyvalue);# endif    }  else    YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);  switch (yytype)    {      default:        break;    }  YYFPRINTF (yyout, ")");}#endif /* YYDEBUG. *//*-----------------------------------------------.| Release the memory associated to this symbol.  |`-----------------------------------------------*/static void#if defined (__STDC__) || defined (__cplusplus)yydestruct (int yytype, YYSTYPE yyvalue)#elseyydestruct (yytype, yyvalue)    int yytype;    YYSTYPE yyvalue;#endif{  /* Pacify ``unused variable'' warnings.  */  (void) yyvalue;  switch (yytype)    {      default:        break;    }}/* The user can define YYPARSE_PARAM as the name of an argument to be passed   into yyparse.  The argument should have type void *.   It should actually point to an object.   Grammar actions can access the variable by casting it   to the proper pointer type.  */#ifdef YYPARSE_PARAM# if defined (__STDC__) || defined (__cplusplus)#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM#  define YYPARSE_PARAM_DECL# else#  define YYPARSE_PARAM_ARG YYPARSE_PARAM#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;# endif#else /* !YYPARSE_PARAM */# define YYPARSE_PARAM_ARG# define YYPARSE_PARAM_DECL#endif /* !YYPARSE_PARAM *//* Prevent warning if -Wstrict-prototypes.  */#ifdef __GNUC__# ifdef YYPARSE_PARAMint yyparse (void *);# elseint yyparse (void);# endif#endif/* The lookahead symbol.  */int yychar;/* The semantic value of the lookahead symbol.  */YYSTYPE yylval;/* Number of parse errors so far.  */int yynerrs;intyyparse (YYPARSE_PARAM_ARG)     YYPARSE_PARAM_DECL{    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 yychar1 = 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 (yyssp >= yyss + yystacksize - 1)    {      /* 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 (yystacksize >= YYMAXDEPTH)	goto yyoverflowlab;      yystacksize *= 2;      if (yystacksize > YYMAXDEPTH)	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);#  undef YYSTACK_RELOCATE	if (yyss1 != yyssa)	  YYSTACK_FREE (yyss1);      }# endif#endif /* no yyoverflow */      yyssp = yyss + yysize - 1;      yyvsp = yyvs + yysize - 1;      YYDPRINTF ((stderr, "Stack size increased to %lu\n",		  (unsigned long int) yystacksize));      if (yyssp >= yyss + yystacksize - 1)	YYABORT;    }  YYDPRINTF ((stderr, "Entering state %d\n", yystate));  goto yybackup;/*-----------.| yybackup.  |`-----------*/yybackup:/* Do appropriate processing given the current state.  *//* Read a lookahead token if we need one and don't already have one.  *//* yyresume: */  /* First try to decide what to do without reference to lookahead token.  */  yyn = yypact[yystate];  if (yyn == YYPACT_NINF)    goto yydefault;  /* Not known => get a lookahead token if don't already have one.  */  /* yychar is either YYEMPTY or YYEOF     or a valid token in external form.  */  if (yychar == YYEMPTY)    {      YYDPRINTF ((stderr, "Reading a token: "));      yychar = YYLEX;    }  /* Convert token to internal form (in yychar1) for indexing tables with.  */  if (yychar <= 0)		/* This means end of input.  */    {      yychar1 = 0;      yychar = YYEOF;		/* Don't call YYLEX any more.  */      YYDPRINTF ((stderr, "Now at end of input.\n"));    }  else    {      yychar1 = YYTRANSLATE (yychar);      /* We have to keep this `#if YYDEBUG', since we use variables	 which are defined only if `YYDEBUG' is set.  */      YYDPRINTF ((stderr, "Next token is "));      YYDSYMPRINT ((stderr, yychar1, yylval));      YYDPRINTF ((stderr, "\n"));    }  /* If the proper action on seeing token YYCHAR1 is to reduce or to     detect an error, take that action.  */  yyn += yychar1;  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)    goto yydefault;  yyn = yytable[yyn];  if (yyn <= 0)    {      if (yyn == 0 || yyn == YYTABLE_NINF)	goto yyerrlab;      yyn = -yyn;      goto yyreduce;    }  if (yyn == YYFINAL)    YYACCEPT;  /* Shift the lookahead token.  */  YYDPRINTF ((stderr, "Shifting token %d (%s), ",	      yychar, yytname[yychar1]));  /* Discard the token being shifted unless it is eof.  */  if (yychar != YYEOF)    yychar = YYEMPTY;  *++yyvsp = yylval;