#include <perms.h>
const int NO = 0;
const int YES = 1;
const int SETUP = 1;
const int INSTREAM = 2;
const int OUTSTREAM = 3;
const int SSDATAFILETYPE = 4;
const int MARKER = 'LISP';
const int DEFAULTLINELENGTH = 80;
const int MAXLEVEL = 15;
const int LONGBASE = 256;
const int LONGTAIL = 511;
const int NAMEBASE = 512;
const int NAMETAIL = 2047;
const int STACKBASE = 1024;
const int STACKTAIL = 2047;
const int SHORTBASE = 2048;
const int SHORTTAIL = 4095;
const int LISTBASE = 4096;
const int LISTTAIL = 0x7fff;
const int ATOMBASE = 256;
const int CHARBASE = 1919;
const int ZEROBASE = 3072;
const int PNAMEMAX = 8191;
const int T = 2003;
const int PERCENT = 1956;
const int NIL = 512;
const int QUOTE = 513;
const int LABEL = 514;
const int LAMBDA = 515;
const int APVAL = 516;
const int SUBR = 517;
const int FSUBR = 518;
const int EXPR = 519;
const int FEXPR = 520;
const int EXIT = 521;
const int EVLN = 0x8000 | 522;
const int STARS = 523;
const int ERROR = 0;
const int ERROR1 = 1;
const int ERROR2 = 2;
const int ERROR3 = 3;
const int ESCAPE = 0x88;
const int EOF = 0x89;
const char MASK[FEXPR - APVAL + 1] = {3, 6, 2, 5, 1};
const char CODE[127 - 0 + 1] = {
    0x80,   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
    0x80,   0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
    0x80,   EOF,  0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x21, 0x22, 0x23,
    ESCAPE, 0x25, 0x26, 0x84, 0x81, 0x83, 0x2a, 0x2b, 0x2c, 0x2d, 0x82, ESCAPE,
    0x30,   0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
    0x3c,   0x3d, 0x3e, 0x3f, 0x84, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
    0x48,   0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53,
    0x54,   0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x85, 0x5c, 0x87, 0x5e, 0x5f,
    0x60,   0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
    0x6c,   0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
    0x78,   0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f};
const _imp_string SNL = _imp_str_literal("\n");
const _imp_string CHARX[7 - 0 + 1] = {
    _imp_str_literal(" "), _imp_str_literal("("), _imp_str_literal("."),
    _imp_str_literal(")"), _imp_str_literal("'"), _imp_str_literal("["),
    _imp_str_literal(" "), _imp_str_literal("]")};

typedef struct ATOMCELL {
  _imp_string *PNAME;
  char FORM;
  short BIND;
  short PROP;
  short FUNC;

} ATOMCELL;

typedef struct LISPCELL {
  short CAR;
  short CDR;

} LISPCELL;

typedef struct LISPINFO {
  int DATAEND;
  int DATASTART;
  int FILESIZE;
  int FILETYPE;
  int SUM;
  int DATETIME;
  int FORMAT;
  int RECORDS;
  int MARKER;
  int CONST;
  int LONGHEAD;
  int PNAMESPACE;
  int PNAMEBASE;
  int PNAMEHEAD;
  int NAME;
  int NAMEHEAD;
  int STACK;
  int GLOBAL;
  int LIST;
  int LISTHEAD;
  int LISTCOUNT;
  int LINELENGTH;

} LISPINFO;

typedef struct RF {
  int CONAD;
  int FILETYPE;
  int DATASTART;
  int DATAEND;

} RF;

typedef struct STACKFRAME {
  short BACK;
  short BIND;
  short LINK;

} STACKFRAME;
static int CONSTF[LONGTAIL - LONGBASE + 1];
static STACKFRAME STACKF[STACKTAIL - STACKBASE + 1];
static LISPCELL LISTF[LISTTAIL - 0 + 1];
static ATOMCELL NAMEF[NAMETAIL - NAMEBASE + 1];
static char PNAMEF[PNAMEMAX - 0 + 1];
/*system*/ void CONNECT(_imp_string FILE, int MODE, int HOLE, int PROT, RF *R,
                        int *FLAG);                           /*system*/
void DEFINE(int CHAN, _imp_string IDEN, int *AFD, int *FLAG); /*system*/
_imp_string FAILUREMESSAGE(int MESS);                         /*system*/
_imp_string ITOS(int N);                                      /*system*/
void OUTFILE(_imp_string FILE, int SIZE, int HOLE, int PROT, int *CONAD,
             int *FLAG);
extern void PROMPT(_imp_string S); /*system*/
void SETFNAME(_imp_string S);
extern void SETRETURNCODE(int I);
static int AUXP;
static int ERRVAL;
static int INFILE;
static int OUTF;
static int CHAR;
static int RESET;
static int FRONT;
static int PNAMETAIL;
static int PROGFLAG;
static int LOCAL;
static int NILLIST;
static int *LISTCOUNT;
static int *LISTHEAD;
static int *LONGHEAD;
static int *PNAMEHEAD;
static int *GLOBAL;
static int *NAMEHEAD;
static int *LINELENGTH;
static _imp_string PMPT;
static _imp_string PLABEL;
static _imp_string LINE;
static _imp_string CLAUSE;
static _imp_string PSPACES;
static int *CONST;
static LISPINFO *LISPFILE;
static ATOMCELL *NAME;
static LISPCELL *LIST;
static STACKFRAME *STACK;
static int AUXS[1023 - 0 + 1];
static char BLANKS[255 - 0 + 1] = {' '};
static _imp_string ERRORS = _imp_str_literal("Error");
static int EVAL(int FORM);
static int FUNC(ATOMCELL *ATOM, int ARGS);
static void LOOP(_imp_string PMPT, int TERM);
static int PUSH(int INDEX) {
  _imp_enter();
  AUXS[AUXP] = INDEX;
  AUXP = AUXP + 1;
  return (INDEX);
  _imp_leave();
}
static int POP(int INDEX) {
  _imp_enter();
  AUXP = AUXP - 1;
  return (INDEX);
  _imp_leave();
}
static _imp_string PNAME(int INDEX) {
  _imp_enter();
  if (INDEX >= LONGBASE) {
    if (INDEX >= NAMEBASE) {
      if (INDEX >= SHORTBASE) return (ITOS(INDEX - ZEROBASE));
      if (INDEX >= CHARBASE) return (TOSTRING(INDEX - CHARBASE));
      return (NAME.PNAME);

    } else
      return (ITOS(CONST));

  } else
    return (ERRORS);
  _imp_leave();
}
static _imp_string PACK(int INDEX) {
  _imp_enter();
  int CAR;
  _imp_string PACKED;
  PACKED = _imp_str_literal("");
  while (INDEX >= LISTBASE) {
    CAR = LIST.CAR;
    INDEX = LIST.CDR;
    if (CAR >= LISTBASE)
      PACKED = _imp_join(PACKED, PACK(CAR));
    else
      PACKED = _imp_join(PACKED, PNAME);
  }
  if (INDEX != NIL) PACKED = _imp_join(PACKED, PNAME);
  return (PACKED);
  _imp_leave();
}
static int NUMBERP(int *VALUE) {
  _imp_enter();
  if (LONGBASE <= VALUE && VALUE <= LONGTAIL) {
    *VALUE = CONST;
    return (T);
  }
  if (SHORTBASE <= VALUE && VALUE <= SHORTTAIL) {
    *VALUE = VALUE - ZEROBASE;
    return (T);
  }
  return (NIL);
  _imp_leave();
}
static int EQUAL(int ARG1, int ARG2) {
  _imp_enter();
  if (ARG1 == ARG2 ||
      (NUMBERP(ARG1) == T && T == NUMBERP(ARG2) && ARG1 == ARG2) ||
      (ARG1 >= LISTBASE && ARG2 >= LISTBASE && EQUAL(LIST.CAR, LIST.CAR) == T &&
       EQUAL(LIST.CDR, LIST.CDR) == T))
    return (T);
  return (NIL);
  _imp_leave();
}
static int MNUMB(int VALUE) {
  _imp_enter();
  int INDEX;
  if (-1024 <= VALUE && VALUE <= 1023) return (VALUE + ZEROBASE);
  if (LONGBASE > LONGHEAD || LONGHEAD > LONGTAIL) {
    PRINTSTRING(_imp_join(
        SNL, _imp_join(_imp_str_literal(
                           "Atom error:   No more room for long constants"),
                       SNL)));
    return (ERROR);
  }
  INDEX = LONGBASE;
  while (INDEX != LONGHEAD) {
    if (CONST == VALUE) return (INDEX);
    INDEX = INDEX + 1;
  }
  LONGHEAD = LONGHEAD + 1;
  CONST = VALUE;
  return (INDEX);
  _imp_leave();
}
static int MATOM(_imp_string PNAME) {
  _imp_enter();
  int INDEX;
  ATOMCELL *ATOM;
  /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ if (() == 1) {
    return (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ CHARBASE + (() & 0x7f));
  }
  for (INDEX = NAMEBASE; INDEX != NAMEHEAD - 1 + 1; INDEX += 1) {
    if (PNAME == NAME.PNAME) return (INDEX);
  }
  /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ if (NAMEHEAD >= CHARBASE ||
                                                PNAMEHEAD + () + 1 >=
                                                    PNAMETAIL) {
    PRINTSTRING(_imp_join(
        SNL,
        _imp_join(_imp_str_literal("Atom error:   No more space for names"),
                  SNL)));
    return (ERROR);
  }
  ATOM = &NAME; /*ERROR: name_sym_idx is -1!*/    /*C_NAME*/
  ATOM->PNAME = &; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  PNAMEHEAD = PNAMEHEAD + () + 1;
  ATOM->PNAME = PNAME;
  INDEX = NAMEHEAD;
  NAMEHEAD = NAMEHEAD + 1;
  return (INDEX);
  _imp_leave();
}
static int RATOM(void) {
  _imp_enter();
  int TYPE;
  int SIGN;
  int VALUE;
  int TSIGN;
  _imp_string PNAME;
  TYPE = 0;
  VALUE = 0;
  SIGN = +1;
  TSIGN = +1;
  PNAME = _imp_str_literal("");
  for (;;) {
    if ((CHAR & 0x80) != 0) {
      if (PNAME != _imp_str_literal("")) {
        if (TYPE < 2) return (MATOM(PNAME));
        return (MNUMB(VALUE));
      }
      VALUE = CHAR & 0x7f;
      if (CHAR != 0x80) {
        CHAR = 0x80;
        return (VALUE);
      }

    } else {
      if (0 <= TYPE && TYPE <= 2) {
        if ('0' <= CHAR && CHAR <= '9') {
          TYPE = 2;
          if (SIGN == -1) {
            VALUE = -VALUE;
            SIGN = +1;
          }
          VALUE = VALUE * 10 + (CHAR - '0') * TSIGN;

        } else {
          if (TYPE == 0 && (CHAR == '+' || CHAR == '-')) {
            TYPE = 1;
            if (CHAR == '-') {
              SIGN = -1;
              TSIGN = -1;
            }

          } else
            TYPE = -1;
        }

      } /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      PNAME = _imp_join(PNAME, );
    }
    do {
      READCH(CHAR);
      CHAR = CODE[CHAR & 0x7f];
      if (CHAR == EOF) SELECTINPUT(0);
    } while (CHAR == EOF);
    if (CHAR == ESCAPE) {
      READCH(CHAR);
    }
  }

  _imp_leave();
}
static void PRINTCHARS(_imp_string PHRASE) {
  _imp_enter();
  int ADJUSTMENT;
  if (PLABEL != _imp_str_literal("")) {
    PHRASE = _imp_join(PLABEL, PHRASE);
    PLABEL = _imp_str_literal("");
  }
  if (PHRASE == _imp_str_literal("")) {
    /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
    /*C_NAME*/ if (() + () < LINELENGTH) {
      /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
      /*C_NAME*/;

    } else /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is
                                                        -1!*/
        /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/    /*C_NAME*/
      ;
    LINE = _imp_str_literal("");
    CLAUSE = _imp_str_literal("");

  } /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
  /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/   /*C_NAME*/
  if (() + () + () >= LINELENGTH) {
    /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
    /*C_NAME*/ ADJUSTMENT = () - ();
    if (ADJUSTMENT < 0) {
      if (LINE != _imp_str_literal("")) /*ERROR: name_sym_idx is -1!*/
          /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
        ; /*ERROR: name_sym_idx is -1!*/            /*C_NAME*/
            /*ERROR: name_sym_idx is -1!*/          /*C_NAME*/
      ;
      LINE = _imp_str_literal("");
      CLAUSE = _imp_str_literal("");

    } else /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      ADJUSTMENT;
  }
  CLAUSE = _imp_join(CLAUSE, PHRASE);
  _imp_leave();
}
static void PRINT(int INDEX) {
  _imp_enter();
  int LEVEL;
  int CLEVEL;
  int ADJUSTMENT;
  int I;
  char RFLAG;
  char CCOUNT;
  char RCOUNT;
  char LINE1;
  int LINEPOS[MAXLEVEL - 0 + 1];
  auto _imp_string PADDING(void) {
    _imp_enter();
    int INDEX;
    int COUNT;
    if (LEVEL < MAXLEVEL + 1)
      INDEX = LEVEL;
    else
      INDEX = MAXLEVEL; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    COUNT = LINEPOS[INDEX] - ();
    if (COUNT > LINELENGTH) COUNT = LINELENGTH;
    if (COUNT < 0) COUNT = 0;
    BLANKS[0] = COUNT;
    return (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
            /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/);
    _imp_leave();
  }
  auto void LPAREN(void) {
    _imp_enter();
    int I;
    if (LEVEL <= MAXLEVEL && LINEPOS[LEVEL] == 0) {
      /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
      /*C_NAME*/ LINEPOS[LEVEL] = () + ();

    } /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
    /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/   /*C_NAME*/
    /*ERROR: name_sym_idx is -1!*/              /*C_NAME*/
    if (50 < () && () > LINEPOS[LEVEL] || () > 30 || (() > 20 && () > 20))
      CCOUNT = 10;
    if (RFLAG > 0 || CCOUNT >= 10) {
      /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
      /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ if (() + () > LINELENGTH ||
                                                    () - () > 25 ||
                                                    CCOUNT >= 2) {
        if (LEVEL > CLEVEL) {
          /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
          /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ ADJUSTMENT = () - ();
          for (I = CLEVEL + 1; I != LEVEL + 1; I += 1) {
            LINEPOS[I] = LINEPOS[I] - ADJUSTMENT;
          }
        }
        if (LINE != _imp_str_literal("")) /*ERROR: name_sym_idx is -1!*/
            /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
          ;
        LINE = _imp_join(PSPACES, CLAUSE);
        LINE1 = 0;

      } else
        LINE = _imp_join(LINE, CLAUSE);
      CCOUNT = RCOUNT;
      CLAUSE = _imp_str_literal("");
      CLEVEL = LEVEL;
      PSPACES = PADDING();
    }
    if (LINE1 == 0) LEVEL = LEVEL + 1;
    RFLAG = 0;
    RCOUNT = 0;
    PRINTCHARS(_imp_str_literal("("));
    _imp_leave();
  }
  auto void RPAREN(void) {
    _imp_enter();
    PRINTCHARS(_imp_str_literal(")"));
    if (0 < LEVEL && LEVEL <= MAXLEVEL) LINEPOS[LEVEL] = 0;
    if (LEVEL > 0) LEVEL = LEVEL - 1;
    RFLAG = 1;
    RCOUNT = RCOUNT + 1;
    _imp_leave();
  }
  auto void PRINTSEXP(int INDEX) {
    _imp_enter();
    int CAR;
    int CDR;
    LISPCELL *CELL;
    if (INDEX >= LISTBASE) {
      CELL = &LIST;
      CAR = CELL->CAR;
      CDR = CELL->CDR;
      LPAREN();
      PRINTSEXP(CAR);
      if (CDR >= LISTBASE) {
        for (;;) {
          INDEX = CDR;
          CELL = &LIST;
          CAR = CELL->CAR;
          CDR = CELL->CDR;
          if (PLABEL == _imp_str_literal("")) PRINTCHARS(_imp_str_literal(" "));
          if (CDR < LISTBASE) break;
          if (CAR == NIL) {
            LPAREN();
            PRINTCHARS(_imp_str_literal(" "));
            RPAREN();

          } else
            PRINTSEXP(CAR);
        }
        PRINTSEXP(CAR);
      }
      if (CDR != NIL) {
        PRINTCHARS(_imp_str_literal(" . "));
      }
      RPAREN();

    } else {
      if (RFLAG == 1) {
        RFLAG = 2;
        PLABEL = _imp_join(PNAME, _imp_str_literal(" "));

      } else {
        PRINTCHARS(PNAME);
        RFLAG = 0;
      }
    }

    _imp_leave();
  }
  LINE1 = 1;
  RFLAG = 0;
  CCOUNT = 0;
  RCOUNT = 0;
  PSPACES = _imp_str_literal("");
  LEVEL = 0;
  CLEVEL = 0;
  LINEPOS[0] = 4;
  for (I = 1; I != MAXLEVEL + 1; I += 1) LINEPOS[I] = 0;
  PRINTSEXP(INDEX);
  _imp_leave();
}
static void MARK(int INDEX) {
  _imp_enter();
  short *CAR;
  while (INDEX >= LISTBASE && LIST.CAR >= 0) {
    CAR = &LIST.CAR;
    INDEX = LIST.CDR;
    *CAR = CAR | 0x8000;
    if ((CAR & 0x7fff) >= LISTBASE) MARK(CAR & 0x7fff);
  }

  _imp_leave();
}
static void GARBAGECOLLECT(void) {
  _imp_enter();
  LISPCELL *CELL;
  int I;
  for (I = NAMEBASE; I != NAMEHEAD - 1 + 1; I += 1) MARK(NAME.PROP);
  for (I = CHARBASE; I != NAMETAIL + 1; I += 1) MARK(NAME.PROP);
  for (I = STACKBASE; I != FRONT + 1; I += 1) MARK(STACK.BIND);
  for (I = GLOBAL; I != STACKTAIL + 1; I += 1) MARK(STACK.BIND);
  if (AUXP > 0) {
    for (I = 0; I != AUXP - 1 + 1; I += 1) MARK(AUXS[I]);
  }
  LISTCOUNT = 0;
  LISTHEAD = 0;
  for (I = LISTBASE; I != LISTTAIL + 1; I += 1) {
    CELL = &LIST;
    if (CELL->CAR < 0)
      CELL->CAR = CELL->CAR & 0x7fff;
    else {
      LISTCOUNT = LISTCOUNT + 1;
      CELL->CAR = LISTHEAD;
      LISTHEAD = I;
    }
  }

  _imp_leave();
}
static int CONS(int CAR, int CDR) {
  _imp_enter();
  int INDEX;
  int DUMMY;
  LISPCELL *CELL;
  if (LISTCOUNT <= 100 || LISTHEAD < LISTBASE) {
    DUMMY = PUSH(CAR);
    DUMMY = PUSH(CDR);
    AUXP = AUXP + 2;
    GARBAGECOLLECT();
    AUXP = AUXP - 2;
    if (LISTCOUNT <= 1000) {
      /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
      /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/;
      LOOP(_imp_str_literal("Free:"), PERCENT);
    }
  }
  if (LISTHEAD < LISTBASE) {
    /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
    /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/;
    return (ERROR);
  }
  LISTCOUNT = LISTCOUNT - 1;
  INDEX = LISTHEAD;
  CELL = &LIST;
  LISTHEAD = CELL->CAR;
  CELL->CAR = CAR;
  CELL->CDR = CDR;
  return (INDEX);
  _imp_leave();
}
static int REVERSE(int CURR) {
  _imp_enter();
  int LAST;
  LISPCELL *CELL;
  LAST = NIL;
  while (CURR >= LISTBASE) {
    CELL = &LIST;
    LAST = CONS(CELL->CAR, LAST);
    CURR = CELL->CDR;
  }
  return (LAST);
  _imp_leave();
}
static int READSEXP(_imp_string PMPT) {
  _imp_enter();
  auto int CELL(int CAR);
  auto int HEAD(void);
  auto int TAIL(void);
  int COLAPSE;
  auto int CELL(int CAR) {
    _imp_enter();
    int CDR;
    if (CAR >= ATOMBASE) {
      AUXS[AUXP] = CAR;
      AUXP = AUXP + 1;
      CDR = TAIL();
      AUXP = AUXP - 1;
      if (CDR >= ATOMBASE) return (CONS(CAR, CDR));
    }
    return (ERROR);
    _imp_leave();
  }
  auto int HEAD(void) {
    _imp_enter();
    int TEMP;
    int RES;
    static void *SW[3 - 0 + 1] = {
        /* These need to be filled in from associated code block */};
    TEMP = RATOM();
    if (TEMP >= ATOMBASE) return (TEMP);
    goto *SW[TEMP & 3];
  SW_0:;
    return (CONS(QUOTE, CONS(HEAD(), NIL)));
  SW_1:;
    RES = TAIL();
    if (TEMP >= 4) COLAPSE = NO;
    return (RES);
  SW_2:;
  SW_3:;
       /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
       /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    ;
    return (ERROR);
    _imp_leave();
  }
  auto int TAIL(void) {
    _imp_enter();
    int TEMP;
    int RES;
    static void *SW[3 - 0 + 1] = {
        /* These need to be filled in from associated code block */};
    if (COLAPSE == YES) return (NIL);
    TEMP = RATOM();
    if (TEMP >= ATOMBASE) return (CELL(TEMP));
    goto *SW[TEMP & 3];
  SW_0:;
    return (CELL(CONS(QUOTE, CONS(HEAD(), NIL))));
  SW_1:;
    RES = TAIL();
    if (TEMP >= 4) COLAPSE = NO;
    return (CELL(RES));
  SW_2:;
    TEMP = HEAD();
    if (TAIL() == NIL)
      return (TEMP);
          /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is
                                                       -1!*/
          /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    ;
    return (ERROR);
  SW_3:;
    if (TEMP >= 4) COLAPSE = YES;
    return (NIL);
    _imp_leave();
  }
  COLAPSE = NO; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  ;
  return (HEAD());
  _imp_leave();
}
static void LOOP(_imp_string PMPT, int TERM) {
  _imp_enter();
  int VALUE;
  for (;;) {
    RESET = 0;
    VALUE = EVAL(READSEXP(PMPT));
    if (VALUE == TERM) break;
    if (RESET == 0) {
      PRINT(VALUE);
    }
  }

  _imp_leave();
}
static int PCONS(int CAR, int CDR) {
  _imp_enter();
  AUXP = AUXP - 1;
  return (CONS(CAR, CDR));
  _imp_leave();
}
static void XPRINT(_imp_string MESS, int FORM) {
  _imp_enter();
  _imp_string SAVE;
  SAVE = LINE;
  LINE = MESS;
  PRINT(FORM);
  PRINTCHARS(_imp_str_literal(""));
  LINE = SAVE;
  _imp_leave();
}
static void BIND(int SYMB, int ENTRY, int BIND) {
  _imp_enter();
  ATOMCELL *ATOM;
  STACKFRAME *FRAME;
  if (NAMEBASE > SYMB || SYMB >= LISTBASE) {
    /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
    /*C_NAME*/;
    XPRINT(_imp_str_literal(""), SYMB);
    {
      _imp_leave();
      return;
    }
  }
  if (NAME.FORM == 3) {
    /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ XPRINT(
        _imp_join(
            , _imp_str_literal(
                  "Bind error:   Name list entry has constant binding, name=")),
        SYMB);
    {
      _imp_leave();
      return;
    }
  }
  if (GLOBAL <= FRONT) {
    /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
    /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/;
    {
      _imp_leave();
      return;
    }
  }
  FRAME = &STACK;
  ATOM = &NAME;
  if (BIND < ATOMBASE) {
    /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
    /*C_NAME*/;
    XPRINT(_imp_str_literal(""), SYMB);
    BIND = ERROR;
  }
  FRAME->BIND = BIND;
  FRAME->BACK = SYMB;
  FRAME->LINK = ATOM->BIND;
  ATOM->BIND = ENTRY;
  _imp_leave();
}
static void BINDLIST(int *NAMES, int *ARGS) {
  _imp_enter();
  LISPCELL *CELL;
  LISPCELL *ARGC;
  STACK.LINK = LOCAL;
  STACK.BACK = 0;
  LOCAL = FRONT;
  FRONT = FRONT + 1;
  while (NAMES >= LISTBASE) {
    CELL = &LIST;
    ARGC = &LIST;
    BIND;
    FRONT = FRONT + 1;
    *NAMES = CELL->CDR;
    ARGS = ARGC->CDR;
  }

  _imp_leave();
}
static int UNBIND(int RESULT) {
  _imp_enter();
  STACKFRAME *FRAME;
  while (FRONT > LOCAL) {
    FRONT = FRONT - 1;
    FRAME = &STACK;
    if (FRAME->BACK > 0) NAME.BIND = FRAME->LINK;
  }
  FRONT = LOCAL;
  LOCAL = STACK.LINK;
  return (RESULT);
  _imp_leave();
}
static int PROG(int NAMES, int BODY) {
  _imp_enter();
  int PROGLIST;
  int RESULT;
  LISPCELL *CELL;
  BINDLIST(NAMES, NILLIST);
  PROGFLAG = PROGFLAG + 4;
  PROGLIST = BODY;
  while (BODY >= LISTBASE) {
    CELL = &LIST;
    if (CELL->CAR >= LISTBASE) {
      RESULT = EVAL(CELL->CAR);
      if ((PROGFLAG & 3) != 0) {
        if ((PROGFLAG & 1) != 0) {
          PROGFLAG = (PROGFLAG & (~3)) - 4;
          return (UNBIND(RESULT));
        }
        CELL = &LIST;
        PROGFLAG = PROGFLAG & (~3);
        while (CELL->CAR != RESULT) {
          if (CELL->CDR < LISTBASE) {
            PROGFLAG = PROGFLAG - 4;
            return (UNBIND(ERROR));
          }
          CELL = &LIST;
        }
      }
    }
    BODY = CELL->CDR;
  }
  PROGFLAG = PROGFLAG - 4;
  return (UNBIND(RESULT));
  _imp_leave();
}
static int EVLIST(int ARGS) {
  _imp_enter();
  LISPCELL *CELL;
  if (ARGS < LISTBASE) return (ARGS);
  CELL = &LIST;
  return (PCONS(PUSH(EVAL(CELL->CAR)), EVLIST(CELL->CDR)));
  _imp_leave();
}
static int APPLY(int FUNCTION, int ARGS) {
  _imp_enter();
  int CAR;
  int CADR;
  int CADDR;
  LISPCELL *CELL;
  if (FUNCTION >= LISTBASE) {
    CELL = &LIST;
    CAR = CELL->CAR;
    CELL = &LIST;
    CADR = CELL->CAR;
    CELL = &LIST;
    CADDR = CELL->CAR;
    if (CAR == LABEL) {
      BIND;
      FRONT = FRONT + 1;
      return (APPLY(CADDR, ARGS));
    }
    if (CAR == LAMBDA) {
      BINDLIST(CADR, ARGS);
      if (CADR != NIL) {
        BIND;
      }
      return (UNBIND(EVAL(CADDR)));
    }
    return (APPLY(EVAL(FUNCTION), ARGS));
  }
  if (NAMEBASE <= FUNCTION && FUNCTION <= NAMETAIL) {
    return (FUNC);
  }
  return (ERROR);
  _imp_leave();
}
static int PUT(int ATOM, int BIND, int PROP) {
  _imp_enter();
  int ID;
  short *HOLE;
  LISPCELL *PROPCELL;
  LISPCELL *BINDCELL;
  if (NAMEBASE > ATOM || ATOM > NAMETAIL || NAMEBASE > PROP ||
      PROP > NAMETAIL) {
    return (ERROR3);
  }
  HOLE = &NAME.PROP;
  for (;;) {
    if (HOLE < LISTBASE) {
      *HOLE = CONS(PROP, CONS(BIND, NIL));
      break;
    }
    PROPCELL = &LIST;
    BINDCELL = &LIST;
    if (PROPCELL->CAR == PROP) {
      BINDCELL->CAR = BIND;
      break;
    }
    HOLE = &BINDCELL->CDR;
  }
  if (APVAL <= PROP && PROP <= FEXPR) {
    NAME.FORM = MASK[PROP];
    if (SUBR <= PROP && PROP <= FSUBR) {
      ID = BIND;
      if (NUMBERP(ID) != T) return (ERROR3);
      NAME.FUNC = ID;

    } else
      NAME.FUNC = BIND;
  }
  return (BIND);
  _imp_leave();
}
static int FUNC(ATOMCELL *ATOM, int ARGS) {
  _imp_enter();
  int ARG1;
  int ARG2;
  int ARG3;
  int SYMB;
  int AFD;
  int FLAG;
  _imp_string LINE;
  short *HOLE;
  LISPCELL *CELL;
  STACKFRAME *FRAME;
  static void *TYPE[3 - 0 + 1] = {
      /* These need to be filled in from associated code block */};
  static void *FUNC[86 - 0 + 1] = {
      /* These need to be filled in from associated code block */};
  goto *TYPE[ATOM->FORM & 3];
TYPE_3:;
TYPE_0:;
  if (ATOM->BIND >= GLOBAL) return (ERROR2);
  FRONT = FRONT + 1;
  ARGS = EVLIST(ARGS);
  FRONT = FRONT - 1;
  return (APPLY(STACK.BIND, ARGS));
TYPE_1:;
  return (APPLY(ATOM->FUNC, ARGS));
TYPE_2:;
  CELL = &LIST;
  ARG1 = CELL->CAR;
  CELL = &LIST;
  ARG2 = CELL->CAR;
  CELL = &LIST;
  ARG3 = CELL->CAR;
  goto *FUNC[ATOM->FUNC];
FUNC_0:;
  return (ARG1);
FUNC_1:;
  return (LIST.CAR);
FUNC_2:;
  return (LIST.CDR);
FUNC_3:;
  return (LIST.CAR);
FUNC_4:;
  return (LIST.CAR);
FUNC_5:;
  return (LIST.CDR);
FUNC_6:;
  return (LIST.CDR);
FUNC_7:;
  return (CONS(ARG1, ARG2));
FUNC_8:;
  return (ARGS);
FUNC_9:;
  while (ARGS >= LISTBASE) {
    CELL = &LIST;
    ARG1 = EVAL(CELL->CAR);
    if (ARG1 != NIL) {
      while (CELL->CDR >= LISTBASE) {
        CELL = &LIST;
        ARG1 = EVAL(CELL->CAR);
      }
      return (ARG1);
    }
    ARGS = LIST.CDR;
  }
  return (NIL);
FUNC_10:;
  while (ARGS >= LISTBASE) {
    CELL = &LIST;
    if (EVAL(CELL->CAR) == NIL) return (NIL);
    ARGS = CELL->CDR;
  }
  return (T);
FUNC_11:;
  while (ARGS >= LISTBASE) {
    CELL = &LIST;
    if (EVAL(CELL->CAR) != NIL) return (T);
    ARGS = CELL->CDR;
  }
  return (NIL);
FUNC_12:;
  if (ARG1 == NIL)
    return (T);
  else
    return (NIL);
FUNC_13:;
  if (ATOMBASE <= ARG1 && ARG1 < LISTBASE)
    return (T);
  else
    return (NIL);
FUNC_14:;
  return (NUMBERP(ARG1));
FUNC_56:;
  if (NUMBERP(ARG1) == T && (ARG1 & 1) == 0) return (T);
  return (NIL);
FUNC_55:;
  ARG1 = ARG1 - 1;
FUNC_15:;
  if (ARG1 == ZEROBASE)
    return (T);
  else
    return (NIL);
FUNC_16:;
  if (ARG1 == ARG2)
    return (T);
  else
    return (NIL);
FUNC_17:;
  return (EQUAL(ARG1, ARG2));
FUNC_18:;
  if (NUMBERP(ARG1) == T && T == NUMBERP(ARG2) && ARG1 < ARG2)
    return (T);
  else
    return (NIL);
FUNC_19:;
  if (NUMBERP(ARG1) == T && T == NUMBERP(ARG2) && ARG1 > ARG2)
    return (T);
  else
    return (NIL);
FUNC_20:;
  while (ARG2 >= LISTBASE) {
    CELL = &LIST;
    if (ARG1 == CELL->CAR) return (T);
    ARG2 = CELL->CDR;
  }
  return (NIL);
FUNC_21:;
  while (ARG2 >= LISTBASE) {
    CELL = &LIST;
    if (EQUAL(ARG1, CELL->CAR) == T) return (T);
    ARG2 = CELL->CDR;
  }
  return (NIL);
FUNC_22:;
  while (ARG2 >= LISTBASE) {
    CELL = &LIST;
    if (EQUAL(ARG1, LIST.CAR) == T) return (CELL->CAR);
    ARG2 = CELL->CDR;
  }
  return (NIL);
FUNC_23:;
  ARG1 = 0;
  while (ARGS >= LISTBASE) {
    CELL = &LIST;
    ARG2 = CELL->CAR;
    if (NUMBERP(ARG2) == T)
      ARG1 = ARG1 + ARG2;
    else
      return (ERROR3);
    ARGS = CELL->CDR;
  }
  return (MNUMB(ARG1));
FUNC_24:;
  if (NUMBERP(ARG1) != T) return (ERROR3);
  while (ARGS >= LISTBASE) {
    CELL = &LIST;
    ARG2 = CELL->CAR;
    if (NUMBERP(ARG2) == T)
      ARG1 = ARG1 - ARG2;
    else
      return (ERROR3);
    ARGS = CELL->CDR;
  }
  return (MNUMB(ARG1));
FUNC_25:;
  ARG1 = 1;
  while (ARGS >= LISTBASE) {
    CELL = &LIST;
    ARG2 = CELL->CAR;
    if (NUMBERP(ARG2) == T)
      ARG1 = ARG1 * ARG2;
    else
      return (ERROR3);
    ARGS = CELL->CDR;
  }
  return (MNUMB(ARG1));
FUNC_26:;
  if (NUMBERP(ARG1) != T) return (ERROR3);
  while (ARGS >= LISTBASE) {
    CELL = &LIST;
    ARG2 = CELL->CDR;
    if (NUMBERP(ARG2) == T)
      ARG1 = ARG1 / ARG2;
    else
      return (ERROR3);
    ARGS = CELL->CDR;
  }
  return (MNUMB(ARG1));
FUNC_27:;
  if (NUMBERP(ARG1) == T) return (MNUMB(ARG1 + 1));
  return (ERROR3);
FUNC_28:;
  if (NUMBERP(ARG1) == T) return (MNUMB(ARG1 - 1));
  return (ERROR3);
FUNC_29:;
  if (NUMBERP(ARG1) == T)
    return (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ MNUMB());
  return (ERROR3);
FUNC_30:;
  ARG1 = EVAL(ARG1);
  ARGS = LIST.CDR;
  for (;;) {
    ARG3 = ARGS;
    ARGS = LIST.CDR;
    if (ARGS < LISTBASE) break;
    CELL = &LIST;
    ARG2 = CELL->CAR;
    ARG3 = CELL->CDR;
    while (ARG2 >= LISTBASE) {
      CELL = &LIST;
      if (CELL->CAR == ARG1) goto EXIT;
      ARG2 = CELL->CDR;
    }
    if (ARG2 == ARG1) break;
  }

EXIT:;
  while (ARG3 >= LISTBASE) {
    CELL = &LIST;
    ARG1 = EVAL(CELL->CAR);
    ARG3 = CELL->CDR;
  }
  return (ARG1);
FUNC_31:;
  return (PUT(ARG1, ARG3, ARG2));
FUNC_32:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL) return (ERROR3);
  return (NAME.PROP);
FUNC_33:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL || NAMEBASE > ARG2 || ARG2 > NAMETAIL)
    return (ERROR3);
  ATOM = &NAME;
  HOLE = &ATOM->PROP;
  while (HOLE >= LISTBASE) {
    CELL = &LIST;
    if (CELL->CAR == ARG2) {
      CELL = &LIST;
      if (CELL->CAR == ATOM->FUNC) ATOM->FORM = 0;
      *HOLE = CELL->CDR;
      return (T);
    }
    HOLE = &LIST.CDR;
  }
  return (NIL);
FUNC_34:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL || NAMEBASE > ARG2 || ARG2 > NAMETAIL)
    return (ERROR3);
  ARGS = NAME.PROP;
  while (ARGS >= LISTBASE) {
    CELL = &LIST;
    if (CELL->CAR == ARG2) return (LIST.CAR);
    ARGS = LIST.CDR;
  }
  return (NIL);
FUNC_35:;
  return (PUT(ARG1, ARG2, ARG3));
FUNC_36:;
  return (EVAL(ARG1));
FUNC_37:;
  return (EVLIST(ARGS));
FUNC_38:;
  return (APPLY(ARG1, ARG2));
FUNC_39:;
  ARG1 = CONS(EVAL(ARG1), NIL);
  if (RESET == 2) {
    ARG1 = ERRVAL;
    RESET = 0;
  }
  return (ARG1);
FUNC_40:;
  if (ARG1 < LISTBASE) return (ERROR3);
  LIST.CAR = ARG2;
  return (ARG2);
FUNC_41:;
  if (ARG1 < LISTBASE) return (ERROR3);
  LIST.CDR = ARG2;
  return (ARG2);
FUNC_42:;
  if (ARG1 == NIL) return (ARG2);
  if (ARG1 < LISTBASE) return (ERROR3);
  ARGS = ARG1;
  while (LIST.CDR >= LISTBASE) ARG1 = LIST.CDR;
  LIST.CDR = ARG2;
  return (ARGS);
FUNC_43:;
  if (NUMBERP(ARG1) == T && ARG1 < 0) return (T);
  return (NIL);
FUNC_44:;
  ARG2 = EVAL(ARG2);
FUNC_45:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL) return (ERROR3);
  ARG3 = NAME.BIND;
  if (ARG3 < STACKTAIL) {
    STACK.BIND = ARG2;

  } else {
    GLOBAL = GLOBAL - 1;
    BIND;
  }
  return (ARG2);
FUNC_46:;
  if (ATOMBASE > ARG1 || ARG1 >= LISTBASE) return (ERROR3);
  LINE = PNAME;
  ARG2 = NIL;
  for (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/
       /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ ARG1 = () + ();
       ARG1 != () + 1 + -1; ARG1 += -1) {
    /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ SYMB = MISSING_RHS;
    if ('0' <= SYMB && SYMB <= '9')
      SYMB = ZEROBASE + SYMB - '0';
    else
      SYMB = CHARBASE + SYMB;
    ARG2 = CONS(SYMB, ARG2);
  }
  return (ARG2);
FUNC_47:;
  return (MATOM(PACK(ARG1)));
FUNC_48:;
  return (ARG2);
FUNC_49:;
  while (ARGS >= LISTBASE) {
    CELL = &LIST;
    ARG1 = EVAL(CELL->CAR);
    ARGS = CELL->CDR;
  }
  return (ARG1);
FUNC_50:;
  return (PROG(ARG1, LIST.CDR));
FUNC_51:;
  if (NUMBERP(ARG1) == T) return (MNUMB(-ARG1));
  return (ERROR3);
FUNC_52:;
  PROGFLAG = PROGFLAG | 1;
  return (ARG1);
FUNC_53:;
  PROGFLAG = PROGFLAG | 2;
  return (ARG1);
FUNC_54:;
  return (REVERSE(ARG1));
FUNC_60:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL) return (ERROR3);
  PMPT = PNAME;
  return (ARG1);
FUNC_61:;
  if (ATOMBASE <= ARG1 &&
      ARG1 < LISTBASE) /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    ;
  else /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    ; /*ERROR: name_sym_idx is -1!*/  /*C_NAME*/
  ;
  if ('0' <= SYMB && SYMB <= '9')
    return (MNUMB(SYMB - '0'));
  else
    return (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ MATOM());
FUNC_62:;
  if (ATOMBASE <= ARG1 && ARG1 < LISTBASE) return (READSEXP(PNAME));
  return (READSEXP(PMPT));
FUNC_63:;
  PRINT(ARG1);
  return (ARG1);
FUNC_64:;
  PRINT(ARG1);
  PRINTCHARS(_imp_str_literal(""));
  return (ARG1);
FUNC_65:;
  PRINTCHARS(_imp_str_literal(""));
  if (ARG1 < ATOMBASE) ARG1 = NIL;
  return (ARG1);
FUNC_66:;
  if (NUMBERP(ARG1) == T) { /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    ;
  }
  return (ERROR3);
FUNC_67:;
  if (NUMBERP(ARG1) == T) { /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    ;
  }
  return (ERROR3);
FUNC_68:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL)
    return (ERROR3); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  ; /*ERROR: name_sym_idx is -1!*/                  /*C_NAME*/
      /*ERROR: name_sym_idx is -1!*/                /*C_NAME*/
  ;
  ARG2 = INFILE;
  INFILE = ARG1; /*ERROR: name_sym_idx is -1!*/                   /*C_NAME*/
  DEFINE(, NAME.PNAME, AFD, FLAG); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      /*ERROR: name_sym_idx is -1!*/                              /*C_NAME*/
  ;
  return (ARG2);
FUNC_69:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL)
    return (ERROR3); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  ; /*ERROR: name_sym_idx is -1!*/                  /*C_NAME*/
      /*ERROR: name_sym_idx is -1!*/                /*C_NAME*/
  ;
  ARG2 = OUTF;
  OUTF = ARG1; /*ERROR: name_sym_idx is -1!*/                     /*C_NAME*/
  DEFINE(, NAME.PNAME, AFD, FLAG); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      /*ERROR: name_sym_idx is -1!*/                              /*C_NAME*/
  ;
  return (ARG2);
FUNC_70:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL) return (ERROR3);
  ATOM = &NAME;
  ATOM->FORM = ATOM->FORM | 8;
  return (ARG1);
FUNC_71:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL) return (ERROR3);
  ATOM = &NAME;
  ATOM->FORM = ATOM->FORM & (~8);
  return (ARG1);
FUNC_72:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL) return (ERROR3);
  NAME.FORM = NAME.FORM | 16;
  return (ARG1);
FUNC_73:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL) return (ERROR3);
  NAME.FORM = NAME.FORM & (~16);
  return (ARG1);
FUNC_74:;
  if (NAMEBASE > ARG1 || ARG1 > NAMETAIL) return (ERROR3);
  ATOM = &NAME;
  ATOM->BIND = STACKTAIL;
  ATOM->PROP = NIL;
  ATOM->FUNC = 0;
  ATOM->FORM = 0;
  return (ARG1);
FUNC_75:;
  if (NUMBERP(ARG1) == T && FRONT - ARG1 > STACKBASE)
    ARG1 = FRONT - ARG1;
  else
    ARG1 = STACKBASE;
  if (FRONT != ARG1) {
    for (ARG1 = FRONT - 1; ARG1 != ARG1 + -1; ARG1 += -1) {
      FRAME = &STACK;
      LINE = _imp_join(PNAME, _imp_str_literal("         "));
          /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      9;
      if ((FRAME->BACK & 0x8000) != 0)
        LINE = _imp_join(LINE, _imp_str_literal("* "));
      else
        LINE = _imp_join(LINE, _imp_str_literal("= "));
      XPRINT(LINE, FRAME->BIND);
    }
  }
  return (STARS);
FUNC_76:;
  if (ZEROBASE + 40 > ARG1 || ARG1 > ZEROBASE + 255) return (ERROR3);
  LINELENGTH = ARG1 - ZEROBASE;
  return (ARG1);
FUNC_77:;
  GARBAGECOLLECT();
  return (MNUMB(LISTCOUNT));
FUNC_78:;
  PMPT = _imp_str_literal("Read:");
  RESET = 1;
  ERRVAL = NIL;
  return (PERCENT);
FUNC_79:;
  ERRVAL = ARG1;
  RESET = 2;
  return (PERCENT);
FUNC_80:;
  ARG2 = NIL;
  for (ARG1 = NAMEHEAD - 1; ARG1 != NAMEBASE + -1; ARG1 += -1) {
    ARG2 = CONS(ARG1, ARG2);
  }
  return (ARG2);
FUNC_81:;
  ARG2 = NIL;
  ARG3 = NIL;
  for (ARG1 = STACKBASE; ARG1 != FRONT - 1 + 1; ARG1 += 1) {
    FRAME = &STACK;
    if (NAMEBASE <= FRAME->BACK && FRAME->BACK <= NAMETAIL)
      ARG2 = CONS(CONS(FRAME->BACK, FRAME->BIND), ARG2);
  }
  for (ARG1 = STACKTAIL - 1; ARG1 != GLOBAL + -1; ARG1 += -1) {
    FRAME = &STACK;
    ARG3 = CONS(CONS(FRAME->BACK, FRAME->BIND), ARG3);
  }
  return (CONS(ARG2, ARG3));
FUNC_82:;
  if (NUMBERP(ARG1) != T || 0 > ARG1 || ARG1 > 127) return (ERROR3);
  return (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ MATOM());
FUNC_83:;
  if (NUMBERP(ARG1) != T) return (ERROR3);
  while (ARGS >= LISTBASE) {
    CELL = &LIST;
    ARG2 = CELL->CAR;
    if (NUMBERP(ARG2) != T) return (ERROR3);
    if (ARG1 < ARG2) ARG1 = ARG2;
    ARGS = CELL->CDR;
  }
  return (MNUMB(ARG1));
FUNC_84:;
  if (NUMBERP(ARG1) != T) return (ERROR3);
  while (ARGS >= LISTBASE) {
    CELL = &LIST;
    ARG2 = CELL->CAR;
    if (NUMBERP(ARG2) != T) return (ERROR3);
    if (ARG2 < ARG1) ARG1 = ARG2;
    ARGS = CELL->CDR;
  }
  return (MNUMB(ARG1));
FUNC_85:;
  if (NUMBERP(ARG1) != T) return (ERROR3);
  return (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
          /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/);
FUNC_86:;
  if (NUMBERP(ARG1) != T || T != NUMBERP(ARG2)) return (ERROR3);
  return (MNUMB(IEXP(ARG1, ARG2)));
  _imp_leave();
}
static int TRACE(_imp_string MESS, int FORM) {
  _imp_enter();
  XPRINT(MESS, FORM);
  return (FORM);
  _imp_leave();
}
static int EVAL(int FORM) {
  _imp_enter();
  int CAR;
  int CDR;
  LISPCELL *CELL;
  ATOMCELL *ATOM;
  STACKFRAME *FRAME;
  auto int BREAK(int RESULT) {
    _imp_enter();
    int SEXP;
    static void *ERROR[3 - 0 + 1] = {
        /* These need to be filled in from associated code block */};
    if (RESULT >= ATOMBASE || RESET != 0)
      return (RESULT); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    ; /*ERROR: name_sym_idx is -1!*/                  /*C_NAME*/
    ;
    XPRINT(_imp_str_literal("Eval error:   "), FORM);
    goto *ERROR[RESULT];
  ERROR_1:; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
          /*ERROR: name_sym_idx is -1!*/   /*C_NAME*/
    ;
    goto *ERROR[0];
  ERROR_2:;
    XPRINT(_imp_str_literal("    Function not defined: "), CAR);
    goto *ERROR[0];
  ERROR_3:;
    XPRINT(_imp_str_literal("    Argument not of the correct form in "), CDR);
  ERROR_0:;
    LOOP(_imp_str_literal("   %:"), PERCENT);
    if (RESET != 0) return (PERCENT);
    SEXP = READSEXP(_imp_str_literal("Eval:"));
    if (SEXP == PERCENT) SEXP = FORM;
    return (EVAL(SEXP));
    _imp_leave();
  }
  if (RESET != 0) return (PERCENT);
  FRAME = &STACK;
  FRAME->BACK = EVLN;
  FRAME->BIND = FORM;
  if (FORM >= LISTBASE) {
    CELL = &LIST;
    CAR = CELL->CAR;
    CDR = CELL->CDR;
    if (NAMEBASE <= CAR && CAR <= NAMETAIL) {
      ATOM = &NAME;
      if ((ATOM->FORM & 4) != 0) {
        FRONT = FRONT + 1;
        CDR = EVLIST(CDR);
        FRONT = FRONT - 1;
      }
      FORM = PUSH(FORM);
      FRAME->BACK = CAR | 0x8000;
      FRAME->BIND = CDR;
      if ((ATOM->FORM & 16) != 0) {
        /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/;
            /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
        ;
        XPRINT(_imp_str_literal("Lisp Break:   "), FORM);
        FRONT = FRONT + 1;
        LOOP(_imp_str_literal("   %:"), PERCENT);
        FRONT = FRONT - 1;
      }
      if ((ATOM->FORM & 8) != 0) {
        return (
            POP(BREAK(TRACE(_imp_join(_imp_str_literal("<--- "),
                                      _imp_join(PNAME, _imp_str_literal(" "))),
                            FUNC))));
      }
      return (POP(BREAK(FUNC)));
    }
    FRONT = FRONT + 1;
    CDR = EVLIST(CDR);
    FRONT = FRONT - 1;
    return (BREAK(APPLY(CAR, CDR)));
  }
  if (NAMEBASE <= FORM && FORM <= NAMETAIL) {
    ATOM = &NAME;
    if ((ATOM->FORM & 0x7) == 3) return (ATOM->FUNC);
    return (BREAK(STACK.BIND));
  }
  return (FORM);
  _imp_leave();
}
static void INITLISP(void) {
  _imp_enter();
  int I;
  int SEXP;
  ATOMCELL *ATOM;
  LISPCELL *CELL;
  STACKFRAME *FRAME;
  for (I = NAMEBASE; I != NAMETAIL + 1; I += 1) {
    ATOM = &NAME;
    ATOM->BIND = STACKTAIL;
    ATOM->PROP = NIL;
    ATOM->FUNC = 0;
    ATOM->FORM = 0;
    ATOM->PNAME = &ERRORS;
  }
  /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/;
  RESET = 0;
  for (I = NIL; I != STARS + 1; I += 1) SEXP = RATOM();
  for (I = 0; I != LISTBASE - 1 + 1; I += 1) {
    CELL = &LIST;
    CELL->CAR = ERROR3;
    CELL->CDR = ERROR3;
  }
  LISTHEAD = LISTBASE;
  LISTCOUNT = LISTTAIL - LISTHEAD;
  for (I = LISTBASE; I != LISTTAIL - 1 + 1; I += 1) LIST.CAR = I + 1;
  LIST = 0;
  do
    SEXP = PUT(RATOM(), RATOM(), RATOM());
  while (SEXP != NIL);
  STACK.BIND = ERROR;
  FRAME = &STACK;
  FRAME->LINK = GLOBAL;
  FRAME->BIND = ERROR1;
  AUXS[AUXP] = ERROR;
  do
    SEXP = EVAL(READSEXP(_imp_str_literal("")));
  while (SEXP != NIL); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  ;
  _imp_leave();
}
void LISP(_imp_string PARMS) {
  _imp_enter();
  int FLAG;
  int CONAD;
  int INITMODE;
  int I;
  int FIXUP;
  _imp_string WORK;
  RF RR;
  char *PNAMESPACE;
  ATOMCELL *ATOM;
  LOCAL = STACKBASE;
  FRONT = STACKBASE;
  AUXP = 0;
  PMPT = _imp_str_literal("Read:");
  CHAR = 0x80;
  if (_imp_cond_resolve(PARMS, WORK, _imp_str_literal("/"), PARMS) &&
      WORK == _imp_str_literal("")) {
    if (PARMS == _imp_str_literal("")) PARMS = _imp_str_literal("T#LSPMACH");
    OUTFILE(PARMS, 196608, 0, 0, CONAD, FLAG);
    if (FLAG != 0) goto ERR;
    INITMODE = YES;

  } else {
    INITMODE = NO;
    CONNECT(PARMS, 3, 0, 0, RR, FLAG);
    if (FLAG != 0) goto ERR;
    CONAD = RR.CONAD;
  }
  /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ LISPFILE = &;
  if (INITMODE == YES) {
    LISPFILE->DATAEND = LISPFILE->FILESIZE;
    LISPFILE->FILETYPE = SSDATAFILETYPE;
    LISPFILE->FORMAT = 3;
    LISPFILE->MARKER = MARKER;
    LISPFILE->CONST = 0x1000;
    LISPFILE->LONGHEAD = LONGBASE;
    LISPFILE->PNAMESPACE = LISPFILE->CONST + 4 * (LONGTAIL - LONGBASE + 1);
    LISPFILE->PNAMEBASE = LISPFILE->PNAMESPACE;
    LISPFILE->PNAMEHEAD = LISPFILE->PNAMEBASE;
    LISPFILE->NAME = 0x4000;
    LISPFILE->NAMEHEAD = NAMEBASE;
    LISPFILE->STACK = 0xA000;
    LISPFILE->GLOBAL = STACKTAIL;
    LISPFILE->LIST = 0x10000;
    LISPFILE->LINELENGTH = DEFAULTLINELENGTH;

  } else {
    if (LISPFILE->MARKER != MARKER) {
      FLAG = 311;
      SETFNAME(PARMS);
      goto ERR;
    }
  }
  /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ CONST = &;
  LONGHEAD = &LISPFILE->LONGHEAD; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  PNAMESPACE = &;
  PNAMEHEAD = &LISPFILE->PNAMEHEAD; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  PNAMETAIL = MISSING_RHS; /*ERROR: name_sym_idx is -1!*/          /*C_NAME*/
  NAME = &;
  NAMEHEAD = &LISPFILE->NAMEHEAD;
  GLOBAL = &LISPFILE->GLOBAL;
  LINELENGTH = &LISPFILE->LINELENGTH; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  FIXUP = () - LISPFILE->PNAMEBASE;
  LISPFILE->PNAMEBASE = LISPFILE->PNAMEBASE + FIXUP;
  LISPFILE->PNAMEHEAD = LISPFILE->PNAMEHEAD + FIXUP;
  for (I = NAMEBASE; I != NAMEHEAD - 1 + 1; I += 1) {
    ATOM = &NAME; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
        /*ERROR: name_sym_idx is -1!*/           /*C_NAME*/
    ATOM->PNAME = &;
    if (GLOBAL > ATOM->BIND || ATOM->BIND > STACKTAIL) ATOM->BIND = STACKTAIL;
  }
  for (I = CHARBASE; I != NAMETAIL + 1; I += 1) {
    ATOM = &NAME;
    if (GLOBAL > ATOM->BIND || ATOM->BIND > STACKTAIL) ATOM->BIND = STACKTAIL;
  }
  /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ LIST = &;
  LISTHEAD = &LISPFILE->LISTHEAD;
  LISTCOUNT = &LISPFILE->LISTCOUNT; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  STACK = &;
  PSPACES = _imp_str_literal("");
  PLABEL = _imp_str_literal("");
  LINE = _imp_str_literal("");
  CLAUSE = _imp_str_literal("");
  PROGFLAG = 0;
  FLAG = 0;
  if (INITMODE == YES) INITLISP();
  NILLIST = CONS(NIL, NIL);
  LIST.CDR = PUSH(NILLIST);
  INFILE = MATOM(_imp_str_literal(".IN"));
  OUTF = MATOM(_imp_str_literal(".OUT"));
  LOOP(_imp_str_literal("Lisp:"), EXIT);
  SETRETURNCODE(0);
  exit(0);
ERR:;
  /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/;    /*ERROR: name_sym_idx is -1!*/
      /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  ;
  SETRETURNCODE(FLAG);
  exit(0);
  _imp_leave();
}