reduce-historical/r37/lisp/csl/cslbase/r2l.c

#if defined(__STDC__) || defined(__cplusplus)
#define YYCONST const
#define YYPARAMS(x) x
#define YYDEFUN(name, arglist, args) name(args)
#define YYAND ,
#define YYPTR void *
#else
#define YYCONST
#define YYPARAMS(x) ()
#define YYDEFUN(name, arglist, args) name arglist args;
#define YYAND ;
#define YYPTR char *
#endif
#ifndef lint
YYCONST static char yysccsid[] = "@(#)yaccpar	1.8 (Berkeley +Cygnus.28) 01/20/91";
#endif
#define YYBYACC 1
#ifndef YYDONT_INCLUDE_STDIO
#include <stdio.h>
#endif
#ifdef __cplusplus
#include <stdlib.h> /* for malloc/realloc/free */
#endif
#line 36 "r2l.y"


/*
 * This is a "yacc" specification of the syntax of RLISP. It is used
 * to provide a (symbolic-mode) RLISP to Lisp translator that can be
 * made freely available without reference to anybody apart from
 * myself!  The Lisp dialect generated is Standard Lisp and in all reality
 * I intend it to be for use with CSL (my own Lisp). I am putting in
 * a switch that causes generation of something a bit more like Common
 * Lisp but please do not expect this to be fully sorted out and
 * suitable for use with full Common Lisp: again it is tuned to my own
 * private purposes...
 *
 * I will think about making this work with Bison as wall as Yacc but
 * maybe I prefer the licence terms associated with Yacc. But it is quite
 * certain that if you receive this code and can make it work with Bison
 * you can use it internally: the only issues are to do with distribution,
 * and if you are careful to use a sufficiently modern release of Bison
 * its skeleton code may be distributed without bad license consequences.
 *
 * Usage:
 *      r2l -common -rights -Dname=val source1.red ... sourcen.red dest.lsp
 */

/*
 * This code may be used and modified, and redistributed in binary
 * or source form, subject to the "CCL Public License", which should
 * accompany it. This license is a variant on the BSD license, and thus
 * permits use of code derived from this in either open and commercial
 * projects: but it does require that updates to this code be made
 * available back to the originators of the package.
 * Before merging other code in with this or linking this code
 * with other packages or libraries please check that the license terms
 * of the other material are compatible with those of this.
 */


/* Signature: 7db71bcc 21-Apr-2002 */


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

int *heap;
int heapfringe = 0;

int yyparse();

FILE *inputfile, *outputfile;
FILE *filestack[30];
int filestackp = 0;


char *defined_names[20];
int n_defined_names;
int common;

static char *rights_message[] =
{
    "",
    " This code may be used and modified, and redistributed in binary",
    " or source form, subject to the \"CCL Public License\", which should",
    " accompany it. This license is a variant on the BSD license, and thus",
    " permits use of code derived from this in either open and commercial",
    " projects: but it does require that updates to this code be made",
    " available back to the originators of the package.",
    " Before merging other code in with this or linking this code",
    " with other packages or libraries please check that the license terms",
    " of the other material are compatible with those of this.",
    "",
    NULL
};

int main(int argc, char *argv[])
{
    int rights = 0;
    inputfile = NULL;
    outputfile = NULL;
    common = 0;
/*
 * If the very first arg is "-common" pick that off.
 */
    if (argc > 1 &&
        strcmp(argv[1], "-common") == 0)
    {   common = 1;
        printf("Common Lisp mode activated\n");
        argv++;
        argc--;
    }
/*
 * If the next arg is "-rights" then pick that off.
 */
    if (argc > 1 &&
        strcmp(argv[1], "-rights") == 0)
    {   rights = 1;
        printf("Will insert re-distribution rights notice\n");
        argv++;
        argc--;
    }
/*
 * Pick off initial command-line things of the form "-D..." and store the
 * "..." bit.
 */
    n_defined_names = 0;
    while (argc > 1 &&
           argv[1][0] == '-' &&
           argv[1][1] == 'D')
    {   if (n_defined_names < 20)
            defined_names[n_defined_names++] = &argv[1][2];
        argv++;
        argc--;
    }
/*
 * If > 1 arg then final arg is destination. If only one arg then arg is
 * a source!
 */
    if (argc > 2)
    {   if (strcmp(argv[--argc], "-") == 0) outputfile = stdout;
        else outputfile = fopen(argv[argc], "w");
    }
    if (outputfile == NULL) outputfile = stdout;

    if (common)
        fprintf(outputfile, "\n;; RLISP to LISP converter. A C Norman 2002\n");
    else fprintf(outputfile, "\n%% RLISP to LISP converter. A C Norman 2002\n");
    fprintf(outputfile, "\n\n");
    if (rights)
    {   char **p = rights_message;
        char *m;
        while ((m = *p++) != NULL)
        {   fprintf(outputfile, "%s%s\n", (common ? ";;" : "%"), m);
        }
        fprintf(outputfile, "\n\n");
    }
    heap = (int *)malloc(2000000); /* Rather arbitrary size! */
    if (argc == 1) filestack[filestackp++] = stdin;
    else while (--argc != 0)
    {   if ((inputfile = fopen(argv[argc], "r")) == NULL)
            printf("File %s not readable\n", argv[argc]);
        else filestack[filestackp++] = inputfile;
    }
    inputfile = filestack[--filestackp];
    yyparse();
    fclose(outputfile);
    printf("Finished...\n");
    return 0;
}

char *lookup_name(char *s)
{
    int i, n = strlen(s);
    for (i=0; i<n_defined_names; i++)
    {   char *w = defined_names[i];  /* name or name=value */
        if (strncmp(s, w, n) == 0 &&
            w[n] == 0 ||
            w[n] == '=') return (w[n]==0 ? "" : &w[n+1]);
    }
    return NULL;
}

char linebuffer[128];
int linep = 0;

int ch = '\n';
int linecount = 1;

int nextch()
{
    if (ch == -1) return ch; /* end of file sticks */
    for (;;)
    {   ch = getc(inputfile);
        if (ch == -1 && filestackp != 0)
        {   inputfile = filestack[--filestackp];
            continue;
        }
        else break;
    }
    if (ch == '\n') linecount++;
    linebuffer[127 & linep++] = ch;
    return ch;
}

void yyerror(char *m)
{
    int q = 0;
    fprintf(stderr, "\nSyntax error (%s) around line %d\n", m, linecount);
    if (linep >= 128) q = linep-128;
    while (q != linep) fprintf(stderr, "%c", linebuffer[127 & q++]);
    fprintf(stderr, "$$$");
    while ((q = nextch()) != -1 && q != '\n') fprintf(stderr, "%c", q);
    fprintf(stderr, "\n");
    fflush(stderr);
    exit(0);
}

typedef struct keyword_code
{
    char *name;
    int code;
} keyword_code;

static keyword_code operators[];

int find_symbol(char *s)
{
    char *r = (char *)&heap[heapfringe];
    int len = strlen(s);
    strcpy(r, s);
    heapfringe += (len+4)/4;
    return (int)(r+1);
}

static int gennum = 1000;

int genlabel()
{
    char name[32];
    sprintf(name, "lab%d", gennum++);
    return find_symbol(name);
}

int genvar()
{
    char name[32];
    sprintf(name, "var%d", gennum++);
    return find_symbol(name);
}


static int yylex();

#define C_nil ((int)0)
#define qcar(x) (((int *)(x))[0])
#define qcdr(x) (((int *)(x))[1])

int cons(int a, int b)
{
    int *r = &heap[heapfringe];
    heapfringe += 2;
    qcar(r) = a;
    qcdr(r) = b;
    return (int)r;
}

int ncons(int a)
{
    int *r = &heap[heapfringe];
    heapfringe += 2;
    qcar(r) = a;
    qcdr(r) = C_nil;
    return (int)r;
}

int list1(int a)
{
    return cons(a, C_nil);
}

int list2(int a, int b)
{
    return cons(a, cons(b, C_nil));
}

int list3(int a, int b, int c)
{
    return cons(a, cons(b, cons(c, C_nil)));
}

int list4(int a, int b, int c, int d)
{
    return cons(a, cons(b, cons(c, cons(d, C_nil))));
}

int list5(int a, int b, int c, int d, int e)
{
    return cons(a, cons(b, cons(c, cons(d, cons(e, C_nil)))));
}

int list6(int a, int b, int c, int d, int e, int f)
{
    return cons(a, cons(b, cons(c, cons(d, cons(e, cons(f, C_nil))))));
}

int list7(int a, int b, int c, int d, int e, int f, int g)
{
    return cons(a, cons(b, cons(c, cons(d,
                cons(e, cons(f, cons(g, C_nil)))))));
}

int list8(int a, int b, int c, int d, int e, int f, int g, int h)
{
    return cons(a, cons(b, cons(c, cons(d,
                cons(e, cons(f, cons(g, cons(h, C_nil))))))));
}

int list9(int a, int b, int c, int d, int e, int f, int g, int h, int i)
{
    return cons(a, cons(b, cons(c, cons(d,
                cons(e, cons(f, cons(g, cons(h, cons(i, C_nil)))))))));
}

int append(int a, int b)
{
    if (a == C_nil || ((a & 1) != 0)) return b;
    else return cons(qcar(a), append(qcdr(a), b));
}

#define atom(x) ((int)(x)==0 || (((int)(x)) & 1) != 0)

int otlpos = 0;

int checkspace(int n)
{
    if (otlpos + n < 78)
    {   otlpos += n;
        return 1;
    }
    fprintf(outputfile, "\n");
    otlpos = n;
    return 0;
}

static char common_name[256];

char *tocommon(char *s)
{
   int easy = 1, c;
   int p = 0, q = 0;
   if (s[0] == '"') return s;   /* a string */
   if (isdigit(s[0])) return s; /* a number */
   while ((c = s[p++]) != 0)
   {  if (c == '!') c = s[p++];
      common_name[q++] = c;
      if (c == ':') common_name[q++] = c;  /* double up ':' */
      else if (!isalpha(c) && !isdigit(c) && c != '-' &&
          c != '_' && c != '*' && c != '&' && c != '$') easy = 0;
   }
   common_name[q] = 0;
   if (!easy)
   {   common_name[q+1] = '|';
       common_name[q+2] = 0;
       while (q != 0)
       {   common_name[q] = common_name[q-1];
           q--;
       }
       common_name[0] = '|';
   }
   return common_name;
}

void print(int a)
{
    if (a == C_nil)
    {   checkspace(3);
        fprintf(outputfile, "nil");
        return;
    }
    else if (atom(a))
    {   char *s = ((char *)a) - 1;
        if (common) s = tocommon(s);
        checkspace(strlen(s));
        fprintf(outputfile, "%s", s);
        return;
    }
    checkspace(1);
    fprintf(outputfile, "(");
    print(qcar(a));
    a = qcdr(a);
    while (!atom(a))
    {   if (checkspace(1)) fprintf(outputfile, " ");
        print(qcar(a));
        a = qcdr(a);
    }
    if ((int)a != 0)
    {   checkspace(2);
        fprintf(outputfile, " .");
        if (checkspace(1)) fprintf(outputfile, " ");
        print(a);
    }
    checkspace(1);
    fprintf(outputfile, ")");
}

static void evalorprint(int a)
{
    if (a != C_nil && !atom(a))
    {   int fn = qcar(a);
        if (fn != C_nil && atom(fn) && strcmp((char *)fn-1, "in")==0)
        {   a = qcar(qcdr(a));
            if (a != C_nil && !atom(a))
            {   fn = qcar(a);
                if (fn != C_nil && atom(fn) &&
                    strcmp((char *)fn-1, "list")==0)
                {   a = qcar(qcdr(a));
                    if (a != C_nil && atom(a))
                    {   FILE *f;
                        char filename[200];
                        char *s = (char *)a-1;
                        if (*s == '"')
                        {   s++;
                            s[strlen(s)-1] = 0;
                        }
                        if (*s != '$') strcpy(filename, s);
                        else
                        {   char parmname[200];
                            int k=0;
                            char *val;
                            s++;
                            parmname[k++] = '@';
                            while (*s != '/') parmname[k++] = *s++;
                            parmname[k] = 0;
                            val = lookup_name(parmname);
                            if (val == NULL) val = ".";
                            strcpy(filename, val);
                            strcat(filename, s);
                        }
                        f = fopen(filename, "r");
                        if (f == NULL)
                        {   printf("File \"%s\" not found\n", filename);
                            exit(1);
                        }
                        filestack[filestackp++] = inputfile;
                        inputfile = f;
                        printf("READING FILE <%s>\n", filename);
                        return;
                    }
                }
            }
        }
    }
    print(a);
}


#define sym_0                                find_symbol("0")
#define sym_car                              find_symbol("car")
#define sym_cdr                              find_symbol("cdr")
/* I have reversip available even in Common Lisp mode for nreverse */
#define sym_reversip                         find_symbol("reversip")
#define sym_plus                             find_symbol("plus")
#define sym_minus                            find_symbol("minus")
#define sym_minusp                           find_symbol("minusp")
#define sym_getv                             find_symbol("getv")
#define sym_difference                       find_symbol("difference")
#define sym_times                            find_symbol("times")
#define sym_quotient                         find_symbol("quotient")
#define sym_expt                             find_symbol("expt")
#define sym_cons                             find_symbol("cons")
#define sym_list                             find_symbol("list")
#define sym_progn                            find_symbol("progn")
#define sym_prog                             find_symbol("prog")
#define sym_de                               find_symbol("de")
#define sym_dm                               find_symbol("dm")
#define sym_ds                               find_symbol("ds")
#define sym_greaterp                         find_symbol("greaterp")
#define sym_lessp                            find_symbol("lessp")
#define sym_equal                            find_symbol("equal")
#define sym_setq                             find_symbol("setq")
#define sym_and                              find_symbol("and")
#define sym_or                               find_symbol("or")
#define sym_not                              find_symbol("not")
#define sym_member                           find_symbol("member")
#define sym_memq                             find_symbol("memq")
#define sym_neq                              find_symbol("neq")
#define sym_eq                               find_symbol("eq")
#define sym_geq                              find_symbol("geq")
#define sym_leq                              find_symbol("leq")
#define sym_freeof                           find_symbol("freeof")
#define sym_symbolic                         find_symbol("symbolic")
#define sym_algebraic                        find_symbol("algebraic")
#define sym_expr                             find_symbol("expr")
#define sym_macro                            find_symbol("macro")
#define sym_smacro                           find_symbol("smacro")
#define sym_procedure                        find_symbol("procedure")
#define sym_for                              find_symbol("for")
#define sym_step                             find_symbol("step")
#define sym_until                            find_symbol("until")
#define sym_each                             find_symbol("each")
#define sym_foreach                          find_symbol("foreach")
#define sym_in                               find_symbol("in")
#define sym_on                               find_symbol("on")
#define sym_do                               find_symbol("do")
#define sym_collect                          find_symbol("collect")
#define sym_sum                              find_symbol("sum")
#define sym_if                               find_symbol("if")
#define sym_then                             find_symbol("then")
#define sym_else                             find_symbol("else")
#define sym_repeat                           find_symbol("repeat")
#define sym_while                            find_symbol("while")
#define sym_begin                            find_symbol("begin")
#define sym_end                              find_symbol("end")
#define sym_lsect                            find_symbol("<<")
#define sym_rsect                            find_symbol(">>")
#define sym_go                               find_symbol("go")
#define sym_to                               find_symbol("to")
#define sym_goto                             find_symbol("goto")
#define sym_scalar                           find_symbol("scalar")
#define sym_integer                          find_symbol("integer")
#define sym_lambda                           find_symbol("lambda")
#define sym_symbol                           find_symbol("symbol")
#define sym_number                           find_symbol("number")
#define sym_string                           find_symbol("string")
#define sym_quoted                           find_symbol("quoted")
#define sym_return                           find_symbol("return")
#define sym_where                            find_symbol("where")
#define sym_rlistat                          find_symbol("rlistat")
#define sym_endstat                          find_symbol("endstat")
#define sym_null                             find_symbol("null")

int make_where(int body, int var, int val)
{
    return list2(
       list3(sym_lambda, list1(var), body),
       val);
}

int make_in_do(int var, int input, int body)
{
    int lab1 = genlabel();
    int var1 = genvar();
    return list8(sym_prog, list1(var1),
        list3(sym_setq, var1, input),
    lab1,
        list3(sym_if, list2(sym_null, var1), list2(sym_return, C_nil)),
        list4(sym_prog, list1(var), list3(sym_setq, var, list2(sym_car, var1)), body),
        list3(sym_setq, var1, list2(sym_cdr, var1)),
        list2(sym_go, lab1));
}

int make_on_do(int var, int input, int body)
{
    int lab1 = genlabel();
    return list8(sym_prog, list1(var),
        list3(sym_setq, var, input),
    lab1,
        list3(sym_if, list2(sym_null, var), list2(sym_return, C_nil)),
        body,
        list3(sym_setq, var, list2(sym_cdr, var)),
        list2(sym_go, lab1));
}

int make_in_collect(int var, int input, int body)
{
    int lab1 = genlabel();
    int var1 = genvar();
    int var2 = genvar();
    return list8(sym_prog, list2(var1, var2),
        list3(sym_setq, var1, input),
    lab1,
        list3(sym_if,
            list2(sym_null, var1), 
            list2(sym_return, list2(sym_reversip, var2))),
        list4(sym_prog, list1(var),
            list3(sym_setq, var, list2(sym_car, var1)),
            list3(sym_setq, var2, list3(sym_cons, body, var2))),
        list3(sym_setq, var1, list2(sym_cdr, var1)),
        list2(sym_go, lab1));
}

int make_on_collect(int var, int input, int body)
{
    int lab1 = genlabel();
    int var2 = genvar();
    return list8(sym_prog, list1(var),
        list3(sym_setq, var, input),
    lab1,
        list3(sym_if,
            list2(sym_null, var), 
            list2(sym_return, list2(sym_reversip, var2))),
        list3(sym_setq, var2, list3(sym_cons, body, var2)),
        list3(sym_setq, var, list2(sym_cdr, var)),
        list2(sym_go, lab1));
}

int make_in_sum(int var, int input, int body)
{
    int lab1 = genlabel();
    int var1 = genvar();
    int var2 = genvar();
    return list9(sym_prog, list2(var1, var2),
        list3(sym_setq, var1, input),
        list3(sym_setq, var2, sym_0),
    lab1,
        list3(sym_if,
            list2(sym_null, var1), 
            list2(sym_return, var2)),
        list4(sym_prog, list1(var),
            list3(sym_setq, var, list2(sym_car, var1)),
            list3(sym_setq, var2, list3(sym_plus, body, var2))),
        list3(sym_setq, var1, list2(sym_cdr, var1)),
        list2(sym_go, lab1));
}

int make_foreach(int var, int type, int input, int action, int body)
{
    int inon = 0, docollect = 0;
    if (strcmp((char *)type-1, "on") == 0) inon = 1;
    if (strcmp((char *)action-1, "collect") == 0) docollect = 1;
    else if (strcmp((char *)action-1, "sum") == 0) docollect = 2;
    switch (inon+2*docollect)
    {
case 0: /* in/do */
        return make_in_do(var, input, body);
case 1: /* on/do */
        return make_on_do(var, input, body);
case 2: /* in/collect */
        return make_in_collect(var, input, body);
case 3: /* on/collect */
        return make_on_collect(var, input, body);
case 4: /* in/sum */
        return make_in_sum(var, input, body);
case 5: /* on/sum WHICH CAN NOT MAKE SENSE */
default:
        return C_nil;
   }
}

int for_do(int var, int init, int step, int end, int body)
{
    int lab1 = genlabel();
    return list8(sym_prog, list1(var),
        list3(sym_setq, var, init),
    lab1,
        list3(sym_if,
            list2(sym_minusp,
                list3(sym_times, step,
                    list3(sym_difference, end, var))),
            list2(sym_return, C_nil)),
        body,
        list3(sym_setq, var, list3(sym_plus, var, step)),
        list2(sym_go, lab1));
}

int for_collect(int var, int init, int step, int end, int body)
{
    int lab1 = genlabel();
    int var1 = genvar();
    return list8(sym_prog, list2(var, var1),
        list3(sym_setq, var, init),
    lab1,
        list3(sym_if,
            list2(sym_minusp,
                list3(sym_times, step,
                    list3(sym_difference, end, var))),
            list2(sym_return, list2(sym_reversip, var1))),
        list3(sym_setq, var1, list3(sym_cons, body, var1)),
        list3(sym_setq, var, list3(sym_plus, var, step)),
        list2(sym_go, lab1));
}

int for_sum(int var, int init, int step, int end, int body)
{
    int lab1 = genlabel();
    int var1 = genvar();
    return list9(sym_prog, list2(var, var1),
        list3(sym_setq, var, init),
        list3(sym_setq, var1, sym_0),
    lab1,
        list3(sym_if,
            list2(sym_minusp,
                list3(sym_times, step,
                    list3(sym_difference, end, var))),
            list2(sym_return, var1)),
        list3(sym_setq, var1, list3(sym_plus, body, var1)),
        list3(sym_setq, var, list3(sym_plus, var, step)),
        list2(sym_go, lab1));
}

int make_for(int var, int init, int step, int end, int action, int body)
{
    int docollect = 0;
    if (strcmp((char *)action-1, "collect") == 0) docollect = 1;
    else if (strcmp((char *)action-1, "sum") == 0) docollect = 2;
    switch (docollect)
    {
case 0: /* do */
        return for_do(var, init, step, end, body);
case 1: /* collect */
        return for_collect(var, init, step, end, body);
case 2: /* sum */
        return for_sum(var, init, step, end, body);
default:
        return C_nil;
    }
}

int lex_eof = 0;

#line 716 "r2l.c"
#define SETQ 257
#define AND 258
#define OR 259
#define NOT 260
#define MEMBER 261
#define MEMQ 262
#define NEQ 263
#define EQ 264
#define GEQ 265
#define LEQ 266
#define FREEOF 267
#define SYMBOLIC 268
#define ALGEBRAIC 269
#define EXPR 270
#define MACRO 271
#define SMACRO 272
#define PROCEDURE 273
#define FOR 274
#define STEP 275
#define UNTIL 276
#define EACH 277
#define FOREACH 278
#define IN 279
#define ON 280
#define DO 281
#define COLLECT 282
#define SUM 283
#define IF 284
#define THEN 285
#define ELSE 286
#define REPEAT 287
#define WHILE 288
#define BEGIN 289
#define END 290
#define ENDFILE 291
#define LSECT 292
#define RSECT 293
#define GO 294
#define TO 295
#define GOTO 296
#define SCALAR 297
#define INTEGER 298
#define LAMBDA 299
#define SYMBOL 300
#define NUMBER 301
#define STRING 302
#define LIST 303
#define RETURN 304
#define WHERE 305
#define RLISTAT 306
#define ENDSTAT 307
#define HASHIF 308
#define HASHELSE 309
#define HASHELIF 310
#define HASHENDIF 311
#define YYERRCODE 256
static YYCONST short yylhs[] = {                                        -1,
    0,    0,    1,    1,    1,    1,    3,    3,    4,    4,
    5,    5,    5,    6,    6,    7,    7,    7,    7,    7,
    7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
    7,    7,    7,    7,    8,    8,    8,    9,    9,    9,
    9,    9,    9,   10,   10,   10,   10,   11,   11,   11,
   12,   12,    2,    2,   14,   14,   15,   15,   16,   16,
   16,   17,   17,   18,   18,   18,   19,   20,   21,   21,
   22,   22,   22,   23,   23,   23,   24,   25,   25,   25,
   26,   26,   27,   27,   28,   28,   28,   28,   28,   29,
   29,   30,   30,   31,   31,   31,   13,   13,   32,   32,
   33,   33,   34,   34,   35,   35,   38,   38,   37,   37,
   41,   41,   36,   36,   42,   42,   39,   39,   45,   45,
   40,   40,   43,   43,   44,   44,   46,   46,   46,   46,
   46,   46,   46,   46,   46,   46,   46,   47,   47,   47,
   47,   47,   47,   47,   47,   47,   47,   47,   49,   49,
   51,   51,   52,   52,   50,   50,   57,   57,   48,   48,
   53,   53,   56,   56,   54,   54,   55,   55,   58,   58,
   59,   59,   59,   60,   60,   61,   61,   61,   64,   64,
   62,   62,   69,   69,   63,   63,   65,   65,   65,   65,
   68,   68,   66,   66,   66,   66,   67,   67,   72,   72,
   72,   72,   73,   73,   70,   70,   70,   70,   71,   71,
   76,   76,   76,   76,   75,   75,   75,   75,   75,   75,
   75,   75,   75,   75,   78,   78,   78,   78,   74,   74,
   79,   79,   80,   81,   82,   82,   82,   82,   82,   82,
   77,   77,   77,   77,   77,   77,   77,   77,   77,   77,
   77,   77,   83,   83,   83,   83,   83,   83,
};
static YYCONST short yylen[] = {                                         2,
    1,    2,    2,    2,    1,    2,    1,    1,    1,    1,
    1,    1,    1,    1,    3,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
    4,    2,    3,    4,    5,    5,    6,    1,    1,    1,
    1,    3,    1,    2,    6,    4,    2,    4,    1,    1,
    1,    1,    1,    7,    7,    6,    4,    4,    1,    2,
    2,    2,    3,    1,    2,    3,    3,    1,    3,    3,
    3,    3,    1,    2,    1,    2,    3,    3,    2,    3,
    2,    1,    3,    4,    5,    6,    1,    1,    5,    1,
    5,    1,    3,    1,    3,    1,    1,    3,    3,    1,
    1,    3,    3,    1,    1,    3,    3,    1,    1,    3,
    3,    1,    2,    1,    2,    1,    3,    3,    3,    3,
    3,    3,    3,    3,    3,    3,    1,    3,    3,    3,
    3,    3,    3,    3,    3,    3,    3,    1,    2,    1,
    2,    1,    1,    3,    3,    1,    1,    3,    3,    1,
    2,    1,    3,    1,    2,    1,    3,    1,    2,    1,
    2,    2,    1,    2,    1,    2,    2,    1,    1,    3,
    3,    1,    1,    3,    3,    1,    2,    2,    2,    1,
    3,    1,    2,    2,    2,    1,    3,    1,    2,    2,
    2,    1,    3,    1,    2,    2,    2,    1,    3,    1,
    2,    2,    2,    1,    3,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    2,    2,    2,    1,    3,    1,
    1,    3,    3,    5,    4,    3,    2,    2,    2,    1,
    1,    1,    2,    2,    2,    2,    2,    2,    2,    2,
    2,    2,    1,    1,    1,    1,    1,    1,
};
static YYCONST short yydefred[] = {                                      0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    9,   10,   11,   12,   13,    0,    0,    0,   49,
   50,    0,    0,    0,    0,    0,    1,    0,    0,    0,
    0,  253,  254,  255,  256,    0,   48,  224,    0,    0,
    0,    0,    0,    0,    0,    0,  223,    0,   53,  216,
  217,  218,  219,  220,  221,  257,  258,  222,   97,    0,
  100,  102,    0,  104,  110,    0,  118,    0,  124,  126,
    0,  137,    0,  156,  164,  168,  173,  178,    0,  182,
  192,  198,    0,  210,    0,  242,  241,    0,    0,  243,
  245,  244,    0,  123,  125,  246,  247,  248,  249,  250,
  251,  252,   35,    0,   36,   37,    0,    0,    0,    0,
    0,    0,    0,    0,   85,    0,    0,    0,    7,    8,
    0,    0,   83,    0,   91,    6,    0,    0,   72,   71,
    0,    0,   70,    0,  171,  170,  176,  175,  172,  177,
    0,    2,    3,    0,    4,    0,    0,   54,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,  237,  238,  239,    0,   16,   18,   17,   19,   20,
   22,   23,   24,   26,   28,   39,   21,   25,   27,   29,
   30,   31,   32,   33,   34,    0,    0,   42,    0,    0,
    0,   62,   63,    0,    0,    0,    0,    0,    0,    0,
   86,    0,   89,   84,   90,   74,    0,   77,   73,    0,
   92,    0,    0,    0,  169,  174,  233,    0,    0,    0,
    0,    0,  103,  105,  109,  107,    0,  113,  117,  115,
    0,  121,    0,  152,  127,  150,  138,  128,  139,  130,
  141,  131,  142,  132,  143,  134,  145,  136,  147,  129,
  140,  133,  144,  135,  146,    0,  155,  153,    0,    0,
  162,  159,  163,  167,    0,    0,    0,  181,  179,    0,
    0,  190,  185,    0,    0,    0,  191,  208,  197,  202,
  209,  203,    0,    0,    0,  228,  214,  215,  229,  236,
    0,    0,    0,    0,   40,   43,   44,    0,    0,    0,
    0,   68,   67,    0,   78,   81,   82,   87,   88,   75,
    0,    0,   94,   14,    0,    0,    0,    0,    0,    0,
   52,    0,    0,    0,  149,  151,  161,  165,    0,  187,
  193,  188,  194,  189,  195,    0,  205,  199,  206,  200,
  207,  201,  211,  225,  212,  226,  213,  227,  235,    0,
   41,    0,    0,    0,    0,   59,   61,   60,    0,    0,
    0,    0,   76,   93,    0,    0,   95,   45,    0,   46,
   99,  101,  108,  112,  116,  120,  154,  158,  180,  184,
  231,    0,  234,    0,    0,   57,    0,   66,   55,   80,
   79,   15,   96,   47,    0,   65,    0,   64,  232,   58,
};
static YYCONST short yydgoto[] = {                                      42,
   43,  121,  122,   93,   46,  326,  197,  107,  108,   47,
   48,  148,   49,   50,  365,  369,  204,   51,   52,   53,
   54,   55,  218,   56,  316,  123,  124,  125,   57,  222,
   58,   59,   60,   61,   62,   63,   64,  235,   65,   66,
  238,  239,   67,   68,  242,   69,   70,   71,  245,   72,
  247,  267,  268,  269,   73,   74,  272,  135,   75,  137,
   76,   77,   78,  278,  279,  280,   79,   80,  283,  287,
   81,  289,   82,   83,   84,  298,   85,  299,  393,   86,
   90,   87,   88,
};
static YYCONST short yysindex[] = {                                   1038,
   14,   14,   14, 1303,   14,   14,   14,   14,   14,   14,
   14,    0,    0,    0,    0,    0,  -13, -235, -227,    0,
    0, 1303, 1199, 1303,  -28,   12,    0, 1199, -234, -219,
  -35,    0,    0,    0,    0, 1303,    0,    0, 1358, 1358,
 1303,    0, 1038,   12,   20, -174,    0, 1303,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0, -191,
    0,    0, -124,    0,    0, -131,    0, -120,    0,    0,
   50,    0,  111,    0,    0,    0,    0,    0,   28,    0,
    0,    0,   48,    0,  107,    0,    0,   38, 1303,    0,
    0,    0, -149,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0, 1925,    0,    0, -133,   12, -115,  -99,
 -173, -126, -101,  -88,    0, -103,  -91,  141,    0,    0,
  -23,  151,    0,  -28,    0,    0,  -16,  -87,    0,    0,
    3,  -19,    0, 1358,    0,    0,    0,    0,    0,    0,
  175,    0,    0,  -13,    0,  -56,  -13,    0,  205,  -81,
 1303, 1303, 1303, 1500, 1500, 1500, 1500, 1500, 1500, 1500,
 1500, 1500, 1500, 1553, 1358, 1608, 1659, 1659, 1736, 1449,
 1303,    0,    0,    0,  219,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  -18,  -72,    0, 1199, -173,
 1303,    0,    0, 1303, 1199, 1303, 1199,   13,   13,  151,
    0,  151,    0,    0,    0,    0, 1148,    0,    0,  -15,
    0, 1199,   33,   12,    0,    0,    0,   12,  -13,   12,
 1303,  223,    0,    0,    0,    0,   21,    0,    0,    0,
   31,    0, 1500,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0, 1553,    0,    0,  243,  249,
    0,    0,    0,    0, 1608, 1608, 1608,    0,    0,  255,
  251,    0,    0, 1659, 1659, 1659,    0,    0,    0,    0,
    0,    0, 1736, 1736, 1736,    0,    0,    0,    0,    0,
   39,  208, 1303,   33,    0,    0,    0, 1303,  -51, -179,
   16,    0,    0, -240,    0,    0,    0,    0,    0,    0,
  -16,    3,    0,    0,   18,   12, 1199, 1199,   12, 1199,
    0, 1303, 1303, 1303,    0,    0,    0,    0, 1553,    0,
    0,    0,    0,    0,    0, 1608,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,   56,
    0, -179, 1303, 1303, -179,    0,    0,    0, 1199, 1199,
   13,   13,    0,    0,   33, 1199,    0,    0, 1199,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0, 1303,    0, 1199,   43,    0, 1199,    0,    0,    0,
    0,    0,    0,    0,   56,    0, 1303,    0,    0,    0,
};
static YYCONST short yyrindex[] = {                                      0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0, 1093,    0,    0,    0,    0,
    0,    0,    0,    0,    0, 1792,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0, 1847,
    0,    0,  930,    0,    0,  970,    0,  904,    0,    0,
  710,    0,  789,    0,    0,    0,    0,    0,  553,    0,
    0,    0,  457,    0,  420,    0,    0,  263,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,   17,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,  101,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0, 1933,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,  983,    0,    0,    0,
  943,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  849,  668,
    0,    0,    0,    0,    0,    0,    0,    0,    0,  598,
  516,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 2005,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
};
static YYCONST short yygindex[] = {                                    277,
    0,    1,  -26,   41,  -34, -277,    0,    0, -109,    0,
    0,   95,  -20,    0,    0, -298,  132,    0,    0,    0,
    0,    0,   26,    0, -199,  210,    0,   -9,    0,   27,
    0,    0,    0, -142, -125,    0,    0,    4, -119, -118,
    9,   19,   -1,    2,   35,    0,    0,  -69,  424,  329,
  445,   -4,   82,   84, -150, -127,   22,   15,    6,   23,
   11,    0,    0,    5, -158, -145, -141,  -98,    8, -116,
  -59,  184,   90, -129,  -73, -168,    0,  -40,  -50,  285,
  619,  290,    0,
};
#define YYTABLESIZE 2298
static YYCONST short yytable[] = {                                     126,
   44,  112,   94,  114,  132,   95,  364,  120,  233,  317,
  146,   41,  120,  270,   39,  133,   40,  143,  145,  120,
  141,  224,  305,  113,  281,  234,  361,  149,  127,  105,
  119,  106,  236,  237,  228,  119,  271,  230,  120,  296,
   45,  109,  119,   44,  136,  136,  220,  120,  120,  138,
  138,  291,   38,   89,  139,  120,  314,  371,  146,  372,
  128,  119,  140,  394,  110,  129,  397,  282,  175,  166,
  119,  119,  111,  324,  167,   38,  325,  170,  119,  227,
  130,  199,  303,   45,  244,  244,  244,  244,  244,  244,
  244,  244,  244,  244,  212,  297,  391,  402,  147,  392,
  217,  366,  367,  368,  221,  202,  203,  288,  288,  163,
  161,  162,  213,  150,  215,  270,  340,  342,  344,  329,
   14,   15,   16,  144,  353,  355,  357,  152,  171,  341,
  343,  345,  151,  281,  281,  281,  253,  153,  271,  136,
  253,  168,  253,  253,  138,  253,  253,  253,  225,  301,
  302,  240,  169,  164,  241,  165,  226,  201,  205,  253,
  253,  253,  253,  296,  296,  296,  198,  347,  349,  351,
  136,  400,  401,  244,  206,  138,  282,  282,  282,  273,
  309,  315,  315,  310,  200,  312,  120,  274,  270,  381,
   41,  253,  207,   39,  253,   40,  208,  327,  210,  307,
  318,  328,  319,  330,  281,  311,  382,  313,  209,  119,
  149,  271,  219,  236,  237,  227,  229,  321,  232,  297,
  297,  297,  323,  363,  288,  288,  288,  306,    1,    2,
    3,    4,    5,    6,    7,    8,    9,   10,   11,   12,
   13,   14,   15,   16,   17,   18,  103,  282,  231,   19,
   20,   21,  354,  356,  358,   22,  290,  290,   23,   24,
   25,  115,  303,   28,  131,   29,  211,   30,  116,  117,
   31,  118,   33,   34,   35,   36,  216,   37,   38,  333,
  223,  304,  360,  332,  322,  339,  104,  362,  334,   14,
   15,   16,  144,  165,  217,  221,  346,  167,  240,  376,
  359,  370,  379,  240,  240,  240,  240,  240,  240,  240,
  154,  155,  156,  157,  158,  159,  160,  375,  407,  142,
  240,  240,  240,  240,  240,  331,   25,  377,  378,   28,
  380,  308,  240,  214,  387,  241,  383,   32,   33,   34,
   35,  384,  395,  396,  315,  315,  373,  337,  374,  338,
  389,  292,  385,  390,  409,  240,  240,  253,  253,  253,
  388,  253,  253,  253,  253,  253,  253,  253,  386,  398,
  399,  405,  172,  290,  290,  290,  403,  174,    0,  404,
    0,    0,    0,    0,    0,    0,  410,    0,    0,  253,
  253,    0,  253,    0,  406,    0,    0,  408,    0,    0,
  253,  253,  253,  253,    0,  253,    0,    1,    2,    3,
    4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
   14,   15,   16,   17,   18,    0,    0,    0,   19,   20,
   21,    0,    0,    0,   22,    0,    0,   23,   24,   25,
  115,    0,   28,    0,   29,    0,   30,    0,    0,   31,
  118,   33,   34,   35,   36,  230,   37,   38,    0,    0,
  230,  230,  230,  230,  230,    0,  230,  348,  350,  352,
    0,    0,    0,    0,    0,    0,    0,  230,  230,  230,
  230,  230,  246,  246,  246,  246,  246,  246,  246,  246,
  246,  246,  204,    0,    0,    0,    0,  204,  204,  204,
  204,  204,    0,  204,    0,    0,    0,    0,    0,    0,
    0,    0,  230,  230,  204,  204,  204,  204,  204,  240,
  240,  240,    0,  240,  240,  240,  240,  240,  240,  240,
    0,    0,    0,    0,    0,    0,    0,  240,  240,    0,
    0,    0,    0,  240,  240,  240,    0,  240,  240,  204,
    0,  196,  240,    0,    0,  240,  196,  196,  196,  196,
  196,    0,    0,    0,    0,    0,    0,  240,    0,    0,
    0,  246,    0,  196,  196,  196,  196,  196,  248,  250,
  252,  254,  256,  258,  260,  262,  264,    0,  186,    0,
    0,    0,    0,  186,    0,  186,  186,  186,    0,  249,
  251,  253,  255,  257,  259,  261,  263,  265,  196,    0,
  186,  186,  186,  186,  186,    0,    0,    0,    0,    0,
   91,   92,    0,   96,   97,   98,   99,  100,  101,  102,
    0,    0,    0,  183,    0,    0,    0,    0,  183,    0,
  183,  183,  183,    0,    0,  186,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  183,  183,  183,  183,  183,
    0,    0,    0,    0,    0,    0,  335,    0,    0,    0,
    0,    0,    0,    0,    0,    0,  230,  230,  230,    0,
  230,  230,  230,  230,  230,  230,  230,  336,    0,    0,
  183,    0,    0,    0,  230,  230,    0,    0,    0,    0,
  230,  230,  230,  166,  230,  230,  173,    0,  166,  230,
  166,  166,  230,  204,  204,  204,    0,  204,  204,  204,
  204,  204,  204,  204,  230,  166,  166,  166,  166,  166,
    0,  204,  204,    0,    0,    0,    0,  204,  204,  204,
    0,  204,  204,    0,    0,  148,  204,    0,    0,  204,
  148,    0,    0,  148,    0,    0,    0,    0,    0,    0,
  166,  204,    0,    0,    0,    0,    0,  148,  148,    0,
    0,    0,  196,  196,  196,    0,  196,  196,  196,  196,
  196,  196,  196,    0,    0,    0,    0,    0,    0,    0,
  196,  196,    0,    0,    0,    0,  196,  196,  196,    0,
  196,  196,  148,    0,    0,  196,    0,    0,  196,  186,
  186,  186,    0,  186,  186,  186,  186,  186,  186,  186,
  196,    0,    0,    0,  160,    0,    0,  186,  186,  160,
    0,    0,  160,  186,  186,  186,    0,  186,  186,    0,
    0,    0,  186,    0,    0,  186,  160,  160,  160,  160,
  160,    0,    0,    0,  183,  183,  183,  186,  183,  183,
  183,  183,  183,  183,  183,    0,    0,    0,    0,    0,
    0,    0,  183,  183,    0,    0,    0,    0,  183,  183,
  183,  160,  183,  183,  157,    0,    0,  183,    0,  157,
  183,    0,  157,    0,    0,    0,    0,    0,    0,    0,
    0,    0,  183,    0,    0,    0,  157,  157,  157,  157,
  157,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,  166,  166,  166,    0,  166,  166,
  166,  166,  166,  166,  166,    0,    0,    0,    0,  122,
    0,  157,  166,  166,  122,    0,    0,  122,  166,  166,
  166,    0,  166,  166,    0,    0,    0,  166,    0,    0,
  166,  122,  122,    0,    0,  106,  148,  148,  148,    0,
  106,    0,  166,  106,    0,    0,    0,    0,  119,    0,
    0,    0,    0,  119,  148,  148,  119,  106,  106,    0,
  148,  148,  148,    0,  148,  148,  122,    0,    0,  148,
  119,  119,  148,    0,    0,  114,    0,    0,    0,    0,
  114,    0,    0,  114,  148,    0,    0,    0,  111,    0,
    0,    0,  106,  111,    0,    0,  111,  114,  114,    0,
    0,    0,    0,    0,    0,  119,    0,    0,    0,    0,
  111,  111,    0,    0,    0,  160,  160,  160,    0,  160,
  160,  160,  160,  160,  160,  160,    0,    0,    0,    0,
    0,    0,  114,  160,  160,    0,    0,    0,    0,  160,
  160,  160,    0,  160,  160,  111,    0,   41,  160,    0,
   39,  160,   40,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,  160,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  157,  157,  157,    0,  157,
  157,  157,  157,  157,  157,  157,    0,    0,    0,    0,
    0,    0,    0,  157,  157,    0,    0,    0,    0,  157,
  157,  157,    5,  157,  157,    5,    0,    5,  157,    0,
    0,  157,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,  157,    0,    0,    0,    0,    0,    0,
  122,    0,  122,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  122,  122,
    0,    0,    0,    0,  122,  122,  122,   41,  122,  122,
   39,    0,   40,  122,    0,    0,  122,    0,    0,  119,
    0,  119,    0,    0,  106,  106,    0,    0,  122,    0,
  106,  106,  106,    0,  106,  106,    0,  119,  119,  106,
    0,    0,  106,  119,  119,  119,  114,  119,  119,    0,
    0,    0,  119,    0,  106,  119,    0,    0,   41,  111,
    0,   39,    0,   40,  114,  114,    0,  119,    0,    0,
  114,  114,  114,    0,  114,  114,    0,  111,  111,  114,
    0,    0,  114,  111,  111,  111,    0,  111,  111,    0,
    0,    0,  111,    0,  114,  111,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,  111,    0,    0,
    0,    0,    0,    0,    1,    2,    3,    4,    5,    6,
    7,    8,    9,   10,   11,   12,   13,   14,   15,   16,
   17,   18,    0,    0,    0,   19,   20,   21,    0,    0,
    0,   22,    0,    0,   23,   24,   25,   26,   27,   28,
    0,   29,    0,   30,    0,    0,   31,   32,   33,   34,
   35,   36,   41,   37,   38,   39,    0,   40,    0,    5,
    5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
    5,    5,    5,    5,    5,    5,    5,    0,    0,    0,
    5,    5,    5,    0,    0,    0,    5,    0,    0,    5,
    5,    5,    5,    5,    5,    0,    5,    0,    5,    0,
    0,    5,    5,    5,    5,    5,    5,   41,    5,    5,
   39,    0,   40,    0,    1,    2,    3,    4,    5,    6,
    7,    8,    9,   10,   11,   12,   13,   14,   15,   16,
   17,   18,    0,    0,    0,   19,   20,   21,    0,    0,
    0,   22,    0,    0,   23,   24,   25,    0,    0,   28,
  320,   29,    0,   30,    0,    0,   31,   32,   33,   34,
   35,   36,    0,   37,   38,    1,    2,    3,    4,    5,
    6,    7,    8,    9,   10,   11,   12,   13,   14,   15,
   16,   17,   18,    0,    0,    0,   19,   20,   21,    0,
    0,    0,   22,    0,    0,   23,   24,   25,   41,  300,
   28,   39,   29,   40,   30,    0,    0,   31,   32,   33,
   34,   35,   36,    0,   37,   38,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,   41,
    0,    0,   39,    0,   40,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    1,
    2,    3,    4,    5,    6,    7,    8,    9,   10,   11,
   12,   13,   14,   15,   16,   17,   18,    0,    0,    0,
   19,    0,    0,    0,    0,    0,   22,    0,    0,   23,
   24,   25,   41,    0,   28,   39,   29,   40,   30,    0,
    0,   31,   32,   33,   34,   35,   36,    0,    0,   38,
    0,    0,    0,    0,    1,    2,    3,  134,    5,    6,
    7,    8,    9,   10,   11,   12,   13,   14,   15,   16,
   17,   18,    0,    0,    0,   19,    0,    0,    0,    0,
    0,   22,    0,    0,   23,   24,   25,   41,    0,   28,
  276,   29,  277,   30,    0,    0,   31,   32,   33,   34,
   35,   36,    0,    0,   38,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,   41,    0,
    0,  285,    0,  286,    0,    1,    2,    3,    4,    5,
    6,    7,    8,    9,   10,   11,   12,   13,   14,   15,
   16,   17,   18,    0,    0,    0,   19,    0,    0,    0,
    0,    0,   22,    0,    0,   23,   24,   25,    0,    0,
   28,    0,   29,    0,   30,    0,    0,   31,   32,   33,
   34,   35,   36,    0,    0,   38,    1,    2,    3,  243,
    5,    6,    7,    8,    9,   10,   11,   12,   13,   14,
   15,   16,   17,   18,    0,   41,    0,   19,  294,    0,
  295,    0,    0,   22,    0,    0,   23,   24,   25,    0,
    0,   28,    0,   29,    0,   30,    0,    0,   31,   32,
   33,   34,   35,   36,    0,    0,   38,    0,    0,    1,
    2,    3,  266,    5,    6,    7,    8,    9,   10,   11,
   12,   13,   14,   15,   16,   17,   18,   69,    0,    0,
   19,    0,   69,    0,    0,   69,   22,    0,    0,   23,
   24,   25,    0,    0,   28,    0,   29,    0,   30,   69,
   69,   31,   32,   33,   34,   35,   36,    0,    0,   38,
    0,    0,    0,    0,    1,    2,    3,  275,    5,    6,
    7,    8,    9,   10,   11,   12,   13,   14,   15,   16,
   17,   18,   98,    0,   69,   19,    0,   98,    0,    0,
   98,   22,    0,    0,   23,   24,   25,    0,    0,   28,
    0,   29,    0,   30,   98,   98,   31,   32,   33,   34,
   35,   36,    0,    0,   38,    1,    2,    3,  284,    5,
    6,    7,    8,    9,   10,   11,   12,   13,   14,   15,
   16,   17,   18,    0,    0,    0,   19,    0,    0,   98,
    0,    0,   22,    0,    0,   23,   24,   25,    0,    0,
   28,    0,   29,    0,   30,    0,    0,   31,   32,   33,
   34,   35,   36,    0,  196,   38,  192,  190,   51,  191,
  195,  193,    0,   51,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,  189,  187,  188,    0,    0,    0,
   51,   51,    1,    2,    3,  293,    5,    6,    7,    8,
    9,   10,   11,   12,   13,   14,   15,   16,   17,   18,
    0,    0,    0,   19,    0,    0,    0,    0,  194,   22,
    0,    0,   23,   24,   25,   51,    0,   28,    0,   29,
    0,   30,    0,    0,   31,   32,   33,   34,   35,   36,
   56,    0,   38,    0,    0,   56,    0,    0,   56,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,   56,   56,    0,    0,   69,   69,    0,    0,
    0,    0,   69,   69,   69,    0,   69,   69,    0,    0,
    0,   69,    0,    0,   69,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   56,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,   98,   98,    0,    0,    0,    0,   98,   98,   98,
    0,   98,   98,    0,    0,    0,   98,    0,    0,   98,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,  176,  177,  178,    0,  179,  180,  181,  182,  183,
  184,  185,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   51,   51,    0,
    0,    0,    0,   51,   51,   51,    0,   51,   51,    0,
    0,    0,   51,    0,  186,   51,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,   56,
   56,    0,    0,    0,    0,   56,   56,   56,    0,   56,
    0,    0,    0,    0,   56,    0,    0,   56,
};
static YYCONST short yycheck[] = {                                      26,
    0,   22,    4,   24,   40,    4,   58,   36,  151,  209,
   45,   40,   36,  164,   43,   36,   45,   44,   45,   36,
   41,   41,   41,   23,  166,  151,  304,   48,   28,   43,
   59,   45,  152,  152,  144,   59,  164,  147,   36,  169,
    0,  277,   59,   43,   39,   40,   44,   36,   36,   39,
   40,  168,   36,   40,   40,   36,   44,  298,   93,  300,
  295,   59,   40,  362,  300,  300,  365,  166,   89,   42,
   59,   59,  300,   41,   47,   59,   44,   40,   59,   41,
  300,  108,   44,   43,  154,  155,  156,  157,  158,  159,
  160,  161,  162,  163,  121,  169,   41,  375,  273,   44,
  127,  281,  282,  283,  131,  279,  280,  167,  168,   60,
   61,   62,  122,  305,  124,  266,  275,  276,  277,  229,
  270,  271,  272,  273,  293,  294,  295,  259,   91,  275,
  276,  277,  257,  275,  276,  277,   36,  258,  266,  134,
   40,   94,   42,   43,  134,   45,   46,   47,  134,  170,
  171,  153,   46,   43,  153,   45,  134,  257,  285,   59,
   60,   61,   62,  293,  294,  295,  300,  284,  285,  286,
  165,  371,  372,  243,  276,  165,  275,  276,  277,  165,
  201,  208,  209,  204,  300,  206,   36,  165,  339,  332,
   40,   91,  281,   43,   94,   45,  300,  224,   58,  199,
  210,  228,  212,  230,  346,  205,  332,  207,  300,   59,
  231,  339,  300,  333,  333,   41,  273,  217,  300,  293,
  294,  295,  222,  275,  284,  285,  286,  300,  257,  258,
  259,  260,  261,  262,  263,  264,  265,  266,  267,  268,
  269,  270,  271,  272,  273,  274,  260,  346,   44,  278,
  279,  280,  293,  294,  295,  284,  167,  168,  287,  288,
  289,  290,   44,  292,  300,  294,  290,  296,  297,  298,
  299,  300,  301,  302,  303,  304,  293,  306,  307,  259,
  300,  300,  303,   61,  300,   43,  300,  308,  258,  270,
  271,  272,  273,   45,  321,  322,   42,   47,   36,  326,
   93,  286,  329,   41,   42,   43,   44,   45,   46,   47,
  261,  262,  263,  264,  265,  266,  267,  300,  276,   43,
   58,   59,   60,   61,   62,  231,  289,  327,  328,  292,
  330,  200,  334,  124,  339,  334,  333,  300,  301,  302,
  303,  333,  363,  364,  371,  372,  321,  266,  322,  266,
  346,  168,  334,  346,  405,   93,   94,  257,  258,  259,
  339,  261,  262,  263,  264,  265,  266,  267,  334,  369,
  370,  392,   88,  284,  285,  286,  376,   88,   -1,  379,
   -1,   -1,   -1,   -1,   -1,   -1,  407,   -1,   -1,  289,
  290,   -1,  292,   -1,  394,   -1,   -1,  397,   -1,   -1,
  300,  301,  302,  303,   -1,  305,   -1,  257,  258,  259,
  260,  261,  262,  263,  264,  265,  266,  267,  268,  269,
  270,  271,  272,  273,  274,   -1,   -1,   -1,  278,  279,
  280,   -1,   -1,   -1,  284,   -1,   -1,  287,  288,  289,
  290,   -1,  292,   -1,  294,   -1,  296,   -1,   -1,  299,
  300,  301,  302,  303,  304,   36,  306,  307,   -1,   -1,
   41,   42,   43,   44,   45,   -1,   47,  284,  285,  286,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   58,   59,   60,
   61,   62,  154,  155,  156,  157,  158,  159,  160,  161,
  162,  163,   36,   -1,   -1,   -1,   -1,   41,   42,   43,
   44,   45,   -1,   47,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   93,   94,   58,   59,   60,   61,   62,  257,
  258,  259,   -1,  261,  262,  263,  264,  265,  266,  267,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  275,  276,   -1,
   -1,   -1,   -1,  281,  282,  283,   -1,  285,  286,   93,
   -1,   36,  290,   -1,   -1,  293,   41,   42,   43,   44,
   45,   -1,   -1,   -1,   -1,   -1,   -1,  305,   -1,   -1,
   -1,  243,   -1,   58,   59,   60,   61,   62,  155,  156,
  157,  158,  159,  160,  161,  162,  163,   -1,   36,   -1,
   -1,   -1,   -1,   41,   -1,   43,   44,   45,   -1,  155,
  156,  157,  158,  159,  160,  161,  162,  163,   93,   -1,
   58,   59,   60,   61,   62,   -1,   -1,   -1,   -1,   -1,
    2,    3,   -1,    5,    6,    7,    8,    9,   10,   11,
   -1,   -1,   -1,   36,   -1,   -1,   -1,   -1,   41,   -1,
   43,   44,   45,   -1,   -1,   93,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   58,   59,   60,   61,   62,
   -1,   -1,   -1,   -1,   -1,   -1,  243,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,  257,  258,  259,   -1,
  261,  262,  263,  264,  265,  266,  267,  243,   -1,   -1,
   93,   -1,   -1,   -1,  275,  276,   -1,   -1,   -1,   -1,
  281,  282,  283,   36,  285,  286,   88,   -1,   41,  290,
   43,   44,  293,  257,  258,  259,   -1,  261,  262,  263,
  264,  265,  266,  267,  305,   58,   59,   60,   61,   62,
   -1,  275,  276,   -1,   -1,   -1,   -1,  281,  282,  283,
   -1,  285,  286,   -1,   -1,   36,  290,   -1,   -1,  293,
   41,   -1,   -1,   44,   -1,   -1,   -1,   -1,   -1,   -1,
   93,  305,   -1,   -1,   -1,   -1,   -1,   58,   59,   -1,
   -1,   -1,  257,  258,  259,   -1,  261,  262,  263,  264,
  265,  266,  267,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  275,  276,   -1,   -1,   -1,   -1,  281,  282,  283,   -1,
  285,  286,   93,   -1,   -1,  290,   -1,   -1,  293,  257,
  258,  259,   -1,  261,  262,  263,  264,  265,  266,  267,
  305,   -1,   -1,   -1,   36,   -1,   -1,  275,  276,   41,
   -1,   -1,   44,  281,  282,  283,   -1,  285,  286,   -1,
   -1,   -1,  290,   -1,   -1,  293,   58,   59,   60,   61,
   62,   -1,   -1,   -1,  257,  258,  259,  305,  261,  262,
  263,  264,  265,  266,  267,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,  275,  276,   -1,   -1,   -1,   -1,  281,  282,
  283,   93,  285,  286,   36,   -1,   -1,  290,   -1,   41,
  293,   -1,   44,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,  305,   -1,   -1,   -1,   58,   59,   60,   61,
   62,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,  257,  258,  259,   -1,  261,  262,
  263,  264,  265,  266,  267,   -1,   -1,   -1,   -1,   36,
   -1,   93,  275,  276,   41,   -1,   -1,   44,  281,  282,
  283,   -1,  285,  286,   -1,   -1,   -1,  290,   -1,   -1,
  293,   58,   59,   -1,   -1,   36,  257,  258,  259,   -1,
   41,   -1,  305,   44,   -1,   -1,   -1,   -1,   36,   -1,
   -1,   -1,   -1,   41,  275,  276,   44,   58,   59,   -1,
  281,  282,  283,   -1,  285,  286,   93,   -1,   -1,  290,
   58,   59,  293,   -1,   -1,   36,   -1,   -1,   -1,   -1,
   41,   -1,   -1,   44,  305,   -1,   -1,   -1,   36,   -1,
   -1,   -1,   93,   41,   -1,   -1,   44,   58,   59,   -1,
   -1,   -1,   -1,   -1,   -1,   93,   -1,   -1,   -1,   -1,
   58,   59,   -1,   -1,   -1,  257,  258,  259,   -1,  261,
  262,  263,  264,  265,  266,  267,   -1,   -1,   -1,   -1,
   -1,   -1,   93,  275,  276,   -1,   -1,   -1,   -1,  281,
  282,  283,   -1,  285,  286,   93,   -1,   40,  290,   -1,
   43,  293,   45,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  305,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,  257,  258,  259,   -1,  261,
  262,  263,  264,  265,  266,  267,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  275,  276,   -1,   -1,   -1,   -1,  281,
  282,  283,   40,  285,  286,   43,   -1,   45,  290,   -1,
   -1,  293,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  305,   -1,   -1,   -1,   -1,   -1,   -1,
  257,   -1,  259,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  275,  276,
   -1,   -1,   -1,   -1,  281,  282,  283,   40,  285,  286,
   43,   -1,   45,  290,   -1,   -1,  293,   -1,   -1,  257,
   -1,  259,   -1,   -1,  275,  276,   -1,   -1,  305,   -1,
  281,  282,  283,   -1,  285,  286,   -1,  275,  276,  290,
   -1,   -1,  293,  281,  282,  283,  257,  285,  286,   -1,
   -1,   -1,  290,   -1,  305,  293,   -1,   -1,   40,  257,
   -1,   43,   -1,   45,  275,  276,   -1,  305,   -1,   -1,
  281,  282,  283,   -1,  285,  286,   -1,  275,  276,  290,
   -1,   -1,  293,  281,  282,  283,   -1,  285,  286,   -1,
   -1,   -1,  290,   -1,  305,  293,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  305,   -1,   -1,
   -1,   -1,   -1,   -1,  257,  258,  259,  260,  261,  262,
  263,  264,  265,  266,  267,  268,  269,  270,  271,  272,
  273,  274,   -1,   -1,   -1,  278,  279,  280,   -1,   -1,
   -1,  284,   -1,   -1,  287,  288,  289,  290,  291,  292,
   -1,  294,   -1,  296,   -1,   -1,  299,  300,  301,  302,
  303,  304,   40,  306,  307,   43,   -1,   45,   -1,  257,
  258,  259,  260,  261,  262,  263,  264,  265,  266,  267,
  268,  269,  270,  271,  272,  273,  274,   -1,   -1,   -1,
  278,  279,  280,   -1,   -1,   -1,  284,   -1,   -1,  287,
  288,  289,  290,  291,  292,   -1,  294,   -1,  296,   -1,
   -1,  299,  300,  301,  302,  303,  304,   40,  306,  307,
   43,   -1,   45,   -1,  257,  258,  259,  260,  261,  262,
  263,  264,  265,  266,  267,  268,  269,  270,  271,  272,
  273,  274,   -1,   -1,   -1,  278,  279,  280,   -1,   -1,
   -1,  284,   -1,   -1,  287,  288,  289,   -1,   -1,  292,
  293,  294,   -1,  296,   -1,   -1,  299,  300,  301,  302,
  303,  304,   -1,  306,  307,  257,  258,  259,  260,  261,
  262,  263,  264,  265,  266,  267,  268,  269,  270,  271,
  272,  273,  274,   -1,   -1,   -1,  278,  279,  280,   -1,
   -1,   -1,  284,   -1,   -1,  287,  288,  289,   40,   41,
  292,   43,  294,   45,  296,   -1,   -1,  299,  300,  301,
  302,  303,  304,   -1,  306,  307,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   40,
   -1,   -1,   43,   -1,   45,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,
  258,  259,  260,  261,  262,  263,  264,  265,  266,  267,
  268,  269,  270,  271,  272,  273,  274,   -1,   -1,   -1,
  278,   -1,   -1,   -1,   -1,   -1,  284,   -1,   -1,  287,
  288,  289,   40,   -1,  292,   43,  294,   45,  296,   -1,
   -1,  299,  300,  301,  302,  303,  304,   -1,   -1,  307,
   -1,   -1,   -1,   -1,  257,  258,  259,  260,  261,  262,
  263,  264,  265,  266,  267,  268,  269,  270,  271,  272,
  273,  274,   -1,   -1,   -1,  278,   -1,   -1,   -1,   -1,
   -1,  284,   -1,   -1,  287,  288,  289,   40,   -1,  292,
   43,  294,   45,  296,   -1,   -1,  299,  300,  301,  302,
  303,  304,   -1,   -1,  307,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   40,   -1,
   -1,   43,   -1,   45,   -1,  257,  258,  259,  260,  261,
  262,  263,  264,  265,  266,  267,  268,  269,  270,  271,
  272,  273,  274,   -1,   -1,   -1,  278,   -1,   -1,   -1,
   -1,   -1,  284,   -1,   -1,  287,  288,  289,   -1,   -1,
  292,   -1,  294,   -1,  296,   -1,   -1,  299,  300,  301,
  302,  303,  304,   -1,   -1,  307,  257,  258,  259,  260,
  261,  262,  263,  264,  265,  266,  267,  268,  269,  270,
  271,  272,  273,  274,   -1,   40,   -1,  278,   43,   -1,
   45,   -1,   -1,  284,   -1,   -1,  287,  288,  289,   -1,
   -1,  292,   -1,  294,   -1,  296,   -1,   -1,  299,  300,
  301,  302,  303,  304,   -1,   -1,  307,   -1,   -1,  257,
  258,  259,  260,  261,  262,  263,  264,  265,  266,  267,
  268,  269,  270,  271,  272,  273,  274,   36,   -1,   -1,
  278,   -1,   41,   -1,   -1,   44,  284,   -1,   -1,  287,
  288,  289,   -1,   -1,  292,   -1,  294,   -1,  296,   58,
   59,  299,  300,  301,  302,  303,  304,   -1,   -1,  307,
   -1,   -1,   -1,   -1,  257,  258,  259,  260,  261,  262,
  263,  264,  265,  266,  267,  268,  269,  270,  271,  272,
  273,  274,   36,   -1,   93,  278,   -1,   41,   -1,   -1,
   44,  284,   -1,   -1,  287,  288,  289,   -1,   -1,  292,
   -1,  294,   -1,  296,   58,   59,  299,  300,  301,  302,
  303,  304,   -1,   -1,  307,  257,  258,  259,  260,  261,
  262,  263,  264,  265,  266,  267,  268,  269,  270,  271,
  272,  273,  274,   -1,   -1,   -1,  278,   -1,   -1,   93,
   -1,   -1,  284,   -1,   -1,  287,  288,  289,   -1,   -1,
  292,   -1,  294,   -1,  296,   -1,   -1,  299,  300,  301,
  302,  303,  304,   -1,   40,  307,   42,   43,   36,   45,
   46,   47,   -1,   41,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   60,   61,   62,   -1,   -1,   -1,
   58,   59,  257,  258,  259,  260,  261,  262,  263,  264,
  265,  266,  267,  268,  269,  270,  271,  272,  273,  274,
   -1,   -1,   -1,  278,   -1,   -1,   -1,   -1,   94,  284,
   -1,   -1,  287,  288,  289,   93,   -1,  292,   -1,  294,
   -1,  296,   -1,   -1,  299,  300,  301,  302,  303,  304,
   36,   -1,  307,   -1,   -1,   41,   -1,   -1,   44,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   58,   59,   -1,   -1,  275,  276,   -1,   -1,
   -1,   -1,  281,  282,  283,   -1,  285,  286,   -1,   -1,
   -1,  290,   -1,   -1,  293,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   93,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,  275,  276,   -1,   -1,   -1,   -1,  281,  282,  283,
   -1,  285,  286,   -1,   -1,   -1,  290,   -1,   -1,  293,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,  257,  258,  259,   -1,  261,  262,  263,  264,  265,
  266,  267,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  275,  276,   -1,
   -1,   -1,   -1,  281,  282,  283,   -1,  285,  286,   -1,
   -1,   -1,  290,   -1,  300,  293,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  275,
  276,   -1,   -1,   -1,   -1,  281,  282,  283,   -1,  285,
   -1,   -1,   -1,   -1,  290,   -1,   -1,  293,
};
#define YYFINAL 42
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 311
#if YYDEBUG
static YYCONST char *YYCONST yyname[] = {
"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,"'$'",0,0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0,0,0,0,0,0,0,
0,0,"':'","';'","'<'","'='","'>'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,"'['",0,"']'","'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"SETQ","AND","OR","NOT","MEMBER","MEMQ","NEQ",
"EQ","GEQ","LEQ","FREEOF","SYMBOLIC","ALGEBRAIC","EXPR","MACRO","SMACRO",
"PROCEDURE","FOR","STEP","UNTIL","EACH","FOREACH","IN","ON","DO","COLLECT",
"SUM","IF","THEN","ELSE","REPEAT","WHILE","BEGIN","END","ENDFILE","LSECT",
"RSECT","GO","TO","GOTO","SCALAR","INTEGER","LAMBDA","SYMBOL","NUMBER","STRING",
"LIST","RETURN","WHERE","RLISTAT","ENDSTAT","HASHIF","HASHELSE","HASHELIF",
"HASHENDIF",
};
static YYCONST char *YYCONST yyrule[] = {
"$accept : wholefile",
"wholefile : ENDFILE",
"wholefile : command wholefile",
"command : cmnd sep",
"command : proc_type sep",
"command : END",
"command : END sep",
"sep : ';'",
"sep : '$'",
"proc_type : SYMBOLIC",
"proc_type : ALGEBRAIC",
"proc_qual : EXPR",
"proc_qual : MACRO",
"proc_qual : SMACRO",
"sym_list : ')'",
"sym_list : ',' SYMBOL sym_list",
"infix : SETQ",
"infix : OR",
"infix : AND",
"infix : MEMBER",
"infix : MEMQ",
"infix : '='",
"infix : NEQ",
"infix : EQ",
"infix : GEQ",
"infix : '>'",
"infix : LEQ",
"infix : '<'",
"infix : FREEOF",
"infix : '+'",
"infix : '-'",
"infix : '*'",
"infix : '/'",
"infix : '^'",
"infix : '.'",
"prefix : NOT",
"prefix : '+'",
"prefix : '-'",
"proc_head : SYMBOL",
"proc_head : SYMBOL SYMBOL",
"proc_head : SYMBOL '(' ')'",
"proc_head : SYMBOL '(' SYMBOL sym_list",
"proc_head : prefix SYMBOL",
"proc_head : SYMBOL infix SYMBOL",
"proc_def : PROCEDURE proc_head sep cmnd",
"proc_def : proc_type PROCEDURE proc_head sep cmnd",
"proc_def : proc_qual PROCEDURE proc_head sep cmnd",
"proc_def : proc_type proc_qual PROCEDURE proc_head sep cmnd",
"rlistat : RLISTAT",
"rlistat : IN",
"rlistat : ON",
"rltail : expr",
"rltail : expr ',' rltail",
"cmnd : expr",
"cmnd : rlistat rltail",
"if_stmt : IF expr THEN cmnd ELSE cmnd",
"if_stmt : IF expr THEN cmnd",
"for_update : ':' expr",
"for_update : STEP expr UNTIL expr",
"for_action : DO",
"for_action : SUM",
"for_action : COLLECT",
"for_inon : IN",
"for_inon : ON",
"for_stmt : FOR SYMBOL SETQ expr for_update for_action cmnd",
"for_stmt : FOR EACH SYMBOL for_inon expr for_action cmnd",
"for_stmt : FOREACH SYMBOL for_inon expr for_action cmnd",
"while_stmt : WHILE expr DO cmnd",
"repeat_stmt : REPEAT cmnd UNTIL expr",
"return_stmt : RETURN",
"return_stmt : RETURN expr",
"goto_stmt : GOTO SYMBOL",
"goto_stmt : GO SYMBOL",
"goto_stmt : GO TO SYMBOL",
"group_tail : RSECT",
"group_tail : sep RSECT",
"group_tail : sep cmnd group_tail",
"group_expr : LSECT cmnd group_tail",
"scalar_tail : sep",
"scalar_tail : ',' SYMBOL scalar_tail",
"scalar_tail : ',' INTEGER scalar_tail",
"scalar_def : SCALAR SYMBOL scalar_tail",
"scalar_def : INTEGER SYMBOL scalar_tail",
"scalar_defs : scalar_def",
"scalar_defs : scalar_defs scalar_def",
"block_tail : END",
"block_tail : cmnd END",
"block_tail : SYMBOL ':' block_tail",
"block_tail : cmnd sep block_tail",
"block_tail : sep block_tail",
"block_expr : BEGIN scalar_defs block_tail",
"block_expr : BEGIN block_tail",
"lambda_vars : sep",
"lambda_vars : ',' SYMBOL lambda_vars",
"lambda_expr : LAMBDA SYMBOL lambda_vars cmnd",
"lambda_expr : LAMBDA '(' ')' sep cmnd",
"lambda_expr : LAMBDA '(' SYMBOL sym_list sep cmnd",
"expr : rx0",
"expr : lx0",
"rx0 : lx0 WHERE SYMBOL '=' rx1",
"rx0 : rx1",
"lx0 : lx0 WHERE SYMBOL '=' lx1",
"lx0 : lx1",
"rx1 : lx2 SETQ rx1",
"rx1 : rx2",
"lx1 : lx2 SETQ lx1",
"lx1 : lx2",
"rx2tail : rx3",
"rx2tail : lx3 OR rx2tail",
"rx2 : lx3 OR rx2tail",
"rx2 : rx3",
"lx2tail : lx3",
"lx2tail : lx3 OR lx2tail",
"lx2 : lx3 OR lx2tail",
"lx2 : lx3",
"rx3tail : rx4",
"rx3tail : lx4 AND rx3tail",
"rx3 : lx4 AND rx3tail",
"rx3 : rx4",
"lx3tail : lx4",
"lx3tail : lx4 AND lx3tail",
"lx3 : lx4 AND lx3tail",
"lx3 : lx4",
"rx4 : NOT rx4",
"rx4 : rx5",
"lx4 : NOT lx4",
"lx4 : lx5",
"rx5 : lx6 MEMBER ry6",
"rx5 : lx6 MEMQ ry6",
"rx5 : lx6 '=' ry6",
"rx5 : lx6 NEQ ry6",
"rx5 : lx6 EQ ry6",
"rx5 : lx6 GEQ ry6",
"rx5 : lx6 '>' ry6",
"rx5 : lx6 LEQ ry6",
"rx5 : lx6 '<' ry6",
"rx5 : lx6 FREEOF ry6",
"rx5 : rx6",
"lx5 : lx6 MEMBER ly6",
"lx5 : lx6 MEMQ ly6",
"lx5 : lx6 '=' ly6",
"lx5 : lx6 NEQ ly6",
"lx5 : lx6 EQ ly6",
"lx5 : lx6 GEQ ly6",
"lx5 : lx6 '>' ly6",
"lx5 : lx6 LEQ ly6",
"lx5 : lx6 '<' ly6",
"lx5 : lx6 FREEOF ly6",
"lx5 : lx6",
"ry6 : NOT ry6",
"ry6 : rx6",
"ly6 : NOT ly6",
"ly6 : lx6",
"rx6tail : ry6a",
"rx6tail : ly6a '+' rx6tail",
"rx6 : lx6a '+' rx6tail",
"rx6 : rx6a",
"lx6tail : ly6a",
"lx6tail : ly6a '+' lx6tail",
"lx6 : lx6a '+' lx6tail",
"lx6 : lx6a",
"ry6a : NOT ry6a",
"ry6a : rx6a",
"rx6a : lx6a '-' ry7",
"rx6a : rx7",
"ly6a : NOT ly6a",
"ly6a : lx6a",
"lx6a : lx6a '-' ly7",
"lx6a : lx7",
"ry7 : NOT ry7",
"ry7 : rx7",
"rx7 : '+' ry7",
"rx7 : '-' ry7",
"rx7 : rx8",
"ly7 : NOT ly7",
"ly7 : lx7",
"lx7 : '+' ly7",
"lx7 : '-' ly7",
"lx7 : lx8",
"rx8tail : ry9",
"rx8tail : ly9 '*' rx8tail",
"rx8 : lx9 '*' rx8tail",
"rx8 : rx9",
"lx8tail : ly9",
"lx8tail : ly9 '*' lx8tail",
"lx8 : lx9 '*' lx8tail",
"lx8 : lx9",
"ry9 : NOT ry9",
"ry9 : '+' ry9",
"ry9 : '-' ry9",
"ry9 : rx9",
"rx9 : lx9 '/' ry10",
"rx9 : rx10",
"ly9 : NOT ly9",
"ly9 : '+' ly9",
"ly9 : '-' ly9",
"ly9 : lx9",
"lx9 : lx9 '/' ly10",
"lx9 : lx10",
"ly10 : NOT ly10",
"ly10 : '+' ly10",
"ly10 : '-' ly10",
"ly10 : lx10",
"lx10 : lx11 '^' ly10",
"lx10 : lx11",
"ry10 : NOT ry10",
"ry10 : '+' ry10",
"ry10 : '-' ry10",
"ry10 : rx10",
"rx10 : lx11 '^' ry10",
"rx10 : rx11",
"ry11 : NOT ry11",
"ry11 : '+' ry11",
"ry11 : '-' ry11",
"ry11 : rx11",
"rx11 : x12 '.' ry11",
"rx11 : if_stmt",
"rx11 : for_stmt",
"rx11 : while_stmt",
"rx11 : repeat_stmt",
"rx11 : return_stmt",
"rx11 : goto_stmt",
"rx11 : lambda_expr",
"rx11 : proc_def",
"rx11 : ENDSTAT",
"ly11 : NOT ly11",
"ly11 : '+' ly11",
"ly11 : '-' ly11",
"ly11 : lx11",
"lx11 : x12 '.' ly11",
"lx11 : x12",
"arg_list : ')'",
"arg_list : ',' expr arg_list",
"parened : '(' expr ')'",
"commaparened : '(' expr ',' expr arg_list",
"x12notparened : x13b '[' expr ']'",
"x12notparened : x13b '(' ')'",
"x12notparened : x13b parened",
"x12notparened : x13b commaparened",
"x12notparened : x13b x12notparened",
"x12notparened : x13b",
"x12 : x12notparened",
"x12 : parened",
"x12 : SETQ commaparened",
"x12 : OR commaparened",
"x12 : AND commaparened",
"x12 : MEMBER commaparened",
"x12 : MEMQ commaparened",
"x12 : NEQ commaparened",
"x12 : EQ commaparened",
"x12 : GEQ commaparened",
"x12 : LEQ commaparened",
"x12 : FREEOF commaparened",
"x13b : SYMBOL",
"x13b : NUMBER",
"x13b : STRING",
"x13b : LIST",
"x13b : group_expr",
"x13b : block_expr",
};
#endif
#ifndef YYSTYPE
typedef int YYSTYPE;
#endif
#define YYLEX yylex()
#define YYEMPTY -1
#define yyclearin (yychar=(YYEMPTY))
#define yyerrok (yyerrflag=0)
#ifndef YYINITDEPTH
#define YYINITDEPTH 200
#endif
#ifdef YYSTACKSIZE
#ifndef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#endif
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 500
#define YYMAXDEPTH 500
#endif
#endif
#ifndef YYMAXSTACKSIZE
#define YYMAXSTACKSIZE 10000
#endif
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
YYSTYPE yyval;
YYSTYPE yylval;
static short *yyss;
static YYSTYPE *yyvs;
static int yystacksize;
#define yyfree(x) free(x)
extern int yylex();

static YYPTR
YYDEFUN (yymalloc, (bytes), unsigned bytes)
{
    YYPTR ptr = (YYPTR) malloc (bytes);
    if (ptr != 0) return (ptr);
    yyerror ("yyparse: memory exhausted");
    return (0);
}

static YYPTR
YYDEFUN (yyrealloc, (old, bytes), YYPTR old YYAND unsigned bytes)
{
    YYPTR ptr = (YYPTR) realloc (old, bytes);
    if (ptr != 0) return (ptr);
    yyerror ("yyparse: memory exhausted");
    return (0);
}

static int
#ifdef __GNUC__
__inline__
#endif
yygrow ()
{
    int old_stacksize = yystacksize;
    short *new_yyss;
    YYSTYPE *new_yyvs;

    if (yystacksize == YYMAXSTACKSIZE)
        return (1);
    yystacksize += (yystacksize + 1 ) / 2;
    if (yystacksize > YYMAXSTACKSIZE)
        yystacksize = YYMAXSTACKSIZE;
#if YYDEBUG
    if (yydebug)
        printf("yydebug: growing stack size from %d to %d\n",
               old_stacksize, yystacksize);
#endif
    new_yyss = (short *) yyrealloc ((char *)yyss, yystacksize * sizeof (short));
    if (new_yyss == 0)
        return (1);
    new_yyvs = (YYSTYPE *) yyrealloc ((char *)yyvs, yystacksize * sizeof (YYSTYPE));
    if (new_yyvs == 0)
    {
        yyfree (new_yyss);
        return (1);
    }
    yyss = new_yyss;
    yyvs = new_yyvs;
    return (0);
}
#line 1287 "r2l.y"



static keyword_code operators[] =
    {
       {"plus",                -1},
       {"minus",               -1},
       {"getv",                -1},
       {"difference",          -1},
       {"times",               -1},
       {"quotient",            -1},
       {"expt",                -1},
       {"cons",                -1},
       {"list",                -1},
       {"progn",               -1},
       {"prog",                -1},
       {"de",                  -1},
       {"dm",                  -1},
       {"ds",                  -1},
       {"greaterp",            -1},
       {"lessp",               -1},
       {"equal",               -1},
       {"setq",                SETQ},
       {"and",                 AND},
       {"or",                  OR},
       {"not",                 NOT},
       {"member",              MEMBER},
       {"memq",                MEMQ},
       {"neq",                 NEQ},
       {"eq",                  EQ},
       {"geq",                 GEQ},
       {"leq",                 LEQ},
       {"freeof",              FREEOF},
       {"symbolic",            SYMBOLIC},
       {"algebraic",           ALGEBRAIC},
       {"expr",                EXPR},
       {"macro",               MACRO},
       {"smacro",              SMACRO},
       {"procedure",           PROCEDURE},
       {"for",                 FOR},
       {"step",                STEP},
       {"until",               UNTIL},
       {"each",                EACH},
       {"foreach",             FOREACH},
       {"in",                  IN},
       {"on",                  ON},
       {"do",                  DO},
       {"collect",             COLLECT},
       {"sum",                 SUM},
       {"if",                  IF},
       {"then",                THEN},
       {"else",                ELSE},
       {"repeat",              REPEAT},
       {"while",               WHILE},
       {"begin",               BEGIN},
       {"end",                 END},
       {":lsect",              LSECT},
       {":rsect",              RSECT},
       {"go",                  GO},
       {"to",                  TO},
       {"goto",                GOTO},
       {"scalar",              SCALAR},
       {"integer",             INTEGER},
       {"lambda",              LAMBDA},
       {":symbol",             SYMBOL},
       {":number",             NUMBER},
       {":string",             STRING},
       {":list",               LIST},
       {"return",              RETURN},
       {"where",               WHERE},
       {"rlistat",             RLISTAT},
       {"endstat",             ENDSTAT},
       {"!#if",                HASHIF},
       {"!#else",              HASHELSE},
       {"!#elif",              HASHELIF},
       {"!#endif",             HASHENDIF},
       {NULL,                  0}
    };

int skipcomment()
{
    if (ch == '%')
    {   while (ch != '\n' && ch != -1) nextch();
        return 1;
    }
    else return 0;
}

static int onechar(int c)
{
    char b[4];
    b[0] = c;
    b[1] = 0;
    return find_symbol(b);
}

int lisp_token()
{
    char buffer[1000];
    int bp = 0, num = 0, r;
    while (isspace(ch) || skipcomment()) nextch();
    num = isdigit(ch);
    while (isalpha(ch) || isdigit(ch) || ch=='_' || ch == '!' ||
           (num && ch == '.'))
    {   buffer[bp++] = ch;
        if (ch == '!')
        {   buffer[bp++] = nextch();
        }
        nextch();
    }
    buffer[bp] = 0;
    if (bp != 0)
    {   yylval = find_symbol((char *)buffer);
        return num ? '0': 'a';
    }
    if (ch == '"')
    {   for (;;)
        {   buffer[bp++] = ch;
            while (nextch() != '"' && ch != '\n' && ch != EOF)
                buffer[bp++] = ch;
            buffer[bp++] = ch;
            if (nextch() != '"') break;
        }
        buffer[bp] = 0;
        yylval = find_symbol((char *)buffer);
        return '"';
    }
    if (ch == '\'' || ch == '(' || ch == ')' || ch == '.')
    {   r = ch;
        nextch();
        return r;
    }
    r = ch;
    nextch();
    return onechar(r);
}


static int read_tail();
/*
 *    L  ->  atom
 *    L  ->  ' L
 *    L  ->  ( T
 *    L  ->  . error
 *    L  ->  ) error
 *
 *    T  ->  )
 *    T  ->  . L )
 *    T  ->  L T
 *
 */

static int read_list(int r)
{
    switch (r)
    {
case '(': return read_tail();

case '.':
case ')': return C_nil;   /* errors! */

case '\'':
          return list2(find_symbol("quote"), read_list(lisp_token()));
default:
          return yylval;
    }
}

int read_tail()
{
    int r;
    switch (r = lisp_token())
    {
case ')': return C_nil;
case '.': r = read_list(lisp_token());
          if (lisp_token() != ')') fprintf(stderr, "\nBad syntax after '.'\n");
          return r;
case '\'':
          r = list2(find_symbol("quote"), read_list(lisp_token()));
          return cons(r, read_tail());
case '(': r = read_list(r);
          return cons(r, read_tail());
default:  r = yylval;
          return cons(r, read_tail());
    }
}


static int skipping = 0;

static int genuine_yylex();

static int evaluates_to_true(int r)
{
    int fn, arg;
    char *s, *v;
    if (r == C_nil) return 0;
    else if (atom(r))
    {   s = (char *)r;
        v = lookup_name(s-1);
        if (v == NULL) return 0;
        else return 1;
    }
    fn = qcar(r);
    r = qcdr(r);
    if (fn == C_nil || !atom(fn)) return 0;
    s = (char *)fn;
    if (strcmp(s-1, "and") == 0)
    {   while (r != C_nil && !atom(r))
        {   arg = qcar(r);
            r = qcdr(r);
            if (!evaluates_to_true(arg)) return 0;
        }
        return 1;
    }
    else if (strcmp(s-1, "or") == 0)
    {   while (r != C_nil && !atom(r))
        {   arg = qcar(r);
            r = qcdr(r);
            if (evaluates_to_true(arg)) return 1;
        }
        return 0;
    }
    else if (strcmp(s-1, "not") == 0)
        return !evaluates_to_true(qcar(r));
    else return 0; /* junk treated as false! */
}


static void skip_tokens()
{
    int r;
    skipping = 1;
    for (;;)
    {   r = genuine_yylex();
        switch (r)
        {
    case HASHIF:
            skipping++;
            continue;
    case HASHELSE:
            if (skipping == 1)
            {   skipping = 0;
                return;
            }
            else continue;
    case HASHELIF:
            if (skipping == 1)
            {   skipping = 0;
                r = read_list(lisp_token());
                if (evaluates_to_true(r)) return;
                skipping = 1;
                continue;
            }
            else continue;
    case HASHENDIF:
            skipping--;
            if (skipping == 0) return;
            else continue;
    default:continue;
        }
    }
}

static int genuine_yylex()
{
    char buffer[1000];
    int bp, num, r;
restart_lex:
    bp = 0;
    num = 0;
    while (isspace(ch) || skipcomment()) nextch();
    if (ch == -1)
    {   if (skipping)
        {   printf("\n+++ EOF while within !#if\n");
            exit(1);
        }
        return ENDFILE;
    }
    num = isdigit(ch);
    while (isalpha(ch) || isdigit(ch) || ch=='_' || ch == '!' ||
           (num && ch == '.'))
    {   buffer[bp++] = ch;
        if (ch == '!')
        {   buffer[bp++] = nextch();
        }
        nextch();
    }
    buffer[bp] = 0;
    if (bp != 0)
    {   int k;
        for (k=0;;k++)
        {   char *n = operators[k].name;
            int v = operators[k].code;
            if (n == NULL) break;
            if (v < 0) continue;
            if (strcmp(n, buffer) == 0)
            {
                switch (v)
                {
            case HASHIF:
                    if (skipping != 0) return v;
                    r = read_list(lisp_token());
                    if (!evaluates_to_true(r)) skip_tokens();
                    goto restart_lex;
            case HASHELSE:
            case HASHELIF:
                    if (skipping != 0) return v;
                    skip_tokens();
                    goto restart_lex;
            case HASHENDIF:
                    if (skipping != 0) return v;
                    else goto restart_lex; /* Ignore it! */
            default:break;
                }
                return v;
            }
        }
        yylval = find_symbol((char *)buffer);
        return num ? NUMBER : SYMBOL;
    }
    if (ch == '"')
    {   for (;;)
        {   buffer[bp++] = ch;
            while (nextch() != '"' && ch != EOF && ch != '\n')
                buffer[bp++] = ch;
            buffer[bp++] = ch;
            if (nextch() != '"') break;
        }
        buffer[bp] = 0;
        yylval = find_symbol((char *)buffer);
        return STRING;
    }
    if (ch == '\'')
    {   nextch();
        r = read_list(lisp_token());
        yylval = list2(find_symbol("quote"), r);
        return LIST;
    }
    r = ch;
    nextch();
    if (r == ':' && ch == '=') { nextch(); r = SETQ; }
    else if (r == '<' && ch == '=') { nextch(); r = LEQ; }
    else if (r == '>' && ch == '=') { nextch(); r = GEQ; }
    else if (r == '<' && ch == '<') { nextch(); r = LSECT; }
    else if (r == '>' && ch == '>') { nextch(); r = RSECT; }
    return r;
}


static int yylex()
{
    return genuine_yylex();
}


/* end of file */
#line 2175 "r2l.c"
#define YYABORT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab

#if YYDEBUG
#ifdef __cplusplus
extern "C" char *getenv();
#else
extern char *getenv();
#endif
#endif

int
yyparse()
{
    register int yym, yyn, yystate;
    register YYSTYPE *yyvsp;
    register short *yyssp;
    short *yysse;
#if YYDEBUG
    register YYCONST char *yys;

    if (yys = getenv("YYDEBUG"))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);

    if (yyss == 0)
    {
        yyss = (short *) yymalloc (YYSTACKSIZE * sizeof (short));
        if (yyss == 0)
          goto yyabort;
        yyvs = (YYSTYPE *) yymalloc (YYSTACKSIZE * sizeof (YYSTYPE));
        if (yyvs == 0)
        {
            yyfree (yyss);
            goto yyabort;
        }
        yystacksize = YYSTACKSIZE;
    }
    yysse = yyss + yystacksize - 1;
    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;
    goto yyloop;

yypush_lex:
    yyval = yylval;
    yystate = yytable[yyn];
yypush:
    if (yyssp >= yysse)
    {
        int depth = yyssp - yyss;
        if (yygrow() != 0)
             goto yyoverflow;
        yysse = yyss + yystacksize -1;
        yyssp = depth + yyss;
        yyvsp = depth + yyvs;
    }
    *++yyssp = yystate;
    *++yyvsp = yyval;

yyloop:
    if (yyn = yydefred[yystate]) goto yyreduce;
    yyn = yysindex[yystate];
    if (yychar < 0)
    {
        if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("yydebug: state %d, reading %d (%s)\n", yystate,
                    yychar, yys);
        }
#endif
    }
    if (yyn != 0
        && ((yyn += yychar), ((unsigned)yyn <= (unsigned)YYTABLESIZE))
        && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("yydebug: state %d, shifting to state %d\n",
                    yystate, yytable[yyn]);
#endif
        if (yyerrflag > 0)  --yyerrflag;
        yychar = (-1);
        goto yypush_lex;
    }
    yyn = yyrindex[yystate];
    if (yyn != 0
        && ((yyn += yychar), ((unsigned)yyn <= (unsigned)YYTABLESIZE))
        && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;
#ifdef lint
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#ifdef lint
    goto yyerrlab;
#endif
yyerrlab:
    ++yynerrs;
yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            yyn = yysindex[*yyssp];
            if (yyn != 0
                && ((yyn += YYERRCODE), ((unsigned)yyn <= (unsigned)YYTABLESIZE))
                && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("yydebug: state %d, error recovery shifting\
 to state %d\n", *yyssp, yytable[yyn]);
#endif
                goto yypush_lex;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("yydebug: error recovery discarding state %d\n",
                            *yyssp);
#endif
                if (yyssp <= yyss) goto yyabort;
                --yyssp;
                --yyvsp;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("yydebug: state %d, error recovery discards token %d (%s)\n",
                    yystate, yychar, yys);
        }
#endif
        yychar = (-1);
        goto yyloop;
    }
yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("yydebug: state %d, reducing by rule %d (%s)\n",
                yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    yyval = yyvsp[1-yym];
    switch (yyn)
    {
case 1:
#line 809 "r2l.y"
{  
    if (common) fprintf(outputfile, "\n;; end of file\n");
    else fprintf(outputfile, "\n%% end of file\n");
    exit(0);
                                        }
break;
case 3:
#line 816 "r2l.y"
{ evalorprint(yyvsp[-1]); 
					  fprintf(outputfile, "\n\n");
                                          otlpos = 0;
                                          heapfringe = 0;
					}
break;
case 9:
#line 830 "r2l.y"
{ yyval = sym_symbolic; }
break;
case 10:
#line 831 "r2l.y"
{ yyval = sym_algebraic; }
break;
case 11:
#line 834 "r2l.y"
{ yyval = sym_de; }
break;
case 12:
#line 835 "r2l.y"
{ yyval = sym_dm; }
break;
case 13:
#line 836 "r2l.y"
{ yyval = sym_ds; }
break;
case 14:
#line 839 "r2l.y"
{ yyval = C_nil; }
break;
case 15:
#line 840 "r2l.y"
{ yyval = cons(yyvsp[-1], yyvsp[0]); }
break;
case 16:
#line 848 "r2l.y"
{ yyval = sym_setq; }
break;
case 17:
#line 849 "r2l.y"
{ yyval = sym_or; }
break;
case 18:
#line 850 "r2l.y"
{ yyval = sym_and; }
break;
case 19:
#line 851 "r2l.y"
{ yyval = sym_member; }
break;
case 20:
#line 852 "r2l.y"
{ yyval = sym_memq; }
break;
case 21:
#line 853 "r2l.y"
{ yyval = sym_equal; }
break;
case 22:
#line 854 "r2l.y"
{ yyval = sym_neq; }
break;
case 23:
#line 855 "r2l.y"
{ yyval = sym_eq; }
break;
case 24:
#line 856 "r2l.y"
{ yyval = sym_geq; }
break;
case 25:
#line 857 "r2l.y"
{ yyval = sym_greaterp; }
break;
case 26:
#line 858 "r2l.y"
{ yyval = sym_leq; }
break;
case 27:
#line 859 "r2l.y"
{ yyval = sym_lessp; }
break;
case 28:
#line 860 "r2l.y"
{ yyval = sym_freeof; }
break;
case 29:
#line 861 "r2l.y"
{ yyval = sym_plus; }
break;
case 30:
#line 862 "r2l.y"
{ yyval = sym_difference; }
break;
case 31:
#line 863 "r2l.y"
{ yyval = sym_times; }
break;
case 32:
#line 864 "r2l.y"
{ yyval = sym_quotient; }
break;
case 33:
#line 865 "r2l.y"
{ yyval = sym_expt; }
break;
case 34:
#line 866 "r2l.y"
{ yyval = sym_cons; }
break;
case 35:
#line 869 "r2l.y"
{ yyval = sym_not; }
break;
case 36:
#line 870 "r2l.y"
{ yyval = sym_plus; }
break;
case 37:
#line 871 "r2l.y"
{ yyval = sym_minus; }
break;
case 38:
#line 874 "r2l.y"
{ yyval = cons(yyvsp[0], C_nil); }
break;
case 39:
#line 875 "r2l.y"
{ yyval = list2(yyvsp[-1], yyvsp[0]); }
break;
case 40:
#line 876 "r2l.y"
{ yyval = cons(yyvsp[-2], C_nil); }
break;
case 41:
#line 878 "r2l.y"
{ yyval = cons(yyvsp[-3], cons(yyvsp[-1], yyvsp[0])); }
break;
case 42:
#line 879 "r2l.y"
{ yyval = list2(yyvsp[-1], yyvsp[0]); }
break;
case 43:
#line 880 "r2l.y"
{ yyval = list3(yyvsp[-1], yyvsp[-2], yyvsp[0]); }
break;
case 44:
#line 884 "r2l.y"
{ yyval = list4(sym_de, qcar(yyvsp[-2]), qcdr(yyvsp[-2]), yyvsp[0]); }
break;
case 45:
#line 886 "r2l.y"
{ yyval = list4(sym_de, qcar(yyvsp[-2]), qcdr(yyvsp[-2]), yyvsp[0]); }
break;
case 46:
#line 888 "r2l.y"
{ yyval = list4(yyvsp[-4], qcar(yyvsp[-2]), qcdr(yyvsp[-2]), yyvsp[0]); }
break;
case 47:
#line 890 "r2l.y"
{ yyval = list4(yyvsp[-4], qcar(yyvsp[-2]), qcdr(yyvsp[-2]), yyvsp[0]); }
break;
case 49:
#line 894 "r2l.y"
{ yyval = sym_in; }
break;
case 50:
#line 895 "r2l.y"
{ yyval = sym_on; }
break;
case 51:
#line 898 "r2l.y"
{ yyval = cons(yyvsp[0], C_nil); }
break;
case 52:
#line 899 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 54:
#line 908 "r2l.y"
{ yyval = list2(yyvsp[-1], cons(sym_list, yyvsp[0])); }
break;
case 55:
#line 918 "r2l.y"
{ yyval = list4(sym_if, yyvsp[-4], yyvsp[-2], yyvsp[0]); }
break;
case 56:
#line 919 "r2l.y"
{ yyval = list3(sym_if, yyvsp[-2], yyvsp[0]); }
break;
case 57:
#line 922 "r2l.y"
{ yyval = cons(find_symbol("1"), yyvsp[0]); }
break;
case 58:
#line 923 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 59:
#line 926 "r2l.y"
{ yyval = sym_do; }
break;
case 60:
#line 927 "r2l.y"
{ yyval = sym_sum; }
break;
case 61:
#line 928 "r2l.y"
{ yyval = sym_collect; }
break;
case 62:
#line 931 "r2l.y"
{ yyval = sym_in; }
break;
case 63:
#line 932 "r2l.y"
{ yyval = sym_on; }
break;
case 64:
#line 936 "r2l.y"
{ yyval = make_for(yyvsp[-5], yyvsp[-3], qcar(yyvsp[-2]), qcdr(yyvsp[-2]), yyvsp[-1], yyvsp[0]); }
break;
case 65:
#line 938 "r2l.y"
{ yyval = make_foreach(yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); }
break;
case 66:
#line 940 "r2l.y"
{ yyval = make_foreach(yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); }
break;
case 67:
#line 943 "r2l.y"
{
       int lab1 = genlabel();
       yyval = list6(sym_prog, C_nil, lab1,
                  list3(sym_if, list2(sym_null, yyvsp[-2]), list2(sym_return, C_nil)),
                  yyvsp[0],
                  list2(sym_go, lab1)); }
break;
case 68:
#line 951 "r2l.y"
{
       int lab1 = genlabel();
       yyval = list5(sym_prog, C_nil, lab1,
                  yyvsp[-2],
                  list3(sym_if, list2(sym_null, yyvsp[0]), list2(sym_go, lab1))); }
break;
case 69:
#line 958 "r2l.y"
{ yyval = list2(sym_return, C_nil); }
break;
case 70:
#line 959 "r2l.y"
{ yyval = list2(sym_return, yyvsp[0]); }
break;
case 71:
#line 962 "r2l.y"
{ yyval = list2(sym_go, yyvsp[0]); }
break;
case 72:
#line 963 "r2l.y"
{ yyval = list2(sym_go, yyvsp[0]); }
break;
case 73:
#line 964 "r2l.y"
{ yyval = list2(sym_go, yyvsp[0]); }
break;
case 74:
#line 967 "r2l.y"
{ yyval = C_nil; }
break;
case 75:
#line 968 "r2l.y"
{ yyval = C_nil; }
break;
case 76:
#line 969 "r2l.y"
{ yyval = cons(yyvsp[-1], yyvsp[0]); }
break;
case 77:
#line 972 "r2l.y"
{ yyval = cons(sym_progn, cons(yyvsp[-1], yyvsp[0])); }
break;
case 78:
#line 975 "r2l.y"
{ yyval = C_nil; }
break;
case 79:
#line 977 "r2l.y"
{ yyval = cons(yyvsp[-1], yyvsp[0]); }
break;
case 80:
#line 979 "r2l.y"
{ yyval = cons(yyvsp[-1], yyvsp[0]); }
break;
case 81:
#line 983 "r2l.y"
{ yyval = cons(yyvsp[-1], yyvsp[0]); }
break;
case 82:
#line 985 "r2l.y"
{ yyval = cons(yyvsp[-1], yyvsp[0]); }
break;
case 84:
#line 990 "r2l.y"
{ yyval = append(yyvsp[-1], yyvsp[0]); }
break;
case 85:
#line 993 "r2l.y"
{ yyval = C_nil; }
break;
case 86:
#line 994 "r2l.y"
{ yyval = cons(yyvsp[-1], C_nil); }
break;
case 87:
#line 995 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 88:
#line 996 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 89:
#line 997 "r2l.y"
{ yyval = yyvsp[0]; }
break;
case 90:
#line 1001 "r2l.y"
{ yyval = cons(sym_prog, cons(yyvsp[-1], yyvsp[0])); }
break;
case 91:
#line 1002 "r2l.y"
{ yyval = cons(sym_prog, cons(C_nil, yyvsp[0])); }
break;
case 92:
#line 1005 "r2l.y"
{ yyval = C_nil; }
break;
case 93:
#line 1007 "r2l.y"
{ yyval = cons(yyvsp[-1], yyvsp[0]); }
break;
case 94:
#line 1011 "r2l.y"
{ yyval = list3(sym_lambda, ncons(yyvsp[-2]), yyvsp[-1]); }
break;
case 95:
#line 1013 "r2l.y"
{ yyval = list3(sym_lambda, C_nil, yyvsp[0]); }
break;
case 96:
#line 1015 "r2l.y"
{ yyval = list3(sym_lambda, cons(yyvsp[-3], yyvsp[-2]), yyvsp[0]); }
break;
case 99:
#line 1028 "r2l.y"
{ yyval = make_where(yyvsp[-4], yyvsp[-2], yyvsp[0]); }
break;
case 101:
#line 1033 "r2l.y"
{ yyval = make_where(yyvsp[-4], yyvsp[-2], yyvsp[0]); }
break;
case 103:
#line 1037 "r2l.y"
{ yyval = list3(sym_setq, yyvsp[-2], yyvsp[0]); }
break;
case 105:
#line 1041 "r2l.y"
{ yyval = list3(sym_setq, yyvsp[-2], yyvsp[0]); }
break;
case 107:
#line 1045 "r2l.y"
{ yyval = ncons(yyvsp[0]); }
break;
case 108:
#line 1046 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 109:
#line 1048 "r2l.y"
{ yyval = cons(sym_or, cons(yyvsp[-2], yyvsp[0])); }
break;
case 111:
#line 1052 "r2l.y"
{ yyval = ncons(yyvsp[0]); }
break;
case 112:
#line 1053 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 113:
#line 1055 "r2l.y"
{ yyval = cons(sym_or, cons(yyvsp[-2], yyvsp[0])); }
break;
case 115:
#line 1059 "r2l.y"
{ yyval = ncons(yyvsp[0]); }
break;
case 116:
#line 1060 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 117:
#line 1062 "r2l.y"
{ yyval = cons(sym_and, cons(yyvsp[-2], yyvsp[0])); }
break;
case 119:
#line 1066 "r2l.y"
{ yyval = ncons(yyvsp[0]); }
break;
case 120:
#line 1067 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 121:
#line 1069 "r2l.y"
{ yyval = cons(sym_and, cons(yyvsp[-2], yyvsp[0])); }
break;
case 123:
#line 1073 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 125:
#line 1077 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 127:
#line 1081 "r2l.y"
{ yyval = list3(sym_member, yyvsp[-2], yyvsp[0]); }
break;
case 128:
#line 1082 "r2l.y"
{ yyval = list3(sym_memq, yyvsp[-2], yyvsp[0]); }
break;
case 129:
#line 1083 "r2l.y"
{ yyval = list3(sym_equal, yyvsp[-2], yyvsp[0]); }
break;
case 130:
#line 1084 "r2l.y"
{ yyval = list3(sym_neq, yyvsp[-2], yyvsp[0]); }
break;
case 131:
#line 1085 "r2l.y"
{ yyval = list3(sym_eq, yyvsp[-2], yyvsp[0]); }
break;
case 132:
#line 1086 "r2l.y"
{ yyval = list3(sym_geq, yyvsp[-2], yyvsp[0]); }
break;
case 133:
#line 1087 "r2l.y"
{ yyval = list3(sym_greaterp, yyvsp[-2], yyvsp[0]); }
break;
case 134:
#line 1088 "r2l.y"
{ yyval = list3(sym_leq, yyvsp[-2], yyvsp[0]); }
break;
case 135:
#line 1089 "r2l.y"
{ yyval = list3(sym_lessp, yyvsp[-2], yyvsp[0]); }
break;
case 136:
#line 1090 "r2l.y"
{ yyval = list3(sym_freeof, yyvsp[-2], yyvsp[0]); }
break;
case 138:
#line 1094 "r2l.y"
{ yyval = list3(sym_member, yyvsp[-2], yyvsp[0]); }
break;
case 139:
#line 1095 "r2l.y"
{ yyval = list3(sym_memq, yyvsp[-2], yyvsp[0]); }
break;
case 140:
#line 1096 "r2l.y"
{ yyval = list3(sym_equal, yyvsp[-2], yyvsp[0]); }
break;
case 141:
#line 1097 "r2l.y"
{ yyval = list3(sym_neq, yyvsp[-2], yyvsp[0]); }
break;
case 142:
#line 1098 "r2l.y"
{ yyval = list3(sym_eq, yyvsp[-2], yyvsp[0]); }
break;
case 143:
#line 1099 "r2l.y"
{ yyval = list3(sym_geq, yyvsp[-2], yyvsp[0]); }
break;
case 144:
#line 1100 "r2l.y"
{ yyval = list3(sym_greaterp, yyvsp[-2], yyvsp[0]); }
break;
case 145:
#line 1101 "r2l.y"
{ yyval = list3(sym_leq, yyvsp[-2], yyvsp[0]); }
break;
case 146:
#line 1102 "r2l.y"
{ yyval = list3(sym_lessp, yyvsp[-2], yyvsp[0]); }
break;
case 147:
#line 1103 "r2l.y"
{ yyval = list3(sym_freeof, yyvsp[-2], yyvsp[0]); }
break;
case 149:
#line 1107 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 151:
#line 1111 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 153:
#line 1115 "r2l.y"
{ yyval = ncons(yyvsp[0]); }
break;
case 154:
#line 1116 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 155:
#line 1118 "r2l.y"
{ yyval = cons(sym_plus, cons(yyvsp[-2], yyvsp[0])); }
break;
case 157:
#line 1122 "r2l.y"
{ yyval = ncons(yyvsp[0]); }
break;
case 158:
#line 1123 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 159:
#line 1125 "r2l.y"
{ yyval = cons(sym_plus, cons(yyvsp[-2], yyvsp[0])); }
break;
case 161:
#line 1129 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 163:
#line 1133 "r2l.y"
{ yyval = list3(sym_difference, yyvsp[-2], yyvsp[0]); }
break;
case 165:
#line 1137 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 167:
#line 1141 "r2l.y"
{ yyval = list3(sym_difference, yyvsp[-2], yyvsp[0]); }
break;
case 169:
#line 1145 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 171:
#line 1149 "r2l.y"
{ yyval = yyvsp[0]; }
break;
case 172:
#line 1150 "r2l.y"
{ yyval = list2(sym_minus, yyvsp[0]); }
break;
case 174:
#line 1154 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 176:
#line 1158 "r2l.y"
{ yyval = yyvsp[0]; }
break;
case 177:
#line 1159 "r2l.y"
{ yyval = list2(sym_minus, yyvsp[0]); }
break;
case 179:
#line 1163 "r2l.y"
{ yyval = ncons(yyvsp[0]); }
break;
case 180:
#line 1164 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 181:
#line 1166 "r2l.y"
{ yyval = cons(sym_times, cons(yyvsp[-2], yyvsp[0])); }
break;
case 183:
#line 1170 "r2l.y"
{ yyval = ncons(yyvsp[0]); }
break;
case 184:
#line 1171 "r2l.y"
{ yyval = cons(yyvsp[-2], yyvsp[0]); }
break;
case 185:
#line 1173 "r2l.y"
{ yyval = cons(sym_times, cons(yyvsp[-2], yyvsp[0])); }
break;
case 187:
#line 1177 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 188:
#line 1178 "r2l.y"
{ yyval = yyvsp[0]; }
break;
case 189:
#line 1179 "r2l.y"
{ yyval = list2(sym_minus, yyvsp[0]); }
break;
case 191:
#line 1183 "r2l.y"
{ yyval = list3(sym_quotient, yyvsp[-2], yyvsp[0]); }
break;
case 193:
#line 1187 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 194:
#line 1188 "r2l.y"
{ yyval = yyvsp[0]; }
break;
case 195:
#line 1189 "r2l.y"
{ yyval = list2(sym_minus, yyvsp[0]); }
break;
case 197:
#line 1193 "r2l.y"
{ yyval = list3(sym_quotient, yyvsp[-2], yyvsp[0]); }
break;
case 199:
#line 1197 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 200:
#line 1198 "r2l.y"
{ yyval = yyvsp[0]; }
break;
case 201:
#line 1199 "r2l.y"
{ yyval = list2(sym_minus, yyvsp[0]); }
break;
case 203:
#line 1203 "r2l.y"
{ yyval = list3(sym_expt, yyvsp[-2], yyvsp[0]); }
break;
case 205:
#line 1207 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 206:
#line 1208 "r2l.y"
{ yyval = yyvsp[0]; }
break;
case 207:
#line 1209 "r2l.y"
{ yyval = list2(sym_minus, yyvsp[0]); }
break;
case 209:
#line 1213 "r2l.y"
{ yyval = list3(sym_expt, yyvsp[-2], yyvsp[0]); }
break;
case 211:
#line 1217 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 212:
#line 1218 "r2l.y"
{ yyval = yyvsp[0]; }
break;
case 213:
#line 1219 "r2l.y"
{ yyval = list2(sym_minus, yyvsp[0]); }
break;
case 215:
#line 1223 "r2l.y"
{ yyval = list3(sym_cons, yyvsp[-2], yyvsp[0]); }
break;
case 224:
#line 1232 "r2l.y"
{ yyval = ncons(yyvsp[0]); }
break;
case 225:
#line 1235 "r2l.y"
{ yyval = list2(sym_not, yyvsp[0]); }
break;
case 226:
#line 1236 "r2l.y"
{ yyval = yyvsp[0]; }
break;
case 227:
#line 1237 "r2l.y"
{ yyval = list2(sym_minus, yyvsp[0]); }
break;
case 229:
#line 1241 "r2l.y"
{ yyval = list3(sym_cons, yyvsp[-2], yyvsp[0]); }
break;
case 231:
#line 1245 "r2l.y"
{ yyval = C_nil; }
break;
case 232:
#line 1246 "r2l.y"
{ yyval = cons(yyvsp[-1], yyvsp[0]); }
break;
case 233:
#line 1249 "r2l.y"
{ yyval = yyvsp[-1]; }
break;
case 234:
#line 1252 "r2l.y"
{ yyval = cons(yyvsp[-3], cons(yyvsp[-1],yyvsp[0])); }
break;
case 235:
#line 1255 "r2l.y"
{ yyval = list3(sym_getv, yyvsp[-3], yyvsp[-1]); }
break;
case 236:
#line 1256 "r2l.y"
{ yyval = cons(yyvsp[-2], C_nil); }
break;
case 237:
#line 1257 "r2l.y"
{ yyval = cons(yyvsp[-1], cons(yyvsp[0], C_nil)); }
break;
case 238:
#line 1258 "r2l.y"
{ yyval = cons(yyvsp[-1], yyvsp[0]); }
break;
case 239:
#line 1259 "r2l.y"
{ yyval = list2(yyvsp[-1], yyvsp[0]); }
break;
case 241:
#line 1263 "r2l.y"
{ yyval = yyvsp[0]; }
break;
case 242:
#line 1264 "r2l.y"
{ yyval = yyvsp[0]; }
break;
case 243:
#line 1265 "r2l.y"
{ yyval = cons(sym_setq, yyvsp[0]); }
break;
case 244:
#line 1266 "r2l.y"
{ yyval = cons(sym_or, yyvsp[0]); }
break;
case 245:
#line 1267 "r2l.y"
{ yyval = cons(sym_and, yyvsp[0]); }
break;
case 246:
#line 1268 "r2l.y"
{ yyval = cons(sym_member, yyvsp[0]); }
break;
case 247:
#line 1269 "r2l.y"
{ yyval = cons(sym_memq, yyvsp[0]); }
break;
case 248:
#line 1270 "r2l.y"
{ yyval = cons(sym_neq, yyvsp[0]); }
break;
case 249:
#line 1271 "r2l.y"
{ yyval = cons(sym_eq, yyvsp[0]); }
break;
case 250:
#line 1272 "r2l.y"
{ yyval = cons(sym_geq, yyvsp[0]); }
break;
case 251:
#line 1273 "r2l.y"
{ yyval = cons(sym_leq, yyvsp[0]); }
break;
case 252:
#line 1274 "r2l.y"
{ yyval = cons(sym_freeof, yyvsp[0]); }
break;
#line 3148 "r2l.c"
    }
    yyssp -= yym;
    yyvsp -= yym;
    yym = yylhs[yyn];
    yystate = *yyssp;
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("yydebug: after reduction, shifting from state 0 to\
 state %d\n", YYFINAL);
#endif
        yystate = YYFINAL;
        *++yyssp = YYFINAL;
        *++yyvsp = yyval;
        if (yychar < 0)
        {
            if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("yydebug: state %d, reading %d (%s)\n",
                        YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    yyn = yygindex[yym];
	 if (yyn != 0
        && ((yyn += yystate), ((unsigned)yyn <= (unsigned)YYTABLESIZE))
        && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("yydebug: after reduction, shifting from state %d \
to state %d\n", *yyssp, yystate);
#endif
    goto yypush;
yyoverflow:
    yyerror("yacc stack overflow");
yyabort:
    return (1);
yyaccept:
    return (0);
}