#include <perms.h>
int _imp_mainep(int _imp_argc, char **_imp_argv) {
  _imp_enter();
  const _imp_string TITLE =
      _imp_str_literal("  EUCSD IMP Compiler for M68000.  APM Version  2.2g");
  const int WHICH = '.imp';
  const int MAXNAME = 127;
  _imp_string MAINFILE;
  _imp_string OBJFILE;

  typedef struct EDFILE {
    _imp_string NAME;
    char TOP;
    char WIN;
    char BOT;
    char MIN;
    char ROW;
    char COL;
    int START1;
    int LIM1;
    int START2;
    int LIM2;
    int LIM;
    int LBEG;
    int FP;
    int CHANGE;
    int FLAG;
    int LINE;
    int DIFF;

  } EDFILE;
  extern void EDI(EDFILE * MAIN, EDFILE, _imp_string MESSAGE);
  const int NEWGROUP = 1;
  const int NODEFAULT = 2;
  extern void DEFINEPARAM(_imp_string NAME, void *VARIABLE, int FLAGS) /* See
                                                                          https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/Function-Attributes.html
                                                                        */
      ;
  extern void DEFINEINTPARAM(_imp_string NAME, void *VARIABLE, int FLAGS) /* See
                                                                             https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/Function-Attributes.html
                                                                           */
      ;
  extern void DEFINEBOOLEANPARAMS(_imp_string NAME, void *VARIABLE,
                                  int FLAGS) /* See
                                                https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/Function-Attributes.html
                                              */
      ;
  extern void PROCESSPARAMETERS(_imp_string PARM) /* See
                                                     https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/Function-Attributes.html
                                                   */
      ;
  extern void CONNECTEDFILE(EDFILE * F);
  extern void DISCONNECTEDFILE(EDFILE * F);
  extern _imp_string DATE(void);
  extern _imp_string TIME(void);
  static int ITEM = 0;
  static int LISTOUT = 0;
  const int ARRBIT = 0x80000000;
  const int LOOPBIT = 0x40000000;
  const int CAPBIT = 0x20000000;
  const int OVERBIT = 0x10000000;
  const int ASSBIT = 0x08000000;
  const int STRASSBIT = 0x04000000;
  const int SASSBIT = 0x02000000;
  const int BASSBIT = 0x01000000;
  const int ASSMASK = ASSBIT | STRASSBIT | SASSBIT | BASSBIT;
  const int LINEBIT = 0x00800000;
  const int DIAGBIT = 0x00400000;
  const int TRACEBIT = 0x00200000;
  const int STACKBIT = 0x00100000;
  const int CHECKBIT = 0x00080000;
  const int SYSBIT = 0x00040000;
  const int STRICTBIT = 0x00020000;
  const int VOLBIT = 0x00010000;
  const int HALFBIT = 0x00008000;
  const int LOWBIT = 0x00004000;
  const int EDITBIT = 0x00002000;
  const int RUNBIT = 0x00001000;
  const int FORCEBIT = 0x00000800;
  const int LOGBIT = 0x00000400;
  const int WARNBIT = 0x00000200;
  const int NONSBIT = 0x00000100;
  const int PERMBIT = 0x00000080;
  const int NEWBIT = 0x00000040;
  const int CODELIST = 0x00000020;
  const int DICTLIST = 0x00000010;
  const int EXPLIST = 0x00000008;
  const int MAPLIST = 0x00000004;
  const int TTLIST = 0x00000002;
  const int LIST = 0x00000001;
  const int LISTBITS = CODELIST + DICTLIST + EXPLIST + MAPLIST + TTLIST + LIST;
  static int CONTROL = WARNBIT + CHECKBIT + LINEBIT + DIAGBIT + EDITBIT +
                       VOLBIT + STRASSBIT + ASSBIT + ARRBIT + LOOPBIT + CAPBIT +
                       STACKBIT;
  int INITCON;
  int TIME1;
  int TIME2;
  const int OFLOW = 1;
  const int FAIL = 11;
  const int DONE = 12;
  const int REDO = 13;
  const int ABANDON = 14;
  const int MAXINT = 0x7FFFFFFF;
  const int MININT = ~MAXINT;
  const int SIGN16 = ~0x7FFF;
  const int SIGN = ~0x7FFFFFFF;
  const int SMALLMIN = -1024;
  const int SMALLMAX = 1023;
  const int LITMAX = SMALLMIN - (SMALLMAX + 1);
  const int LITMIN = LITMAX - 199;
  const int LITMITE = -255;
  const int LITQUICK = -16;
  const int ONE = -(1 << 1);
  const int D0 = 1;
  const int D1 = D0 + 1;
  const int D2 = D0 + 2;
  const int D7 = D0 + 7;
  const int A0 = D0 + 8;
  const int A1 = A0 + 1;
  const int A6 = A0 + 6;
  const int A7 = A0 + 7;
  const int INDA0 = A0 + 8;
  const int INDA7 = INDA0 + 7;
  const int POSTA0 = INDA0 + 8;
  const int POSTA7 = POSTA0 + 7;
  const int PREA0 = POSTA0 + 8;
  const int PREA7 = PREA0 + 7;
  const int UNDEF = A7;
  static int DICTLIM = 1000;
  static int FINALBOUND = 64;
  int LABLIM;
  int NP0;
  int EXPLIM;
  int CHARBOUND;
  const int LABELS = 42;
  const int TRIPLES = 200;
  const int AD = 16384;
  const int BREG = D0 + 4;
  const int LINELOC = D0 + 5;
  const int F1 = A0 + 6;
  const int GB = A0 + 5;
  const int MB = A0 + 4;
  const int MAXDREG = D0 + 3;
  const int MAXAREG = A0 + 3;
  const int D0B = 1;
  const int D1B = 2;
  const int D2B = 4;
  const int BREGB = 16;
  const int A0B = 0x100;
  const int A1B = 0x200;
  const int A2B = 0x400;
  const int ANYDREG = 0x00FF - BREGB;
  const int ANYAREG = 0xFF00;
  const int ANYREG = 0xFFFF;
  const int DEFAULTFREE =
      (2 << (MAXDREG - D0)) - 1 + (((2 << (MAXAREG - A0)) - 1) << 8) + BREGB;
  int MAXCALLDREG;
  int MAXCALLAREG;
  int FREE;
  int LITPOS;
  int LITSTORE[LITMAX - LITMIN + 1];

  typedef struct OBJINFO {
    int VAL;
    char REG;
    char MODE;
    short LINK;
    short FLAGS;
    short TYPE;

  } OBJINFO;

  typedef struct IDENTINFO {
    short TEXT;
    short HLINK;
    int VAL;
    char REG;
    char MODE;
    short LINK;
    short FLAGS;
    short TYPE;

  } IDENTINFO;
  const int AREGMODE = 0b001000;
  const int DISPMODE = 0b101000;
  const int INDEXMODE = 0b110000;
  const int ABSMODE = 0b111000;
  const int PCMODE = 0b111010;
  const int LITMODE = 0b111100;
  const int INDIR = 8;
  const int POST = 16;
  const int PRE = 24;
  const int LABMODE = 0b10000000 + PCMODE;
  const int PROCMODE = 0b11000000 + PCMODE;
  const int GLOBALMODE = DISPMODE + (GB - A0);
  const int OWNMODE = 0b01000000 + DISPMODE + (MB - A0);
  const int CONSTMODE = 0b01000000 + PCMODE;
  const int FRAMEMODE = 0b10000000 + DISPMODE;
  const int CAT = 0x000F;
  const int WRITABLE = 0x0001;
  const int READABLE = 0x0002;
  const int VOLATILE = 0x0004;
  const int ARRFLAG = 0x0008;
  const int ALT = 0x0008;
  const int WFLAG = 0x0010;
  const int RFLAG = 0x0020;
  const int OKFLAG = 0x0040;
  const int NORET = 0x0040;
  const int MFLAG = 0x0080;
  const int SPEC = 0x0100;
  const int TYPEID = 0x0200;
  const int PACKED = 0x0400;
  const int INDIRECT = 0x0800;
  const int PROC = 0x3000;
  const int PROC1 = 0x1000;
  const int PROC2 = 0x2000;
  const int EXT = 0x4000;
  const int NAME = SIGN16;
  const int HERITABLE =
      WRITABLE + READABLE + VOLATILE + WFLAG + RFLAG + OKFLAG + ARRFLAG;
  const int INTY = 0;
  const int CHARY = 1;
  const int BOOLY = 2;
  const int ENUMY = 3;
  const int POINTY = 4;
  const int REALY = 5;
  const int STRINGY = 8;
  const int ARRY = 9;
  const int SETY = 10;
  const int RECY = 12;
  const int FILEY = 13;
  const int NONORD = 12;
  static OBJINFO DEFINEDLABEL = 0;
  static OBJINFO FORWARDLABEL = 0;
  static OBJINFO BEGINBLOCK = 0;
  static OBJINFO TYPEIDENT = 0;
  const int MAIN = 1;
  EDFILE FILE[3 - 1 + 1];
  EDFILE *CUR;
  int FCONTROL[3 - 1 + 1];
  int CURFILE;
  int LASTFILE;
  int CURSTART;
  int CURLIM;
  auto void SETOPTIONS(_imp_string PARM) {
    _imp_enter();
    const int CHECKS = ASSMASK + ARRBIT + LOOPBIT + CAPBIT + OVERBIT;
    DEFINEBOOLEANPARAMS(
        _imp_join(
            _imp_str_literal("ARR,LOOP,CAP,OVER,ASS,STRASS,SASS,BASS,LINE,DIAG,"
                             "TRACE,STACK,"),
            _imp_join(_imp_str_literal("CHECK,SYS,STRICT,VOL,HALF,LOW,EDIT,RUN,"
                                       "FORCE,LOG,WARN,NONS,PERM,NEW,"),
                      _imp_str_literal("CODE,DICT,EXP,MAP,TT,LIST"))),
        CONTROL, 0);
    PROCESSPARAMETERS(PARM);
    if ((CONTROL & CHECKBIT) == 0) CONTROL = CONTROL & (~CHECKS);
    if ((CONTROL & LISTBITS) != 0) CONTROL = CONTROL & (~EDITBIT);
    _imp_leave();
  }
  auto void SETEXTENSION(_imp_string * MAXNAME, *F, _imp_string EXT) {
    _imp_enter();
    int STRIP;
    auto int LAST4(_imp_string * S) {
      _imp_enter();
      int I;
      int E;
      I = 0;
      E = 0;
      while (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ I < ()) {
        I = I + 1; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
        E = (E << 8) + ();
      }
      return (E);
      _imp_leave();
    }
    STRIP = LAST4(EXT);
    if (F == _imp_str_literal("")) {
      *F = MAINFILE;
      STRIP = WHICH;
    }
    if ((LAST4(F) | 0x202020) == STRIP)           /*ERROR: name_sym_idx is -1!*/
        /*C_NAME*/ /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      () - 4;
    *F = _imp_join(F, EXT);
    _imp_leave();
  }
  auto void OPENFILES(void) {
    _imp_enter();
    _imp_string LISTFILE = _imp_str_literal("");
    OBJFILE = _imp_str_literal("");
    DEFINEPARAM(_imp_str_literal("SOURCE"), MAINFILE, NODEFAULT);
    DEFINEPARAM(_imp_str_literal("OFILE"), OBJFILE, NEWGROUP);
    DEFINEPARAM(_imp_str_literal("LFILE"), LISTFILE, 0);
    DEFINEINTPARAM(_imp_str_literal("IDents"), DICTLIM, NEWGROUP);
    DEFINEINTPARAM(_imp_str_literal("KBytes"), FINALBOUND, 0);
    FILE[MAIN] = 0;
    SETOPTIONS(CLIPARAM());
    if ((CONTROL & DIAGBIT) == 0) CONTROL = CONTROL & (~LINEBIT);
    FILE[MAIN].NAME = MAINFILE;
    FILE[MAIN].FLAG = 32768;
    TIME1 = TIME1 - CPUTIME();
    CONNECTEDFILE(FILE[MAIN]);
    TIME1 = TIME1 + CPUTIME();
    if (FILE[MAIN].FLAG != 0) exit(0);
    if (LISTFILE != _imp_str_literal("") || (CONTROL & (LIST + TTLIST)) != 0) {
      if ((CONTROL & TTLIST) == 0) {
        SETEXTENSION(LISTFILE, _imp_str_literal(".lis"));
        LISTOUT = 2;
        OPENOUTPUT(LISTOUT, LISTFILE);
      }
      CONTROL = CONTROL & (~(EDITBIT + TTLIST));
      if ((CONTROL & LISTBITS) == 0) CONTROL = CONTROL | LIST;
    }
    SELECTOUTPUT(LISTOUT);
    if ((CONTROL & LISTBITS) != 0) {
      if ((CONTROL & LISTBITS) != MAPLIST) CONTROL = CONTROL | LIST;
      NEWLINES(2);
      PRINTSTRING(TITLE);
      NEWLINES(2);
      PRINTSTRING(_imp_str_literal("   "));
      PRINTSTRING(FILE[MAIN].NAME);
      PRINTSTRING(_imp_str_literal("  compiled on "));
      PRINTSTRING(DATE());
      PRINTSTRING(_imp_str_literal("  at  "));
      PRINTSTRING(TIME());
      NEWLINES(2);
    }
    INITCON = CONTROL;
    _imp_leave();
  }
  TIME1 = 0;
  OPENFILES();
  DICTLIM = DICTLIM + 300;
  CHARBOUND = DICTLIM * 8;
  FINALBOUND = (FINALBOUND << 10) + 4095;
  LABLIM = DICTLIM + LABELS;
  EXPLIM = LABLIM + TRIPLES;
  NP0 = LABLIM + 4;
  FILE[MAIN].CHANGE = 0x7FFFFFFF;
  FORWARDLABEL.FLAGS = SPEC;
  FORWARDLABEL.MODE = LABMODE;
  DEFINEDLABEL.MODE = LABMODE;
  BEGINBLOCK.MODE = PROCMODE;
  TYPEIDENT.FLAGS = TYPEID + RECY;
  IDENTINFO DICT[EXPLIM - 1 - 0 + 1];
  int DLIM;
  int DLIM0;
  int DMIN;
  int DMIN0;
  int DICTSHOWN;
  int INCLIM;
  IDENTINFO *DLINK;
  IDENTINFO *DFORMAT;
  IDENTINFO *DTEMP;
  IDENTINFO *DTEMP2;
  IDENTINFO *DTSPREL;
  IDENTINFO *DINT;
  int SUBBED;
  int RANGES;
  char CHAR[CHARBOUND - 0 + 1];
  int CHAR0;
  int CHARLIM;
  int CHARMIN;
  int NEWLEN;
  short HASHINDEX[255 - 0 + 1];
  short *HEAD;
  const int NULL = 41;
  const int PROCSTAR = 42;
  const int INTTYPE = 43;
  const int SHORTTYPE = 46;
  const int HALFTYPE = 49;
  const int BYTETYPE = 52;
  const int MITETYPE = 55;
  const int BOOLTYPE = 58;
  const int CHARTYPE = 61;
  const int STRINGSTAR = 62;
  const int STRING1 = 63;
  const int STRINGTYPE = 64;
  const int ARRSTAR = 65;
  const int NULLSETTYPE = 66;
  const int RECSTAR = 67;
  const int REALTYPE = 69;
  const int SIGNAL = 73;
  const int DADDR = 74;
  const int DSIZEOF = 77;
  const int INDEX = 78;
  const int LENREF = 79;
  const int SINDEX = 82;
  const int IMUL = 86;
  const int IDIV = 87;
  const int IPOW = 88;
  const int FNEG = 89;
  const int FADD = 90;
  const int FSUB = 91;
  const int FMUL = 92;
  const int FDIV = 93;
  const int FPOW = 94;
  const int FLOAT = 95;
  const int DREM = 98;
  const int UNASS = 102;
  const int ADOK = 103;
  const int STACKOK = 104;
  const int ASIZE = 105;
  const int CONCAT = 106;
  const int DTOSTRING = 107;
  const int AGET = 109;
  const int FOROK = 110;
  const int CHECK = 111;
  const int SCOMP = 112;
  const int STRCOPY = 113;
  const int STRTOSTK = 114;
  const int DNEW = 115;
  const int RESOLVES = 117;
  const int DEVENTF = 128;
  const int DEVENT = 134;
  const int DNIL = 137;
  const int DPRINTSTR = 155;
  const int DWRITE = 183;
  const int OPMAX = RESOLVES;
  auto void SETHASHHEAD(_imp_string * S) {
    _imp_enter();
    int H;
    int I;
    H = 0;
    for (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ I = 1; I != () + 1;
         I += 1) /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      H = H << 1 ^ ();
    HEAD = &HASHINDEX[H & 255];
    _imp_leave();
  }
  auto void PRESET(void) {
    _imp_enter();
    const int CMAX = 775;
    const char CHARINIT[CMAX - 0 + 1] = {
        0,   2,   'd', '0', 2,   'd', '1', 2,   'd', '2', 2,   'd', '3', 2,
        'd', '4', 2,   'd', '5', 2,   'd', '6', 2,   'd', '7', 2,   'a', '0',
        2,   'a', '1', 2,   'a', '2', 2,   'a', '3', 2,   'a', '4', 2,   'a',
        '5', 2,   'a', '6', 2,   'a', '7', 7,   'i', 'n', 't', 'e', 'g', 'e',
        'r', 6,   'M', 'A', 'X', 'I', 'N', 'T', 12,  's', 'h', 'o', 'r', 't',
        'i', 'n', 't', 'e', 'g', 'e', 'r', 11,  'h', 'a', 'l', 'f', 'i', 'n',
        't', 'e', 'g', 'e', 'r', 11,  'b', 'y', 't', 'e', 'i', 'n', 't', 'e',
        'g', 'e', 'r', 11,  'm', 'i', 't', 'e', 'i', 'n', 't', 'e', 'g', 'e',
        'r', 7,   'B', 'O', 'O', 'L', 'E', 'A', 'N', 5,   'F', 'A', 'L', 'S',
        'E', 4,   'T', 'R', 'U', 'E', 4,   'c', 'h', 'a', 'r', 6,   's', 't',
        'r', 'i', 'n', 'g', 5,   'a', 'r', 'r', 'a', 'y', 6,   'r', 'e', 'c',
        'o', 'r', 'd', 4,   'T', 'E', 'X', 'T', 4,   'r', 'e', 'a', 'l', 8,
        'l', 'o', 'n', 'g', 'r', 'e', 'a', 'l', 6,   'S', 'I', 'G', 'N', 'A',
        'L', 4,   'a', 'd', 'd', 'r', 6,   's', 'i', 'z', 'e', 'o', 'f', 5,
        'I', 'N', 'D', 'E', 'X', 6,   'l', 'e', 'n', 'g', 't', 'h', 6,   'c',
        'h', 'a', 'r', 'n', 'o', 4,   'I', 'M', 'U', 'L', 4,   'I', 'D', 'I',
        'V', 4,   'I', 'P', 'O', 'W', 4,   'F', 'N', 'E', 'G', 4,   'F', 'A',
        'D', 'D', 4,   'F', 'S', 'U', 'B', 4,   'F', 'M', 'U', 'L', 4,   'F',
        'D', 'I', 'V', 4,   'F', 'P', 'O', 'W', 5,   'f', 'l', 'o', 'a', 't',
        3,   'r', 'e', 'm', 5,   'U', 'N', 'A', 'S', 'S', 4,   'A', 'D', 'O',
        'K', 7,   'S', 'T', 'A', 'C', 'K', 'O', 'K', 5,   'A', 'S', 'I', 'Z',
        'E', 6,   'C', 'O', 'N', 'C', 'A', 'T', 8,   't', 'o', 's', 't', 'r',
        'i', 'n', 'g', 4,   'A', 'G', 'E', 'T', 5,   'F', 'O', 'R', 'O', 'K',
        5,   'C', 'H', 'E', 'C', 'K', 5,   'S', 'C', 'O', 'M', 'P', 7,   'S',
        'T', 'R', 'C', 'O', 'P', 'Y', 8,   'S', 'T', 'R', 'T', 'O', 'S', 'T',
        'K', 3,   'n', 'e', 'w', 8,   'r', 'e', 's', 'o', 'l', 'v', 'e', 's',
        9,   's', 'u', 'b', 's', 't', 'r', 'i', 'n', 'g', 7,   'e', 'v', 'e',
        'n', 't', 'f', 'm', 5,   'e', 'v', 'e', 'n', 't', 3,   's', 'u', 'b',
        4,   'l', 'i', 'n', 'e', 5,   'e', 'x', 't', 'r', 'a', 7,   'm', 'e',
        's', 's', 'a', 'g', 'e', 5,   'e', 'v', 'e', 'n', 't', 2,   'n', 'l',
        3,   's', 'n', 'l', 3,   'n', 'i', 'l', 7,   'd', 'i', 's', 'p', 'o',
        's', 'e', 5,   'r', 'o', 'u', 'n', 'd', 5,   't', 'r', 'u', 'n', 'c',
        8,   'f', 'r', 'a', 'c', 't', 'i', 'o', 'n', 3,   'i', 'n', 't', 5,
        'i', 'n', 't', 'p', 't', 6,   'f', 'r', 'a', 'c', 'p', 't', 4,   's',
        'q', 'r', 't', 10,  'n', 'e', 'x', 't', 's', 'y', 'm', 'b', 'o', 'l',
        10,  'r', 'e', 'a', 'd', 's', 'y', 'm', 'b', 'o', 'l', 10,  's', 'k',
        'i', 'p', 's', 'y', 'm', 'b', 'o', 'l', 11,  'p', 'r', 'i', 'n', 't',
        's', 'y', 'm', 'b', 'o', 'l', 11,  'p', 'r', 'i', 'n', 't', 's', 't',
        'r', 'i', 'n', 'g', 9,   'o', 'p', 'e', 'n', 'i', 'n', 'p', 'u', 't',
        10,  'o', 'p', 'e', 'n', 'o', 'u', 't', 'p', 'u', 't', 11,  's', 'e',
        'l', 'e', 'c', 't', 'i', 'n', 'p', 'u', 't', 12,  's', 'e', 'l', 'e',
        'c', 't', 'o', 'u', 't', 'p', 'u', 't', 8,   's', 'e', 't', 'i', 'n',
        'p', 'u', 't', 9,   's', 'e', 't', 'o', 'u', 't', 'p', 'u', 't', 10,
        'r', 'e', 's', 'e', 't', 'i', 'n', 'p', 'u', 't', 11,  'r', 'e', 's',
        'e', 't', 'o', 'u', 't', 'p', 'u', 't', 10,  'c', 'l', 'o', 's', 'e',
        'i', 'n', 'p', 'u', 't', 11,  'c', 'l', 'o', 's', 'e', 'o', 'u', 't',
        'p', 'u', 't', 6,   'p', 'r', 'o', 'm', 'p', 't', 7,   'n', 'e', 'w',
        'l', 'i', 'n', 'e', 5,   's', 'p', 'a', 'c', 'e', 6,   's', 'p', 'a',
        'c', 'e', 's', 8,   'n', 'e', 'w', 'l', 'i', 'n', 'e', 's', 4,   'r',
        'e', 'a', 'd', 138, 'r', 'e', 'a', 'd', 's', 't', 'r', 'i', 'n', 'g',
        4,   'r', 'e', 'a', 'd', 136, 'r', 'e', 'a', 'd', 'r', 'e', 'a', 'l',
        4,   'r', 'e', 'a', 'd', 5,   'w', 'r', 'i', 't', 'e', 7,   'c', 'p',
        'u', 't', 'i', 'm', 'e', 5,   'p', 'r', 'i', 'n', 't', 7,   'p', 'r',
        'i', 'n', 't', 'f', 'l', 8,   'i', 'n', 's', 't', 'r', 'e', 'a', 'm',
        9,   'o', 'u', 't', 's', 't', 'r', 'e', 'a', 'm', 8,   'c', 'l', 'i',
        'p', 'a', 'r', 'a', 'm', 0};
    const int PREMAX = 196;
    const short DICTINIT[PREMAX * 6 + 5 - 41 * 6 + 1] = {
        516,    -1,     0,     0,      0,      0,      527,    -1,     0,
        0,      0,      4,     512,    43,     4,      56,     -32768, 0,
        0,      -44,    4,     60,     -32768, 0,      0,      43,     4,
        60,     32767,  -1,    512,    43,     2,      56,     -32768, 0,
        0,      -44,    2,     60,     -1,     -32768, 0,      -44,    2,
        60,     0,      32767, 512,    43,     2,      56,     -32768, 0,
        0,      -44,    2,     60,     0,      0,      0,      -44,    2,
        60,     0,      -1,    512,    43,     1,      56,     -32768, 0,
        0,      -44,    1,     60,     0,      0,      0,      -44,    1,
        60,     0,      255,   512,    43,     1,      56,     -32768, 0,
        0,      -44,    1,     60,     -1,     -128,   0,      -44,    1,
        60,     0,      127,   514,    58,     1,      0,      0,      0,
        0,      58,     1,     60,     0,      0,      0,      58,     1,
        60,     0,      1,     513,    61,     255,    0,      0,      0,
        520,    61,     0,     0,      0,      0,      520,    -62,    -2,
        0,      0,      0,     520,    -62,    -256,   0,      0,      0,
        521,    0,      0,     0,      0,      0,      522,    -1,     0,
        0,      0,      0,     524,    0,      0,      0,      0,      0,
        525,    61,     4,     0,      0,      0,      517,    0,      4,
        0,      0,      0,     517,    0,      4,      0,      0,      0,
        0,      -1,     0,     0,      0,      0,      0,      -1,     0,
        0,      0,      0,     4256,   42,     0,      56,     0,      16122,
        4098,   75,     0,     56,     0,      0,      0,      -44,    76,
        0,      0,      4,     -32701, -1,     0,      6313,   -1,     -4,
        4098,   75,     0,     56,     0,      0,      4096,   42,     0,
        56,     -32767, 2861,  4099,   80,     0,      56,     0,      0,
        0,      -53,    81,    6144,   0,      4,      -32701, -63,    0,
        6313,   -1,     -4,    4099,   83,     0,      56,     0,      0,
        0,      -53,    84,    6144,   0,      4,      -32701, -63,    85,
        6313,   -1,     -4,    67,     -44,    0,      169,    -1,     -8,
        4256,   42,     0,     56,     0,      16116,  4256,   42,     0,
        56,     0,      16110, 4096,   42,     0,      56,     0,      16098,
        4096,   42,     0,     56,     0,      16092,  4096,   42,     0,
        56,     0,      16086, 4096,   42,     0,      56,     0,      16080,
        4096,   42,     0,     56,     0,      16074,  4096,   42,     0,
        56,     0,      16068, 4096,   42,     0,      56,     0,      16062,
        4098,   96,     0,     56,     0,      16056,  0,      -70,    97,
        0,      0,      4,     67,     -44,    0,      169,    -1,     -4,
        4098,   99,     0,     56,     0,      0,      0,      -44,    100,
        0,      0,      4,     67,     -44,    101,    169,    -1,     -4,
        67,     -44,    0,     425,    -1,     -8,     4096,   42,     0,
        56,     -32722, 2578,  4096,   42,     0,      56,     -32704, 2064,
        4096,   42,     0,     56,     -32688, 2839,   4096,   42,     0,
        56,     -32665, 3097,  4096,   42,     0,      56,     -32640, 2077,
        4098,   108,    0,     56,     -32611, 6,      0,      -64,    97,
        6144,   0,      4,     4096,   42,     0,      56,     -32605, 2597,
        4096,   42,     0,     56,     -32568, 2334,   4096,   42,     0,
        56,     -32538, 1806,  4096,   42,     0,      56,     -32524, 2626,
        4096,   42,     0,     56,     -32458, 2070,   4096,   42,     0,
        56,     -32436, 2090,  4103,   116,    0,      56,     0,      16008,
        0,      -68,    76,    6144,   0,      4,      22786,  118,    0,
        108,    0,      0,     0,      -59,    119,    0,      0,      0,
        -32701, -63,    120,   6313,   -1,     -4,     67,     -65,    121,
        6569,   -1,     -260,  -32701, -63,    122,    6825,   -1,     -264,
        -32701, -63,    0,     7081,   -1,     -268,   4098,   124,    0,
        56,     -32394, 15,    0,      -65,    125,    6144,   0,      4,
        -32701, -63,    126,   6313,   -1,     -4,     67,     -44,    127,
        169,    -1,     -8,    67,     -44,    0,      425,    -1,     -12,
        524,    0,      129,   0,      -1,     -264,   3,      52,     0,
        0,      0,      0,     3,      52,     0,      0,      0,      1,
        3,      46,     0,     0,      0,      2,      3,      43,     0,
        0,      0,      4,     3,      64,     0,      0,      0,      8,
        67,     128,    0,     45,     0,      32,     66,     43,     0,
        60,     0,      10,    66,     61,     0,      60,     0,      10,
        67,     67,     0,     56,     0,      0,      4096,   139,    0,
        56,     0,      16002, 0,      -1,     76,     0,      0,      4,
        4098,   141,    0,     56,     0,      16050,  0,      -44,    142,
        0,      0,      4,     67,     -70,    0,      169,    -1,     -4,
        4098,   141,    0,     56,     0,      16044,  4098,   145,    0,
        56,     0,      16038, 0,      -70,    142,    0,      0,      4,
        4098,   141,    0,     56,     0,      16032,  4098,   141,    0,
        56,     0,      16026, 4098,   145,    0,      56,     0,      16020,
        4098,   145,    0,     56,     0,      16014,  4098,   132,    0,
        56,     0,      15996, 4098,   132,    0,      56,     0,      15990,
        4096,   42,     0,     56,     0,      15990,  4256,   154,    0,
        56,     0,      15984, 0,      -1,     97,     0,      0,      4,
        4096,   156,    0,     56,     0,      15978,  0,      -1,     157,
        0,      0,      4,     67,     -65,    0,      6313,   -1,     -256,
        26880,  159,    0,     108,    0,      0,      0,      -1,     160,
        0,      0,      0,     67,     -44,    161,    169,    -1,     -4,
        67,     -65,    0,     6313,   -1,     -260,   26880,  159,    0,
        108,    0,      0,     4096,   154,    0,      56,     0,      15960,
        4096,   154,    0,     56,     0,      15954,  26880,  166,    0,
        108,    0,      0,     0,      -1,     97,     0,      0,      0,
        26880,  166,    0,     108,    0,      0,      26880,  0,      0,
        108,    0,      0,     26880,  0,      0,      108,    0,      0,
        4096,   42,     0,     56,     0,      15936,  4096,   42,     0,
        56,     0,      15930, 26880,  173,    0,      108,    0,      0,
        0,      -1,     157,   0,      0,      0,      4096,   42,     0,
        56,     -32379, 4,     4096,   42,     0,      56,     -32375, 4,
        22784,  166,    0,     108,    0,      0,      22784,  166,    0,
        108,    0,      0,     22790,  179,    0,      108,    0,      0,
        0,      -65,    0,     6144,   0,      0,      22798,  181,    0,
        108,    0,      0,     0,      -70,    0,      0,      0,      0,
        22798,  1,      0,     108,    0,      0,      22784,  184,    0,
        108,    0,      0,     0,      -1,     100,    0,      0,      0,
        26886,  1,      0,     108,    0,      0,      22784,  187,    0,
        108,    0,      0,     0,      -1,     188,    0,      0,      0,
        67,     -70,    189,   169,    -1,     -4,     67,     -44,    190,
        425,    -1,     -8,    67,     -44,    0,      681,    -1,     -12,
        22784,  192,    0,     108,    0,      0,      0,      -1,     193,
        0,      0,      0,     67,     -70,    101,    169,    -1,     -4,
        67,     43,     0,     45,     0,      392,    67,     43,     0,
        45,     0,      396,   67,     64,     0,      45,     0,      464};
    int I;
    int CI;
    int ANONS;
    IDENTINFO *DP;
    auto void PUTCHAR(void) {
      _imp_enter();
      /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ CHARINIT[CI];
      CHARLIM = CHARLIM + 1;
      CI = CI + 1;
      _imp_leave();
    }
    auto void TEXTSET(IDENTINFO * DP) {
      _imp_enter();
      int LEN;
      DP->HLINK = 0;
      if (DP->TYPE < 0) {
        DP->TYPE = ~DP->TYPE;
        DP->TEXT = 0;
        ANONS = ANONS - 1;
        if (ANONS == 0 && DLIM <= MITETYPE + 2) {
          DP->HLINK = RANGES;
          RANGES = DLIM;
        }

      } else {
        DP->TEXT = CI;
        if ((CHARINIT[CI + 1] & 32) != 0) {
          if (DEVENTF < DLIM && DLIM < DEVENT) {
            *HEAD = DLIM;
            HEAD = &DP->HLINK;

          } else { /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
                   /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
            SETHASHHEAD();
            DP->HLINK = HEAD;
            *HEAD = DLIM;
            if (DLIM == DEVENTF) HEAD = &DP->LINK;
          }
        }
        LEN = CHARINIT[CI];
        do {
          PUTCHAR();
        } while (LEN >= 0);
        LEN = CHARINIT[CI] - 128;
        while (LEN >= 0) {
          PUTCHAR();
        }
        ANONS = 2;
      }
      _imp_leave();
    }
    for (I = 0; I != 255 + 1; I += 1)
      HASHINDEX[I] = 0; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    0;
    CHARLIM = CHAR0 + 1;
    CHARMIN = CHARLIM + CHARBOUND;
    RANGES = 0;
    CI = 1;
    ANONS = 100;
    DICT[0] = 0;
    DLIM = D0;
    do {
      DP = &DICT[DLIM];
      if (DLIM <= PREA7) {
        *DP = 0;
        DP->FLAGS = OKFLAG + WRITABLE + READABLE;
        DP->MODE = DLIM - D0;
        DP->TYPE = INTTYPE;
        if (DLIM <= A7) TEXTSET(DP);

      } 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*/
        DP->= MISSING_RHS;
        TEXTSET(DP);
      }
      DLIM = DLIM + 1;
      if ((CONTROL & PERMBIT) != 0 && DLIM >= SIGNAL) break;
    } while (DLIM <= PREMAX);
    DICTSHOWN = DLIM;
    I = DICTLIM;
    do {
      DP = &DICT[I];
      *DP = 0;
      DP->MODE = LABMODE;
      I = I + 1;
    } while (I != NP0);
    _imp_leave();
  }
  int EXPLO;
  int OLDEXPLO;
  int NP;
  int STARTNP;
  const int MOVE = 1;
  const int ADD = 2;
  const int SUB = 3;
  const int CMP = 4;
  const int AND = 5;
  const int OR = 6;
  const int EOR = 7;
  const int NOT = 8;
  const int NEG = 9;
  const int LSL = 10;
  const int LSR = 11;
  const int MULS = 12;
  const int DIVS = 13;
  const int MULU = 14;
  const int DIVU = 15;
  const int BRA = 16;
  const int BSR = 17;
  const int BCC = 20;
  const int BCS = 21;
  const int BNE = 22;
  const int BEQ = 23;
  const int BVC = 24;
  const int BVS = 25;
  const int BGE = 28;
  const int BLT = 29;
  const int BGT = 30;
  const int BLE = 31;
  const int COMPARE = CMP;
  const int GOTO = BRA;
  const int JAMASS = 32;
  const int OKASS = 33;
  const int ASSIGN = 34;
  const int INCASS = 35;
  const int FORASS = 36;
  const int STOP = 37;
  const int RETURN = 38;
  const int REPEAT = 39;
  const int ELSE = 40;
  const int JUMPOUT = 41;
  const int SETTRAP = 42;
  const int SWGOTO = 43;
  const int LABEL = 44;
  const int RECREF = 45;
  const int PREL = 46;
  const int STOREMAP = 47;
  const int IABS = 48;
  const int FABS = 49;
  const int END = 50;
  int STARTS;
  int CYCLES;
  int CURLAB;
  int PENDOUT;
  int PENDCOND;
  int PENDIN;
  int POLARITY;
  int CONDOP;
  static short EXTSPECS = 0;
  static short EXTERNS = 0;

  typedef struct CONTENTINFO {
    short CONTENT[A7 - D0 + 1];
    short CCX;
    short CCY;
    short LINE;

  } CONTENTINFO;

  typedef struct BLOCKINF {
    CONTENTINFO REG;
    IDENTINFO *DPID;
    int SP;
    int STACK;
    int EXTRA;
    int TOTSTACK;
    int FREE;
    int STATUS;
    int TYPE;
    int LOCALDPOS;
    int PARLIM;
    int LOCALTEXT;
    int LOCALAD;
    int VINTAGE;
    int LOCALPC;
    int LOCALSWPC;
    int PID;
    int ACCESS;
    int FORWARD;
    int LAB1;
    int LOOPLAB;
    int EVENTSP;
    int FAULTS;
    int RETURN;
    int SHORTS;
    int TEMPS;
    int DYNARRAY;
    int OLDCONTROL;
    int MODE;
    int VAL;

  } BLOCKINF;
  const int UNKNOWN = 0x0002;
  const int WRONGCC = 0x0004;
  const int ONSTACK = 0x0008;
  const int GLOBBED = 0x0010;
  const int LABGLOBBED = 0x0020;
  const int HADSPEC = 0x0040;
  const int HADSWITCH = 0x0080;
  const int HADON = 0x1000;
  const int HADORDERERR = 0x2000;
  const int HADINST = 0x4000;
  const int OUTERLEVEL = 0;
  const int MAXLEVEL = 7;
  int LEVEL;
  int VINTAGE;
  BLOCKINF C;
  BLOCKINF HOLD[MAXLEVEL - 1 - 0 + 1];
  CONTENTINFO LREG[LABELS - 0 + 1];
  const int PROGBOUND = 16383;
  short PROG[PROGBOUND - 0 + 1];
  char PFLAG[PROGBOUND - 0 + 1];
  const int SHORTJUMP = 1;
  const int JUMP = 2;
  const int LONGJUMP = 3;
  const int GLOBAL = 4;
  const int INDGLOBAL = 7;
  const int ZEROSHORTS = 8;
  int PC;
  int SWPC;
  char FINAL[FINALBOUND - 0 + 1];
  int CAD;
  int OWNAD;
  int JOKERAD;
  int OWNBASE;
  int FINAL0;
  int ACCOUNTED;
  int FIRSTENTRY;
  int FIRSTPOS;
  static int TYPE = 0;
  static int VALUE = 0;
  IDENTINFO *DITEM;
  int SPECCING;
  int DUMP;
  static int ATOM = 0;
  int MATCHED;
  int SYM;
  int LINE;
  static int CODEFLAG = ' ';
  int LISTFLAG;
  int LINESTART;
  int FP;
  int ATOMP;
  int EXPP;
  auto int ISSHORT(int V) {
    _imp_enter();
    if (-32768 <= V && V <= 32767) return (1);
    return (0);
    _imp_leave();
  }
  auto int ISMITE(int V) {
    _imp_enter();
    if (-128 <= V && V <= 127) return (1);
    return (0);
    _imp_leave();
  }
  auto int MITE(int V) {
    _imp_enter();
    V = V & 255;
    if ((V & 128) != 0) V = V - 256;
    return (V);
    _imp_leave();
  }
  auto IDENTINFO *TYPECELL(int T) {
    _imp_enter();
    return (&DICT[T]);
    _imp_leave();
  }
  auto int CATEGORY(int T) {
    _imp_enter();
    return (DICT[T].FLAGS & (PACKED + CAT));
    _imp_leave();
  }
  auto int LITVAL(int V) {
    _imp_enter();
    if (V == 0) return (V);
    if (V > LITMAX) {
      if ((V & 1) == 0) return ((-V) >> 1);
      return (~((-V) >> 1));
    }
    return (LITSTORE[V]);
    _imp_leave();
  }
  int FAULTS;
  int OTHERS;
  int FAULTNUM;
  int FAULTP;
  int STATEMENTS;
  int COMMENTS;
  int ATOMS;
  int IDENTATOMS;
  int LITATOMS;
  int ZAPS;
  int STEPS;
  int JUMPS;
  int SHORTS;
  _imp_string REP;
  auto void PRINTLINE(void) {
    _imp_enter();
    PRINTSTRING(REP); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    PRINTSYMBOL();
    REP = _imp_str_literal("");
    _imp_leave();
  }
  auto void PUTSYM(int K) {
    _imp_enter();
    /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ REP = _imp_join(REP, );
    _imp_leave();
  }
  auto void PUTSTRING(_imp_string S) {
    _imp_enter();
    REP = _imp_join(REP, S);
    _imp_leave();
  }
  auto void PUTNUM(int VAL) {
    _imp_enter();
    auto void PD(int V) {
      _imp_enter();
      if (V <= -10) {
        PD(V / 10);
      }
      PUTSYM('0' - V);
      _imp_leave();
    }
    if (VAL < 0) {
      PUTSYM('-');
    } else
      PD(-VAL);
    _imp_leave();
  }
  auto void PUTIDENT(int P, int MODE) {
    _imp_enter();
    IDENTINFO *DP;
    do {
      /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ if (() > 50)
        PRINTLINE();
      if (REP == _imp_str_literal("")) SPACES(6);
      DP = &DICT[P];
      if (MODE != 0) {
        PUTSYM(' ');
      }
      if (DP->TEXT > 0) /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
        PUTSTRING();
      else if (DP->TEXT < 0)
        PUTNUM(~DP->TEXT);
      else
        PUTNUM(P);
      if (MODE != 0) PUTSYM('"');
      if (MODE <= 0) {
        _imp_leave();
        return;
      }
      P = DP->HLINK;
    } while (P != 0);
    _imp_leave();
  }
  auto void SPACES(int N) {
    _imp_enter();
    while (N > 0) {
      PUTSYM(' ');
      N = N - 1;
    }

    _imp_leave();
  }
  auto void PUTSPNUM(int VAL) {
    _imp_enter();
    if (VAL >= 0) PUTSYM(' ');
    PUTNUM(VAL);
    _imp_leave();
  }
  const char HEXSYM[15 - 0 + 1] = {'0', '1', '2', '3', '4', '5', '6', '7',
                                   '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  auto void PUTHEX(int VAL) {
    _imp_enter();
    int I;
    for (I = 12; I != 0 + -4; I += -4) PUTSYM(HEXSYM[VAL >> I & 15]);
    _imp_leave();
  }
  auto void PUTOPERAND(int V) {
    _imp_enter();
    int I;
    auto void INTERPRET(int MODE) {
      _imp_enter();
      static void *S[7 - 0 + 1] = {
          /* These need to be filled in from associated code block */};
      goto *S[MODE >> 3 & 7];
    S_0:;
      PUTSYM('D');
    PUTRNO:;
      PUTSYM((MODE & 7) + '0');
      {
        _imp_leave();
        return;
      }
    S_1:;
      if (MODE >= FRAMEMODE - DISPMODE)
        PUTSYM('F');
      else
        PUTSYM('A');
      goto PUTRNO;
    S_4:;
      PUTSYM('-');
    S_2:;
    IND:;
      PUTSYM('(');
      INTERPRET((MODE & 0b11000111) + AREGMODE);
      PUTSYM(')');
      {
        _imp_leave();
        return;
      }
    S_3:;
      INTERPRET(MODE - 8);
      PUTSYM('+');
      {
        _imp_leave();
        return;
      }
    S_5:;
      PUTNUM(I);
      goto IND;
    S_6:;
      PUTNUM(MITE(I));
      PUTSYM('(');
      INTERPRET(MODE + (AREGMODE - INDEXMODE));
      PUTSYM(',');
      INTERPRET(I >> 12 & 15);
      PUTSYM('.');
      if ((I & 0x800) == 0)
        PUTSYM('W');
      else
        PUTSYM('L');
      PUTSYM(')');
      {
        _imp_leave();
        return;
      }
    S_7:;
      if ((MODE & 63) == PCMODE) {
        if (MODE == PCMODE) PUTNUM(I);
        PUTSTRING(_imp_str_literal("(PC)"));
        {
          _imp_leave();
          return;
        }
      }
      if (MODE <= ABSMODE + 1) {
        PUTSYM('$');
        if (MODE == ABSMODE + 1 || !ISSHORT(I)) PUTHEX(I >> 16);

      } else {
        PUTSYM(HEXSYM[MODE >> 4 & 3]);
        PUTSYM(HEXSYM[MODE & 15]);
        PUTSYM('_');
      }
      PUTHEX(I);
      _imp_leave();
    }
    if (V <= 0) {
      V = LITVAL(V);
      PUTSYM('#');
      if (ISMITE(V))
        PUTNUM(V);
      else {
        PUTSYM('$');
        if (V >> 16 != 0) PUTHEX(V >> 16);
        PUTHEX(V & 0xFFFF);
      }

    } else if (V <= PREA7) {
      INTERPRET(V - D0);
    } else if (V < DICTLIM) {
      PUTIDENT(V, 0);
    } else if (V < LABLIM) {
      PUTSYM('L');
      PUTNUM(V - DICTLIM);
    } else {
      I = DICT[V].VAL;
      INTERPRET(DICT[V].MODE);
    }
    _imp_leave();
  }
  auto void MARKAT(int COL) {
    _imp_enter();
    while (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ () < COL) PUTSYM(' ');
    PUTSYM('|');
    _imp_leave();
  }
  auto void SHOWDICT(int FROM) {
    _imp_enter();
    int I;
    IDENTINFO D;
    const char FLAGSYM[15 - 0 + 1] = {'W', 'R', 'V', 'A', 'w', 'r', 'o', 'm',
                                      'S', 'T', 'K', '?', 'P', 'p', 'E', '*'};
    const char CATSYM[15 - 0 + 1] = {'I', 'C', 'B', 'E', '@', 'X', '?', '?',
                                     'S', 'A', 'Z', '?', 'R', 'F', '?', '?'};
    if (FROM >= DLIM) {
      _imp_leave();
      return;
    }
    if (REP != _imp_str_literal(""))
      PRINTLINE(); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    0;
    SPACES(6);
    PUTSTRING(_imp_str_literal(
        "___identifier____flags___type__link__par_mode___value____"));
    PRINTLINE();
    do {
      PUTSPNUM(FROM);
      MARKAT(6);
      D = DICT[FROM];
      PUTSYM(' ');
      PUTIDENT(FROM, 0);
      if (D.TEXT > 0) {
        I = CHAR0 + D.TEXT; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
        I = I + () + 1; /*ERROR: name_sym_idx is -1!*/     /*C_NAME*/
        if ((() & 128) != 0) {
          /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
              /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ () - 128;
          PUTSYM(':'); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
          PUTSTRING(); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
              /*ERROR: name_sym_idx is -1!*/          /*C_NAME*/
          () + 128;
        }
      }
      MARKAT(22);
      if ((D.FLAGS & TYPEID) != 0) {
        PUTSYM(CATSYM[D.FLAGS & CAT]);
      } else {
        PUTSYM(' ');
      }
      do {
        if ((D.FLAGS >> I & 1) != 0) PUTSYM(FLAGSYM[I]);
        I = I + 1;
      } while (I <= 15);
      MARKAT(30);
      PUTSPNUM(D.TYPE);
      MARKAT(35);
      PUTSPNUM(D.LINK);
      MARKAT(42);
      PUTSPNUM(D.REG);
      MARKAT(46);
      PUTSPNUM(D.MODE);
      MARKAT(51);
      PUTSPNUM(D.VAL);
      MARKAT(63);
      PRINTLINE();
      FROM = FROM + 1;
    } while (FROM != DLIM);
    SPACES(6);
    PUTSTRING(_imp_str_literal(
        "+-------------------------------------------------------+"));
    PRINTLINE();
    _imp_leave();
  }
  auto void PUTMNEMONIC(int M) {
    _imp_enter();
    M = M << 2;
    do {
      PUTSYM((M >> 27) + 'A' - 1);
      M = M << 5;
    } while (M != 0);
    _imp_leave();
  }
  auto void PUTOPCODE(int OP);
  auto void SHOWEXP(int STARTP) {
    _imp_enter();
    int P;
    int Q;
    IDENTINFO *DP;
    const int BOPMAX = 51;
    const int EXTRA[BOPMAX - 32 + 1] = {
        -736721293, -558838176, -1019632402, -756971917, -856095117,
        -414728192, -463841714, -463989708,  -892759040, -880488448,
        -383729664, -411844977, -669969024,  -464402266, -517820416,
        -414632912, -770618368, -871281664,  -891158528, -655110494};
    auto void PUTOPRAND(int V) {
      _imp_enter();
      if (V >= EXPLIM) {
        PUTSYM('#');
      }
      if (V < NP0)
        PUTOPERAND(V);
      else
        PUTNUM(V);
      _imp_leave();
    }
    if (REP != _imp_str_literal("")) PRINTLINE();
    if (NP <= NP0) {
      _imp_leave();
      return;
    }
    PUTSTRING(
        _imp_str_literal("      ______action_______first_______second____"));
    PRINTLINE();
    P = NP0;
    do {
      if (P == NP) {
        P = EXPLO;
        if (P >= OLDEXPLO) break;
        PUTSTRING(_imp_str_literal(
            "      |---------------------------------------|"));
        PRINTLINE();
      }
      if (P == STARTP)
        PUTSYM('>');
      else
        PUTSYM(' ');
      PUTNUM(P);
      MARKAT(6);
      DP = &DICT[P];
      PUTSYM(' '); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      Q = DP->;
      if (Q <= 31)
        PUTOPCODE(Q);
      else if (Q <= BOPMAX)
        PUTMNEMONIC(EXTRA[Q]);
      else
        PUTIDENT(Q, 0);
      MARKAT(22);
      PUTSYM(' '); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      PUTOPRAND(DP->);
      MARKAT(34);
      PUTSYM(' '); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      PUTOPRAND(DP->);
      MARKAT(46);
      if (P >= EXPLO) {
        PUTSPNUM(DP->TYPE);
        if (DP->FLAGS < 0) PUTSYM('*');
      }
      PRINTLINE();
      P = P + 1;
    } while (P < OLDEXPLO);
    OLDEXPLO = EXPLO;
    PUTSTRING(
        _imp_str_literal("      +---------------------------------------+"));
    PRINTLINE();
    _imp_leave();
  }
  auto void CROAK(_imp_string S) {
    _imp_enter();
    SELECTOUTPUT(0);
    PUTSTRING(_imp_str_literal("** "));
    PUTSTRING(S);
    PUTSTRING(_imp_str_literal(".  Compilation abandoned at line "));
    PUTNUM(LINE);
    PRINTLINE();
    _imp_signal(ABANDON, 0, 0, _imp_str_literal(""));
    _imp_leave();
  }
  const int INTERNERR = 1;
  const int PLEXERR = 2;
  const int CREACHERR = 3;
  const int REACHERR = 4;
  const int NORESULT = 5;
  const int DREACHERR = 6;
  const int FORMERR = 7;
  const int ATOMERR = 8;
  const int NAMERR = 9;
  const int CLASSERR = 10;
  const int SIZERR = 11;
  const int TYPERR = 12;
  const int BOUNDSERR = 13;
  const int UNENDING = 14;
  const int LOWLEVEL = 15;
  const int ACCESSERR = 16;
  const int NOTINLOOP = 17;
  const int NOTINROUT = 18;
  const int NOTINFUN = 19;
  const int NOTINPRED = 20;
  const int DUPERR = 21;
  const int ORDERERR = 22;
  const int MATCHERR = 23;
  const int RANGERR = 24;
  const int NONLITERAL = 25;
  const int MOPERR = 26;
  const int NOCYCLE = 27;
  const int NOSTART = 28;
  const int NOIF = 29;
  const int ILLSTARRED = 30;
  const int NONSTARTER = 31;
  const int NONVAR = 32;
  const int NONREF = 33;
  const int TOOFEW = 34;
  const int TOOMANY = 35;
  const int NOBEGIN = 36;
  const int DUBIOUS = 37;
  const int NOTINBLOCK = 38;
  const int NONSTAND = 39;
  const int NOTIN = 40;
  const int ASSERR = 41;
  const int NOEND = 42;
  const int NOFINISH = 43;
  const int NOREPEAT = 44;
  const int COUNTERR = 45;
  const int SLABMISSING = 46;
  const int IDMISSING = 47;
  const int POINT = 64;
  const int WARN = -128;
  const int NOW = 128;
  auto void REPORT(int N, int ID, int NUM) {
    _imp_enter();
    static int LASTCHANGE = 0;
    int MARK;
    int START;
    int ERRLINE;
    auto void PRINTTEXT(int STREAM) {
      _imp_enter();
      const int ESC = 27;
      int K;
      int P;
      const _imp_string MESSAGE[44 - 1 + 1] = {
          _imp_str_literal("Internal error "),
          _imp_str_literal("Reg not free"),
          _imp_str_literal("Out of reach "),
          _imp_str_literal(" out of reach!"),
          _imp_str_literal("RESULT missing"),
          _imp_str_literal("Out of reach"),
          _imp_str_literal("Faulty form"),
          _imp_str_literal("Unknown atom"),
          _imp_str_literal("Unknown name"),
          _imp_str_literal("Wrong class"),
          _imp_str_literal("Wrong size"),
          _imp_str_literal("Wrong type"),
          _imp_str_literal("Inside out"),
          _imp_str_literal("Endless loop"),
          _imp_str_literal("Low level"),
          _imp_str_literal("Not accessible"),
          _imp_str_literal("Not in loop"),
          _imp_str_literal("Not in routine"),
          _imp_str_literal("Not in fn/map"),
          _imp_str_literal("Not in pred"),
          _imp_str_literal("Duplicate"),
          _imp_str_literal("Out of order"),
          _imp_str_literal("Mismatch"),
          _imp_str_literal("Out of range"),
          _imp_str_literal("Not literal"),
          _imp_str_literal("Faulty operand"),
          _imp_str_literal("%CYCLE missing"),
          _imp_str_literal("%START missing"),
          _imp_str_literal("Extra %ELSE"),
          _imp_str_literal("Ill-starred"),
          _imp_str_literal("Non-starter"),
          _imp_str_literal("Not variable"),
          _imp_str_literal("Not reference"),
          _imp_str_literal("Too few args"),
          _imp_str_literal("Too many args"),
          _imp_str_literal("%BEGIN missing"),
          _imp_str_literal("Dubious usage"),
          _imp_str_literal("Not in block"),
          _imp_str_literal("Nonstandard "),
          _imp_str_literal("Not supported"),
          _imp_str_literal(" void"),
          _imp_str_literal("%END missing"),
          _imp_str_literal("%FINISH missing"),
          _imp_str_literal("%REPEAT missing")};
      PUTSYM(MARK);
      if (ERRLINE < 1000) PUTSYM(' ');
      if (ERRLINE < 100) PUTSYM(' ');
      if (ERRLINE < 10) PUTSYM(' ');
      PUTNUM(ERRLINE);
      PUTSYM(LISTFLAG);
      PUTSYM(' ');
      K = N & 63;
      if (K >= COUNTERR) {
        if (K == COUNTERR) {
          if (NUM < 0) {
            PUTNUM(-NUM);
            PUTSTRING(_imp_str_literal(" extra"));

          } else {
            if (NUM != 0) PUTNUM(NUM);
            PUTSTRING(_imp_str_literal(" missing"));
          }
          PUTSTRING(_imp_str_literal(" value(s) for "));
          PUTIDENT(ID, 0);
          {
            _imp_leave();
            return;
          }
        }
        if (K != SLABMISSING) {
          PUTIDENT(ID, 1);

        } else {
          PUTIDENT(ID, 0);
          PUTSYM('(');
          PUTNUM(NUM);
          PUTSYM(')');
        }
        PUTSTRING(_imp_str_literal(" missing"));
      MEND:;
        if (C.DPID->TEXT != 0) {
          PUTSTRING(_imp_str_literal(" in "));
          PUTIDENT(C.PID, -1);
        }
        {
          _imp_leave();
          return;
        }
      }
      if (ID > 0) PUTIDENT(ID, 0);
      PUTSTRING(MESSAGE[K]);
      if (NUM > 0) PUTNUM(NUM);
      if (CREACHERR <= K && K <= NORESULT)
        goto MEND; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      SPACES(22 - ());
      P = START;
      while (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ () == ' ') P = P + 1;
      if (P < FAULTP - 50) {
        P = FAULTP - 47;
        PUTSTRING(_imp_str_literal("..."));
      } else
        PUTSYM(' ');
      for (;;) {
        /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ K = MISSING_RHS;
        P = P + 1;
        if (P == FAULTP) {
          PUTSYM('|');

        } /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
        if (K == ()) break;
        PUTSYM(K);
      }
      {
        _imp_leave();
        return;
      }
      _imp_leave();
    }
    MARK = '?';
    if (N > 0) {
      MARK = '*';
      C.FAULTS = C.FAULTS + 1;
      FAULTS = FAULTS + 1;
    }
    FAULTNUM = 0;
    C.ACCESS = -1;
    if (FILE[MAIN].START1 <= FP && FP < LASTCHANGE) {
      _imp_leave();
      return;
    }
    START = LINESTART;
    ERRLINE = LINE;
    if ((N & POINT) == 0) {
      FAULTP = 0;

    } else {
      while (START >= FAULTP) {
        START = START - 1; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
            /*ERROR: name_sym_idx is -1!*/                /*C_NAME*/
        if (() == ()) ERRLINE = ERRLINE - 1;
      }
      while (/*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
                 /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ START != CURSTART &&
             () != ())
        START = START - 1;
    }
    TIME1 = TIME1 - CPUTIME();
    if (LISTOUT != 0) {
      PRINTTEXT(LISTOUT);
      PRINTLINE();
    }
    SELECTOUTPUT(0);
    if (CURFILE != LASTFILE) {
      LASTFILE = CURFILE;
      PUTSTRING(CUR->NAME);
      PRINTLINE();
    }
    PRINTTEXT(0);
    if (N > REACHERR && CURFILE == MAIN && (CONTROL & EDITBIT) != 0) {
      if (FAULTP > START) START = FAULTP - 1;
      CUR->FP = START;
      CUR->LINE = LINE;
      if (LASTCHANGE != 0) CUR->CHANGE = 0x7FFFFFFE;
      SELECTINPUT(0);
      FILE[MAIN + 1] = 0;
      EDI(FILE[MAIN], FILE[MAIN + 1], REP);
      REP = _imp_str_literal("");
      SELECTOUTPUT(LISTOUT);
      TIME1 = TIME1 + CPUTIME();
      if (CUR->FLAG < 0) _imp_signal(ABANDON, 0, 0, _imp_str_literal(""));
      if (CUR->FLAG == 'I') CONTROL = CONTROL & (~EDITBIT);
      if (CUR->CHANGE < 0x7FFFFFFE) {
        LASTCHANGE = CUR->CHANGE;
        _imp_signal(REDO, 0, 0, _imp_str_literal(""));
      }

    } else {
      PRINTLINE();
      SELECTOUTPUT(LISTOUT);
      TIME1 = TIME1 + CPUTIME();
    }
    _imp_leave();
  }
  auto void FAULT(int N) {
    _imp_enter();
    if (FAULTNUM == 0 || (N > 0 && FAULTNUM < 0)) {
      FAULTNUM = N;
      FAULTP = ATOMP;
      if (FAULTNUM >= NOW) REPORT(FAULTNUM & 127, 0, 0);
    }
    _imp_leave();
  }
  auto void INTERN(int N) {
    _imp_enter();
    REPORT(INTERNERR, 0, N);
    _imp_leave();
  }
  auto int LITREF(int V) {
    _imp_enter();
    int I;
    if (V == 0) return (V);
    if (V > 0) {
      if (V <= SMALLMAX) return (-(V << 1));

    } else {
      if (V >= SMALLMIN) return ((V << 1) + 1);
    }
    LITSTORE[LITPOS] = V;
    I = LITMIN - 1;
    do
      I = I + 1;
    while (LITSTORE[I] != V);
    if (I == LITPOS) {
      LITPOS = LITPOS + 1;
      if (LITPOS >= LITMAX) CROAK(_imp_str_literal("Too many literals"));
    }
    return (I);
    _imp_leave();
  }
  auto void PUTEXP(int ACT, int X, int Y, int T) {
    _imp_enter();
    TYPE = T;
    ITEM = EXPLIM;
    if (EXPLO <= X && X < ITEM) ITEM = X;
    if (EXPLO <= Y && Y < ITEM) ITEM = Y;
    do {
      ITEM = ITEM - 1;
      DITEM = &DICT[ITEM];
      if (ITEM < EXPLO) {
        EXPLO = ITEM;
        DITEM->ACT = ACT;
        DITEM->X = X;
        DITEM->Y = Y;
        DITEM->FLAGS = 0;
        DITEM->TYPE = T;
        DITEM->MODE = 0;
        break;
      }
    } while (DITEM->ACT != ACT || DITEM->X != X || DITEM->Y != Y);
    _imp_leave();
  }
  auto void PUTEXP2(int OP, int FIRST, int T) {
    _imp_enter();
    if (ITEM == 0) {
      ITEM = LITREF(VALUE);
    }
    PUTEXP(OP, FIRST, ITEM, T);
    _imp_leave();
  }
  auto int NORMITEM(void) {
    _imp_enter();
    if (ITEM != 0) return (ITEM);
    return (LITREF(VALUE));
    _imp_leave();
  }
  auto void TOREAL(void) {
    _imp_enter();
    if (ITEM != 0)
      PUTEXP(FLOAT, ITEM, 0, REALTYPE);
    else { /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
           /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      VALUE;
      TYPE = REALTYPE;
    }
    _imp_leave();
  }
  auto int TEMP(int M, int V) {
    _imp_enter();
    DTEMP->MODE = M;
    DTEMP->VAL = V;
    return (LABLIM);
    _imp_leave();
  }
  auto int TEMPX(int R1, int R2) {
    _imp_enter();
    DTEMP->MODE = R1 + (INDEXMODE - A0);
    DTEMP->VAL = ((R2 - D0) << 12) + 0x0800;
    return (LABLIM);
    _imp_leave();
  }
  auto int TEMPD(int A, int DISP) {
    _imp_enter();
    DTEMP->MODE = A + (DISPMODE - A0);
    DTEMP->VAL = DISP;
    return (LABLIM);
    _imp_leave();
  }
  auto int TEMPX2(int R1, int R2) {
    _imp_enter();
    DTEMP2->MODE = R1 + (INDEXMODE - A0);
    DTEMP2->VAL = ((R2 - D0) << 12) + 0x0800;
    return (LABLIM + 1);
    _imp_leave();
  }
  const int LEA = 78;
  const int PEA = 55;
  const int CLR = 52;
  const int DBRA = 81;
  const int JSR = 56;
  const int LINK = 72;
  const int UNLK = 73;
  const int RTS = 68;
  const int MOVEM = 100;
  const int TRAPI = 101;
  const int DC = 102;
  const int SHIFT = 32;
  const int REG = 1;
  const int AREG = 2;
  const int IREG = 3;
  const int QUICK = 4;
  const int MQUICK = 5;
  const int EA = 6;
  const int RWEA = 7;
  const int WEA = 8;
  const int IMM = 9;
  const int TQUICK = 10;
  const int REL = 11;
  const int LONGREL = 12;
  const int QREG = 13;
  const int POSTAREG = 14;
  const int QEA = 15;
  const int REVEA = 16;
  const int XIMM = 17;
  const int DATA = 18;
  const int PREAREG = 19;
  const int QPRE = 20;
  const int EXREG = 21 + SHIFT;
  const int REG9 = REG + SHIFT;
  const int QREG9 = QREG + SHIFT;
  const int IREG9 = IREG + SHIFT;
  const int POSTAREG9 = POSTAREG + SHIFT;
  const int QUICK9 = QUICK + SHIFT;
  const int AREG9 = AREG + SHIFT;
  const int SIZED = 1 << 15;
  const int ASIZED = 1 << 14;
  const int REVERSIBLE = (REVEA << 6) + REG9 + SIZED;
  const int MULTIPLE = (XIMM << 6) + EA + ASIZED;
  const int DEFMAX = 129;
  const int DEF[DEFMAX + DEFMAX - 0 + 1] = {
    0, (0x0000 << 16) + (EA << 6) + WEA + SHIFT + SIZED, -621079552,
    (0xD000 << 16) + REVERSIBLE, -1035862016, (0x9000 << 16) + REVERSIBLE,
    -414121984, (0xB000 << 16) + (EA << 6) + REG9 + SIZED, -958922752,
    (0xC000 << 16) + REVERSIBLE, -1025376256, (0x8000 << 16) + REVERSIBLE,
    -551550976, (0xB100 << 16) + (REG9 << 6) + RWEA + SIZED, -889651200,
    (0x4600 << 16) + RWEA + SIZED, -587595776, (0x4400 << 16) + RWEA + SIZED,
    -598507520, (0xE108 << 16) + (QREG9 << 6) + REG + SIZED, -650772480,
    (0xE008 << 16) + (QREG9 << 6) + REG + SIZED, -650575872,
    (0xC1C0 << 16) + (EA << 6) + REG9, -615101440,
    (0x81C0 << 16) + (EA << 6) + REG9, -929346560,
    (0xC0C0 << 16) + (EA << 6) + REG9, -615099392,
    (0x80C0 << 16) + (EA << 6) + REG9, -929344512, (0x6000 << 16) + REL,
    -987725824, (0x6100 << 16) + REL, -986120192, (0x6200 << 16) + REL,
    -997949440, (0x6300 << 16) + REL, -993427456, (0x6400 << 16) + REL,
    -1003388928, (0x6500 << 16) + REL, -1002864640, (0x6600 << 16) + REL,
    -991789056, (0x6700 << 16) + REL, -1000833024, (0x6800 << 16) + REL,
    -983465984, (0x6900 << 16) + REL, -982941696, (0x6A00 << 16) + REL,
    -989462528, (0x6B00 << 16) + REL, -992706560, (0x6C00 << 16) + REL,
    -999129088, (0x6D00 << 16) + REL, -993394688, (0x6E00 << 16) + REL,
    -998637568, (0x6F00 << 16) + REL, -993886208,
    (0xE100 << 16) + (QREG9 << 6) + REG + SIZED, -1019871232,
    (0xE000 << 16) + (QREG9 << 6) + REG + SIZED, -1019674624,
    (0xE118 << 16) + (QREG9 << 6) + REG + SIZED, -453640192,
    (0xE018 << 16) + (QREG9 << 6) + REG + SIZED, -453443584,
    (0x7000 << 16) + (MQUICK << 6) + REG9, -621079008,
    (0x5000 << 16) + (QUICK9 << 6) + RWEA + SIZED, -1035844608,
    (0x5100 << 16) + (QUICK9 << 6) + RWEA + SIZED, -414104576,
    (0x3040 << 16) + (EA << 6) + AREG9 + ASIZED, -621079520,
    (0xD0C0 << 16) + (EA << 6) + AREG9 + ASIZED, -1035860992,
    (0x90C0 << 16) + (EA << 6) + AREG9 + ASIZED, -414120960,
    (0xB0C0 << 16) + (EA << 6) + AREG9 + ASIZED, -958921728,
    (0xB108 << 16) + (POSTAREG << 6) + POSTAREG9, -958909440,
    (0x0600 << 16) + (IMM << 6) + RWEA + SIZED, -1035852800,
    (0x0400 << 16) + (IMM << 6) + RWEA + SIZED, -414112768,
    (0x0C00 << 16) + (IMM << 6) + EA + SIZED, -958913536,
    (0x0200 << 16) + (IMM << 6) + RWEA + SIZED, -1025367040,
    (0x0000 << 16) + (IMM << 6) + RWEA + SIZED, -551256064,
    (0x0A00 << 16) + (IMM << 6) + RWEA + SIZED, -889641984,
    (0xE110 << 16) + (QREG9 << 6) + REG + SIZED, -453234688,
    (0xE010 << 16) + (QREG9 << 6) + REG + SIZED, -453228544,
    (0x4200 << 16) + WEA + SIZED, -959905792, (0x4000 << 16) + RWEA + SIZED,
    -598482944, (0x4800 << 16) + RWEA, -601780224, (0x4840 << 16) + EA,
    -531595264, (0x4E80 << 16) + EA, -717684736, (0x4EC0 << 16) + EA,
    -724041728, (0x4AC0 << 16) + RWEA, -400982016, (0x4A00 << 16) + EA + SIZED,
    -382074880, (0xC100 << 16) + (QPRE << 6) + REG9, -1037987840,
    (0x8100 << 16) + (QPRE << 6) + REG9, -434008064,
    (0xD100 << 16) + (QPRE << 6) + REG9 + SIZED, -1035837440,
    (0x9100 << 16) + (QPRE << 6) + REG9 + SIZED, -414097408, 1316028416,
    -587726848, 1315962880, -463890816, 1316159488, -448626688, 1316421632,
    -448200704, 1316290560, -448167936, (0x4E72 << 16) + IMM, -414728192,
    1316356096, -383728960, (0x4E40 << 16) + TQUICK, -383729664,
    (0x4E50 << 16) + (IMM << 6) + AREG, -661181440, (0x4E58 << 16) + AREG,
    -354014208, (0x4840 << 16) + REG, -412041216, (0x4880 << 16) + REG,
    -880124928, (0x48C0 << 16) + REG, -880136192,
    (0xC140 << 16) + (EXREG << 6) + REG, -880574464,
    (0x41C0 << 16) + (QEA << 6) + AREG9, -665812992,
    (0x4180 << 16) + (EA << 6) + REG9, -964329472,
    (0x50C8 << 16) + (REG << 6) + LONGREL, -936615936,
    (0x51C8 << 16) + (REG << 6) + LONGREL, -936836096,
    (0x52C8 << 16) + (REG << 6) + LONGREL, -937155584,
    (0x53C8 << 16) + (REG << 6) + LONGREL, -937014272,
    (0x54C8 << 16) + (REG << 6) + LONGREL, -937325568,
    (0x55C8 << 16) + (REG << 6) + LONGREL, -937309184,
    (0x56C8 << 16) + (REG << 6) + LONGREL, -936963072,
    (0x57C8 << 16) + (REG << 6) + LONGREL, -937245696,
    (0x58C8 << 16) + (REG << 6) + LONGREL, -936702976,
    (0x59C8 << 16) + (REG << 6) + LONGREL, -936686592,
    (0x5AC8 << 16) + (REG << 6) + LONGREL, -936890368,
    (0x5BC8 << 16) + (REG << 6) + LONGREL, -936991744,
    (0x5CC8 << 16) + (REG << 6) + LONGREL, -937192448,
    (0x5DC8 << 16) + (REG << 6) + LONGREL, -937013248,
    (0x5EC8 << 16) + (REG << 6) + LONGREL, -937177088,
    (0x5FC8 << 16) + (REG << 6) + LONGREL, -937028608,
    (0x0140 << 16) + (IREG9 << 6) + RWEA, -1003217920, (0x0180 << 16)