#include <perms.h>
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);
const _imp_string Permfile = _imp_str_literal("ERCLIB:VECCE.IPERM");
const int Logbit = 0x00040000;
const int Warnbit = 0x00020000;
const int Nonsbit = 0x00010000;
const int Dictlist = 0x00001000;
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;
  const int Formerr = 0;
  const int Atomerr = 1;
  const int Namerr = 2;
  const int Caterr = 3;
  const int Sizerr = 4;
  const int Asserr = 5;
  const int Typerr = 6;
  const int Duperr = 7;
  const int Nostart = 8;
  const int Nocycle = 9;
  const int Ordererr = 10;
  const int Matcherr = 11;
  const int Rangerr = 12;
  const int Nonliteral = 13;
  const int Boundserr = 14;
  const int Accesserr = 15;
  const int Notinloop = 16;
  const int Notinrout = 17;
  const int Notinfun = 18;
  const int Notinpred = 19;
  const int Plexerr = 20;
  const int Noif = 21;
  const int Nonstand = 22;
  const int Notin = 23;
  const int Indexerr = 24;
  const int Moperr = 27;
  const int Noterm = 28;
  const int Nonstarter = 29;
  const int Nonvar = 30;
  const int Nonref = 31;
  const int Toomany = 32;
  const int Toofew = 33;
  const int Unwanted = 34;
  const int Noparm = 35;
  const int Unending = 37;
  const int Selfref = 38;
  const int Noend = 40;
  const int Nobegin = 41;
  const int Idmissing = 42;
  const int Nofinish = 43;
  const int Norepeat = 44;
  const int Counterr = 45;
  const int Noresult = 46;
  const int Errmax = 46;
  const int Point = 64;
  const int Warn = 128;
  static int Faultnum = 0;
  static int Faults = 0;
  const int Maxint = 0x7FFFFFFF;
  const int Minint = ~Maxint;
  const int Max10 = Maxint / 10;
  const int Maxdig = Maxint - Max10 * 10;
  const int False = 0;
  const int True = 1;
  int I;
  static int Statements = 0;
  const int Smallmin = -1000;
  const int Smallmax = 1000;
  const int Litmin = Smallmax + 1;
  const int Litmax = Smallmax + 1000;
  const int D0 = Litmax + 1;
  const int D1 = D0 + 1;
  const int D2 = D0 + 2;
  const int D6 = D0 + 6;
  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 Posta0 = Inda0 + 8;
  const int Posta7 = Posta0 + 7;
  const int Prea0 = Posta0 + 8;
  const int Prea7 = Prea0 + 7;
  const int Dictmin = Prea0 + 8;
  const int Dictmax = Prea0 + 1200;
  const int Labmin = Dictmax + 1;
  const int Lab1 = Labmin + 1;
  const int Labmax = Labmin + 20;
  const int Expmin = Labmax + 1;
  const int Expmax = Labmax + 300;
  const int Undef = Expmax + 1;
  const int Ad = 0x4000;
  const int Maxdreg = D0 + 4;
  const int Maxareg = A0 + 3;
  const int D0b = 1;
  const int D1b = 2;
  const int D2b = 4;
  const int A0b = 0x100;
  const int A1b = 0x200;
  const int A2b = 0x400;
  const int Allregs = 0b0000111100011111;
  static int Free = Allregs;
  const int Nulltype = Dictmin;
  const int Recy = Nulltype + 1;
  const int Arry = Recy + 1;
  const int Stringy = Arry + 1;
  const int Realy = Stringy + 1;
  const int Inty = Realy + 1;
  const int Chartype = Inty + 1;
  const int Booltype = Chartype + 1;
  const int Falseconst = Booltype + 1;
  const int Trueconst = Booltype + 2;
  const int Inttype = Trueconst + 1;
  const int Shorttype = Inttype + 1;
  const int Halftype = Shorttype + 1;
  const int Bytetype = Halftype + 1;
  const int Mitetype = Bytetype + 1;
  const int Bittype = Mitetype + 1;
  const int Longinttype = Bittype + 1;
  const int Realtype = Longinttype + 1;
  const int Longrealtype = Realtype + 1;
  const int Puretype = 8191;
  const int Direct = 8192;
  const int Indirect = 16384;
  const int Anyint = Inty + Direct;
  const int Anyintvar = Inty + Indirect;
  const int Anystring = Stringy + Direct;
  const int Anystringvar = Stringy + Indirect;
  const int Anyname = Nulltype + Indirect;
  static int Dictshown = Dictmin;
  static int Litpos = Litmin;
  static int Slitpos = Litmax;
  int Litstore[1000 /*1001:2000*/];
  const int Bytesize = 1;
  const int Wordsize = 2;
  const int Longsize = 3;
  const int Sizemask = 0xC0;
  const int Sizeshift = 6;
  const int Dmode = 0;
  const int Amode = 0b001000;
  const int Indmode = 0b010000;
  const int Postmode = 0b011000;
  const int Premode = 0b100000;
  const int Dispmode = 0b101000;
  const int Indexmode = 0b110000;
  const int Absmode = 0b111000;
  const int Pcmode = 0b111010;
  const int Litmode = 0b111100;
  const int Ownmode = Dispmode + 6;
  typedef struct Objinfo {
    int Flags;
    int Type;
    int Val;
  } Objinfo;
  typedef struct Identinfo {
    int Text;
    int Link;
  } Identinfo;
  const int Var = 0x0001;
  const int Lab = 0x0002;
  const int Proc = 0x0004;
  const int Static = 0x0008;
  const int Spec = 0x0010;
  const int Ext = 0x0020;
  const int Parm = 0x0040;
  const int More = 0x0080;
  const int Typeid = 0x0100;
  const int Okflag = 0x0200;
  const int Alt = 0x0800;
  const int Rflag = 0x1000;
  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;
  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;
  const int Np0 = Expmin;
  static int Np;
  static int Condnp;
  static int Instnp;
  const int End = 1;
  const int Repeat = 2;
  const int Finish = 3;
  const int Else = 4;
  const int Begin = 5;
  const int Exit = 6;
  const int Return = 7;
  const int Tf = 8;
  const int Result = 9;
  const int Stop = 10;
  const int Goto = 11;
  const int Signal = 12;
  const int Monitor = 13;
  const int On = 15;
  const int Iu = 16;
  const int While = 17;
  const int Until = 18;
  const int For = 19;
  const int Then = 20;
  const int Start = 21;
  const int Cycle = 22;
  const int Keylabel = 23;
  const int Prefix = 24;
  const int Krange = 25;
  const int Keylong = 26;
  const int Keyinteger = 27;
  const int Keyreal = 28;
  const int Keystring = 29;
  const int Keyrecord = 30;
  const int Keyformat = 31;
  const int Fnmap = 32;
  const int Rpred = 33;
  const int Keyspec = 34;
  const int Keyarray = 35;
  const int Keyname = 36;
  const int Keyswitch = 37;
  const int Of = 38;
  const int Keyfile = 39;
  const int Program = 40;
  const int Keylist = 41;
  const int Keycontrol = 42;
  const int Comment = 43;
  const int Keyevent = 44;
  const int Include = 45;
  const int Alias = 46;
  const int Keynot = 47;
  const int Keyand = 64;
  const int Keyor = 65;
  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};
  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};
  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};
  const int Terminator = 52;
  const int Const = 53;
  const int Ident = 54;
  const int Aref = 55;
  const int Recref = 56;
  const int Modsign = 57;
  const int Colon = 58;
  const int Comma = 59;
  const int Right = 60;
  const int Rightbracket = 61;
  const int Dud = 63;
  const int Booland = 64;
  const int Boolor = 65;
  const int Boolnot = 66;
  const int Float = 67;
  const int Imod = 68;
  const int Fmod = 69;
  const int Equals = 70;
  const int Noteq = 71;
  const int Lesseq = 72;
  const int Less = 73;
  const int Greateq = 74;
  const int Greater = 75;
  const int Eqeq = 76;
  const int Noteqeq = 77;
  const int Resolve = 79;
  const int Plus = 80;
  const int Minus = 81;
  const int Logor = 82;
  const int Logxor = 83;
  const int Concat = 84;
  const int Mult = 88;
  const int Fdiv = 89;
  const int Idiv = 90;
  const int Logand = 91;
  const int Fpower = 96;
  const int Ipower = 97;
  const int Lshift = 100;
  const int Rshift = 101;
  const int Lognot = 102;
  const int Fcall = 106;
  const int Mcall = 107;
  const int Atommax = 107;
  const int Swgoto = 35;
  const int Rcall = Mcall + 2;
  const int Assign = 41;
  const int Jamassign = 42;
  const int Plusass = 43;
  const int Compare = 44;
  const int Jump = 45;
  const int Label = 46;
  const int Adecl = 47;
  const int Actmax = 49;
  const int Eq = 0b0111;
  const int Ne = 0b0110;
  const int Gt = 0b1110;
  const int Le = 0b1111;
  const int Lt = 0b1101;
  const int Ge = 0b1100;
  const int Cc = 0b0100;
  const int Cs = 0b0101;
  const int Double = 16;
  const int Dshort = Dictmin + 6;
  const int Dlength = Dshort + 1;
  const int Dcharno = Dlength + 1;
  const int Daddr = Dcharno + 1;
  const int Dtostr = Daddr + 1;
  const int Drem = Dtostr + 1;
  const int Dnextsym = Drem + 1;
  const int Dreadsym = Dnextsym + 1;
  const int Dprintstr = Dreadsym + 3;
  const int Dread = Dictmin + 27;
  const int Dnewline = Dictmin + 41;
  const int Sigentry = 0x1114;
  const int Scompentry = 0x1128;
  const int Boundentry = 0x1134;
  const int Agetentry = 0x1138;
  const int Indexentry = 0x113C;
  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;
  const int Wrongcc = 2;
  const int Nonlocalref = 4;
  const int Dynarray = 8;
  const int Hadon = 0x10;
  const int Hadinst = 0x20;
  const int Outerlevel = 0;
  const int Maxlevel = 16;
  static int Level = Outerlevel;
  Blockinf C;
  Blockinf Hold[16 /*0:15*/];
  const int Purebound = 0;
  const int Ownbase = Purebound + 1;
  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;
  const int Casemask = 95;
  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) {
      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) {
          Putsym('~');
        }
        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, "Switch label 'S(%d):' not set in %s", S_sw,
              __PRETTY_FUNCTION__);
      exit(1) /* or %signal ... */;
    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;
    }
  }
  const int Pred = 1;
  const int Uparr = 1 << 1;
  const int Nocomma = 1 << 2;
  const int Overload = 1 << 3;
  const int Ranges = 1 << 4;
  const int Nolength = 1 << 5;
  const int Initass = 1 << 6;
  const int Kgoto = 1 << 7;
  const int Hyphen = 1 << 8;
  const int Naming = 1 << 9;
  const int Klabel = 1 << 10;
  const int Ibmhex = 1 << 11;
  const int Oldcycle = 1 << 12;
  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;
  const int Arrow = Resolve;
  const int Exclam = Logor;
  const int Exclam2 = Logxor;
  const int Dot = Concat;
  const int Star = Mult;
  const int Slash = Fdiv;
  const int Slash2 = Idiv;
  const int Ampersand = Logand;
  const int Backslash = Fpower;
  const int Backslash2 = Ipower;
  const int Uparrow = Fpower;
  const int Uparrow2 = Ipower;
  const int Tilde = Lognot;
  const int Left = Aref;
  const int Underline = Recref;
  const int Leftbracket = 106;
  const int Simple = 104;
  const int Major = Plus;
  const int Scond = Equals;
  const int Cond = Keyand;
  const int Recok = 1 << 0;
  const int Arrok = 1 << 1;
  const int Stringok = 1 << 2;
  const int Realok = 1 << 3;
  const int Intok = 1 << 4;
  const int Charok = 1 << 5;
  const int Boolok = 1 << 6;
  const int Enumok = 1 << 7;
  const int Setok = 1 << 8;
  const int Znop = 1 << 9;
  const int Refonly = 1 << 10;
  const int Varonly = 1 << 11;
  const int Arithok = Intok + Realok;
  const int Ordok = Intok + Charok + Boolok + Enumok;
  const int Any = Realok + Ordok + Stringok + Arrok + Recok;
  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,
    };
    const int Tab = 9;
    int I;
    int J;
    int P;
    int Radix;
    int Digits;
    float Rval;
    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 == ' ');
    if (Sym == '\'') {
      if (Hash == 'x') {
        Radix = 16;
        goto Ibm;
      }
      if (Hash == 'k') {
        Radix = 8;
        goto Ibm;
      }
      if (Hash == 'b') {
        Radix = 2;
        goto Ibm;
      }
    }
    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);
  Ibm:;
    Nonstandard(Ibmhex);
    Item = -1;
    T.Val = 0;
    goto Ibm1;
  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 = 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);
    }
    if (Item < 0) {
      if (Sym != '\'')
        return (Dud);
      Item = 0;
    } else {
      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 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 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 & (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 = (I >> 3) + 8;
        I += 8;
        Getreference(Dp->Type);
      }
    } while (A(Comma) != 0);
    Item = Explo;
  }
  void Getresolution(void) {
    if (A(Left) == 0) {
      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 (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) == 0)
                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) == 0)
                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() == 0)
              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) != 0 || A(Goto) != 0) {
            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) != 0);
    }
    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 (Eventinf >> 8 == 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) == 0)
        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) == 0)
        break;
      if (A(Start))
        goto Fudge;
      if (A(Iu) == 0) {
        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) != 0);
    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) != 0)
        Getlitstring();
    }
    void Getidentlist(void) {
      Dlim0 = Dlim;
      do {
        Get(Ident);
        Declare();
        if ((D.Flags & Ext) != 0 && A(Alias) != 0)
          Getlitstring();
      } while (A(Comma) != 0);
    }
    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) == 0)
                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) == 0)
                    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) == 0)
                  return;
              }
            }
        }
        Max = 0;
        Base = 0;
        do {
          Disp = Base;
          Getunit();
          if (Max < Disp)
            Max = Disp;
        } while (A(Keyor) != 0);
        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) == 0) {
          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) == 0) {
            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) == 0) {
          if (A(Ident) == 0) {
            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) != 0 || A(Keyname) != 0) {
        if (Atom == Keyarray) {
          if (D.Type >= Indirect)
            Nonstandard(Naming);
          if (A(Keyname) == 0) {
            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) == 0)
              Getlitint();
            Get(Right);
          }
          Elements -= T.Val;
        } while (A(Comma) != 0);
        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) != 0);
    }
    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) == 0 && Atom == Right)
              break;
            if (Atom != Comma)
              Nonstandard(Nocomma);
            else
              Atom = Nextatom();
          } else {
            Getident();
            Speccing += 2;
            Getparmdef();
            Speccing -= 2;
            if (A(Comma) == 0)
              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) != 0)
        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() == 0)
          Syntaxerror();
        Getliteral(D.Type);
        if (Faultnum == Rangerr + Point)
          Faultnum = Rangerr + Point + Warn;
        Dict[Dlim - 1].Val = T.Val;
      } while (A(Comma) != 0);
    } 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) != 0);
    } 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) != 0);
    }
    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) != 0);
    }
  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) == 0) {
      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();
}