YYLTYPE yylloc;			/*  location data for the lookahead	*/				/*  symbol				*/#endifint yynerrs;			/*  number of parse errors so far       */#endif  /* not YYPURE */#if YYDEBUG != 0int yydebug;			/*  nonzero means print parse trace	*//* Since this is uninitialized, it does not stop multiple parsers   from coexisting.  */#endif/*  YYINITDEPTH indicates the initial size of the parser's stacks	*/#ifndef	YYINITDEPTH#define YYINITDEPTH 200#endif/*  YYMAXDEPTH is the maximum size the stacks can grow to    (effective only if the built-in stack extension method is used).  */#if YYMAXDEPTH == 0#undef YYMAXDEPTH#endif#ifndef YYMAXDEPTH#define YYMAXDEPTH 10000#endif/* Define __yy_memcpy.  Note that the size argument   should be passed with type unsigned int, because that is what the non-GCC   definitions require.  With GCC, __builtin_memcpy takes an arg   of type size_t, but it can handle unsigned int.  */#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */#define __yy_memcpy(TO,FROM,COUNT)	__builtin_memcpy(TO,FROM,COUNT)#else				/* not GNU C or C++ */#ifndef __cplusplus/* This is the most reliable way to avoid incompatibilities   in available built-in functions on various systems.  */static void__yy_memcpy (to, from, count)     char *to;     char *from;     unsigned int count;{  register char *f = from;  register char *t = to;  register int i = count;  while (i-- > 0)    *t++ = *f++;}#else /* __cplusplus *//* This is the most reliable way to avoid incompatibilities   in available built-in functions on various systems.  */static void__yy_memcpy (char *to, char *from, unsigned int count){  register char *t = to;  register char *f = from;  register int i = count;  while (i-- > 0)    *t++ = *f++;}#endif#endif#line 217 "/usr/local/share/bison.simple"/* 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#ifdef __cplusplus#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM#define YYPARSE_PARAM_DECL#else /* not __cplusplus */#define YYPARSE_PARAM_ARG YYPARSE_PARAM#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;#endif /* not __cplusplus */#else /* not YYPARSE_PARAM */#define YYPARSE_PARAM_ARG#define YYPARSE_PARAM_DECL#endif /* not YYPARSE_PARAM *//* Prevent warning if -Wstrict-prototypes.  */#ifdef __GNUC__#ifdef YYPARSE_PARAMint yyparse (void *);#elseint yyparse (void);#endif#endifintyyparse(YYPARSE_PARAM_ARG)     YYPARSE_PARAM_DECL{  register int yystate;  register int yyn;  register short *yyssp;  register YYSTYPE *yyvsp;  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */  int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */  short	yyssa[YYINITDEPTH];	/*  the state stack			*/  YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */#ifdef YYLSP_NEEDED  YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/  YYLTYPE *yyls = yylsa;  YYLTYPE *yylsp;#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)#else#define YYPOPSTACK   (yyvsp--, yyssp--)#endif  int yystacksize = YYINITDEPTH;  int yyfree_stacks = 0;#ifdef YYPURE  int yychar;  YYSTYPE yylval;  int yynerrs;#ifdef YYLSP_NEEDED  YYLTYPE yylloc;#endif#endif  YYSTYPE yyval;		/*  the variable used to return		*/				/*  semantic values from the action	*/				/*  routines				*/  int yylen;#if YYDEBUG != 0  if (yydebug)    fprintf(stderr, "Starting parse\n");#endif  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 - 1;  yyvsp = yyvs;#ifdef YYLSP_NEEDED  yylsp = yyls;#endif/* Push a new state, which is found in  yystate  .  *//* In all cases, when you get here, the value and location stacks   have just been pushed. so pushing a state here evens the stacks.  */yynewstate:  *++yyssp = yystate;  if (yyssp >= yyss + yystacksize - 1)    {      /* 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;#ifdef YYLSP_NEEDED      YYLTYPE *yyls1 = yyls;#endif      /* Get the current used size of the three stacks, in elements.  */      int size = yyssp - yyss + 1;#ifdef yyoverflow      /* Each stack pointer address is followed by the size of	 the data in use in that stack, in bytes.  */#ifdef YYLSP_NEEDED      /* 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, size * sizeof (*yyssp),		 &yyvs1, size * sizeof (*yyvsp),		 &yyls1, size * sizeof (*yylsp),		 &yystacksize);#else      yyoverflow("parser stack overflow",		 &yyss1, size * sizeof (*yyssp),		 &yyvs1, size * sizeof (*yyvsp),		 &yystacksize);#endif      yyss = yyss1; yyvs = yyvs1;#ifdef YYLSP_NEEDED      yyls = yyls1;#endif#else /* no yyoverflow */      /* Extend the stack our own way.  */      if (yystacksize >= YYMAXDEPTH)	{	  yyerror("parser stack overflow");	  if (yyfree_stacks)	    {	      free (yyss);	      free (yyvs);#ifdef YYLSP_NEEDED	      free (yyls);#endif	    }	  return 2;	}      yystacksize *= 2;      if (yystacksize > YYMAXDEPTH)	yystacksize = YYMAXDEPTH;#ifndef YYSTACK_USE_ALLOCA      yyfree_stacks = 1;#endif      yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));      __yy_memcpy ((char *)yyss, (char *)yyss1,		   size * (unsigned int) sizeof (*yyssp));      yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));      __yy_memcpy ((char *)yyvs, (char *)yyvs1,		   size * (unsigned int) sizeof (*yyvsp));#ifdef YYLSP_NEEDED      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));      __yy_memcpy ((char *)yyls, (char *)yyls1,		   size * (unsigned int) sizeof (*yylsp));#endif#endif /* no yyoverflow */      yyssp = yyss + size - 1;      yyvsp = yyvs + size - 1;#ifdef YYLSP_NEEDED      yylsp = yyls + size - 1;#endif#if YYDEBUG != 0      if (yydebug)	fprintf(stderr, "Stack size increased to %d\n", yystacksize);#endif      if (yyssp >= yyss + yystacksize - 1)	YYABORT;    }#if YYDEBUG != 0  if (yydebug)    fprintf(stderr, "Entering state %d\n", yystate);#endif  goto 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 == YYFLAG)    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)    {#if YYDEBUG != 0      if (yydebug)	fprintf(stderr, "Reading a token: ");#endif      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 */#if YYDEBUG != 0      if (yydebug)	fprintf(stderr, "Now at end of input.\n");#endif    }  else    {      yychar1 = YYTRANSLATE(yychar);#if YYDEBUG != 0      if (yydebug)	{	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);	  /* Give the individual parser a way to print the precise meaning	     of a token, for further debugging info.  */#ifdef YYPRINT	  YYPRINT (stderr, yychar, yylval);#endif	  fprintf (stderr, ")\n");	}#endif    }  yyn += yychar1;  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)    goto yydefault;  yyn = yytable[yyn];  /* yyn is what to do for this token type in this state.     Negative => reduce, -yyn is rule number.     Positive => shift, yyn is new state.       New state is final state => don't bother to shift,       just return success.     0, or most negative number => error.  */  if (yyn < 0)    {      if (yyn == YYFLAG)	goto yyerrlab;      yyn = -yyn;      goto yyreduce;    }  else if (yyn == 0)    goto yyerrlab;  if (yyn == YYFINAL)    YYACCEPT;  /* Shift the lookahead token.  */#if YYDEBUG != 0  if (yydebug)    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);#endif  /* Discard the token being shifted unless it is eof.  */  if (yychar != YYEOF)    yychar = YYEMPTY;  *++yyvsp = yylval;#ifdef YYLSP_NEEDED  *++yylsp = yylloc;#endif  /* count tokens shifted since error; after three, turn off error status.  */  if (yyerrstatus) yyerrstatus--;  yystate = yyn;  goto yynewstate;/* Do the default action for the current state.  */yydefault:  yyn = yydefact[yystate];  if (yyn == 0)    goto yyerrlab;/* Do a reduction.  yyn is the number of a rule to reduce with.  */yyreduce:  yylen = yyr2[yyn];  if (yylen > 0)    yyval = yyvsp[1-yylen]; /* implement default value of the action */#if YYDEBUG != 0  if (yydebug)    {      int i;      fprintf (stderr, "Reducing via rule %d (line %d), ",	       yyn, yyrline[yyn]);      /* Print the symbols being reduced, and their result.  */      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)	fprintf (stderr, "%s ", yytname[yyrhs[i]]);      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);    }#endif  switch (yyn) {case 1:#line 175 "plural.y"{	    if (yyvsp[0].exp == NULL)	      YYABORT;	    ((struct parse_args *) arg)->res = yyvsp[0].exp;	  ;    break;}case 2:#line 183 "plural.y"{	    yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);	  ;    break;}case 3:#line 187 "plural.y"{	    yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);	  ;    break;}case 4:#line 191 "plural.y"{	    yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);	  ;    break;}case 5:#line 195 "plural.y"{	    yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);	  ;    break;}case 6:#line 199 "plural.y"{	    yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);	  ;    break;}case 7: