yychar1 = YYTRANSLATE (yychar);  #if YYDEBUG  if (yydebug) { YYFPRINTF (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);  # ifdef YYPRINT YYPRINT (stderr, yychar, yylval); # endif YYFPRINTF (stderr, ")\n"); } #endif
yytoken = YYTRANSLATE (yychar); YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
yyparse (YYPARSE_PARAM_ARG)     YYPARSE_PARAM_DECL{  /* If reentrant, generate the variables here. */#if YYPURE  YY_DECL_VARIABLES#endif  /* !YYPURE */  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;#if YYLSP_NEEDED  /* The location stack.  */  YYLTYPE yylsa[YYINITDEPTH];  YYLTYPE *yyls = yylsa;  YYLTYPE *yylsp;#endif#if YYLSP_NEEDED# define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)#else# define YYPOPSTACK   (yyvsp--, yyssp--)#endif  YYSIZE_T yystacksize = YYINITDEPTH;  /* The variables used to return semantic value and location from the     action routines.  */  YYSTYPE yyval;#if YYLSP_NEEDED  YYLTYPE yyloc;#endif  /* 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;#if YYLSP_NEEDED  yylsp = yyls;#endif  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.  */# if YYLSP_NEEDED	YYLTYPE *yyls1 = yyls;	/* 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),		    &yyls1, yysize * sizeof (*yylsp),		    &yystacksize);	yyls = yyls1;# else	yyoverflow ("parser stack overflow",		    &yyss1, yysize * sizeof (*yyssp),		    &yyvs1, yysize * sizeof (*yyvsp),		    &yystacksize);# endif	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);# if YYLSP_NEEDED	YYSTACK_RELOCATE (yyls);# endif# undef YYSTACK_RELOCATE	if (yyss1 != yyssa)	  YYSTACK_FREE (yyss1);      }# endif#endif /* no yyoverflow */      yyssp = yyss + yysize - 1;      yyvsp = yyvs + yysize - 1;#if YYLSP_NEEDED      yylsp = yyls + yysize - 1;#endif      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 == 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)    {      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);#if YYDEBUG     /* We have to keep this `#if YYDEBUG', since we use variables	which are defined only if `YYDEBUG' is set.  */      if (yydebug)	{	  YYFPRINTF (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	  YYFPRINTF (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.  */  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;#if YYLSP_NEEDED  *++yylsp = yylloc;#endif  /* Count tokens shifted since error; after three, turn off error     status.  */  if (yyerrstatus)    yyerrstatus--;  yystate = yyn;  goto yynewstate;/*-----------------------------------------------------------.| yydefault -- do the default action for the current state.  |`-----------------------------------------------------------*/yydefault:  yyn = yydefact[yystate];  if (yyn == 0)    goto yyerrlab;  goto yyreduce;/*-----------------------------.| yyreduce -- Do a reduction.  |`-----------------------------*/yyreduce:  /* yyn is the number of a rule to reduce with.  */  yylen = yyr2[yyn];  /* If YYLEN is nonzero, implement the default value of the action:     `$$ = $1'.     Otherwise, the following line sets YYVAL to the semantic value of     the lookahead token.  This behavior is undocumented and Bison     users should not rely upon it.  Assigning to YYVAL     unconditionally makes the parser a bit smaller, and it avoids a     GCC warning that YYVAL may be used uninitialized.  */  yyval = yyvsp[1-yylen];#if YYLSP_NEEDED  /* Similarly for the default location.  Let the user run additional     commands if for instance locations are ranges.  */  yyloc = yylsp[1-yylen];  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);#endif#if YYDEBUG  /* We have to keep this `#if YYDEBUG', since we use variables which     are defined only if `YYDEBUG' is set.  */  if (yydebug)    {      int yyi;      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",		 yyn, yyrline[yyn]);      /* Print the symbols being reduced, and their result.  */      for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)	YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);    }#endif  switch (yyn) {case 2:#line 142 "jamgram.y"{ parse_save( yyvsp[0].parse ); }    break;case 3:#line 153 "jamgram.y"{ yyval.parse = yyvsp[0].parse; }    break;case 4:#line 155 "jamgram.y"{ yyval.parse = yyvsp[0].parse; }    break;case 5:#line 159 "jamgram.y"{ yyval.parse = yyvsp[0].parse; }    break;case 6:#line 161 "jamgram.y"{ yyval.parse = prules( yyvsp[-1].parse, yyvsp[0].parse ); }    break;case 7:#line 163 "jamgram.y"{ yyval.parse = plocal( yyvsp[-3].parse, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 8:#line 167 "jamgram.y"{ yyval.parse = pnull(); }    break;case 9:#line 171 "jamgram.y"{ yyval.parse = yyvsp[0].parse; yyval.number = ASSIGN_SET; }    break;case 10:#line 173 "jamgram.y"{ yyval.parse = yyvsp[0].parse; yyval.number = ASSIGN_APPEND; }    break;case 11:#line 177 "jamgram.y"{ yyval.parse = yyvsp[-1].parse; }    break;case 12:#line 179 "jamgram.y"{ yyval.parse = P0; }    break;case 13:#line 183 "jamgram.y"{ yyval.number = 1; }    break;case 14:#line 185 "jamgram.y"{ yyval.number = 0; }    break;case 15:#line 189 "jamgram.y"{ yyval.parse = yyvsp[-1].parse; }    break;case 16:#line 191 "jamgram.y"{ yyval.parse = pincl( yyvsp[-1].parse ); }    break;case 17:#line 193 "jamgram.y"{ yyval.parse = prule( yyvsp[-2].string, yyvsp[-1].parse ); }    break;case 18:#line 195 "jamgram.y"{ yyval.parse = pset( yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-2].number ); }    break;case 19:#line 197 "jamgram.y"{ yyval.parse = pset1( yyvsp[-5].parse, yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-2].number ); }    break;case 20:#line 199 "jamgram.y"{ yyval.parse = yyvsp[-1].parse; }    break;case 21:#line 201 "jamgram.y"{ yyval.parse = pfor( yyvsp[-5].string, yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-6].number ); }    break;case 22:#line 203 "jamgram.y"{ yyval.parse = pswitch( yyvsp[-3].parse, yyvsp[-1].parse ); }    break;case 23:#line 205 "jamgram.y"{ yyval.parse = pif( yyvsp[-3].parse, yyvsp[-1].parse, pnull() ); }    break;case 24:#line 207 "jamgram.y"{ yyval.parse = pmodule( yyvsp[-3].parse, yyvsp[-1].parse ); }    break;case 25:#line 209 "jamgram.y"{ yyval.parse = pwhile( yyvsp[-3].parse, yyvsp[-1].parse ); }    break;case 26:#line 211 "jamgram.y"{ yyval.parse = pif( yyvsp[-5].parse, yyvsp[-3].parse, yyvsp[0].parse ); }    break;case 27:#line 213 "jamgram.y"{ yyval.parse = psetc( yyvsp[-2].string, yyvsp[0].parse, yyvsp[-1].parse, yyvsp[-4].number ); }    break;case 28:#line 215 "jamgram.y"{ yyval.parse = pon( yyvsp[-1].parse, yyvsp[0].parse ); }    break;case 29:#line 217 "jamgram.y"{ yymode( SCAN_STRING ); }    break;case 30:#line 219 "jamgram.y"{ yymode( SCAN_NORMAL ); }    break;case 31:#line 221 "jamgram.y"{ yyval.parse = psete( yyvsp[-6].string,yyvsp[-5].parse,yyvsp[-2].string,yyvsp[-7].number ); }    break;case 32:#line 229 "jamgram.y"{ yyval.number = ASSIGN_SET; }    break;case 33:#line 231 "jamgram.y"{ yyval.number = ASSIGN_APPEND; }    break;case 34:#line 233 "jamgram.y"{ yyval.number = ASSIGN_DEFAULT; }    break;case 35:#line 235 "jamgram.y"{ yyval.number = ASSIGN_DEFAULT; }    break;case 36:#line 242 "jamgram.y"{ yyval.parse = peval( EXPR_EXISTS, yyvsp[0].parse, pnull() ); }    break;case 37:#line 244 "jamgram.y"{ yyval.parse = peval( EXPR_EQUALS, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 38:#line 246 "jamgram.y"{ yyval.parse = peval( EXPR_NOTEQ, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 39:#line 248 "jamgram.y"{ yyval.parse = peval( EXPR_LESS, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 40:#line 250 "jamgram.y"{ yyval.parse = peval( EXPR_LESSEQ, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 41:#line 252 "jamgram.y"{ yyval.parse = peval( EXPR_MORE, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 42:#line 254 "jamgram.y"{ yyval.parse = peval( EXPR_MOREEQ, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 43:#line 256 "jamgram.y"{ yyval.parse = peval( EXPR_AND, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 44:#line 258 "jamgram.y"{ yyval.parse = peval( EXPR_AND, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 45:#line 260 "jamgram.y"{ yyval.parse = peval( EXPR_OR, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 46:#line 262 "jamgram.y"{ yyval.parse = peval( EXPR_OR, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 47:#line 264 "jamgram.y"{ yyval.parse = peval( EXPR_IN, yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 48:#line 266 "jamgram.y"{ yyval.parse = peval( EXPR_NOT, yyvsp[0].parse, pnull() ); }    break;case 49:#line 268 "jamgram.y"{ yyval.parse = yyvsp[-1].parse; }    break;case 50:#line 279 "jamgram.y"{ yyval.parse = P0; }    break;case 51:#line 281 "jamgram.y"{ yyval.parse = pnode( yyvsp[-1].parse, yyvsp[0].parse ); }    break;case 52:#line 285 "jamgram.y"{ yyval.parse = psnode( yyvsp[-2].string, yyvsp[0].parse ); }    break;case 53:#line 294 "jamgram.y"{ yyval.parse = pnode( P0, yyvsp[0].parse ); }    break;case 54:#line 296 "jamgram.y"{ yyval.parse = pnode( yyvsp[0].parse, yyvsp[-2].parse ); }    break;case 55:#line 306 "jamgram.y"{ yyval.parse = yyvsp[0].parse; yymode( SCAN_NORMAL ); }    break;case 56:#line 310 "jamgram.y"{ yyval.parse = pnull(); yymode( SCAN_PUNCT ); }    break;case 57:#line 312 "jamgram.y"{ yyval.parse = pappend( yyvsp[-1].parse, yyvsp[0].parse ); }    break;case 58:#line 316 "jamgram.y"{ yyval.parse = plist( yyvsp[0].string ); }    break;case 59:#line 317 "jamgram.y"{ yymode( SCAN_NORMAL ); }    break;case 60:#line 318 "jamgram.y"{ yyval.parse = yyvsp[-1].parse; }    break;case 61:#line 327 "jamgram.y"{ yyval.parse = prule( yyvsp[-1].string, yyvsp[0].parse ); }    break;case 62:#line 329 "jamgram.y"{ yyval.parse = pon( yyvsp[-2].parse, prule( yyvsp[-1].string, yyvsp[0].parse ) ); }    break;case 63:#line 331 "jamgram.y"{ yyval.parse = pon( yyvsp[-2].parse, yyvsp[0].parse ); }    break;case 64:#line 341 "jamgram.y"{ yyval.number = 0; }    break;case 65:#line 343 "jamgram.y"{ yyval.number = yyvsp[-1].number | yyvsp[0].number; }    break;case 66:#line 347 "jamgram.y"{ yyval.number = EXEC_UPDATED; }    break;case 67:#line 349 "jamgram.y"{ yyval.number = EXEC_TOGETHER; }    break;case 68:#line 351 "jamgram.y"{ yyval.number = EXEC_IGNORE; }    break;case 69:#line 353 "jamgram.y"{ yyval.number = EXEC_QUIETLY; }    break;case 70:#line 355 "jamgram.y"{ yyval.number = EXEC_PIECEMEAL; }    break;case 71:#line 357 "jamgram.y"{ yyval.number = EXEC_EXISTING; }    break;case 72:#line 366 "jamgram.y"{ yyval.parse = pnull(); }    break;case 73:#line 368 "jamgram.y"{ yyval.parse = yyvsp[0].parse; }    break;}#line 705 "/usr/share/bison/bison.simple"  yyvsp -= yylen;  yyssp -= yylen;#if YYLSP_NEEDED  yylsp -= yylen;#endif#if YYDEBUG  if (yydebug)    {      short *yyssp1 = yyss - 1;      YYFPRINTF (stderr, "state stack now");      while (yyssp1 != yyssp)	YYFPRINTF (stderr, " %d", *++yyssp1);      YYFPRINTF (stderr, "\n");    }#endif  *++yyvsp = yyval;#if YYLSP_NEEDED  *++yylsp = yyloc;#endif  /* Now `shift' the result of the reduction.  Determine what state     that goes to, based on the state we popped back to and the rule     number reduced by.  */  yyn = yyr1[yyn];  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)    yystate = yytable[yystate];  else    yystate = yydefgoto[yyn - YYNTBASE];  goto yynewstate;/*------------------------------------.| yyerrlab -- here on detecting error |`------------------------------------*/yyerrlab:  /* If not already recovering from an error, report this error.  */  if (!yyerrstatus)    {      ++yynerrs;#ifdef YYERROR_VERBOSE      yyn = yypact[yystate];      if (yyn > YYFLAG && yyn < YYLAST)	{	  YYSIZE_T yysize = 0;	  char *yymsg;	  int yyx, yycount;	  yycount = 0;	  /* Start YYX at -YYN if negative to avoid negative indexes in	     YYCHECK.  */	  for (yyx = yyn < 0 ? -yyn : 0;	       yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)	    if (yycheck[yyx + yyn] == yyx)	      yysize += yystrlen (yytname[yyx]) + 15, yycount++;	  yysize += yystrlen ("parse error, unexpected ") + 1;	  yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);	  yymsg = (char *) YYSTACK_ALLOC (yysize);	  if (yymsg != 0)	    {	      char *yyp = yystpcpy (yymsg, "parse error, unexpected ");	      yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);	      if (yycount < 5)		{		  yycount = 0;		  for (yyx = yyn < 0 ? -yyn : 0;		       yyx < (int) (sizeof (yytname) / sizeof (char *));		       yyx++)		    if (yycheck[yyx + yyn] == yyx)		      {			const char *yyq = ! yycount ? ", expecting " : " or ";			yyp = yystpcpy (yyp, yyq);			yyp = yystpcpy (yyp, yytname[yyx]);			yycount++;		      }		}	      yyerror (yymsg);	      YYSTACK_FREE (yymsg);	    }	  else	    yyerror ("parse error; also virtual memory exhausted");	}      else#endif /* defined (YYERROR_VERBOSE) */	yyerror ("parse error");    }  goto yyerrlab1;/*--------------------------------------------------.| yyerrlab1 -- error raised explicitly by an action |`--------------------------------------------------*/yyerrlab1:  if (yyerrstatus == 3)    {      /* If just tried and failed to reuse lookahead token after an	 error, discard it.  */      /* return failure if at end of input */      if (yychar == YYEOF)	YYABORT;      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",		  yychar, yytname[yychar1]));      yychar = YYEMPTY;    }  /* Else will try to reuse lookahead token after shifting the error     token.  */  yyerrstatus = 3;		/* Each real token shifted decrements this */  goto yyerrhandle;/*-------------------------------------------------------------------.| yyerrdefault -- current state does not do anything special for the || error token.                                                       |`-------------------------------------------------------------------*/yyerrdefault:#if 0  /* This is wrong; only states that explicitly want error tokens     should shift them.  */  /* If its default is to accept any token, ok.  Otherwise pop it.  */  yyn = yydefact[yystate];  if (yyn)    goto yydefault;#endif/*---------------------------------------------------------------.| yyerrpop -- pop the current state because it cannot handle the || error token                                                    |`---------------------------------------------------------------*/yyerrpop:  if (yyssp == yyss)    YYABORT;  yyvsp--;  yystate = *--yyssp;#if YYLSP_NEEDED  yylsp--;#endif#if YYDEBUG  if (yydebug)    {      short *yyssp1 = yyss - 1;      YYFPRINTF (stderr, "Error: state stack now");      while (yyssp1 != yyssp)	YYFPRINTF (stderr, " %d", *++yyssp1);      YYFPRINTF (stderr, "\n");    }#endif/*--------------.| yyerrhandle.  |`--------------*/yyerrhandle:  yyn = yypact[yystate];  if (yyn == YYFLAG)    goto yyerrdefault;  yyn += YYTERROR;  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)    goto yyerrdefault;  yyn = yytable[yyn];  if (yyn < 0)    {      if (yyn == YYFLAG)	goto yyerrpop;      yyn = -yyn;      goto yyreduce;    }  else if (yyn == 0)    goto yyerrpop;  if (yyn == YYFINAL)    YYACCEPT;  YYDPRINTF ((stderr, "Shifting error token, "));  *++yyvsp = yylval;#if YYLSP_NEEDED  *++yylsp = yylloc;#endif  yystate = yyn;  goto yynewstate;/*-------------------------------------.| yyacceptlab -- YYACCEPT comes here.  |`-------------------------------------*/yyacceptlab:  yyresult = 0;  goto yyreturn;/*-----------------------------------.| yyabortlab -- YYABORT comes here.  |`-----------------------------------*/yyabortlab:  yyresult = 1;  goto yyreturn;/*---------------------------------------------.| yyoverflowab -- parser overflow comes here.  |`---------------------------------------------*/yyoverflowlab:  yyerror ("parser stack overflow");  yyresult = 2;  /* Fall through.  */yyreturn:#ifndef yyoverflow  if (yyss != yyssa)    YYSTACK_FREE (yyss);#endif  return yyresult;}