/*
  !!DESCRIPTION!!
  !!ORIGIN!!      LCC 4.1 Testsuite
  !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
*/

/*#define STANDALONE*/

#include "common.h"

#ifndef YACCDBG

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

/*
#define LEXDEBUG
#define YYDEBUG
*/

#endif

FILE *infile, *outfile;
#define getchar() fgetc(infile)

/* hack the original tables to work with both petscii and ascii */
#define CHARSETHACK

# define ID 257
# define CON 258
# define UNARYMINUS 259
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern short yyerrflag;
#ifndef YYMAXDEPTH
/*#define YYMAXDEPTH 150*/
#define YYMAXDEPTH 50
#endif
#ifndef YYSTYPE
#define YYSTYPE int
#endif
YYSTYPE yylval, yyval;
# define YYERRCODE 256

# define U(x) x
# define NLSTATE yyprevious=YYNEWLINE
# define BEGIN yybgin = yysvec + 1 +
# define INITIAL 0
# define YYLERR yysvec
# define YYSTATE (yyestate-yysvec-1)
# define YYOPTIM 1
# define YYLMAX 200
# define output(c) (void)putc(c,yyout)

/* # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar) */
# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getchar())==('\n')?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)

# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
# define yymore() (yymorfg=1)
# define ECHO fprintf(yyout, "%s",yytext)
# define REJECT { nstr = yyreject(); goto yyfussy;}
int yyleng; extern char yytext[];
int yymorfg;
extern char *yysptr, yysbuf[];
int yytchar;

#define yyin  infile
#define yyout outfile

extern int yylineno;
struct yysvf 
{
        struct yywork *yystoff;
        struct yysvf *yyother;
        int *yystops;
};
struct yysvf *yyestate;
extern struct yysvf yysvec[], *yybgin;

/*# define YYNEWLINE 10 */
# define YYNEWLINE ('\n')

#ifdef NO_IMPLICIT_FUNC_PROTOTYPES
yylook();
int yywrap();
yyparse();
yyerror(char *s);
yyunput(int c);
yyoutput(int c);
yyinput();
yyback(int *p,int m);
#endif

#ifdef YYDEBUG
void printchar(char *name,int ch)
{
        if((ch==YYNEWLINE))
        {
                fprintf(yyout," %s=YYNEWLINE\n",name);
        }
        else if((ch<0)||(ch>0xf0)||(!isprint(ch)))
        {
                fprintf(yyout," %s=%04x\n",name,ch &0xffff);
        }
        else
        {
                fprintf(yyout," %s='%c'\n",name,ch);
        }
}
#endif

yylex()
{
int nstr;
extern int yyprevious;

#ifdef YYDEBUG
        fprintf(yyout,"yylex()\n");
#endif

        while((nstr = yylook()) >= 0)
        {
#ifdef YYDEBUG
        fprintf(yyout,"yylex: nstr=%d\n",nstr);
#endif
yyfussy:
        switch(nstr)
        {
                case 0:
                        if(yywrap()) return(0);
                        break;
                case 1:
                        return ID;
                break;
                case 2:
                        return CON;
                break;
                case 3:
                        ;
                break;
                case 4:
                        return yytext[0];
                break;
                case -1:
                break;
                default:
                        fprintf(yyout,"yylex: bad switch yylook %d\n",nstr);
        }

        }
        
#ifdef YYDEBUG
        fprintf(yyout,"yylex: return 0\n");
#endif
        return(0);
}
/* end of yylex */

int yyvstop[] =
{
        0,4,0,3,4,0,2,4,0,1,4,0,2,0,1,0,0
};

# define YYTYPE char
struct yywork 
{ 
        YYTYPE 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},
/* 0x40 */
        {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},
/* 0x80 */
        {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},

#ifdef CHARSETHACK
        {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},

/* 0xc0 */
        {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},
#endif
        {0,0}
};

/*
struct yysvf 
{
        struct yywork *yystoff;
        struct yysvf *yyother;
        int *yystops;
};
*/
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}
};
 /* 0x8d */
/* struct yywork *yytop = yycrank+141; */
 /* 0xff */
struct yywork *yytop = yycrank+255;

struct yysvf *yybgin = yysvec+1;

/*
        WARNING: this table contains one entry per character
                 in the execution character set and must match it.
*/
char yymatch[] =
{
        00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
#ifdef CHARSETHACK
        01  ,011 ,012 ,01  ,01  ,012  ,01  ,01  ,
#else
        01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
#endif
        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  ,
 
/* 0x40 (ascii) @A... (petscii) @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  ,'A' ,
 
/* 0x60 (ascii) @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  ,
 
#ifdef CHARSETHACK
/* 0x80 */
        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,

/* 0xc0 (petcii) @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,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,
#endif
        0
};
char yyextra[] =
{
        0,0,0,0,0,0,0,0,0
};

/*      ncform  4.1     83/08/11        */

int yylineno =1;
# define YYU(x) x
# define NLSTATE yyprevious=YYNEWLINE
char yytext[YYLMAX];
struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
char yysbuf[YYLMAX];
char *yysptr = yysbuf;
int *yyfnd;
extern struct yysvf *yyestate;
int yyprevious = YYNEWLINE;

unsigned char testbreak=0;

yylook()
{
        register struct yysvf *yystate, **lsp;
        register struct yywork *yyt;
        struct yysvf *yyz;
        int yych;
        struct yywork *yyr;
/*
# ifdef LEXDEBUG
        int debug;
# endif
*/
        
        char *yylastch;
        
        /* start off machines */

/*
# ifdef LEXDEBUG
        debug = 1;
# else
        debug = 0;
# endif
*/

# ifdef LEXDEBUG
#define debug 1
# else
#define debug 0
#endif
        
#ifdef YYDEBUG
        fprintf(yyout,"yylook()\n");
# endif
        
        if (!yymorfg)
                yylastch = yytext;
        else
        {
                yymorfg=0;
                yylastch = yytext+yyleng;
        }

#ifdef YYDEBUG
        fprintf(yyout,"yylook: yymorfg=%d\n",yymorfg);
# endif
                
        for(;;)
        {
#ifdef YYDEBUG
                fprintf(yyout,"yylook:  (outer loop)");
                printchar("yyprevious",yyprevious);
# endif
                lsp = yylstate;
                yyestate = yystate = yybgin;
                if (yyprevious==YYNEWLINE) yystate++;

                testbreak=0;
                
                for (;;)
                {
# ifdef LEXDEBUG
                        fprintf(yyout,"yylook:   (inner loop) state %d\n",yystate-yysvec-1);
# endif
                        if(testbreak==5)
                        {
                                fprintf(yyout,"yylook:   error, aborted after 5 loops\n");
                                exit(EXIT_FAILURE);
                        }
                        testbreak++;
                        
                        yyt = yystate->yystoff;

/*                      fprintf(yyout,"yylook:   yyt offs: %02x\n",yyt-yycrank); */

                        
                        if(yyt == yycrank)
                        {               /* may not be any transitions */
                                yyz = yystate->yyother;
                                if(yyz == 0)break;
                                if(yyz->yystoff == yycrank)break;
                        }
                        *yylastch++ = yych = input();

# ifdef LEXDEBUG
                        fprintf(yyout,"yylook:   input ");
                        printchar("yych",yych);
# endif
                        
                tryagain:

# ifdef LEXDEBUG
/*                      fprintf(yyout,"yylook:   yych=%02x yymatch[yych]=%02x\n",yych,yymatch[yych]); */
                        fprintf(yyout,"yylook:   tryagain\n");
# endif
                        yyr = yyt;

/*                      fprintf(yyout,"yylook:   yyr offs: %02x\n",yyr-yycrank); */
                        
                        if ( yyt > yycrank)
                        {
                                yyt = yyr + yych;
                                if (yyt <= yytop && yyt->verify+yysvec == yystate)
                                {
                                        if(yyt->advance+yysvec == YYLERR)       /* error transitions */
                                        {
# ifdef LEXDEBUG
                                                fprintf(yyout,"yylook:   unput (1) ");
                                                printchar("*yylastch",*yylastch);
# endif
                                                unput(*--yylastch);
                                                break;
                                        }
                                        *lsp++ = yystate = yyt->advance+yysvec;
# ifdef LEXDEBUG
                                        fprintf(yyout,"yylook:   continue (1)\n");
# endif
                                        goto contin;
                                }
# ifdef LEXDEBUG
                                fprintf(yyout,"yylook:   ( yyt > yycrank)\n");
# endif
                        }
# ifdef YYOPTIM
                        else if(yyt < yycrank) /* r < yycrank */
                        {               
                                yyt = yyr = yycrank+(yycrank-yyt);
# ifdef LEXDEBUG
                                fprintf(yyout,"yylook:   compressed state\n");
# endif
                                yyt = yyt + yych;
                                if(yyt <= yytop && yyt->verify+yysvec == yystate)
                                {
# ifdef LEXDEBUG
                                        fprintf(yyout,"yylook:   (1)\n");
# endif
                                        if(yyt->advance+yysvec == YYLERR)       /* error transitions */
                                        {
# ifdef LEXDEBUG
                                                fprintf(yyout,"yylook:   unput (2) ");
                                                printchar("*yylastch",*yylastch);
# endif
                                                unput(*--yylastch);
                                                break;
                                        }
                                        *lsp++ = yystate = yyt->advance+yysvec;
# ifdef LEXDEBUG
                                        fprintf(yyout,"yylook:   continue (2)\n");
# endif
                                        goto contin;
                                        
                                }
# ifdef LEXDEBUG
/*
                                fprintf(yyout,"yylook:   yych=%02x yymatch[yych]=%02x\n",yych,yymatch[yych]);
                                fprintf(yyout,"yylook:   yyt offs: %02x\n",yyt-yycrank);
                                fprintf(yyout,"yylook:   yyr offs: %02x\n",yyr-yycrank);
*/
# endif
                                yyt = yyr + YYU(yymatch[yych]);
# ifdef LEXDEBUG
/*
                                fprintf(yyout,"yylook:   yyt offs: %02x <= yytop offs: %02x\n",yyt-yycrank,yytop-yycrank);
                                fprintf(yyout,"yylook:   yyt->verify=%04x yysvec=%04x (yyt->verify+yysvec)=%04x == yystate=%04x\n",yyt->verify,yysvec,(yyt->verify+yysvec),yystate);
*/
                                fprintf(yyout,"yylook:   try fall back character\n");
# endif
                                if(yyt <= yytop && yyt->verify+yysvec == yystate) 
                                {
# ifdef LEXDEBUG
                                        fprintf(yyout,"yylook:   (2a)\n");
# endif
                                        
                                        if(yyt->advance+yysvec == YYLERR)       /* error transition */
                                        {
# ifdef LEXDEBUG
/* cc65 compiles this ?!                                                fprintf(yyout,"yylook:   unput (3) ",); */
                                                fprintf(yyout,"yylook:   unput (3) ");
                                                printchar("*yylastch",*yylastch);
# endif
                                                unput(*--yylastch);
                                                break;
                                        }
                                        *lsp++ = yystate = yyt->advance+yysvec;
# ifdef LEXDEBUG
/*                                      fprintf(yyout,"yylook:   yyt offs: %02x yyt->advance=%d\n",yyt-yycrank,yyt->advance); */
                                        fprintf(yyout,"yylook:   continue (3)\n");
# endif
                                        goto contin;
                                        
                                }
# ifdef LEXDEBUG
                                fprintf(yyout,"yylook:   (2)\n");
# endif
                        }
                        if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank)
                        {
# ifdef LEXDEBUG
                                fprintf(yyout,"yylook:   fall back to state %d\n",yystate-yysvec-1);
# endif
                                goto tryagain;
                        }
# endif
                        else
                        {
# ifdef LEXDEBUG
                                fprintf(yyout,"yylook:   unput (4) ");
                                printchar("*yylastch",*yylastch);
# endif
                                unput(*--yylastch);
                                break;
                        }
                contin:
# ifdef LEXDEBUG
                        fprintf(yyout,"yylook:   contin state=%d\n",yystate-yysvec-1);
# endif
                        ;
                }

# ifdef LEXDEBUG
                if (lsp == yylstate)
                {
                        fprintf(yyout,"yylook:  stopped (end)\n");
                }
                else
                {
                        fprintf(yyout,"yylook:  stopped at %d with:\n",*(lsp-1)-(yysvec+1));
                }
# endif
                while (lsp-- > yylstate)
                {
                        *yylastch-- = 0;
                        if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0)
                        {
                                yyolsp = lsp;
                                if(yyextra[*yyfnd]) /* must backup */
                                {               
                                        while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate)
                                        {
                                                lsp--;
# ifdef LEXDEBUG
                                                fprintf(yyout,"yylook:   unput (5) ");
                                                printchar("*yylastch",*yylastch);
# endif
                                                unput(*yylastch--);
                                        }
                                }
                                yyprevious = YYU(*yylastch);
                                yylsp = lsp;
                                yyleng = yylastch-yytext+1;
                                yytext[yyleng] = 0;
# ifdef LEXDEBUG
                                fprintf(yyout,"yylook:  match action %d\n",*yyfnd);
                                fprintf(yyout,"yylook:  done loops: %d\n",testbreak);
# endif
                                return(*yyfnd++);
                        }
                        unput(*yylastch);
                }
                if (yytext[0] == 0  /* && feof(yyin) */)
                {
                        yysptr=yysbuf;
# ifdef LEXDEBUG
                        fprintf(yyout,"yylook:  done loops: %d\n",testbreak);
# endif
                        return(0);
                }
                yyprevious = yytext[0] = input();

# ifdef LEXDEBUG
                fprintf(yyout,"yylook:   input ");
                printchar("yyprevious",yyprevious);
# endif

                if (yyprevious>0)
                        output(yyprevious);
                yylastch=yytext;
# ifdef LEXDEBUG
/*              if(debug)putchar('\n'); */
# endif
        }

# ifdef LEXDEBUG
        fprintf(yyout,"yylook: done loops: %d\n",testbreak);
        fprintf(yyout,"yylook: return <void>\n");
# endif
}

        
yyback(p, m)
        int *p;
{
        if (p==0) return(0);
        while (*p)
        {
                if (*p++ == m)
                {
                        return(1);
                }
        }
        return(0);
}
        /* the following are only used in the lex library */
yyinput()
{
        int out=input();
        
#ifdef YYDEBUG
        fprintf(yyout,"yylook:   input ");
        printchar("out",out);
#endif  
        return(out);
}
yyoutput(c)
  int c; 
{
        output(c);
}
yyunput(c)
   int c; 
{
        unput(c);
}

main() 
{
        printf("main start\n");
        infile = fopen("yacc.in","rb");
        if (infile == NULL) {
            return EXIT_FAILURE;
        }
        outfile = stdout;
        yyparse();
        fclose(infile);
        printf("main end\n");
        return 0;
}

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

# define YYNPROD 15
# define YYLAST 249

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 
};

# define YYFLAG -1000
# define YYERROR goto yyerrlab
# define YYACCEPT return(0)
# define YYABORT return(1)

/*      parser for yacc output  */

#ifdef YYDEBUG
int yydebug = 1; /* 1 for debugging */
#else
int yydebug = 0; /* 1 for debugging */
#endif
YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
int yychar = -1; /* current input token number */
int yynerrs = 0;  /* number of errors */
short yyerrflag = 0;  /* error recovery flag */

yyparse() 
{
        short yys[YYMAXDEPTH];
        short yyj, yym;
        register YYSTYPE *yypvt;
        register short yystate, *yyps, yyn;
        register YYSTYPE *yypv;
        register short *yyxi;

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

 yystack:    /* put a state and value onto the stack */
#ifdef YYDEBUG
         printf("yyparse: yystack\n");
#endif

#ifdef YYDEBUG
        printf("yyparse: yystate=%d, ", yystate);
        printchar("yychar",yychar);
#endif
        if( ++yyps> &yys[YYMAXDEPTH] )
        {
                yyerror( "yyparse: yacc stack overflow" );
                return(1);
        }
        *yyps = yystate;
        ++yypv;
        *yypv = yyval;

 yynewstate:
#ifdef YYDEBUG
         printf("yyparse: yynewstate\n");
#endif

        yyn = yypact[yystate];

        if( yyn<= YYFLAG ) goto yydefault; /* simple state */

#ifdef YYDEBUG
         printf("yyparse: yynewstate (1)\n");
#endif
        
        if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;

#ifdef YYDEBUG
         
        printf("yyparse: yynewstate yyn=%d ",yyn);
        printchar("yychar",yychar);
#endif
        
        if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;

#ifdef YYDEBUG
         printf("yyparse: yynewstate (2)\n");
#endif
        
        if( yychk[ yyn=yyact[ yyn ] ] == yychar ) /* valid shift */
        { 
                yychar = -1;
                yyval = yylval;
                yystate = yyn;

#ifdef YYDEBUG
                 printf("yyparse: yynewstate (3)\n");
#endif

                if( yyerrflag > 0 ) --yyerrflag;
                goto yystack;
        }

 yydefault:
#ifdef YYDEBUG
         printf("yyparse: yydefault yystate=%d\n",yystate);
#endif
        /* default state action */

        if( (yyn=yydef[yystate]) == -2 )
        {
                if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
                /* look through exception table */

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

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

#ifdef YYDEBUG
         printf("yyparse: yyn=%d yyerrflag=%d\n",yyn,yyerrflag);
#endif
        
        if( yyn == 0 ) /* error */
        { 
                /* error ... attempt to resume parsing */

                switch( yyerrflag ){
                case 0:   /* brand new error */

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

                case 1:
                case 2: /* incompletely recovered error ... try again */

                        yyerrflag = 3;

                        /* find a state where "error" is a legal shift action */

                        while ( yyps >= yys ) {
                           yyn = yypact[*yyps] + YYERRCODE;
                           if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
                              yystate = yyact[yyn];  /* simulate a shift of "error" */
                              goto yystack;
                              }
                           yyn = yypact[*yyps];

                           /* the current yyps has no shift onn "error", pop stack */

#ifdef YYDEBUG
                           printf("yyparse: error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
#endif
                           --yyps;
                           --yypv;
                           }

                        /* there is no state on the stack with an error shift ... abort */

        yyabort:
                        return(1);

                case 3:  /* no shift yet; clobber input char */

#ifdef YYDEBUG
                        printf("yyparse: error recovery discards char ");
                        printchar("yychar",yychar);
#endif

                        if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
                        yychar = -1;
                        goto yynewstate;   /* try again in the same state */

                        }

        }

        /* reduction by production yyn */

#ifdef YYDEBUG
                printf("yyparse: reduce %d\n",yyn);
#endif
                yyps -= yyr2[yyn];
                yypvt = yypv;
                yypv -= yyr2[yyn];
                yyval = yypv[1];
                yym=yyn;
                        /* consult goto table to find next state */
                yyn = yyr1[yyn];
                yyj = yypgo[yyn] + *yyps + 1;
                if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
                
                switch(yym)
                {
                        case 4:
                        { 
                                yyerrok; 
                        }
                        break;
                        case 5:
                        { 
                                printf("[STORE]\n");
                        } 
                        break;
                        case 6:
                        { 
                                printf("[ADD]\n");
                        } 
                        break;
                        case 7:
                        { 
                                printf("[NEG]\n[ADD]\n");
                        } 
                        break;
                        case 8:
                        { 
                                printf("[MUL]\n");
                        } 
                        break;
                        case 9:
                        { 
                                printf("[DIV]\n");
                        } 
                        break;
                        case 10:
                        { 
                                printf("[NEG]\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;  /* stack new state and value */
}
        
int yywrap() 
{ 
        return 1; 
}
