#include <perms.h>
static const int Maxname = 127;
typedef struct Edfile {
  int Start1;
  int Lim1;
  int Start2;
  int Lim2;
  int Lim;
  int Lbeg;
  int Fp;
  int Change;
  int Flag;
  int Line;
  int Diff;
  int Shift;
  unsigned char Top;
  unsigned char Win;
  unsigned char Bot;
  unsigned char Min;
  unsigned char Row;
  unsigned char Col;
  _imp_string Name;
} Edfile;
void Edi(Edfile *Main, Edfile *Sec, _imp_string Message) {}
void Connectedfile(Edfile *F) {}
void Disconnectedfile(Edfile *F) {}
static const _imp_string Permfile = _imp_str_literal("ECCE_PERM");
static const int Logbit = 0x00040000;
static const int Warnbit = 0x00020000;
static const int Nonsbit = 0x00010000;
static const int Dictlist = 0x00001000;
static const int Explist = 0x00000800;
static int Control = Warnbit + Nonsbit;
void Ecceci(Edfile *Main) {
  static _imp_string Extraname;
  static Edfile Extra = 0;
  static Edfile Null = 0;
  int Curstart;
  int Curlim;
  int Nonstop;
  static int Change = 0;
  static const int Formerr = 0;
  static const int Atomerr = 1;
  static const int Namerr = 2;
  static const int Caterr = 3;
  static const int Sizerr = 4;
  static const int Asserr = 5;
  static const int Typerr = 6;
  static const int Duperr = 7;
  static const int Nostart = 8;
  static const int Nocycle = 9;
  static const int Ordererr = 10;
  static const int Matcherr = 11;
  static const int Rangerr = 12;
  static const int Nonliteral = 13;
  static const int Boundserr = 14;
  static const int Accesserr = 15;
  static const int Notinloop = 16;
  static const int Notinrout = 17;
  static const int Notinfun = 18;
  static const int Notinpred = 19;
  static const int Plexerr = 20;
  static const int Noif = 21;
  static const int Nonstand = 22;
  static const int Notin = 23;
  static const int Indexerr = 24;
  static const int Moperr = 27;
  static const int Noterm = 28;
  static const int Nonstarter = 29;
  static const int Nonvar = 30;
  static const int Nonref = 31;
  static const int Toomany = 32;
  static const int Toofew = 33;
  static const int Unwanted = 34;
  static const int Noparm = 35;
  static const int Unending = 37;
  static const int Selfref = 38;
  static const int Noend = 40;
  static const int Nobegin = 41;
  static const int Idmissing = 42;
  static const int Nofinish = 43;
  static const int Norepeat = 44;
  static const int Counterr = 45;
  static const int Noresult = 46;
  static const int Errmax = 46;
  static const int Point = 64;
  static const int Warn = 128;
  static int Faultnum = 0;
  static int Faults = 0;
  static const int Maxint = 0x7FFFFFFF;
  static const int Minint = ~Maxint;
  static const int Max10 = Maxint / 10;
  static const int Maxdig = Maxint - Max10 * 10;
  static const int False = 0;
  static const int True = 1;
  int I;
  static int Statements = 0;
  static const int Smallmin = -1000;
  static const int Smallmax = 1000;
  static const int Litmin = Smallmax + 1;
  static const int Litmax = Smallmax + 1000;
  static const int D0 = Litmax + 1;
  static const int D1 = D0 + 1;
  static const int D2 = D0 + 2;
  static const int D6 = D0 + 6;
  static const int D7 = D0 + 7;
  static const int A0 = D0 + 8;
  static const int A1 = A0 + 1;
  static const int A6 = A0 + 6;
  static const int A7 = A0 + 7;
  static const int Inda0 = A0 + 8;
  static const int Posta0 = Inda0 + 8;
  static const int Posta7 = Posta0 + 7;
  static const int Prea0 = Posta0 + 8;
  static const int Prea7 = Prea0 + 7;
  static const int Dictmin = Prea0 + 8;
  static const int Dictmax = Prea0 + 1200;
  static const int Labmin = Dictmax + 1;
  static const int Lab1 = Labmin + 1;
  static const int Labmax = Labmin + 20;
  static const int Expmin = Labmax + 1;
  static const int Expmax = Labmax + 300;
  static const int Undef = Expmax + 1;
  static const int Ad = 0x4000;
  static const int Maxdreg = D0 + 4;
  static const int Maxareg = A0 + 3;
  static const int D0b = 1;
  static const int D1b = 2;
  static const int D2b = 4;
  static const int A0b = 0x100;
  static const int A1b = 0x200;
  static const int A2b = 0x400;
  static const int Allregs = 0b0000111100011111;
  static int Free = Allregs;
  static const int Nulltype = Dictmin;
  static const int Recy = Nulltype + 1;
  static const int Arry = Recy + 1;
  static const int Stringy = Arry + 1;
  static const int Realy = Stringy + 1;
  static const int Inty = Realy + 1;
  static const int Chartype = Inty + 1;
  static const int Booltype = Chartype + 1;
  static const int Falseconst = Booltype + 1;
  static const int Trueconst = Booltype + 2;
  static const int Inttype = Trueconst + 1;
  static const int Shorttype = Inttype + 1;
  static const int Halftype = Shorttype + 1;
  static const int Bytetype = Halftype + 1;
  static const int Mitetype = Bytetype + 1;
  static const int Bittype = Mitetype + 1;
  static const int Longinttype = Bittype + 1;
  static const int Realtype = Longinttype + 1;
  static const int Longrealtype = Realtype + 1;
  static const int Puretype = 8191;
  static const int Direct = 8192;
  static const int Indirect = 16384;
  static const int Anyint = Inty + Direct;
  static const int Anyintvar = Inty + Indirect;
  static const int Anystring = Stringy + Direct;
  static const int Anystringvar = Stringy + Indirect;
  static const int Anyname = Nulltype + Indirect;
  static int Dictshown = Dictmin;
  static int Litpos = Litmin;
  static int Slitpos = Litmax;
  int Litstore[1000 /*1001:2000*/];
  static const int Bytesize = 1;
  static const int Wordsize = 2;
  static const int Longsize = 3;
  static const int Sizemask = 0xC0;
  static const int Sizeshift = 6;
  static const int Dmode = 0;
  static const int Amode = 0b001000;
  static const int Indmode = 0b010000;
  static const int Postmode = 0b011000;
  static const int Premode = 0b100000;
  static const int Dispmode = 0b101000;
  static const int Indexmode = 0b110000;
  static const int Absmode = 0b111000;
  static const int Pcmode = 0b111010;
  static const int Litmode = 0b111100;
  static const int Ownmode = Dispmode + 6;
  typedef struct Objinfo {
    int Flags;
    int Type;
    int Val;
  } Objinfo;
  typedef struct Identinfo {
    int Text;
    int Link;
  } Identinfo;
  static const int Var = 0x0001;
  static const int Lab = 0x0002;
  static const int Proc = 0x0004;
  static const int Static = 0x0008;
  static const int Spec = 0x0010;
  static const int Ext = 0x0020;
  static const int Parm = 0x0040;
  static const int More = 0x0080;
  static const int Typeid = 0x0100;
  static const int Okflag = 0x0200;
  static const int Alt = 0x0800;
  static const int Rflag = 0x1000;
  static const int Wflag = 0x2000;
  Identinfo Dict[1254 /*2001:3254*/];
  static int Dlim = Trueconst + 1;
  static int Dlim0;
  static int Permlim = Dictmin;
  static int Dmin = Dictmax - 1;
  static const int Charbound = 6000;
  unsigned char Char[6001 /*0:6000*/];
  int Charbase;
  int Charlim;
  int Charmin;
  int Newlen;
  int Hashindex[256 /*0:255*/];
  int *Head;
  static int Explo = Expmax + 1;
  static int Oldexplo = Expmax + 1;
  static const int Np0 = Expmin;
  static int Np;
  static int Condnp;
  static int Instnp;
  static const int End = 1;
  static const int Repeat = 2;
  static const int Finish = 3;
  static const int Else = 4;
  static const int Begin = 5;
  static const int Exit = 6;
  static const int Return = 7;
  static const int Tf = 8;
  static const int Result = 9;
  static const int Stop = 10;
  static const int Goto = 11;
  static const int Signal = 12;
  static const int Monitor = 13;
  static const int On = 15;
  static const int Iu = 16;
  static const int While = 17;
  static const int Until = 18;
  static const int For = 19;
  static const int Then = 20;
  static const int Start = 21;
  static const int Cycle = 22;
  static const int Keylabel = 23;
  static const int Prefix = 24;
  static const int Krange = 25;
  static const int Keylong = 26;
  static const int Keyinteger = 27;
  static const int Keyreal = 28;
  static const int Keystring = 29;
  static const int Keyrecord = 30;
  static const int Keyformat = 31;
  static const int Fnmap = 32;
  static const int Rpred = 33;
  static const int Keyspec = 34;
  static const int Keyarray = 35;
  static const int Keyname = 36;
  static const int Keyswitch = 37;
  static const int Of = 38;
  static const int Keyfile = 39;
  static const int Program = 40;
  static const int Keylist = 41;
  static const int Keycontrol = 42;
  static const int Comment = 43;
  static const int Keyevent = 44;
  static const int Include = 45;
  static const int Alias = 46;
  static const int Keynot = 47;
  static const int Keyand = 64;
  static const int Keyor = 65;
  static const int Syminit[26 /*97:122*/] = {2,   15,  27,  57, 64,  87,  118, 122, 126, 1,   1, 141, 154,
                                             168, 175, 184, 1,  199, 230, 270, 278, 1,   288, 1, 1,   1};
  static const unsigned char Symbol[292 /*1:292*/] = {
      128, 114, 114, 97,  121, 163, 108, 105, 97,  115, 174, 110, 100, 192, 101, 103, 105, 110, 133, 121, 116, 101, 153,
      105, 116, 153, 111, 110, 116, 105, 110, 117, 101, 134, 121, 99,  108, 101, 150, 109, 109, 101, 110, 116, 171, 115,
      116, 97,  110, 116, 152, 152, 114, 111, 108, 170, 121, 110, 97,  109, 105, 99,  152, 110, 100, 129, 108, 115, 101,
      132, 120, 105, 116, 134, 118, 101, 110, 116, 172, 116, 101, 114, 110, 97,  108, 152, 105, 110, 105, 115, 104, 131,
      97,  108, 115, 101, 136, 111, 114, 109, 97,  116, 159, 110, 160, 117, 110, 99,  116, 105, 111, 110, 160, 147, 108,
      101, 167, 111, 116, 111, 139, 97,  108, 102, 153, 102, 144, 110, 116, 101, 103, 101, 114, 155, 99,  108, 117, 100,
      101, 173, 97,  98,  101, 108, 151, 111, 110, 103, 154, 105, 115, 116, 169, 111, 110, 105, 116, 111, 114, 141, 105,
      116, 101, 153, 97,  112, 160, 97,  109, 101, 164, 111, 116, 175, 110, 143, 119, 110, 152, 102, 166, 114, 193, 114,
      101, 100, 105, 99,  97,  116, 101, 161, 111, 103, 114, 97,  109, 168, 101, 112, 101, 97,  116, 130, 111, 117, 116,
      105, 110, 101, 161, 116, 117, 114, 110, 135, 115, 117, 108, 116, 137, 97,  108, 156, 99,  111, 114, 100, 158, 116,
      111, 112, 138, 105, 103, 110, 97,  108, 140, 121, 115, 116, 101, 109, 152, 104, 111, 114, 116, 153, 112, 101, 99,
      162, 119, 105, 116, 99,  104, 165, 97,  114, 116, 149, 114, 105, 110, 103, 157, 114, 117, 101, 136, 104, 101, 110,
      148, 110, 108, 101, 115, 115, 144, 116, 105, 108, 146, 104, 105, 108, 101, 145};
  static const unsigned char Altdisp[292 /*1:292*/] = {
      0,  5,  0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0,  5, 0, 0, 0, 0, 4,  0, 0,  3, 0, 0, 5, 8, 12, 17, 23, 0, 0, 0,
      0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  4, 0, 0, 9, 9, 0,  0, 0,  0, 0, 0, 0, 0, 0,  0,  40, 3, 0, 0,
      4,  0,  0, 0, 4, 8, 0, 1, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 40, 6, 27, 0, 0, 0, 0, 5, 0,  0,  0,  0, 6, 0,
      14, 0,  0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0,  0, 0,  0, 0, 0, 2, 2, 0,  0,  6,  0, 0, 0,
      0,  0,  0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 4,  0, 0, 0, 0, 0, 0,  0, 7,  0, 0, 0, 0, 0, 0,  4,  0,  0, 4, 0,
      0,  1,  4, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 8,  2, 0, 0, 0, 0, 8,  0, 0,  0, 0, 0, 0, 1, 0,  0,  0,  0, 0, 0,
      6,  12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5,  0, 0, 0, 0, 5, 0,  0, 0,  0, 3, 0, 0, 0, 0,  0,  0,  0, 4, 30,
      0,  0,  6, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 40, 5, 0, 0, 0, 1, 4,  0, 0,  0, 0, 0, 0, 0, 0,  0,  4,  0, 0, 0,
      0,  0,  0, 0, 0, 4, 0, 0, 1, 0, 0, 0, 0, 0,  5, 0, 0, 0, 1, 0,  0, 0,  1, 0, 0, 0, 0, 0};
  static const int Terminator = 52;
  static const int Const = 53;
  static const int Ident = 54;
  static const int Aref = 55;
  static const int Recref = 56;
  static const int Modsign = 57;
  static const int Colon = 58;
  static const int Comma = 59;
  static const int Right = 60;
  static const int Rightbracket = 61;
  static const int Dud = 63;
  static const int Booland = 64;
  static const int Boolor = 65;
  static const int Boolnot = 66;
  static const int Float = 67;
  static const int Imod = 68;
  static const int Fmod = 69;
  static const int Equals = 70;
  static const int Noteq = 71;
  static const int Lesseq = 72;
  static const int Less = 73;
  static const int Greateq = 74;
  static const int Greater = 75;
  static const int Eqeq = 76;
  static const int Noteqeq = 77;
  static const int Resolve = 79;
  static const int Plus = 80;
  static const int Minus = 81;
  static const int Logor = 82;
  static const int Logxor = 83;
  static const int Concat = 84;
  static const int Mult = 88;
  static const int Fdiv = 89;
  static const int Idiv = 90;
  static const int Logand = 91;
  static const int Fpower = 96;
  static const int Ipower = 97;
  static const int Lshift = 100;
  static const int Rshift = 101;
  static const int Lognot = 102;
  static const int Fcall = 106;
  static const int Mcall = 107;
  static const int Atommax = 107;
  static const int Swgoto = 35;
  static const int Rcall = Mcall + 2;
  static const int Assign = 41;
  static const int Jamassign = 42;
  static const int Plusass = 43;
  static const int Compare = 44;
  static const int Jump = 45;
  static const int Label = 46;
  static const int Adecl = 47;
  static const int Actmax = 49;
  static const int Eq = 0b0111;
  static const int Ne = 0b0110;
  static const int Gt = 0b1110;
  static const int Le = 0b1111;
  static const int Lt = 0b1101;
  static const int Ge = 0b1100;
  static const int Cc = 0b0100;
  static const int Cs = 0b0101;
  static const int Double = 16;
  static const int Dshort = Dictmin + 6;
  static const int Dlength = Dshort + 1;
  static const int Dcharno = Dlength + 1;
  static const int Daddr = Dcharno + 1;
  static const int Dtostr = Daddr + 1;
  static const int Drem = Dtostr + 1;
  static const int Dnextsym = Drem + 1;
  static const int Dreadsym = Dnextsym + 1;
  static const int Dprintstr = Dreadsym + 3;
  static const int Dread = Dictmin + 27;
  static const int Dnewline = Dictmin + 41;
  static const int Sigentry = 0x1114;
  static const int Scompentry = 0x1128;
  static const int Boundentry = 0x1134;
  static const int Agetentry = 0x1138;
  static const int Indexentry = 0x113C;
  static const int Ireadentry = 0x1118;
  static int Starts = 0;
  static int Cycles = 0;
  static int Looplab = 0;
  static int Curlab = Lab1;
  typedef struct Blockinf {
    int Sp;
    int Delta;
    int Fortemps;
    int Flags;
    int Type;
    int Localdpos;
    int Parlim;
    int Localtext;
    int Localpc;
    int Localspc;
    int Pidpos;
    int Access;
    int Forward;
    int Events;
    int Eventpc;
    int Faults;
    int Return;
    int Shorts;
  } Blockinf;
  static const int Wrongcc = 2;
  static const int Nonlocalref = 4;
  static const int Dynarray = 8;
  static const int Hadon = 0x10;
  static const int Hadinst = 0x20;
  static const int Outerlevel = 0;
  static const int Maxlevel = 16;
  static int Level = Outerlevel;
  Blockinf C;
  Blockinf Hold[16 /*0:15*/];
  static const int Purebound = 0;
  static const int Ownbase = Purebound + 1;
  static const int Finalbound = Ownbase + 8191;
  unsigned char Final[8193 /*0:8192*/];
  static int Finalad = 2;
  static int Ownad = Ownbase;
  static int Pc = 0;
  static int Spc = Finalbound;
  static const int Casemask = 95;
  static const int Casebit = 32;
  static int Item = 0;
  Objinfo T;
  Identinfo *Ditem;
  static int Elements;
  static int Hash;
  static int Speccing = 0;
  static int Mcoding = 0;
  static int Declmode;
  static int Dsize;
  static Identinfo D;
  static int Atom = 0;
  static int Matched = 1;
  static int Sym = Nl;
  static int Line = 0;
  static int Mainline = 0;
  static int Diagline = -9999;
  static int Proline = 0;
  static int Modesym = '&';
  static int Linestart = 0;
  static int Fp = 0;
  static int Chars = 0;
  static int Atomp = 0;
  static int Faultp = 0;
  static int Mainfp;
  static int Stringp;
  static int Expp;
  static int Listout = 0;
  static _imp_string Rep = _imp_str_literal("");
  void Newline(void) {
    Printstring(Rep);
    Printsymbol(Nl);
    Rep = _imp_str_literal("");
  }
  void Putsym(int K) {
    if (*Length(Rep) < 132) Rep = _imp_join(Rep, Tostring(K));
  }
  void Printstring(_imp_string S) {
    if (*Length(Rep) < 132) Rep = _imp_join(Rep, S);
  }
  void Spaces(int N) {
    while (N > 0) {
      Rep = _imp_join(Rep, _imp_str_literal(" "));
      N--;
    }
  }
  void Write(int Val, int P) {
    void Pd(int V) {
      P--;
      if (V <= -10) {
        Pd(V / 10);
        V -= V / 10 * 10;
      }
      if (P > 0) {
        Spaces(P);
        P = 0;
      }
      Putsym('0' - V);
    }
    if (Val < 0) {
      Putsym('-');
      Pd(Val);
    } else
      Pd(-Val);
  }
  void Report(int N, int Joker) {
    int Mark;
    int Start;
    int Errline;
    int K;
    int Editfp;
    void Printident(int X) {
      Putsym('"');
      Printstring(*String(Dict[X].Text + Charbase));
      Putsym('"');
    }
    void Printtext(int X, int Stream) {
      static const int Esc = 27;
      int K;
      int P;
      static int S_sw;
      static void *S[47 /*0:46*/] = {
          &&S_0,  &&S_1,  &&S_2,  &&S_3,  &&S_4,  &&S_5,       &&S_6,       &&S_7,  &&S_8,  &&S_9,
          &&S_10, &&S_11, &&S_12, &&S_13, &&S_14, &&S_15,      &&S_16,      &&S_17, &&S_18, &&S_19,
          &&S_20, &&S_21, &&S_22, &&S_23, &&S_24, &&S_default, &&S_default, &&S_27, &&S_28, &&S_29,
          &&S_30, &&S_31, &&S_32, &&S_33, &&S_34, &&S_35,      &&S_default, &&S_37, &&S_38, &&S_default,
          &&S_40, &&S_41, &&S_42, &&S_43, &&S_44, &&S_45,      &&S_46,
      };
      Putsym(Mark);
      Write(Line, 4);
      Putsym(Modesym);
      Putsym(' ');
      goto *S[S_sw = N & 63];
    S_0:
      Printstring(_imp_str_literal("Faulty form"));
      goto Print;
    S_1:
      Printstring(_imp_str_literal("Unknown atom"));
      goto Print;
    S_2:
      Printstring(_imp_str_literal("Unknown name"));
      goto Print;
    S_3:
      Printstring(_imp_str_literal("Unsuitable"));
      goto Print;
    S_4:
      Printstring(_imp_str_literal("Size"));
      goto Print;
    S_6:
      Printstring(_imp_str_literal("Wrong type"));
      goto Print;
    S_14:
      Printstring(_imp_str_literal("Inside out"));
      goto Print;
    S_37:
      Printstring(_imp_str_literal("Endless loop"));
      goto Print;
    S_24:
      Printstring(_imp_str_literal("Index"));
      goto Print;
    S_15:
      Printstring(_imp_str_literal("Not accessible"));
      goto Print;
    S_16:
      Printstring(_imp_str_literal("Not in loop"));
      goto Print;
    S_17:
      Printstring(_imp_str_literal("Not in routine"));
      goto Print;
    S_18:
      Printstring(_imp_str_literal("Not in fn/map"));
      goto Print;
    S_19:
      Printstring(_imp_str_literal("Not in pred"));
      goto Print;
    S_20:
      Printstring(_imp_str_literal("Too complex!"));
      goto Print;
    S_7:
      Printstring(_imp_str_literal("Duplicate"));
      goto Print;
    S_10:
      Printstring(_imp_str_literal("Out of order"));
      goto Print;
    S_11:
      Printstring(_imp_str_literal("Mismatch"));
      goto Print;
    S_12:
      Printstring(_imp_str_literal("Out of range"));
      goto Print;
    S_13:
      Printstring(_imp_str_literal("Not literal"));
      goto Print;
    S_22:
      Printstring(_imp_str_literal("Nonstandard"));
      goto Print;
    S_23:
      Printstring(_imp_str_literal("Not in yet"));
      goto Print;
    S_27:
      Printstring(_imp_str_literal("Faulty operand"));
      goto Print;
    S_9:
      Printstring(_imp_str_literal("Missing %CYCLE"));
      goto Print;
    S_8:
      Printstring(_imp_str_literal("Missing %START"));
      goto Print;
    S_21:
      Printstring(_imp_str_literal("Missing %IF"));
      goto Print;
    S_28:
      Printstring(_imp_str_literal("';' missing"));
      goto Print;
    S_29:
      Printstring(_imp_str_literal("Non-starter"));
      goto Print;
    S_30:
      Printstring(_imp_str_literal("Not variable"));
      goto Print;
    S_31:
      Printstring(_imp_str_literal("Not reference"));
      goto Print;
    S_35:
      Printstring(_imp_str_literal("No parameters"));
      goto Print;
    S_33:
      Printstring(_imp_str_literal("Too few"));
      goto Print;
    S_34:
      Printstring(_imp_str_literal("Unwanted"));
      goto Print;
    S_32:
      Printstring(_imp_str_literal("Too many"));
      goto Print;
    S_38:
      Printstring(_imp_str_literal("Self-reference"));
      goto Print;
    S_41:
      Printstring(_imp_str_literal("Extra %END"));
      goto Print;
    Print:;
      Spaces(21 - *Length(Rep));
      P = Start;
      if (P < Faultp - 50) {
        P = Faultp - 47;
        Printstring(_imp_str_literal("..."));
      } else
        Putsym(' ');
      for (;;) {
        K = *Byteinteger(P);
        P++;
        if (P == Faultp) {
          if (!Stream) {
            Putsym(Esc);
            Putsym('F');
          }
          Putsym('~');
          if (!Stream) {
            Putsym(Esc);
            Putsym('G');
          }
        }
        if (K == Nl) break;
        if (' ' <= K && K <= '~')
          Putsym(K);
        else {
          Putsym('[');
          Write(K, -1);
          Putsym(']');
        }
      }
      return;
    S_40:
      Printstring(_imp_str_literal("%END"));
      goto Mend;
    S_46:
      Printstring(_imp_str_literal("Result"));
      goto Mend;
    S_43:
      Printstring(_imp_str_literal("%FINISH"));
      goto Mend0;
    S_44:
      Printstring(_imp_str_literal("%REPEAT"));
    Mend0:
      if (Curlab > Lab1 + 2) Printstring(_imp_str_literal(" etc"));
      goto Mend;
    S_42:;
      do {
        Putsym(' ');
        Printident(X);
        if (!(Dict[X].Flags & Spec)) Printstring(_imp_str_literal("(?)"));
        X = Dict[X].Val;
      } while (X);
    Mend:;
      Printstring(_imp_str_literal(" missing"));
      if (C.Type) {
        Printstring(_imp_str_literal(" at END of "));
        Printident(C.Pidpos);
      } else
        N = 0;
      return;
    S_45:;
      if (Elements < 0) {
        Write(-Elements, 0);
        Printstring(_imp_str_literal(" extra"));
      } else {
        Write(Elements, 0);
        Printstring(_imp_str_literal(" missing"));
      }
      Printstring(_imp_str_literal(" value(s) for "));
      Printident(X);
      return;
    S_5:;
      Printident(X);
      Printstring(_imp_str_literal(" void"));
      goto S_skip;
    S_default:
      fprintf(stderr, "\nSwitch label 'S(%d):' not set in %s\n", S_sw, __PRETTY_FUNCTION__);
      fflush(stderr);
      abort();
    S_skip:;
    }
    Mark = '?';
    if (!(N & Warn)) {
      Mark = '*';
      C.Faults = C.Faults + 1;
      Faults++;
    }
    Faultnum = 0;
    C.Access = -1;
    if (Main.Start1 <= Fp && Fp < Change) return;
    Start = Linestart;
    Errline = Line;
    if (!(N & Point))
      Faultp = 0;
    else {
      if (Joker > 0) Faultp = Joker;
      while (Faultp <= Start) {
        Start--;
        if (*Byteinteger(Start) == Nl) Errline--;
      }
      while (Start != Curstart && *Byteinteger(Start - 1) != Nl) Start--;
    }
    Editfp = Start;
    if (Faultp > Start) Editfp = Faultp - 1;
    if (Curlim == Extra.Lim2) Editfp = Mainfp;
    while (*Byteinteger(Start) == ' ') Start++;
    Printtext(Joker, 0);
    if ((N & Warn) != 0 || Nonstop != 0) {
      Newline();
      return;
    }
    Main.Fp = Editfp;
    Main.Line = Line;
    if (Change) Main.Change = 0x7FFFFFFE;
    Edi(*Main, Null, Rep);
    Rep = _imp_str_literal("");
    if (Main.Flag == 'I') Nonstop = 1;
    if (Main.Flag < 0) exit(0);
    if (Main.Change < 0x7FFFFFFE) _imp_signal(12, 0, 0, _imp_str_literal(""));
  }
  void Croak(_imp_string S) {
    Printstring(_imp_join(_imp_str_literal("** "), _imp_join(S, _imp_str_literal(".  Checking abandoned at line "))));
    Write(Line, 0);
    Newline();
    Nonstop = -999;
    _imp_signal(12, 0, 0, _imp_str_literal(""));
  }
  void Fault(int N) {
    if (!Faultnum) {
      Faultnum = N;
      Faultp = Atomp;
    }
  }
  void Expfault(int N) {
    if (Faultnum == 0 || Expp < Faultp) {
      Faultnum = N | Point;
      Faultp = Expp;
    }
  }
  static const int Pred = 1;
  static const int Uparr = 1 << 1;
  static const int Nocomma = 1 << 2;
  static const int Overload = 1 << 3;
  static const int Ranges = 1 << 4;
  static const int Nolength = 1 << 5;
  static const int Initass = 1 << 6;
  static const int Kgoto = 1 << 7;
  static const int Hyphen = 1 << 8;
  static const int Naming = 1 << 9;
  static const int Klabel = 1 << 10;
  static const int Ibmhex = 1 << 11;
  static const int Oldcycle = 1 << 12;
  static const int Loop2 = 1 << 13;
  void Nonstandard(int Case) {
    static int Hadit = 0;
    if ((Control & Nonsbit) != 0 && (Case & Hadit) == 0) {
      Hadit += Case;
      Fault(Nonstand + Point + Warn);
    }
  }
  void Error(int Case) {
    Report(Case, Atomp);
    _imp_signal(14, 0, 0, _imp_str_literal(""));
  }
  void Nameerror(void) {
    while (Item < 0 && *String(Dict[-Item].Text + Charbase) != *String(Charlim)) Item = Dict[-Item].Link;
    if (Item >= 0) {
      Report(Namerr + Point, Atomp);
      if (Charmin - Newlen - 80 >= Charlim) {
        Dmin--;
        Charmin = Charmin - Newlen - 1;
        *String(Charmin) = *String(Charlim);
        Dict[Dmin].Text = Charmin - Charbase;
        while (*Head > 0) Head = &Dict[*Head].Link;
        Dict[Dmin].Link = *Head;
        *Head = -Dmin;
      }
    }
    _imp_signal(14, 0, 0, _imp_str_literal(""));
  }
  void Syntaxerror(void) {
    int E;
    E = Formerr + Point;
    if (Atom == Dud) E = Atomerr + Point;
    Report(E, Atomp);
    _imp_signal(14, 0, 0, _imp_str_literal(""));
  }
  int Floated(int Item) {
    if (!Item) return (0);
    return (Explo);
  }
  void Forget(void) {}
  void Forgetall(void) {
    int I;
    int J;
    Litpos = Litmin;
    Explo = Expmax + 1;
    Oldexplo = Explo;
  }
  void Setlabel(int B) {}
  void Setuserlabel(int Dpos) {}
  void Compile(int From, int To) { Np = Np0; }
  void Compileentry(void) {}
  void Compileend(void) {}
  void Put3(int Act, int X, int Y) {}
  void Put2(int Act, int X) {}
  int Tempvar(void) { return (Dlim); }
  void Openblock(int Pidpos) {
    Forget();
    if (Level == Maxlevel) Croak(_imp_str_literal("Too many levels"));
    Hold[Level] = C;
    Level++;
    C = 0;
    Starts = 0;
    Cycles = 0;
    Curlab = Lab1;
    Looplab = 0;
    Forgetall();
    C.Flags = 0;
    C.Type = D.Type;
    C.Pidpos = Pidpos;
    C.Localdpos = Dlim;
    C.Parlim = Dlim;
    C.Localtext = Charlim;
    C.Localpc = Pc;
    C.Localspc = Spc;
    C.Access = 1;
  }
  void Closeblock(void) {
    int I;
    int Miss;
    int Dpos;
    int *P;
    Identinfo *Dp;
    Miss = 0;
    P = &Miss;
    Dpos = C.Localdpos;
    while (Dpos != Dlim) {
      Dp = &Dict[Dpos];
      if ((Dp->Flags & (Proc + Lab)) != 0 && (Dp->Flags & (Ext + Spec)) == Spec) {
        *P = Dpos;
        P = &Dp->Val;
        *P = 0;
      }
      Dpos++;
    }
    if (Miss) Report(Idmissing, Miss);
    Compileend();
    Pc = C.Localpc;
    Spc = C.Localspc;
    Dlim = C.Parlim;
    Charlim = C.Localtext;
    for (I = 0; I <= 255; I++)
      while (Hashindex[I] >= C.Localdpos) Hashindex[I] = Dict[Hashindex[I]].Link;
    Level--;
    C = Hold[Level];
    Starts = 0;
    Cycles = 0;
  }
  void Switchinput(void) {
    if (Fp == Main.Lim2) _imp_signal(12, 0, 0, _imp_str_literal(""));
    if (Nonstop < 0) {
      Nonstop += 3;
      Permlim = Dlim;
      C.Localdpos = Dlim;
      C.Parlim = Dlim;
      Statements = 0;
    }
    if (Fp != Main.Lim1) {
      Nonstop--;
      Fp = Mainfp;
      Line = Mainline;
      Curstart = Main.Start1;
      Curlim = Main.Lim1;
    } else
      Fp = Main.Start2;
    if (Main.Start2 <= Fp && Fp <= Main.Lim2) {
      Curstart = Main.Start2;
      Curlim = Main.Lim2;
    }
    Modesym = ' ';
    Sym = Nl;
  }
  void Readline(void) {
    if (Faultnum) Report(Faultnum, Faultp);
    while (Sym != Nl) {
      Sym = *Byteinteger(Fp);
      Fp++;
    }
    while (Fp == Curlim) Switchinput();
    Line++;
    Linestart = Fp;
    Sym = 0;
  }
  static int Percent = 0;
  static int Subatom = 0;
  static const int Arrow = Resolve;
  static const int Exclam = Logor;
  static const int Exclam2 = Logxor;
  static const int Dot = Concat;
  static const int Star = Mult;
  static const int Slash = Fdiv;
  static const int Slash2 = Idiv;
  static const int Ampersand = Logand;
  static const int Backslash = Fpower;
  static const int Backslash2 = Ipower;
  static const int Uparrow = Fpower;
  static const int Uparrow2 = Ipower;
  static const int Tilde = Lognot;
  static const int Left = Aref;
  static const int Underline = Recref;
  static const int Leftbracket = 106;
  static const int Simple = 104;
  static const int Major = Plus;
  static const int Scond = Equals;
  static const int Cond = Keyand;
  static const int Recok = 1 << 0;
  static const int Arrok = 1 << 1;
  static const int Stringok = 1 << 2;
  static const int Realok = 1 << 3;
  static const int Intok = 1 << 4;
  static const int Charok = 1 << 5;
  static const int Boolok = 1 << 6;
  static const int Enumok = 1 << 7;
  static const int Setok = 1 << 8;
  static const int Znop = 1 << 9;
  static const int Refonly = 1 << 10;
  static const int Varonly = 1 << 11;
  static const int Arithok = Intok + Realok;
  static const int Ordok = Intok + Charok + Boolok + Enumok;
  static const int Any = Realok + Ordok + Stringok + Arrok + Recok;
  static const int Opbits[44 /*64:107*/] = {64, 64,  0,   0,   0,   0, 255, 255, 508, 252, 508, 252, 255, 255, 0,
                                            4,  792, 792, 528, 528, 4, 0,   0,   0,   24,  24,  16,  16,  0,   0,
                                            0,  0,   24,  16,  0,   0, 528, 528, 16,  0,   2,   1,   0,   0};
  int Nextatom(void) {
    static int S_sw;
    static void *S[256 /*0:255*/] = {
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_9,       &&S_10,      &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_33,      &&S_34,      &&S_35,      &&S_default, &&S_37,      &&S_38,      &&S_39,
        &&S_40,      &&S_41,      &&S_42,      &&S_43,      &&S_44,      &&S_45,      &&S_46,      &&S_47,
        &&S_48,      &&S_49,      &&S_50,      &&S_51,      &&S_52,      &&S_53,      &&S_54,      &&S_55,
        &&S_56,      &&S_57,      &&S_58,      &&S_59,      &&S_60,      &&S_61,      &&S_62,      &&S_default,
        &&S_default, &&S_65,      &&S_66,      &&S_67,      &&S_68,      &&S_69,      &&S_70,      &&S_71,
        &&S_72,      &&S_73,      &&S_74,      &&S_75,      &&S_76,      &&S_77,      &&S_78,      &&S_79,
        &&S_80,      &&S_81,      &&S_82,      &&S_83,      &&S_84,      &&S_85,      &&S_86,      &&S_87,
        &&S_88,      &&S_89,      &&S_90,      &&S_default, &&S_92,      &&S_default, &&S_94,      &&S_95,
        &&S_default, &&S_97,      &&S_98,      &&S_99,      &&S_100,     &&S_101,     &&S_102,     &&S_103,
        &&S_104,     &&S_105,     &&S_106,     &&S_107,     &&S_108,     &&S_109,     &&S_110,     &&S_111,
        &&S_112,     &&S_113,     &&S_114,     &&S_115,     &&S_116,     &&S_117,     &&S_118,     &&S_119,
        &&S_120,     &&S_121,     &&S_122,     &&S_123,     &&S_124,     &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
    };
    static const int Tab = 9;
    int I;
    int J;
    int P;
    int Radix;
    int Digits;
    float Rval;
    static const unsigned char Map[128 /*0:127*/] = {[0 ... 47] = 0,
                                                     '0',
                                                     '1',
                                                     '2',
                                                     '3',
                                                     '4',
                                                     '5',
                                                     '6',
                                                     '7',
                                                     '8',
                                                     '9',
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     'a',
                                                     'b',
                                                     'c',
                                                     'd',
                                                     'e',
                                                     'f',
                                                     'g',
                                                     'h',
                                                     'i',
                                                     'j',
                                                     'k',
                                                     'l',
                                                     'm',
                                                     'n',
                                                     'o',
                                                     'p',
                                                     'q',
                                                     'r',
                                                     's',
                                                     't',
                                                     'u',
                                                     'v',
                                                     'w',
                                                     'x',
                                                     'y',
                                                     'z',
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     'a',
                                                     'b',
                                                     'c',
                                                     'd',
                                                     'e',
                                                     'f',
                                                     'g',
                                                     'h',
                                                     'i',
                                                     'j',
                                                     'k',
                                                     'l',
                                                     'm',
                                                     'n',
                                                     'o',
                                                     'p',
                                                     'q',
                                                     'r',
                                                     's',
                                                     't',
                                                     'u',
                                                     'v',
                                                     'w',
                                                     'x',
                                                     'y',
                                                     'z',
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0};
    void Assemblereal(void) {
      J = 0;
      for (;;) {
        do {
          Sym = *Byteinteger(Fp);
          Fp++;
        } while (Sym == ' ');
        I = Sym - '0';
        if (0 > I || I >= Radix) return;
        Rval = Rval * Radix + I;
        J++;
      }
    }
    Matched = 0;
  Again:
  S_9:;
    if (Sym == Nl) Readline();
    do {
      Sym = *Byteinteger(Fp);
      Fp++;
    } while (Sym == ' ');
    Atomp = Fp;
    goto *S[S_sw = Sym];
  Linebreak:
  S_10:;
    if (Atom != Comma) return (Terminator);
    goto Again;
  S_123:;
    do {
      Sym = *Byteinteger(Fp);
      Fp++;
      if (Sym == Nl) goto Linebreak;
    } while (Sym != '}');
    goto Again;
  S_43:
    return (Plus);
  S_45:
    if (*Byteinteger(Fp) == '>') {
      Fp++;
      return (Arrow);
    }
    if (*Byteinteger(Fp) == Nl) goto Again;
    return (Minus);
  S_42:
    return (Star);
  S_47:
    if (*Byteinteger(Fp) == '/') {
      Fp++;
      return (Slash2);
    }
    return (Slash);
  S_92:
    if (*Byteinteger(Fp) == '\\') {
      Fp++;
      return (Backslash2);
    }
    return (Backslash);
  S_94:
    Nonstandard(Uparr);
    if (*Byteinteger(Fp) == '^') {
      Fp++;
      return (Uparrow2);
    }
    return (Uparrow);
  S_33:
    if (*Byteinteger(Fp) == '!') {
      Fp++;
      return (Exclam2);
    }
    return (Exclam);
  S_38:
    return (Ampersand);
  S_46:
    return (Dot);
  S_61:
    if (*Byteinteger(Fp) == '=') {
      Fp++;
      return (Eqeq);
    }
    return (Equals);
  S_35:
    if (*Byteinteger(Fp) == '#') {
      Fp++;
      return (Noteqeq);
    }
    return (Noteq);
  S_60:
    if (*Byteinteger(Fp) == '=') {
      Fp++;
      return (Lesseq);
    }
    if (*Byteinteger(Fp) == '>') {
      Fp++;
      return (Noteq);
    }
    if (*Byteinteger(Fp) == '<') {
      Fp++;
      return (Lshift);
    }
    return (Less);
  S_62:
    if (*Byteinteger(Fp) == '=') {
      Fp++;
      return (Greateq);
    }
    if (*Byteinteger(Fp) == '>') {
      Fp++;
      return (Rshift);
    }
    return (Greater);
  S_95:
    return (Underline);
  S_58:
    return (Colon);
  S_44:
    return (Comma);
  S_59:
    return (Terminator);
  S_40:
    return (Left);
  S_41:
    return (Right);
  S_124:
    return (Modsign);
  S_69:
  S_101:;
    if (*Byteinteger(Fp) == '"') {
      Fp++;
      goto Stringconst;
    }
  S_77:
  S_109:
  S_67:
  S_99:;
    if (*Byteinteger(Fp) == '\'') {
      Fp++;
      goto Charconst;
    }
  S_65:
  S_66:
  S_68:
  S_70:
  S_71:
  S_72:;
  S_73:
  S_74:
  S_75:
  S_76:
  S_78:
  S_79:
  S_80:;
  S_81:
  S_82:
  S_83:
  S_84:
  S_85:
  S_86:
  S_87:
  S_88:;
  S_89:
  S_90:
  S_97:
  S_98:
  S_100:
  S_102:;
  S_103:
  S_104:
  S_105:
  S_106:
  S_107:
  S_108:
  S_110:;
  S_111:
  S_112:
  S_113:
  S_114:
  S_115:
  S_116:
  S_117:
  S_118:;
  S_119:
  S_120:
  S_121:
  S_122:;
    if (Percent) goto Keyword;
    Newlen = Charlim + 1;
    Hash = Sym | Casebit;
    *Byteinteger(Newlen) = Hash;
    do {
      Sym = *Byteinteger(Fp);
      Fp++;
    } while (Sym == ' ');
    Sym = Map[Sym];
    if (Sym) do {
        Newlen++;
        *Byteinteger(Newlen) = Sym;
        Hash = Hash << 1 ^ Sym;
        do {
          Sym = *Byteinteger(Fp);
          Fp++;
        } while (Sym == ' ');
        Sym = Map[Sym];
      } while (Sym);
    Fp--;
    Newlen -= Charlim;
    *Byteinteger(Charlim) = Newlen;
    Head = &Hashindex[Hash & 255];
    Item = *Head;
    if (Item > 0) do {
        if (Item <= 0) return (Ident);
        Ditem = &Dict[Item];
        if (*String(Ditem->Text + Charbase) == *String(Charlim)) break;
        Item = Ditem->Link;
      } while (Item > 0);
    return (Ident);
  S_37:;
    Sym = *Byteinteger(Fp);
    if ('a' > (Sym | Casebit) || (Sym | Casebit) > 'z') goto Again;
    Fp++;
  Keyword:;
    Percent = 0;
    P = Syminit[Sym | Casebit];
    for (;;) {
      while (Symbol[P] == (*Byteinteger(Fp) | Casebit)) {
        P++;
        Fp++;
      }
      if (Symbol[P] >= 128) break;
      Atom = Altdisp[P];
      if (!Atom) {
        if ((Sym | Casebit) != 'c' || *Byteinteger(Fp) != Nl) return (Dud);
        Readline();
        goto Again;
      }
      P += Atom;
    }
    if ('a' <= (*Byteinteger(Fp) | Casebit) && (*Byteinteger(Fp) | Casebit) <= 'z') Percent = 1;
    Subatom = Altdisp[P];
    Atom = Symbol[P] - 128;
    if (!Atom) return (Dud);
    return (Atom);
  S_48:
  S_49:
  S_50:
  S_51:
  S_52:
  S_53:
  S_54:
  S_55:
  S_56:
  S_57:;
    Item = 0;
    T.Type = Inty;
    Radix = 10;
    T.Val = Sym - '0';
  Ibm1:;
    for (;;) {
      for (;;) {
        do {
          Sym = *Byteinteger(Fp);
          Fp++;
        } while (Sym == ' ');
        I = Sym - '0';
        if (Radix == 10) {
          if (I < 0 || I >= 10) break;
          if (T.Val > Max10 || (T.Val == Max10 && I > Maxdig)) {
            T.Type = Realy;
            Rval = T.Val;
            Assemblereal();
            break;
          }
          T.Val = T.Val * 10 + I;
        } else {
          if (I >= 10) I = (Sym | Casebit) - 'a' + 10;
          if (I < 0 || I >= Radix) break;
          J = Radix;
          do {
            if (J & 1) I += T.Val;
            T.Val = T.Val << 1;
            J = (unsigned)J >> 1;
          } while (J);
          T.Val = I;
        }
      }
      if (Sym != '_') break;
      Radix = T.Val;
      if (!Radix) return (Dud);
      T.Val = 0;
    }
    if (Sym == '.') {
      if (T.Type == Inty) {
        T.Type = Realy;
        Rval = T.Val;
      }
      Assemblereal();
      if (!J) return (Dud);
      Rval = Rval / REXP(Radix, J);
    }
    Fp--;
    Sym = 0;
    return (Const);
  S_39:;
  Charconst:;
    Item = 0;
    T.Type = Inty;
    T.Val = 0;
    for (;;) {
      Sym = *Byteinteger(Fp);
      Fp++;
      if (Sym == Nl) return (Dud);
      if (Sym == '\'') {
        if (*Byteinteger(Fp) != '\'') break;
        Fp++;
      }
      T.Val = (T.Val << 8) + Sym;
    }
    if (T.Val) return (Const);
    return (Dud);
  S_34:;
  Stringconst:;
    Item = 0;
    T.Type = Stringy;
    Stringp = Atomp;
    T.Val = 0;
    I = Line;
    J = Linestart;
    for (;;) {
      Sym = *Byteinteger(Fp);
      Fp++;
      if (Sym == '"') {
        if (*Byteinteger(Fp) != '"') break;
        Fp++;
      }
      T.Val = T.Val + 1;
      if (T.Val > 255) {
        Sym = 0;
        Fp = Atomp;
        Linestart = J;
        return (Dud);
      }
      if (Sym == Nl) Readline();
    }
    return (Const);
  S_default:;
    return (Dud);
  }
  void Lookupfieldident(int List) {
    Item = List;
    if (!Item) return;
    for (;;) {
      Ditem = &Dict[Item];
      if (!(Ditem->Flags & Typeid)) {
        if (*String(Ditem->Text + Charbase) == *String(Charlim)) return;
        if (!(Ditem->Flags & More)) break;
      }
      Item++;
    }
    Item = 0;
  }
  int /* boolean */ A(int K) {
    if (Matched) Atom = Nextatom();
    if (K != Atom) return (0);
    Matched = 1;
    return (1);
  }
  void Get(int K) {
    if (Matched) Atom = Nextatom();
    Matched = 1;
    if (Atom == K) return;
    if (Atom == Dud) Syntaxerror();
    Faultp = Atomp;
    Report(Formerr + Point, -K);
    _imp_signal(14, 0, 0, _imp_str_literal(""));
  }
  void Allow(int K) {
    if (A(K))
      ;
  }
  void Declare(void) {
    if (!Speccing) {
      if (Item >= C.Localdpos) {
        if ((D.Flags & Spec) == 0 && D.Flags + Spec == Ditem->Flags && Ditem->Type == D.Type) {
          Ditem->Flags = Ditem->Flags - Spec;
          return;
        }
        Fault(Duperr + Point);
      }
      D.Link = *Head;
      *Head = Dlim;
      if (Item > 0)
        D.Text = Ditem->Text;
      else {
        D.Text = Charlim - Charbase;
        Charlim = Charlim + Newlen + 1;
        if (Charlim + 80 >= Charmin) Croak(_imp_str_literal("Identifier space exhausted"));
      }
    } else
      D.Text = 0;
    Item = Dlim;
    Ditem = &Dict[Item];
    *Ditem = D;
    Dlim++;
    if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifiers"));
  }
  void Declareanon(void) {
    D.Text = 0;
    D.Link = 0;
    Dict[Dlim] = D;
    Dlim++;
    if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifiers"));
  }
  static int Jammy;
  int /* boolean */ Aassop(void) {
    if (Matched) Atom = Nextatom();
    if (Atom != Equals && Atom != Eqeq) {
      if (Atom != Less || *Byteinteger(Fp) != '-') return (0);
      Jammy = 2;
      Fp++;
    } else
      Jammy = 0;
    Matched = 1;
    return (1);
  }
  static int Literal = 0;
  auto void Getexpression(int Rank, int Control);
  int Compat(int Control) {
    if (T.Type == Inty) {
      if ((Control & Intok) == 0 && (Control & Realok) != 0) {
        Item = Floated(Item);
        T.Type = Realy;
      }
      return (Control & (Intok + Realok));
    }
    if (T.Type <= Booltype) return (Control & ((unsigned)Boolok >> (Booltype - T.Type)));
    if (T.Type < Direct) return (Control & Enumok);
    return (Control & Arrok);
  }
  int Listmatch(int Alist, int Blist) {
    Identinfo *Ap;
    Identinfo *Bp;
    if (Alist == Blist) return (1);
    if (Alist < Dictmin || Blist < Dictmin) return (0);
    do {
      Ap = &Dict[Alist];
      Bp = &Dict[Blist];
      if (Ap->Type != Bp->Type) return (0);
      Alist++;
      Blist++;
    } while (Ap->Flags & Bp->Flags & More);
    if ((Ap->Flags & More) != 0 || (Bp->Flags & More) != 0) return (0);
    return (1);
  }
  void Getreference(int Reftype) {
    int Type;
    int Temp;
    Getexpression(Simple, Refonly + Any);
    Type = Ditem->Type & Puretype;
    Reftype = Reftype & Puretype;
    if (Reftype == Type) return;
    if (Type < Reftype) {
      Temp = Type;
      Type = Reftype;
      Reftype = Temp;
    }
    if (Reftype == Nulltype) return;
    Type = Dict[Type].Type;
    if (Type <= Inty && Type == Reftype) return;
    if (Type >= Direct && Type == Dict[Reftype].Type) return;
    Expfault(Typerr + Point);
  }
  void Getvalue(int Valtype) {
    Identinfo *Dp;
    Identinfo *P;
    Getexpression(Major, Any);
    Valtype = Valtype & Puretype;
    Dp = &Dict[Valtype];
    if (T.Type != Dp->Type) {
      if (Item == 0 && 0 == T.Val) return;
      if (Dp->Type == Realy && T.Type == Inty) {
        T.Type = Realy;
        return;
      }
    } else if (T.Type >= Inty) {
      if (!Item) {
        if (Dp->Low <= T.Val && T.Val <= Dp->Val) return;
        if (Jammy >= 0) Jammy = Jammy | 1;
      } else if (T.Low >= Dp->Low) {
        if (T.Val <= Dp->Val) return;
        if (Jammy >= 0) Jammy = Jammy | 1;
        if (T.Low <= Dp->Val) return;
      } else {
        if (Jammy >= 0) Jammy = Jammy | 1;
        if (T.Val >= Dp->Low) return;
      }
      if (Jammy < 2) Expfault(Rangerr + Point);
      return;
    } else if (T.Type == Stringy) {
      if (T.Val > Dp->Val) {
        if (Jammy >= 0) Jammy = Jammy | 1;
        if (Item == 0 && Jammy < 2) Expfault(Rangerr + Point);
      }
      return;
    } else if (T.Type == Recy) {
      if (T.Extra == Dp->Extra) return;
      if (Jammy >= 2) {
        Jammy = Jammy | 1;
        return;
      }
    } else if (T.Type == Realy)
      return;
    Expfault(Typerr + Point);
  }
  void Getliteral(int Littype) {
    Literal++;
    Getvalue(Littype);
    Literal--;
  }
  void Getlitint(void) {
    Literal++;
    Getexpression(Major, Intok);
    Literal--;
  }
  void Getlitstring(void) {
    int Holditem;
    Holditem = Item;
    Get(Const);
    if (T.Type != Stringy) Error(Typerr + Point);
    Item = Holditem;
  }
  void Getparmlist(void) {
    Identinfo *Hp;
    Identinfo *Dp;
    int I;
    int J;
    int Headitem;
    int Headact;
    int Dpos;
    int Case;
    int Procnp;
    int First;
    Headitem = Item;
    Hp = Ditem;
    Headact = Rcall;
    I = 0;
    First = 1;
    Dpos = Headitem;
    Dp = Hp;
    do {
      if (!(Dp->Flags & More)) Error(Toomany + Point);
      do {
        Dpos++;
        Dp = &Dict[Dpos];
      } while (!(Dp->Flags & Parm));
      if (Dp->Flags & Proc) {
        Get(Ident);
        if (Item <= 0) Nameerror();
        if (!(Ditem->Flags & Proc)) Fault(Typerr + Point);
        if (Item > Headitem) Fault(Caterr + Point);
      } else if (Dp->Type < Indirect) {
        Case = I & 7;
        I++;
        Getvalue(Dp->Type);
      } else {
        Case = ((unsigned)I >> 3) + 8;
        I += 8;
        Getreference(Dp->Type);
      }
    } while (A(Comma));
    Item = Explo;
  }
  void Getresolution(void) {
    if (!A(Left)) {
      Getreference(Anystringvar);
      Get(Dot);
      Get(Left);
    }
    Getvalue(Anystring);
    Get(Right);
    if (A(Dot)) Getreference(Anystringvar);
  }
  void Getexpression(int Rank, int Control) {
    int Type;
    int F;
    int Opok;
    int C1;
    int Op;
    int Atomp1;
    int Item1;
    Objinfo T1;
    Identinfo *Dp;
    int Litval(void) {
      static int Lit_sw;
      static void *Lit[44 /*64:107*/] = {
          &&Lit_64,      &&Lit_65,      &&Lit_66,      &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_70,
          &&Lit_71,      &&Lit_72,      &&Lit_73,      &&Lit_74,      &&Lit_75,      &&Lit_default, &&Lit_default,
          &&Lit_default, &&Lit_default, &&Lit_80,      &&Lit_81,      &&Lit_82,      &&Lit_83,      &&Lit_84,
          &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_88,      &&Lit_default, &&Lit_90,      &&Lit_91,
          &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default, &&Lit_default,
          &&Lit_default, &&Lit_100,     &&Lit_101,     &&Lit_102,     &&Lit_default, &&Lit_default, &&Lit_default,
          &&Lit_default, &&Lit_default,
      };
      goto *Lit[Lit_sw = (Op)-64];
    Lit_80:
      return (T1.Val + T.Val);
    Lit_81:
      return (T1.Val - T.Val);
    Lit_88:
      return (T1.Val * T.Val);
    Lit_90:
      if (T.Val) return (T1.Val / T.Val);
      Fault(Rangerr);
      return (0);
    Lit_91:;
    Lit_64:
      return (T1.Val & T.Val);
    Lit_82:;
    Lit_65:
      return (T1.Val | T.Val);
    Lit_83:
      return (T1.Val ^ T.Val);
    Lit_100:
      return (T1.Val << T.Val);
    Lit_101:
      return ((unsigned)T1.Val >> T.Val);
    Lit_66:
      return (T.Val ^ True);
    Lit_102:
      return (~T.Val);
    Lit_70:
      if (T1.Val == T.Val) return (True);
      return (False);
    Lit_71:
      if (T1.Val != T.Val) return (True);
      return (False);
    Lit_72:
      if (T1.Val <= T.Val) return (True);
      return (False);
    Lit_73:
      if (T1.Val < T.Val) return (True);
      return (False);
    Lit_74:
      if (T1.Val >= T.Val) return (True);
      return (False);
    Lit_75:
      if (T1.Val > T.Val) return (True);
      return (False);
    Lit_84:
      return (T1.Val + T.Val);
    Lit_default:;
      return (1);
    }
    if (Matched) Atom = Nextatom();
    Atomp1 = Atomp;
    if (Atom == Ident) {
      Matched = 1;
      if (Item <= 0) Nameerror();
      if (Item >= Dlim0) Fault(Selfref + Point);
      Type = Ditem->Type;
      if (Control & (Refonly + Varonly)) {
        if ((Control & Varonly) != 0 && (F & Var) == 0) Error(Nonvar + Point);
        if (Type < Direct) Error(Nonref + Point);
      }
      F = Ditem->Flags;
      if (Inty <= Type && Type <= Booltype && (F & Proc) == 0) {
        Item = 0;
        T = Ditem->Details;
      } else {
        if (Literal > 0) Fault(Nonliteral + Point);
        if (F & Proc) {
          if (F & Parm) {
            Ditem = &Dict[Type];
            Type = Ditem->Type;
          }
          if (Type == Nulltype) Error(Caterr + Point);
          if (A(Left)) {
            Dp = Ditem;
            Getparmlist();
            Get(Right);
            Ditem = Dp;
          } else {
            if (Ditem->Flags & More) Error(Toofew + Point);
            Item = Explo;
          }
        }
        for (;;) {
          Dp = &Dict[Type & Puretype];
          T = Dp->Details;
          if (Matched) Atom = Nextatom();
          if (Atom != Underline && Atom != Left) break;
          Matched = 1;
          Item1 = Item;
          if (Atom == Left) {
            for (;;) {
              if (T.Type < Direct) Syntaxerror();
              Type = T.Type;
              Getvalue(T.Val);
              Item = Explo;
              Ditem = Dp;
              if (!A(Comma)) break;
              Dp = &Dict[Type & Puretype];
              T = Dp->Details;
              Item1 = Item;
            }
            Get(Right);
          } else {
            if (T.Type != Recy) Syntaxerror();
            Get(Ident);
            Lookupfieldident(T.Extra);
            if (Item <= 0) Error(Namerr + Point);
            Type = Ditem->Type;
            Item = Explo;
          }
        }
        if (Control & (Varonly + Refonly)) goto Final;
      }
    } else {
      if (Control & Varonly) Error(Nonvar + Point);
      if (Control & Refonly) Error(Nonref + Point);
      if (A(Const))
        ;
      else if (Atom == Minus) {
        Item = 0;
        T = 0;
        T.Type = Inty;
      } else if (A(Left)) {
        if (Rank < Major)
          Getexpression(Cond, Any);
        else {
          Jammy -= 4;
          C1 = Control;
          if (C1 & Realok) C1 = C1 | Intok;
          Getexpression(Major, C1);
          Jammy += 4;
        }
        Get(Right);
      } else if (A(Keynot)) {
        if (Rank >= Major) Syntaxerror();
        Getexpression(Scond, Any);
        if (!Item)
          T.Val = T.Val ^ True;
        else
          Item = Explo;
      } else if (Atom == Backslash) {
        Item = 0;
        T = 0;
        T.Type = Inty;
        Atom = Tilde;
      } else if (A(Modsign)) {
        if (!(Control & Arithok)) Fault(Typerr + Point);
        Getexpression(Major, Arithok);
        Get(Modsign);
        if (!Item) {
          if (T.Val < 0)
            if (T.Val != Minint)
              T.Val = -T.Val;
            else
              Expfault(Rangerr);
        } else if (T.Type == Inty) {
          Item = Explo;
        } else if (T.Type == Realy) {
          Item = Explo;
        } else
          Error(Typerr);
      } else
        Syntaxerror();
    }
    if (Matched) Atom = Nextatom();
    while (Atom >= Rank) {
      Op = Atom;
      Matched = 1;
      Opok = Opbits[Op];
      C1 = Compat(Opok);
      if (!C1) Fault(Typerr + Point);
      Item1 = Item;
      T1 = T;
      if (Op >= Major) {
        if (Op == Dot)
          Getexpression(Dot, Stringok);
        else
          Getexpression((Op & (~7)) + 8, C1);
        if (T.Type == Realy && T1.Type == Inty) {
          Item1 = Floated(Item1);
          T1.Type = Realy;
        }
      } else {
        if (Op == Resolve)
          Getresolution();
        else if (Op >= Eqeq)
          Getexpression(Simple, Any + Refonly);
        else if (Op >= Equals) {
          Getexpression(Major, C1);
          if (Equals <= Atom && Atom < Eqeq) {
            Op = Atom;
            Matched = 1;
            Getexpression(Major, C1);
          }
          if (T.Type == Realy && T1.Type == Inty) {
            Item1 = Floated(Item1);
            T1.Type = Realy;
          }
        } else {
          Getexpression(Scond, Any);
          if (Atom >= Cond)
            if (Atom != Op) Syntaxerror();
        }
        T.Type = Booltype;
        if (Item) {
          T.Low = 0;
          T.Val = 1;
        }
      }
      if (!Item1)
        if (!Item) {
          T.Val = Litval();
          if (!Item) continue;
        }
      if (!Item) {
        if (Op == Minus && T.Type == Inty) {
          if (T.Val != Minint) T.Val = -T.Val;
          Op = Plus;
        }
        if (T.Val == 0 && (Opok & Znop) != 0) {
          Item = Item1;
          continue;
        }
      }
      Item = Explo;
      T.Low = Minint;
      T.Val = Maxint;
    }
  Final:;
    Expp = Atomp1;
    if (!Compat(Control)) Expfault(Typerr);
  }
  void Getcondition(void) {
    int Polarity;
    Polarity = Subatom;
    Condnp = Np;
    Getexpression(Cond, Any);
  }
  void Getstatements(int Stopper) {
    int Holdnp;
    int Holdlooplab;
    static int Initial_sw;
    static void *Initial[108 /*0:107*/] = {
        &&Initial_default, &&Initial_1,       &&Initial_2,       &&Initial_3,       &&Initial_4,
        &&Initial_5,       &&Initial_6,       &&Initial_7,       &&Initial_8,       &&Initial_9,
        &&Initial_10,      &&Initial_11,      &&Initial_12,      &&Initial_13,      &&Initial_default,
        &&Initial_15,      &&Initial_16,      &&Initial_17,      &&Initial_default, &&Initial_19,
        &&Initial_default, &&Initial_default, &&Initial_22,      &&Initial_23,      &&Initial_24,
        &&Initial_25,      &&Initial_26,      &&Initial_27,      &&Initial_28,      &&Initial_29,
        &&Initial_30,      &&Initial_default, &&Initial_default, &&Initial_33,      &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_37,      &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_41,      &&Initial_42,      &&Initial_default, &&Initial_default,
        &&Initial_45,      &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_52,      &&Initial_default, &&Initial_54,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_63,      &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_79,
        &&Initial_default, &&Initial_default, &&Initial_82,      &&Initial_83,      &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_88,      &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default,
    };
    void Getinstruction(void) {
      int Item1;
      int Hold;
      int Act;
      Identinfo *Ditem1;
      void Putact(void) {}
      if (C.Flags < Hadinst) {
        C.Flags = C.Flags + Hadinst;
        if (Level <= Outerlevel) Fault(Ordererr);
      }
      Instnp = Np;
      do
        if (A(Ident)) {
          if (Item <= 0) Nameerror();
          if (Ditem->Flags & Var) {
            Matched = 0;
            Getexpression(Simple, Any);
            Item1 = Item;
            Ditem1 = Ditem;
            if (A(Equals)) {
              Getvalue(Ditem1->Type);
            } else if (A(Eqeq)) {
              if (Ditem1->Type < Indirect) Syntaxerror();
              Getreference(Ditem1->Type);
              if (Item) Item += Ad;
            } else if (Atom == Less && *Byteinteger(Fp) == '-') {
              Fp++;
              Matched = 1;
              Jammy = 2;
              Getvalue(Ditem1->Type);
            } else {
              if (!A(Arrow)) Syntaxerror();
              Getresolution();
            }
          } else {
            if (!(Ditem->Flags & Proc)) Error(Caterr + Point);
            if (Ditem->Flags & Parm) Ditem = &Dict[Ditem->Type];
            if (Ditem->Type != Nulltype) Error(Caterr + Point);
            if (A(Left)) {
              Getparmlist();
              Get(Right);
            } else {
              if (Ditem->Flags & More) Error(Toofew + Point);
            }
          }
        } else {
          Act = Atom;
          Hold = Subatom;
          T.Val = 0;
          C.Access = 0;
          if (A(Monitor)) {
            C.Access = 1;
          } else if (A(Exit)) {
            if (!Looplab)
              Fault(Notinloop + Point);
            else {
              T.Val = Looplab;
              Putact();
            }
            break;
          } else if (A(Return)) {
            if (C.Type != Nulltype)
              Fault(Notinrout + Point);
            else
              Putact();
            break;
          } else if (A(Result)) {
            if (C.Type <= Nulltype) Error(Notinfun + Point);
            if (!Aassop()) Syntaxerror();
            if (C.Type < Direct) {
              if (Atom == Eqeq) Fault(Caterr + Point);
              Getvalue(C.Type);
            } else {
              if (Atom != Eqeq) Fault(Caterr + Point);
              Getreference(C.Type + (Indirect - Direct));
            }
            break;
          } else if (A(Tf)) {
            if (C.Type != Booltype)
              Fault(Notinpred + Point);
            else
              Putact();
            break;
          } else if (A(Arrow) || A(Goto)) {
            if (Atom == Goto) Nonstandard(Kgoto);
            Get(Ident);
            if (*Byteinteger(Fp) != '(') {
              if (Item < C.Localdpos || (Ditem->Flags & Lab) == 0 || Ditem->Type != Nulltype) {
                D.Flags = Spec + Lab;
                D.Type = Nulltype;
                Declare();
              }
            } else {
              if (Item < C.Localdpos) Nameerror();
              if ((Ditem->Flags & Lab) == 0 || Ditem->Type == Nulltype) Syntaxerror();
              Get(Left);
              Getvalue(Ditem->Type);
              Get(Right);
            }
            break;
          } else if (A(Stop)) {
            Putact();
            break;
          } else if (A(Signal)) {
            C.Access = 1;
            Allow(Keyevent);
            Getlitint();
            if (0 > T.Val || T.Val > 15) Expfault(Rangerr + Point);
            Hold = T.Val;
            T.Val = 0;
            if (A(Comma)) Getlitint();
            Hold += T.Val << 4;
            Item = 0;
            T.Val = 0;
            if (A(Comma)) Getvalue(Anyint);
            break;
          } else
            Syntaxerror();
        }
      while (A(Keyand));
    }
    void Getforclause(void) {
      int Loopvar;
      int K;
      int S;
      int Start;
      int Sval;
      int I;
      int Inc;
      int Ival;
      int E;
      int N;
      int Temp;
      int Eval;
      Identinfo *Dp;
      Holdnp = Np;
      Temp = 0;
      Dict[Curlab].Val = 1;
      Condnp = Np;
      Get(Ident);
      if (Item <= 0) Nameerror();
      if (Dict[Ditem->Type & Puretype].Type != Inty) Fault(Typerr + Point);
      if (Ditem->Type != Direct + Inttype) Fault(Caterr + Point + Warn);
      Loopvar = Item;
      Dp = Ditem;
      Get(Equals);
      Getvalue(Ditem->Type);
      Start = Item;
      Sval = T.Val;
      Get(Comma);
      Getvalue(Anyint);
      Inc = Item;
      Ival = T.Val;
      if (Inc == 0 && 0 == Ival) {
        Expfault(Rangerr + Point);
        Ival = 1;
      }
      Get(Comma);
      Getvalue(Ditem->Type);
      if (!Inc) {
        I = 1;
        if (!Start) {
          Sval -= Ival;
          S = 1;
        } else {
          S = Explo;
        }
      } else {
        S = Explo;
      }
      if (!(Start | Inc | Item)) {
        K = T.Val - Sval;
        N = K / Ival;
        if (N < 0) Fault(Boundserr);
        if (N * Ival != K) Fault(Unending);
      }
    }
    void Getswitchindex(void) {
      int Item1;
      Identinfo *Dp;
      Item1 = Item;
      Dp = Ditem;
      Get(Left);
      Item = 1;
      if (A(Star)) {
        if (Dp->Spare) Fault(Duperr + Point);
        Dp->Spare = 1;
      } else {
        Getliteral(Dp->Type);
        if (Dp->Type > Inttype && Faultnum == 0) {
          T.Val = T.Val - Dict[Dp->Type].Low + Dp->Val;
          if (Final[T.Val]) Expfault(Duperr + Point);
          Final[T.Val] = 1;
        }
      }
      Get(Right);
      C.Access = 1;
    }
    if (_imp_on_event(1, 14)) {
      if (Event.Event() == 1) Report(Rangerr, 0);
      goto Skip;
    }
  Next:;
    Statements++;
  Next1:;
    if (Faultnum) Report(Faultnum, Faultp);
    D = 0;
    Declmode = 0;
    Dsize = 0;
    Dlim0 = Dlim;
    Elements = 0;
    Speccing = 0;
    Mcoding = 0;
    Literal = 0;
    Jammy = 0;
    Dict[Curlab].Val = 0;
    Dict[Curlab + 1].Val = 0;
    Np = Np0;
    Instnp = Np0;
    Condnp = Np0;
    if (Explo < Expmin + 50 || Litpos > Litmax - 50) Forgetall();
    T.Val = 0;
  Initial_52:;
    Atom = Nextatom();
    Matched = 1;
    goto *Initial[Initial_sw = Atom];
  Initial_88:
  Initial_82:
  Initial_83:;
    Readline();
    goto Next1;
  Term:;
    Get(Terminator);
    goto Next;
  Skip:;
    C.Access = -1;
    if (Atom != Terminator) {
      do {
        Subatom = Atom;
        Atom = Nextatom();
      } while (Atom != Terminator);
      if (Subatom == Start) Starts++;
      if (Subatom == Cycle) Cycles++;
    }
    goto Next;
  Initial_63:;
    Syntaxerror();
  Initial_default:;
    Error(Nonstarter + Point);
  Initial_54:;
    if (*Byteinteger(Fp) == ':') {
      Fp++;
      D.Flags = Lab;
      D.Type = Nulltype;
      Declare();
      Setuserlabel(Item);
      goto Next;
    }
    if (Item <= 0) Nameerror();
    if (Ditem->Flags & Lab) {
      Getswitchindex();
      Get(Colon);
      goto Next;
    }
  Initial_7:
  Initial_9:
  Initial_8:;
  Initial_10:
  Initial_12:
  Initial_13:;
  Initial_6:
  Initial_11:
  Initial_79:;
    Matched = 0;
    Getinstruction();
    if (A(Terminator)) goto Next;
    C.Access = 1;
    if (A(Iu)) {
      Holdnp = Np;
      Getcondition();
    } else if (A(While)) {
      Holdnp = Np;
      Getcondition();
    } else if (A(For)) {
      Getforclause();
    } else {
      if (!A(Until)) Syntaxerror();
      Getcondition();
    }
    goto Term;
  Initial_16:;
    for (;;) {
      Holdnp = Np;
      Getcondition();
      if (A(Then)) {
        if (A(Start)) goto Fudge;
        Getinstruction();
      } else {
        Get(Start);
      Fudge:;
        for (;;) {
          Get(Terminator);
          Curlab += 2;
          Getstatements(Else);
          Curlab -= 2;
          if (Atom != Else) break;
          if (A(Iu)) Getcondition();
        }
        if (Atom != Finish) return;
      }
      if (!A(Else)) break;
      if (A(Start)) goto Fudge;
      if (!A(Iu)) {
        Getinstruction();
        break;
      }
    }
    goto Term;
  Initial_22:;
    if (A(Terminator)) {
      Holdlooplab = Looplab;
      Looplab = Curlab;
      Curlab += 2;
      Getstatements(Repeat);
      Curlab -= 2;
      Looplab = Holdlooplab;
      if (Atom != Repeat) return;
      if (A(Until)) Getcondition();
      goto Term;
    }
    Nonstandard(Oldcycle);
    Getforclause();
    goto For1;
  Initial_17:;
    Holdnp = Np;
    Getcondition();
    Get(Cycle);
    Get(Terminator);
    Holdlooplab = Looplab;
    Looplab = Curlab;
    Curlab += 2;
    Getstatements(Repeat);
    Curlab -= 2;
    Looplab = Holdlooplab;
    if (Atom != Repeat) return;
    if (A(Until)) {
      Nonstandard(Loop2);
      Getcondition();
    }
    goto Term;
  Initial_19:;
    Getforclause();
    Get(Cycle);
  For1:;
    Get(Terminator);
    Holdlooplab = Looplab;
    Looplab = Curlab;
    Curlab += 2;
    Getstatements(Repeat);
    Curlab -= 2;
    Looplab = Holdlooplab;
    if (Atom != Repeat) return;
    goto Term;
  Initial_15:;
    if (C.Flags >= Hadon || Level <= Outerlevel) Fault(Ordererr + Point);
    C.Flags = C.Flags | Hadon;
    Matched = 1;
    Allow(Keyevent);
    do {
      Getlitint();
      if (0 > T.Val || T.Val > 15) Expfault(Rangerr + Point);
      C.Events = C.Events | 1 << T.Val;
    } while (A(Comma));
    Get(Start);
    Curlab += 2;
    Getstatements(Finish);
    Curlab -= 2;
    if (Atom != Finish) return;
    goto Term;
  Initial_4:;
    if (Starts) goto Skip;
    if (Stopper == Else) return;
    if (Stopper == Finish) Error(Noif);
  Initial_3:;
    if (Starts) {
      Starts--;
      goto Skip;
    }
    if (Stopper == Finish || Stopper == Else) return;
    Error(Nostart);
  Initial_2:;
    if (Cycles) {
      Cycles--;
      goto Skip;
    }
    if (Stopper == Repeat) return;
    Error(Nocycle);
    int Newatype(int Eltype, int Xtype) {
      int Dpos;
      Identinfo *Dp;
      static Identinfo D = 0;
      Dpos = Dictmin;
      do {
        Dp = &Dict[Dpos];
        if ((Dp->Flags & Typeid) != 0 && Dp->Type == Eltype && Dp->Val == Xtype) return (Dpos + Direct);
        Dpos++;
      } while (Dpos != Dlim);
      D.Flags = Typeid;
      D.Type = Eltype;
      D.Val = Xtype;
      Dict[Dpos] = D;
      Dlim++;
      if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifers"));
      return (Dpos + Direct);
    }
    int Newstype(int Max) {
      int Dpos;
      Identinfo *Dp;
      static Identinfo D = 0;
      Dpos = Dictmin;
      do {
        Dp = &Dict[Dpos];
        if (Dp->Type == Stringy && Dp->Val == Max) return (Dpos);
        Dpos++;
      } while (Dpos != Dlim);
      D.Flags = Typeid;
      D.Type = Stringy;
      D.Val = Max;
      Dict[Dpos] = D;
      Dlim++;
      if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifers"));
      return (Dpos);
    }
    int Newrange(int Type, int Lower, int Upper) {
      int Dpos;
      Identinfo *Dp;
      static Identinfo D = 0;
      if (Lower > Upper) {
        Fault(Boundserr);
        Upper = Lower;
      }
      Elements = Maxint;
      if ((Upper ^ Lower) >= 0 || Minint + Upper - Lower < 0) Elements = Upper - Lower;
      if (Elements != Maxint) Elements++;
      Dpos = Dictmin;
      do {
        Dp = &Dict[Dpos];
        if (Dp->Flags == Typeid && Dp->Type == Type && Dp->Low == Lower && Dp->Val == Upper) return (Dpos);
        Dpos++;
      } while (Dpos != Dlim);
      D.Flags = Typeid;
      D.Type = Type;
      D.Low = Lower;
      D.Val = Upper;
      Dict[Dpos] = D;
      Dlim++;
      if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifers"));
      return (Dpos);
    }
    void Getlitbounds(void) {
      int Lower;
      Get(Left);
      Getlitint();
      Lower = T.Val;
      Get(Colon);
      Getlitint();
      Get(Right);
      T.Low = Lower;
      Item = Newrange(Inty, T.Low, T.Val);
    }
    void Getident(void) {
      Dlim0 = Dlim;
      Get(Ident);
      Declare();
      if ((D.Flags & Ext) != 0 && A(Alias)) Getlitstring();
    }
    void Getidentlist(void) {
      Dlim0 = Dlim;
      do {
        Get(Ident);
        Declare();
        if ((D.Flags & Ext) != 0 && A(Alias)) Getlitstring();
      } while (A(Comma));
    }
    void Gettype(int Flags) {
      static int Fbase;
      static Identinfo *Formp;
      static Identinfo *Fieldp;
      void Getformatdef(void) {
        int Disp;
        int Max;
        int Base;
        void Getfieldident(void) {
          Get(Ident);
          if (Item > 0)
            D.Text = Ditem->Text;
          else {
            D.Text = Charlim - Charbase;
            Charlim = Charlim + Newlen + 1;
            if (Charlim + 80 >= Charmin) Croak(_imp_str_literal("Identifier space exhausted"));
          }
          Ditem = &Dict[Dlim];
          Fieldp = Ditem;
          *Ditem = D;
          if (!Formp->Extra) Formp->Extra = Dlim;
          Dlim++;
          if (Dlim >= Dmin) Croak(_imp_str_literal("Too many identifiers"));
        }
        void Getunit(void) {
          for (;;)
            if (A(Left)) {
              Getformatdef();
              Get(Right);
              if (!A(Comma)) return;
            } else {
              Gettype(Static + More);
              if (!(D.Flags & Parm)) do {
                  if ((Disp & 1) != 0 && Dsize != 1) Disp++;
                  D.Val = Disp;
                  Disp += Dsize;
                  Getfieldident();
                  if (!A(Comma)) return;
                  Atom = Nextatom();
                } while (Atom == Ident);
              else {
                D.Flags = D.Flags - Parm;
                if (Disp & 1) Disp++;
                D.Val = Disp;
                Getfieldident();
                Getlitbounds();
                Fieldp->Type = Newatype(D.Type, Item);
                Disp += Dsize * Elements;
                if (!A(Comma)) return;
              }
            }
        }
        Max = 0;
        Base = 0;
        do {
          Disp = Base;
          Getunit();
          if (Max < Disp) Max = Disp;
        } while (A(Keyor));
        Base = Max;
      }
      Dsize = 0;
      D.Mode = 0;
      D.Val = 0;
      D.Type = Nulltype;
      if (A(Rpred)) {
        if (Flags & Ext) Flags = Flags & (~Static);
        if (Flags & Static) Syntaxerror();
        if (Subatom) {
          Nonstandard(Pred);
          D.Type = Booltype;
        }
        D.Flags = Flags + Proc;
        Declmode += Pcmode;
        return;
      }
      if (A(Krange)) {
        D.Type = Inttype + Subatom;
        Dsize = 1;
        if (D.Type == Shorttype || D.Type == Halftype) Dsize = 2;
        if (D.Type >= Mitetype) Nonstandard(Ranges);
        Allow(Keyinteger);
      } else if (A(Keyinteger)) {
        D.Type = Inttype;
        Dsize = 4;
        Atom = Nextatom();
        if (Atom == Left) {
          Getlitbounds();
          D.Type = Item;
          if (Elements <= 65536 && T.Low >= -32768) Dsize = 2;
          if (Elements <= 256 && T.Low >= -128) Dsize = 1;
        }
      } else if (A(Keylong)) {
        D.Type = Longinttype;
        Dsize = 8;
        if (!A(Keyinteger)) {
          D.Type = Longrealtype;
          Get(Keyreal);
        }
      } else if (A(Keyreal)) {
        D.Type = Realtype;
        Dsize = 4;
      } else if (A(Keystring)) {
        D.Type = Stringy;
        T.Val = 255;
        Dsize = 256;
        if (A(Left)) {
          T.Val = 0;
          if (!A(Star)) {
            Getlitint();
            if (0 >= T.Val || T.Val > 255) {
              Expfault(Rangerr + Point);
              T.Val = 255;
            }
          }
          Get(Right);
        } else
          Nonstandard(Nolength);
        if (T.Val) {
          D.Type = Newstype(T.Val);
          Dsize = (T.Val + 2) & (~1);
        }
      } else if (A(Keyrecord)) {
        D.Type = Recy;
        if (A(Keyformat)) {
          if (Flags & (Static + Ext)) Syntaxerror();
          if (A(Keyspec)) {
            D.Flags = Typeid + Spec;
            Getident();
          } else {
            D.Flags = Typeid;
            Getident();
            Formp = Ditem;
            Get(Left);
            Fbase = 0;
            Getformatdef();
            Fieldp->Flags = Fieldp->Flags - More;
            Get(Right);
          }
          D.Flags = Typeid;
          return;
        }
        Get(Left);
        if (!A(Star)) {
          if (!A(Ident)) {
            Getformatdef();
            Fieldp->Flags = Fieldp->Flags - More;
            Get(Right);
            D.Flags = Typeid;
            Declareanon();
          }
          if (Item <= 0) Nameerror();
          if (Ditem->Type != Recy) Syntaxerror();
          D.Type = Item;
          Dsize = Ditem->Val;
        }
        Get(Right);
      } else {
        if (Atom != Keyname) Syntaxerror();
      }
      if (Dsize <= 4)
        if (Dsize <= 2)
          Declmode = Dsize << Sizeshift;
        else
          Declmode = Longsize << Sizeshift;
      if (A(Fnmap)) {
        if (Flags & Ext) Flags = Flags & (~Static);
        if (Flags & Static) Syntaxerror();
        if (Subatom) {
          Flags++;
          D.Type = D.Type + Direct;
        }
        D.Flags = Flags + Proc;
        Declmode += Pcmode;
        return;
      }
      D.Type = D.Type + Direct;
      while (A(Keyarray) || A(Keyname)) {
        if (Atom == Keyarray) {
          if (D.Type >= Indirect) Nonstandard(Naming);
          if (!A(Keyname)) {
            if (Flags & Parm) Syntaxerror();
            Flags += Parm;
            break;
          }
          D.Type = Newatype(D.Type, Inty);
        }
        if (D.Type >= Indirect) Syntaxerror();
        D.Type = D.Type + (Indirect - Direct);
        Dsize = 4;
      }
      D.Flags = Flags ^ Var;
    }
    void Getownarraydeclaration(void) {
      int Holdval;
      int Dpos;
      Identinfo *Dp;
      Getident();
      Dpos = Item;
      Dp = Ditem;
      Getlitbounds();
      Dp->Type = Newatype(D.Type, Item);
      if (Aassop()) {
        Allow(Terminator);
        do {
          Getliteral(D.Type);
          if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn;
          Holdval = T.Val;
          T.Val = 1;
          if (A(Left)) {
            T.Val = Elements;
            if (!A(Star)) Getlitint();
            Get(Right);
          }
          Elements -= T.Val;
        } while (A(Comma));
        if (Elements != 0 && Faultnum == 0) Report(Counterr, Dpos);
      }
    }
    void Getarraydeclaration(void) {
      int I;
      int Dlim1;
      int Hold;
      int Holdval;
      int Type;
      void Getbounds(void) {
        int Range;
        Getvalue(Anyint);
        Hold = Item;
        if (Hold) T.Val = Minint;
        Holdval = T.Val;
        Get(Colon);
        Getvalue(Anyint);
        if (Item) T.Val = Maxint;
        Range = Newrange(Inty, Holdval, T.Val);
        if (A(Comma)) Getbounds();
        Type = Newatype(Type, Range);
      }
      do {
        Type = D.Type;
        Getidentlist();
        Dlim1 = Dlim;
        Get(Left);
        Getbounds();
        Get(Right);
        while (Dlim0 != Dlim1) {
          Dict[Dlim0].Type = Type;
          Dlim0++;
        }
      } while (A(Comma));
    }
    void Getparmdef(void) {
      int Headitem;
      int Dpos;
      int Dlim1;
      Identinfo *Headditem;
      Identinfo *Dp;
      int Parmmatch(int Apos) {
        int Bpos;
        Identinfo *Ap;
        Identinfo *Bp;
        Bpos = Dlim1;
        Ap = &Dict[Apos];
        while (Bpos != Dlim) {
          if (!(Ap->Flags & More)) return (0);
          do {
            Apos++;
            Ap = &Dict[Apos];
          } while (!(Ap->Flags & Parm));
          Bp = &Dict[Bpos];
          if (Ap->Type != Bp->Type) return (0);
          Bpos++;
        }
        if (!(Ap->Flags & More)) return (1);
        return (0);
      }
      Headitem = Item;
      Headditem = Ditem;
      Dlim1 = Dlim;
      if (A(Left)) {
        for (;;) {
          if (Atom != Ident) Gettype(Parm | More);
          if (!(D.Flags & Proc)) {
            Getident();
            if (!A(Comma) && Atom == Right) break;
            if (Atom != Comma)
              Nonstandard(Nocomma);
            else
              Atom = Nextatom();
          } else {
            Getident();
            Speccing += 2;
            Getparmdef();
            Speccing -= 2;
            if (!A(Comma)) break;
          }
        }
        Dict[Dlim - 1].Flags = Dict[Dlim - 1].Flags - More;
        Get(Right);
      }
      if (Speccing >= 2) {
        Dpos = Dictmin;
        do {
          Dp = &Dict[Dpos];
          if ((Dp->Flags & Proc) != 0 && Dp->Type == Headditem->Type)
            if (Parmmatch(Dpos)) {
              Headditem->Type = Dpos;
              Dlim = Dlim1;
              return;
            }
          Dpos++;
        } while (Dpos < Headitem);
        Fault(Caterr);
        Dlim = Dlim1;
        return;
      }
      if (Speccing == 0 && (Headditem->Flags & Spec) != 0) {
        Headditem->Flags = Headditem->Flags - Spec;
        if (!Parmmatch(Headitem)) Fault(Matcherr);
      } else if (Dlim != Dlim1)
        Headditem->Flags = Headditem->Flags | More;
    }
  Initial_23:
    Nonstandard(Klabel);
    D.Flags = Lab + Spec;
    D.Type = Nulltype;
    Getidentlist();
    goto Term;
  Initial_24:;
    D.Flags = Subatom;
    Atom = Nextatom();
  Initial_25:
  Initial_26:;
  Initial_27:
  Initial_28:;
  Initial_29:
  Initial_30:;
  Initial_33:;
    Matched = 0;
    Gettype(D.Flags);
    if (A(Keyspec)) {
      if (A(Left)) {
        Getlitint();
        Get(Right);
        Declmode = (Declmode & Sizemask) + Absmode;
        D.Val = T.Val;
        Getident();
        if (D.Flags & Proc) {
          Speccing = 1;
          Getparmdef();
        }
        goto Term;
      }
      D.Flags = D.Flags + Spec;
      if (!(D.Flags & Proc)) {
        Getidentlist();
        goto Term;
      }
    }
    if (D.Flags & Proc) {
      Get(Ident);
      if (Item >= C.Localdpos && Ditem->Type == D.Type && (Ditem->Flags & Proc) != 0) {
        if ((Ditem->Flags & Spec) == 0 || (D.Flags & Spec) != 0) {
          Item = 0;
          D.Flags = D.Flags + Alt;
          Declare();
        }
      } else
        Declare();
      if ((D.Flags & Ext) != 0 && A(Alias)) Getlitstring();
      if (D.Flags & Spec) {
        Speccing = 1;
        Getparmdef();
      } else {
        Openblock(Item);
        Getparmdef();
        C.Parlim = Dlim;
        Compileentry();
        Get(Terminator);
        Getstatements(End);
        Closeblock();
      }
    } else if (D.Flags == Typeid)
      ;
    else if (D.Flags & Parm) {
      D.Flags = D.Flags - Parm;
      if (D.Flags & Static)
        Getownarraydeclaration();
      else {
        if ((D.Flags & Static) == 0 && C.Flags >= Hadon) {
          Fault(Ordererr);
          C.Flags = C.Flags & (~(Hadon + Hadinst));
        }
        Getarraydeclaration();
      }
    } else if (D.Flags == Static) {
      D.Type = Dict[D.Type & Puretype].Type;
      if (D.Type == Recy || D.Type == Stringy) D.Type = D.Type + Direct;
      do {
        Getident();
        if (!Aassop()) Syntaxerror();
        Getliteral(D.Type);
        if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn;
        Dict[Dlim - 1].Val = T.Val;
      } while (A(Comma));
    } else if (D.Flags & Static) {
      Declmode += Ownmode;
      do {
        Getident();
        T.Val = 0;
        if (Aassop()) {
          Getliteral(D.Type);
          if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn;
        }
        Elements = 1;
      } while (A(Comma));
    } else {
      if ((D.Flags & Static) == 0 && C.Flags >= Hadon) {
        Fault(Ordererr);
        C.Flags = C.Flags & (~(Hadon + Hadinst));
      }
      do {
        C.Delta = C.Delta - Dsize;
        if (C.Delta & 1) C.Delta = C.Delta - 1;
        T.Val = C.Sp + C.Delta;
        Getident();
        if (Aassop()) {
          Nonstandard(Initass);
          if (D.Type >= Indirect) {
            if (Atom != Eqeq) Fault(Caterr + Point);
            Getreference(D.Type);
            if (Item) Item += Ad;
          } else {
            if (Atom == Eqeq) Fault(Caterr + Point);
            Getvalue(D.Type);
          }
        }
      } while (A(Comma));
    }
    goto Term;
    void Getswitchdeclaration(void) {
      int I;
      int J;
      int Dlim1;
      Matched = 1;
      do {
        D.Flags = Lab;
        D.Type = Nulltype;
        Declmode = Pcmode + (Wordsize << Sizeshift);
        Getidentlist();
        Dlim1 = Dlim;
        Getlitbounds();
        do {
          if (Spc - Elements <= 0) break;
          for (I = 1; I <= Elements; I++) {
            Spc--;
            Final[Spc] = 0;
          }
          Dict[Dlim0].Val = Spc;
          Dict[Dlim0].Type = Item;
          Dlim0++;
        } while (Dlim0 != Dlim1);
      } while (A(Comma));
    }
  Initial_37:;
    Getswitchdeclaration();
    goto Term;
  Initial_42:;
    Getlitint();
    if (!T.Val) Control = 0;
    Control = Control ^ T.Val;
    goto Term;
  Initial_45:;
    Getlitstring();
    Extra.Name = _imp_str_literal("");
    while (T.Val > 0) {
      Extra.Name = _imp_join(Extra.Name, Tostring(*Byteinteger(Atomp)));
      Atomp++;
      T.Val = T.Val - 1;
    }
    Get(Terminator);
    if (!Faultnum) {
      Connectedfile(Extra);
      if (Extra.Flag) {
        Nonstop = -999;
        _imp_signal(12, 0, 0, _imp_str_literal(""));
      }
      Mainfp = Fp;
      Mainline = Line;
      Line = 0;
      Sym = Nl;
      Fp = Extra.Start2;
      Curstart = Fp;
      Curlim = Extra.Lim2;
      Modesym = '&';
      Nonstop++;
    }
    goto Next;
  Initial_41:;
    goto Term;
  Initial_5:;
    C.Sp = -8;
    Get(Terminator);
    Openblock(0);
    Getstatements(0);
    Closeblock();
    if (Stopper >= 0) goto Term;
    return;
  Initial_1:;
    if (!A(Of)) {
      if (Stopper == Else || Stopper == Finish) Fault(Nofinish);
      if (Stopper == Repeat) Fault(Norepeat);
      if (Stopper >= 0) return;
      Fault(Nobegin);
      goto Term;
    }
    if (A(Keylist)) goto Term;
    if (A(Keyfile)) {
      if (Curlim == Extra.Lim2) {
        Switchinput();
        goto Next;
      }
    } else
      Get(Program);
  }
  void Init(int T, int L, int H) {
    D.Flags = Typeid;
    D.Type = T;
    D.Low = L;
    D.Val = H;
    Dict[Dlim] = D;
    Dlim++;
  }
  if (_imp_on_event(12)) {
    if (Fp == Main.Lim2) goto Printout;
    if (Main.Flag < 0 || Nonstop == -999) goto Ended;
    Change = Main.Change;
  }
  Printstring(_imp_str_literal("  IMP Checker  "));
  Newline();
  for (I = 0; I <= 255; I++) Hashindex[I] = 0;
  Charbase = Addr(Char[0]);
  *Byteinteger(Charbase) = 0;
  Charlim = Charbase + 1;
  Charmin = Charlim + Charbound;
  for (I = D0; I <= Labmax; I++) Dict[I].Val = 0;
  D.Flags = Typeid;
  D.Low = Minint;
  D.Val = Maxint;
  Dmin = Dictmax - 1;
  Dlim = Dictmin;
  do {
    D.Type = Dlim;
    Dict[Dlim] = D;
    Dlim++;
  } while (Dlim <= Booltype);
  D.Flags = 0;
  Init(Booltype, 0, 0);
  Init(Booltype, 0, 1);
  D.Flags = Typeid;
  Init(Inty, Minint, Maxint);
  Init(Inty, -32768, 32767);
  Init(Inty, 0, 65535);
  Init(Inty, 0, 255);
  Init(Inty, -128, 127);
  Init(Inty, 0, 1);
  Init(Inty, Minint, Maxint);
  Init(Realy, Minint, Maxint);
  Init(Realy, Minint, Maxint);
  C = 0;
  C.Localdpos = Dlim;
  C.Parlim = Dlim;
  Level = Outerlevel;
  Spc = Finalbound;
  Faults = 0;
  Line = 0;
  Mainline = 0;
  Mainfp = Main.Start1;
  Extra.Name = Permfile;
  Connectedfile(Extra);
  if (Extra.Flag) {
    Nonstop = -999;
    _imp_signal(12, 0, 0, _imp_str_literal(""));
  }
  Fp = Extra.Start2;
  Curstart = Fp;
  Curlim = Extra.Lim2;
  Nonstop = -2;
  if (Main.Flag == 'I') Nonstop = -1;
  Sym = Nl;
  Getstatements(-1);
Printout:;
  if (!Faults) {
    Write(Statements, 1);
    Printstring(_imp_str_literal(" statements checked  "));
  } else {
    Write(Faults, 1);
    Printstring(_imp_str_literal(" fault"));
    if (Faults > 1) Putsym('s');
    Printstring(_imp_str_literal(" reported  "));
  }
  Newline();
Ended:;
  Newline();
}
int _imp_mainep(int _imp_argc, char **_imp_argv) {
  exit(0);
  return (1);
}
