#line 1 "yacc.c"





extern int yychar;
extern short yyerrflag;






 int yylval, yyval;




#line 1 "/tmp/local6/lib/lcc/4.1.beta.6/include/stdio.h"









typedef struct {
	int	_cnt;
	unsigned char *_ptr;
	unsigned char *_base;
	unsigned char _flag;
	unsigned char _file;
} FILE;
extern FILE __iob[];






typedef long fpos_t;











typedef unsigned long size_t;




typedef char *__va_list;







extern int remove(const char *);
extern int rename(const char *, const char *);
extern FILE *tmpfile(void);
extern char *tmpnam(char *);
extern int fclose(FILE *);
extern int fflush(FILE *);
extern FILE *fopen(const char *, const char *);
extern FILE *freopen(const char *, const char *, FILE *);
extern void setbuf(FILE *, char *);
extern int setvbuf(FILE *, char *, int, size_t);
extern int fprintf(FILE *, const char *, ...);
extern int fscanf(FILE *, const char *, ...);
extern int printf(const char *, ...);
extern int scanf(const char *, ...);
extern int sprintf(char *, const char *, ...);
extern int sscanf(const char *, const char *, ...);
extern int vfprintf(FILE *, const char *, __va_list);
extern int vprintf(const char *, __va_list);
extern int vsprintf(char *, const char *, __va_list);
extern int fgetc(FILE *);
extern char *fgets(char *, int, FILE *);
extern int fputc(int, FILE *);
extern int fputs(const char *, FILE *);
extern int getc(FILE *);
extern int getchar(void);
extern char *gets(char *);
extern int putc(int, FILE *);
extern int putchar(int);
extern int puts(const char *);
extern int ungetc(int, FILE *);
extern size_t fread(void *, size_t, size_t, FILE *);
extern size_t fwrite(const void *, size_t, size_t, FILE *);
extern int fgetpos(FILE *, fpos_t *);
extern int fseek(FILE *, long int, int);
extern int fsetpos(FILE *, const fpos_t *);
extern long int ftell(FILE *);
extern void rewind(FILE *);
extern void clearerr(FILE *);
extern int feof(FILE *);
extern int ferror(FILE *);
extern void perror(const char *);






#line 97 "/tmp/local6/lib/lcc/4.1.beta.6/include/stdio.h"
extern int __filbuf(FILE *), __flsbuf(unsigned, FILE *);







#line 20 "yacc.c"















int yyleng; extern char yytext[];
int yymorfg;
extern char *yysptr, yysbuf[];
int yytchar;
FILE *yyin = 0, *yyout = 0;
extern int yylineno;
struct yysvf {
	struct yywork *yystoff;
	struct yysvf *yyother;
	int *yystops;};
struct yysvf *yyestate;
extern struct yysvf yysvec[], *yybgin;

yylex(){
int nstr; extern int yyprevious;
while((nstr = yylook()) >= 0)
yyfussy: switch(nstr){
case 0:
if(yywrap()) return(0); break;
case 1:
 return 257;
break;
case 2:
                 return 258;
break;
case 3:
                  ;
break;
case 4:
                   return yytext[0];
break;
case -1:
break;
default:
fprintf(yyout,"bad switch yylook %d",nstr);
} return(0); }

int yyvstop[] ={
0,

4,
0,

3,
4,
0,

2,
4,
0,

1,
4,
0,

2,
0,

1,
0,
0};

struct yywork {char verify, advance; } yycrank[] ={
0,0,	0,0,	1,3,	0,0,
0,0,	0,0,	0,0,	0,0,
0,0,	0,0,	1,4,	1,3,
0,0,	0,0,	0,0,	0,0,
0,0,	0,0,	0,0,	0,0,
0,0,	0,0,	0,0,	0,0,
0,0,	0,0,	0,0,	0,0,
0,0,	0,0,	0,0,	0,0,
0,0,	0,0,	0,0,	0,0,
0,0,	0,0,	0,0,	0,0,
0,0,	0,0,	0,0,	0,0,
0,0,	0,0,	0,0,	0,0,
0,0,	1,5,	5,7,	5,7,
5,7,	5,7,	5,7,	5,7,
5,7,	5,7,	5,7,	5,7,
0,0,	0,0,	0,0,	0,0,
0,0,	0,0,	1,6,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	0,0,	0,0,	0,0,
0,0,	0,0,	0,0,	0,0,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	0,0,	0,0,
0,0,	0,0,	6,8,	0,0,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	6,8,	6,8,
6,8,	6,8,	0,0,	0,0,
0,0};
struct yysvf yysvec[] ={
0,	0,	0,
yycrank+-1,	0,		0,
yycrank+0,	yysvec+1,	0,
yycrank+0,	0,		yyvstop+1,
yycrank+0,	0,		yyvstop+3,
yycrank+2,	0,		yyvstop+6,
yycrank+19,	0,		yyvstop+9,
yycrank+0,	yysvec+5,	yyvstop+12,
yycrank+0,	yysvec+6,	yyvstop+14,
0,	0,	0};
struct yywork *yytop = yycrank+141;
struct yysvf *yybgin = yysvec+1;
char yymatch[] ={
00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
011 ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
'0' ,'0' ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,'A' ,
01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,01  ,
0};
char yyextra[] ={
0,0,0,0,0,0,0,0,
0};


int yylineno =1;


char yytext[200];
struct yysvf *yylstate [200], **yylsp, **yyolsp;
char yysbuf[200];
char *yysptr = yysbuf;
int *yyfnd;
extern struct yysvf *yyestate;
int yyprevious = 10;
yylook(){
	register struct yysvf *yystate, **lsp;
	register struct yywork *yyt;
	struct yysvf *yyz;
	int yych;
	struct yywork *yyr;



	char *yylastch;




	if (!yymorfg)
		yylastch = yytext;
	else {
		yymorfg=0;
		yylastch = yytext+yyleng;
		}
	for(;;){
		lsp = yylstate;
		yyestate = yystate = yybgin;
		if (yyprevious== 10) yystate++;
		for (;;){



			yyt = yystate->yystoff;
			if(yyt == yycrank){
				yyz = yystate->yyother;
				if(yyz == 0)break;
				if(yyz->yystoff == yycrank)break;
				}
			*yylastch++ = yych =(((yytchar=yysptr>yysbuf? *--yysptr :(--(yyin)->_cnt < 0 ? __filbuf(yyin) : (int)*(yyin)->_ptr++))==10?(yylineno++,yytchar):yytchar)==(-1)?0:yytchar);
		tryagain:







			yyr = yyt;
			if ( yyt > yycrank){
				yyt = yyr + yych;
				if (yyt <= yytop && yyt->verify+yysvec == yystate){
					if(yyt->advance+yysvec == yysvec)
						{{yytchar= (*--yylastch);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;};break;}
					*lsp++ = yystate = yyt->advance+yysvec;
					goto contin;
					}
				}

			else if(yyt < yycrank) {
				yyt = yyr = yycrank+(yycrank-yyt);



				yyt = yyt + yych;
				if(yyt <= yytop && yyt->verify+yysvec == yystate){
					if(yyt->advance+yysvec == yysvec)
						{{yytchar= (*--yylastch);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;};break;}
					*lsp++ = yystate = yyt->advance+yysvec;
					goto contin;
					}
				yyt = yyr + yymatch[yych];







				if(yyt <= yytop && yyt->verify+yysvec == yystate){
					if(yyt->advance+yysvec == yysvec)
						{{yytchar= (*--yylastch);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;};break;}
					*lsp++ = yystate = yyt->advance+yysvec;
					goto contin;
					}
				}
			if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){



				goto tryagain;
				}

			else
				{{yytchar= (*--yylastch);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;};break;}
		contin:







			;
			}







		while (lsp-- > yylstate){
			*yylastch-- = 0;
			if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
				yyolsp = lsp;
				if(yyextra[*yyfnd]){
					while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
						lsp--;
{yytchar= (*yylastch--);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;};
						}
					}
				yyprevious = *yylastch;
				yylsp = lsp;
				yyleng = yylastch-yytext+1;
				yytext[yyleng] = 0;







				return(*yyfnd++);
				}
{yytchar= (*yylastch);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;};
			}
		if (yytext[0] == 0 )
			{
			yysptr=yysbuf;
			return(0);
			}
		yyprevious = yytext[0] =(((yytchar=yysptr>yysbuf? *--yysptr :(--(yyin)->_cnt < 0 ? __filbuf(yyin) : (int)*(yyin)->_ptr++))==10?(yylineno++,yytchar):yytchar)==(-1)?0:yytchar);
		if (yyprevious>0)
(void)(--(yyout)->_cnt < 0 ? __flsbuf((unsigned char) (yyprevious), (yyout)) : (int)(*(yyout)->_ptr++ = (yyprevious)));
		yylastch=yytext;



		}
	}
yyback(p, m)
	int *p;
{
if (p==0) return(0);
while (*p)
	{
	if (*p++ == m)
		return(1);
	}
return(0);
}

yyinput(){
	return((((yytchar=yysptr>yysbuf? *--yysptr :(--(yyin)->_cnt < 0 ? __filbuf(yyin) : (int)*(yyin)->_ptr++))==10?(yylineno++,yytchar):yytchar)==(-1)?0:yytchar));
	}
yyoutput(c)
  int c; {
(void)(--(yyout)->_cnt < 0 ? __flsbuf((unsigned char) (c), (yyout)) : (int)(*(yyout)->_ptr++ = (c)));
	}
yyunput(c)
   int c; {
{yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;};
	}

main() {
	yyin =(&__iob[0]); yyout =(&__iob[1]);
	yyparse();
	return 0;
}


yyerror(s) char *s; {
        printf("%s\n", s);
}
short yyexca[] ={
-1, 1,
	0, -1,
	-2, 0,
	};


short yyact[]={

  12,   2,   9,   8,  17,  11,  25,  17,  15,  18,
  16,  10,  18,  17,  15,   7,  16,  13,  18,   5,
   3,   1,   0,  19,  20,   0,   0,  21,  22,  23,
  24,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   6,  14,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   4,   6 };
short yypact[]={

-1000,  -9,-1000,   5,  -7, -59,-1000,-1000,-1000, -40,
 -29, -40, -40,-1000,-1000, -40, -40, -40, -40, -38,
 -35, -38, -38,-1000,-1000,-1000 };
short yypgo[]={

   0,  21,  20,  17,  11 };
short yyr1[]={

   0,   1,   1,   1,   1,   2,   4,   4,   4,   4,
   4,   4,   4,   4,   3 };
short yyr2[]={

   0,   0,   2,   3,   3,   3,   3,   3,   3,   3,
   2,   3,   1,   1,   1 };
short yychk[]={

-1000,  -1,  10,  -2, 256,  -3, 257,  10,  10,  61,
  -4,  45,  40,  -3, 258,  43,  45,  42,  47,  -4,
  -4,  -4,  -4,  -4,  -4,  41 };
short yydef[]={

   1,  -2,   2,   0,   0,   0,  14,   3,   4,   0,
   5,   0,   0,  12,  13,   0,   0,   0,   0,  10,
   0,   6,   7,   8,   9,  11 };













 int yyv[150];
int yychar = -1;
int yynerrs = 0;
short yyerrflag = 0;

yyparse() {

	short yys[150];
	short yyj, yym;
	register int *yypvt;
	register short yystate, *yyps, yyn;
	register int *yypv;
	register short *yyxi;

	yystate = 0;
	yychar = -1;
	yynerrs = 0;
	yyerrflag = 0;
	yyps= &yys[-1];
	yypv= &yyv[-1];

 yystack:




		if( ++yyps> &yys[150 -1] ) { yyerror( "yacc stack overflow" ); return(1); }
		*yyps = yystate;
		++yypv;
		*yypv = yyval;

 yynewstate:

	yyn = yypact[yystate];

	if( yyn<= -1000 ) goto yydefault;

	if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
	if( (yyn += yychar)<0 || yyn >= 249 ) goto yydefault;

	if( yychk[ yyn=yyact[ yyn ] ] == yychar ){
		yychar = -1;
		yyval = yylval;
		yystate = yyn;
		if( yyerrflag > 0 ) --yyerrflag;
		goto yystack;
		}

 yydefault:


	if( (yyn=yydef[yystate]) == -2 ) {
		if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;


		for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ;

		while( *(yyxi+=2) >= 0 ){
			if( *yyxi == yychar ) break;
			}
		if( (yyn = yyxi[1]) < 0 ) return(0);
		}

	if( yyn == 0 ){


		switch( yyerrflag ){

		case 0:

			yyerror( "syntax error" );
		yyerrlab:
			++yynerrs;

		case 1:
		case 2:

			yyerrflag = 3;



			while ( yyps >= yys ) {
			   yyn = yypact[*yyps] + 256;
			   if( yyn>= 0 && yyn < 249 && yychk[yyact[yyn]] == 256 ){
			      yystate = yyact[yyn];
			      goto yystack;
			      }
			   yyn = yypact[*yyps];






			   --yyps;
			   --yypv;
			   }



	yyabort:
			return(1);


		case 3:





			if( yychar == 0 ) goto yyabort;
			yychar = -1;
			goto yynewstate;

			}

		}






		yyps -= yyr2[yyn];
		yypvt = yypv;
		yypv -= yyr2[yyn];
		yyval = yypv[1];
		yym=yyn;

		yyn = yyr1[yyn];
		yyj = yypgo[yyn] + *yyps + 1;
		if( yyj>= 249 || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
		switch(yym){

case 4:
{yyerrflag = 0; } break;
case 5:
{ printf("store\n"); } break;
case 6:
{ printf("add\n"); } break;
case 7:
{ printf("negate\nadd\n"); } break;
case 8:
{ printf("multiply\n"); } break;
case 9:
{ printf("divide\n"); } break;
case 10:
{ printf("negate\n"); } break;
case 12:
{ printf("load\n"); } break;
case 13:
{ printf("push %s\n", yytext); } break;
case 14:
{ printf("%s\n", yytext); } break;
		}
		goto yystack;

	}
int yywrap() { return 1; }
