#include <perms.h>
static _imp_string255 P2version = _imp_str_literal("4.13");
int _imp_mainep(int _imp_argc, char **_imp_argv) {
  const int Maxenvirs = 13;
  const int Maxlabels = 80;
  const int Maxdepth = 16;
  const int Maxstack = 31;
  const int Initgla = 32;
  const int Lastperm = -24;
  const int Initialfree = 5120;
  const int Minfree = 600;
  const int Maxstatic = 13000;
  const int Reglen = 4;
  const int Testswitch = 1;
  const int Stkdiag = 2;
  const int Arraydiag = 4;
  const int Fordiag = 8;
  const int Assdiag = 16;
  const int Unassdiag = 32;
  const int Trusted = 4096;
  const int R0 = 1;
  const int R1 = 2;
  const int R2 = 3;
  const int R3 = 4;
  const int R4 = 5;
  const int P2 = 6;
  const int P1 = 7;
  const int R9 = 8;
  const int R10 = 9;
  const int R11 = 10;
  const int R12 = 11;
  const int Link = 12;
  const int Fpr0 = 13;
  const int Fpr2 = 14;
  const int Fpr14 = 20;
  const int R15 = 41;
  const int Gla = 42;
  const int Wsp = 43;
  const int Code = 44;
  const int Any = 45;
  const int Any0 = 46;
  const int Anyf = 47;
  const int Param = 48;
  const int Store = 20;
  const unsigned char Basereg[6 /*0:5*/] = {1, 41, 8, 9, 10, 11};
  const unsigned char Actual[45 /*0:44*/] = {
      0,  0,  1, 2, 3, 4, 5, 6,  9,  10, 11,
      12, 8,  0, 2, 4, 6, 8, 10, 12, 14, [21 ... 40] = 0,
      15, 13, 7, 14};
  const int Switch = 6;
  const int Array = 11;
  const int Arrayname = 12;
  const int Constant = 0;
  const int Vinr = 1;
  const int Ains = 2;
  const int Vins = 3;
  const int Ainrec = 4;
  const int Vinrec = 5;
  const int Avins = 6;
  const int Avinrec = 7;
  const int Define = 0;
  const int Redefine = 1;
  const int Integer = 1;
  const int Byte = 2;
  const int Short = 3;
  const int String = 4;
  const int Record = 5;
  const int Reals = 6;
  const int Long = 7;
  const int Unsignedhalfword = 255;
  const int Con = 2;
  const int Permrt = 7;
  const int Formats = '2';
  const int Procedure = '1';
  const int Spec = '0';
  const int Start = 1;
  const int Loadcode = 2;
  const int Loadgla = 3;
  const int Lineflag = 4;
  const int Cend = 5;
  const int Dline = 10;
  const int Diags = 11;
  const int Tagdef = 1;
  const int Cref = 2;
  const int Jref = 3;
  const int Rref = 4;
  const int Pref = 5;
  const int Patchgla = 6;
  const int Patchcode = 7;
  const int Dend = 8;
  const int Instream = 2;
  const int Report = 0;
  const int List = 1;
  const int Object = 2;
  const int Direct = 3;
  const int Comma = ',';
  const int Minus = '-';
  const int Monitor = 0x1EF01;
  const int Rcopy = 0x00902;
  const int Rclear = 0x00903;
  const int Swjump = 0x1EF04;
  const int Aset = 0x06F05;
  const int Iexp = 0x00B07;
  const int Rexp = 0x18108;
  const int Alloc = 0x02E09;
  const int Smove = 0x0090B;
  const int Conc1 = 0x0090B;
  const int Conc2 = 0x0630C;
  const int Scomp = 0x06B0D;
  const int Rsym = 0x1EF0E;
  const int Exbunass = 0x01112;
  const int Exb = 0x00113;
  const int Aref = 0x00314;
  const int Stringass = 0x00015;
  const int Assth = 0x00016;
  const int Asstb = 0x00017;
  const int Fortest = 0x1EF18;
  const int Signalep = 4;
  const int Unasspat = 16;
  const int Not = 1;
  const int Neg = 2;
  const int Add = 3;
  const int Sub = 4;
  const int Mul = 6;
  const int Div = 7;
  const int And = 8;
  const int Ior = 9;
  const int Xor = 10;
  const int Lsh = 11;
  const int Rsh = 12;
  const int Exp = 13;
  const int Conc = 14;
  const int Sadd = 15;
  const int Rdiv = 16;
  const int Rem = 17;
  const int Lis = 0x2400;
  const int Lcs = 0x2500;
  const int Lr = 0x0800;
  const int Lh = 0x4800;
  const int Sth = 0x4000;
  const int Lhi = 0xC800;
  const int Lm = 0xD100;
  const int Stm = 0xD000;
  const int Lhl = 0x7300;
  const int Ais = 0x2600;
  const int Ahi = 0xCA00;
  const int Ah = 0x4A00;
  const int Ar = 0x0A00;
  const int Sis = 0x2700;
  const int Shi = 0xCB00;
  const int Sh = 0x4B00;
  const int Sr = 0x0B00;
  const int Am = 0x5100;
  const int Ahm = 0x6100;
  const int C = 0x5900;
  const int Ch = 0x4900;
  const int Ci = 0xF900;
  const int Cr = 0x0900;
  const int Cl = 0x5500;
  const int Clh = 0x4500;
  const int Cli = 0xF500;
  const int Clr = 0x0500;
  const int Chi = 0xC900;
  const int Clhi = 0xC500;
  const int Chvr = 0x1200;
  const int Ti = 0xF300;
  const int Thi = 0xC300;
  const int Lbr = 0x9300;
  const int Lb = 0xD300;
  const int Stb = 0xD200;
  const int Clb = 0xD400;
  const int Sra = 0xEE00;
  const int Bal = 0x4100;
  const int Jump = 12;
  const int Bfcr = 0x0300;
  const int Svc = 0xE100;
  const int Lme = 0x7200;
  const int Stme = 0x7100;
  const int Ler = 0x2800;
  const int Le = 0x6800;
  const int Ste = 0x6000;
  const int Cer = 0x2900;
  const int Ce = 0x6900;
  const int Aer = 0x2A00;
  const int Ser = 0x2B00;
  const int Mer = 0x2C00;
  const int Der = 0x2D00;
  const int Ae = 0x6A00;
  const int Se = 0x6B00;
  const int Me = 0x6C00;
  const int De = 0x6D00;
  const int Fxr = 0x2E00;
  const int Flr = 0x2F00;
  const int Lw = 0x5800;
  const int St = 0x5000;
  const int Li = 0xF800;
  const int La = 0xE600;
  const int Slls = 0x1100;
  const int Srls = 0x1000;
  const int Sll = 0xED00;
  const int Srl = 0xEC00;
  const int Aw = 0x5A00;
  const int Sw = 0x5B00;
  const int Ai = 0xFA00;
  const int Si = 0xFB00;
  const int Mw = 0x5C00;
  const int Mr = 0x1C00;
  const int Dw = 0x5D00;
  const int Dr = 0x1D00;
  const int Or = 0x0600;
  const int Ow = 0x5600;
  const int Oh = 0x4600;
  const int Oi = 0xF600;
  const int Xr = 0x0700;
  const int Xw = 0x5700;
  const int Xh = 0x4700;
  const int Xi = 0xF700;
  const int Nr = 0x0400;
  const int Nw = 0x5400;
  const int Nh = 0x4400;
  const int Ni = 0xF400;
  const int Ohi = 0xC600;
  const int Xhi = 0xC700;
  const int Nhi = 0xC400;
  typedef struct Varfm {
    int Disp;
    short Format;
    short Extra;
    short Id;
    short Length;
    unsigned char Base;
    unsigned char Type;
    unsigned char Form;
    unsigned char Size;
  } Varfm;
  typedef struct Stackfm {
    int Disp;
    int Format;
    int Extra;
    int Length;
    int Dv;
    short Base;
    short Lop;
    short Type;
    short Form;
    Stackfm *Link;
  } Stackfm;
  typedef struct Sptfm {
    Stackfm *V;
  } Sptfm;
  typedef struct Labelfm {
    short Id;
    short Tag;
    unsigned char Reg;
    unsigned char Base;
    int Limit;
    int Disp;
  } Labelfm;
  typedef struct Usefm {
    int Disp;
    int Ca;
    short Base;
    unsigned char Type;
    unsigned char Form;
  } Usefm;
  typedef struct Envfm {
    int Label;
    int Limen;
    Usefm E[40 /*1:40*/];
  } Envfm;
  Usefm Use[44 /*1:44*/];
  Usefm Known;
  int Activity[45 /*0:44*/];
  Labelfm Labels[80 /*1:80*/];
  Sptfm Stacked[16 /*1:16*/];
  Stackfm Stak[32 /*0:31*/];
  int Used[21 /*0:20*/];
  typedef struct Dfm {
    Stackfm *D;
    Dfm *Link;
  } Dfm;
  Stackfm *Descasl;
  Dfm Dlist[32 /*0:31*/];
  Dfm *Dasl;
  Dfm Using;
  static unsigned char Vbuf[10 /*1:10*/];
  static int Vp = 0;
  static int Xlevel = 0;
  int Blockword;
  static Varfm Begin;
  Envfm Nullenv;
  Varfm *Decvar;
  static int Control = 0b11111111;
  static int Perms = Lastperm;
  int Dynamic;
  int Dope;
  short Half;
  int J;
  int Ca;
  int Ga;
  int Diaggla;
  int Da;
  int Linesize;
  static int Realga;
  int Limen;
  int Currentline;
  int Envp;
  int Stp;
  int Stackasl;
  static int Frame = 0;
  static int Mintemp = 0;
  int Parms;
  int Local;
  int Invert;
  int Swopped;
  int Uncondjump;
  Labelfm *Flab;
  int Gtype;
  int Gmode;
  int Otype = 0;
  int Owntype;
  int Ownform;
  int Ownval;
  int Faulty;
  int Enterunass;
  Stackfm Stwork;
  Stackfm Ccv;
  int Ccreg;
  int Ccca = -1;
  Stackfm *Activestring;
  unsigned char *Cslen;
  unsigned char Currentstring[256 /*0:255*/];
  Envfm Envir[14 /*0:13*/];
  int Maxvars;
  Maxvars = Freespace - Initialfree;
  {
    if (Maxvars <= 0) Maxvars = Maxvars + Initialfree / 4;
    if (Maxvars <= 0) Maxvars = 16;
    Maxvars = Maxvars >> 4;
  }
  Varfm Var[Maxvars];
  void Rx(int Op, int R, int X, int D);
  void Phex(int N) {
    int J;
    int K;
    for (J = 1; J <= 4; J++) {
      K = (N >> 12) & 15;
      N = N << 4;
      if (K > 9)
        K = K - 10 + 'A';
      else
        K = K + '0';
      Printsymbol(K);
    }
  }
  void Decode(int Word) {
    static int Last;
    static int N;
    Selectoutput(List);
    if (Last != Currentline) {
      Last = Currentline;
      if (N != 0) Newline();
      N = 16;
      Write(Currentline, 4);
      Space();
      Phex(Ca);
      Printsymbol(':');
    } else if (N == 16)
      Spaces(11);
    Spaces(2);
    Phex(Word);
    N = N - 1;
    if (N <= 0) {
      N = 16;
      Newline();
    }
    Selectoutput(Object);
  }
  void Show(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
    if (Control < 0) Selectoutput(Report);
    Write(V.Type, 1);
    Write(V.Form, 2);
    Write(V.Base, 2);
    Write(V.Disp, 5);
    Write(V.Extra, 5);
    Write(V.Length, 5);
    if (V.Lop != 0) {
      Write(V.Lop, 2);
      Printsymbol(':');
      Show(V.Link);
    } else
      Newline();
    if (Control < 0) Selectoutput(Object);
  }
  void Abort(int Code) {
    int I;
    int J;
    int L;
    int Fatal;
    static int Sw_sw;
    static void *Sw[16 /*-15:0*/] = {
        &&Sw_M15, &&Sw_M14, &&Sw_M13, &&Sw_M12, &&Sw_M11, &&Sw_M10,
        &&Sw_M9,  &&Sw_M8,  &&Sw_M7,  &&Sw_M6,  &&Sw_M5,  &&Sw_M4,
        &&Sw_M3,  &&Sw_M2,  &&Sw_M1,  &&Sw_0,
    };
    Dfm *Dd;
    I = Report;
    Fatal = 1;
    Control = 0;
    for (;;) {
      Selectoutput(I);
      if (Code > 0) {
        Printstring(_imp_str_literal("*COMPILER ERROR"));
        Write(Code, 1);
        Printstring(_imp_str_literal(" AT LINE"));
        Write(Currentline, 1);
        Newline();
        if (Stp > 0) {
          Printstring(_imp_str_literal("STACK"));
          Newline();
          for (J = 1; J <= Stp; J++) Show(Stacked(J).V);
        }
        if (&Using.Link != &Null) {
          Printstring(_imp_str_literal("USING:"));
          Newline();
          Dd = &Using.Link;
          for (;;) {
            Show(*Dd->D);
            Dd = Dd->Link;
            if (Dd == &Null) break;
          }
        }
        if (I == Report) goto Cont;
        _imp_signal(15, 1, 0, _imp_str_literal(""));
      }
      Printsymbol('*');
      Write(Currentline, 1);
      Printstring(_imp_str_literal(": "));
      goto *Sw[Sw_sw = (Code) - -15];
    Sw_0:;
      Printstring(_imp_str_literal("MORE STORE PLEASE!!"));
      goto Cont;
    Sw_M1:;
    Sw_M2:;
      Printstring(_imp_str_literal("MORE STORE REQ'D FOR THIS COMPILATION"));
      goto Cont;
    Sw_M3:;
      Printstring(_imp_str_literal("BLOCKS TOO DEEPLY NESTED"));
      goto Cont;
    Sw_M4:;
      Printstring(_imp_str_literal("TOO MANY NAMES"));
      goto Cont;
    Sw_M5:;
      Printstring(_imp_str_literal("TOO MANY LABELS"));
      goto Cont;
    Sw_M6:;
      Printstring(_imp_str_literal("DIVISION BY ZERO"));
      goto Nonfatal;
    Sw_M7:;
    Sw_M8:;
      Printstring(_imp_str_literal("ARRAY INSIDE OUT"));
      goto Nonfatal;
    Sw_M9:;
      Printstring(_imp_str_literal("DECLARATION OUT OF CONTEXT"));
      goto Nonfatal;
    Sw_M10:;
      Printstring(_imp_str_literal("FAULTY SWITCH DECLARATION"));
      goto Nonfatal;
    Sw_M11:;
      Printstring(_imp_str_literal("%RESULT UNSPECIFIED"));
      goto Nonfatal;
    Sw_M12:;
      Printstring(_imp_str_literal("ILLEGAL %FOR PARAMETERS"));
      goto Warning;
    Sw_M13:;
      Printstring(_imp_str_literal("STRING CONSTANT TOO LONG"));
      goto Warning;
    Sw_M14:;
      Printstring(_imp_str_literal("UNASSIGNED CHECK INHIBITED"));
      Control = Control & (~Unassdiag);
      goto Warning;
    Sw_M15:;
      Printstring(_imp_str_literal("LOCALS > 16K ???"));
    Warning:;
      L = 0;
    Nonfatal:;
      Fatal = 0;
    Cont:;
      Newline();
      if (I == List) {
        if (Fatal != 0) _imp_signal(15, 2, 0, _imp_str_literal(""));
        Faulty = Faulty + L;
        Selectoutput(Object);
        return;
      }
      I = List;
    }
  }
  void Displayvar(/*C_TYPE_RECORD_FORMAT*/ Varfm V) {
    Selectoutput(List);
    Write(V.Id, 3);
    Printsymbol(':');
    Write(V.Type, 2);
    Write(V.Form, 2);
    Write(V.Base, 3);
    Write(V.Disp, 4);
    Write(V.Extra, 4);
    Write(V.Format, 4);
    Newline();
    Selectoutput(Object);
  }
  void Realerror(int N) {
    int I;
    const short Sym[14 /*1:14*/] = {'\\', '?', '?', '?', '@', '?', '?',
                                    '&',  '!', -33, -60, -62, '?', '.'};
    I = Report;
    for (;;) {
      Selectoutput(I);
      Printsymbol('*');
      Write(Currentline, 4);
      Printstring(_imp_str_literal(" ILLEGAL REAL OPERATION '"));
      N = Sym(N);
      if (N < 0) Printsymbol(-N);
      Printsymbol(abs(N));
      Printsymbol('\'');
      Newline();
      if (I == List) break;
      I = List;
    }
    Faulty = Faulty + 1;
    Selectoutput(Object);
  }
  int /* boolean */ Floating(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
    if (V.Type == Reals ||
        (V.Lop != 0 &&
         (V.Lop == Rdiv || (&V.Link != &Null && V.Link.Type == Reals))))
      return (1);
    return (0);
  }
  int /* boolean */ Same(/*C_TYPE_RECORD_FORMAT*/ Stackfm L,
                         /*C_TYPE_RECORD_FORMAT*/ Stackfm R) {
    if (L.Base != R.Base || L.Disp != R.Disp) return (0);
    if (L.Type != R.Type || L.Form != R.Form) return (0);
    if (L.Extra != R.Extra) return (0);
    return (1);
  }
  int /* boolean */ Zero(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
    if (V.Disp != 0 || V.Base != 0 || V.Form != Constant) return (0);
    if (V.Lop != 0) return (0);
    return (1);
  }
  int /* boolean */ Const(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
    if (V.Form != Constant || V.Lop != 0) return (0);
    if (V.Type > Short) return (0);
    return (1);
  }
  int Power(int N) {
    int Mask;
    int J;
    Mask = 1;
    for (J = 0; J <= 14; J++) {
      if (N == Mask) return (J);
      Mask = Mask << 1;
    }
    return (-1);
  }
  int Temp(void) {
    int T;
    T = (Frame + (Reglen - 1)) & (~(Reglen - 1));
    Frame = T + Reglen;
    return (T);
  }
  int Tag(void) {
    int N;
    int S;
    N = 0;
    for (;;) {
      S = Nextsymbol();
      if ('0' > S || S > '9') return (N);
      N = N * 10 + S - '0';
      Skipsymbol();
    }
  }
  int Eval(int L) {
    int J;
    int N;
    int B;
    int S;
    int Mod;
    const unsigned char Basis[5 /*86:90*/] = {3, 1, 8, 4, 0};
    if (L < 2) return (0);
    Readsymbol(B);
    B = Basis(B);
    N = 0;
    if (B == 0)
      for (J = 2; J <= L; J++) {
        Readsymbol(S);
        N = (N * 4 + N) * 2 + S - 'A';
      }
    else {
      Mod = 'A';
      if (B == 8) Mod = 0;
      for (J = 2; J <= L; J++) {
        Readsymbol(S);
        N = (N << B) + (S - Mod);
      }
    }
    return (N);
  }
  float Realconstant(void) {
    int I;
    int L;
    int S;
    int J;
    int M;
    float N;
    float Factor;
    float Ten;
    float One;
    I = 10;
    Ten = I;
    I = 1;
    One = I;
    M = 0;
    N = 0;
    L = Tag();
    Skipsymbol();
    for (J = 1; J <= L; J++) {
      Readsymbol(S);
      if (S == '.') {
        Factor = 1;
        M = 1;
      } else {
        I = S - 'A';
        if (M == 0)
          N = N * Ten + I;
        else {
          Factor = Factor / Ten;
          N = N + I * Factor;
        }
      }
    }
    return (N);
  }
  void Release(int Reg) {
    if (Reg == 0 || Activity(Reg) < 0) return;
    Activity(Reg) = Activity(Reg) - 1;
    if (Activity(Reg) < 0) Abort(1);
  }
  void Claim(int Reg) {
    if (Reg == 0 || Activity(Reg) < 0) return;
    Used(Reg) = Ca;
    Activity(Reg) = Activity(Reg) + 1;
  }
  void Forget(int Reg) {
    Use(Reg).Ca = Limen;
    Use(Reg + Store).Ca = Limen;
  }
  void Forgetdest(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
    const unsigned char Bits[8 /*0:7*/] = {15, 15, 8, 12, 12, 12, 15, 15};
    int R;
    int Mask;
    int Addr;
    int Type;
    Usefm *U;
    Addr = V.Disp | 3;
    Mask = Bits(V.Type) >> (V.Disp & 3);
    for (R = 1; R <= 40; R++) {
      U = &Use(R);
      if (*U->Ca > Limen)
        if ((*U->Base & 255) == V.Base && *U->Form != Avins)
          if ((*U->Disp | 3) == Addr) {
            Type = *U->Type;
            if ((*U->Form & 128) != 0) Type = 7;
            if (Type == 255) Type = 0;
            if ((Bits(Type) >> (*U->Disp & 3) & Mask) != 0) {
              *U->Ca = Limen;
            }
          }
    }
  }
  void Hazard(int Reg) {
    Dfm *P;
    int N;
    int T;
    int Op;
    void Mod(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
      static int S_sw;
      static void *S[8 /*0:7*/] = {
          &&S_0, &&S_1, &&S_2, &&S_3, &&S_4, &&S_5, &&S_6, &&S_7,
      };
      N = N - 1;
      goto *S[S_sw = V.Form];
    S_0:;
    S_4:;
    S_5:;
    S_7:
      Abort(3);
    S_2:
      V.Form = Ainrec;
      V.Extra = T;
      goto Done;
    S_6:
      V.Form = Avinrec;
      V.Extra = T;
      goto Done;
    S_3:
      V.Form = Vinrec;
      V.Extra = T;
      goto Done;
    S_1:
      V.Form = Vins;
      V.Disp = T;
    Done:
      V.Base = Local;
    }
    N = Activity(Reg);
    if (N <= 0) return;
    Activity(Reg) = 0;
    T = Temp();
    if (Fpr0 <= Reg && Reg <= Fpr14)
      Op = Ste;
    else
      Op = St;
    Rx(Op, Reg, Local, T);
    P = &Using.Link;
    for (;;) {
      if (P == &Null) break;
      if (*P->D.Base == Reg) Mod(*P->D);
      P = P->Link;
    }
    if (N != 0) Abort(4);
  }
  void Hazardall(void) {
    int J;
    for (J = 1; J <= 20; J++) Hazard(J);
  }
  void Remember(int Reg, /*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
    Usefm *U;
    if (Reg <= Store) Remember(Reg + Store, V);
    U = &Use(Reg);
    *U->Base = V.Base;
    *U->Disp = V.Disp;
    *U->Type = V.Type;
    *U->Form = V.Form;
    *U->Ca = Ca;
    if (Control < 0) {
      Selectoutput(List);
      Printstring(_imp_str_literal(" REMEMBER:"));
      Write(*U->Type, 1);
      Write(*U->Form, 1);
      Write(*U->Base, 3);
      Write(*U->Disp, 5);
      Newline();
      Selectoutput(Object);
    }
  }
  int Finduse(int Type, int Form, int Base, int Disp) {
    Usefm *U;
    int J;
    int B;
    int Bb;
    int Bca;
    int Bbca;
    B = Base & 255;
    Bb = Base >> 8;
    if (Activity(B) < 0)
      Bca = Limen + 1;
    else
      Bca = Use(B).Ca;
    if (Activity(Bb) < 0)
      Bbca = Limen + 1;
    else
      Bbca = Use(Bb).Ca;
    if (Bca <= Limen || Bbca <= Limen) return (0);
    for (J = 1; J <= 40; J++) {
      U = &Use(J);
      if (Bca < *U->Ca && Bbca < *U->Ca)
        if (*U->Base == Base && *U->Disp == Disp)
          if (*U->Type == Type && *U->Form == Form) {
            if (J > Store) {
              J = J - Store;
              if (Use(J).Ca <= Limen) Use(J) = *U;
            }
            Claim(J);
            Release(B);
            Release(Bb);
            return (J);
          }
    }
    return (0);
  }
  int Gpr(int Addr) {
    Usefm *Ur;
    Usefm *Us;
    int R;
    int Bestr;
    int Bestca;
    int Bootr;
    int Bootca;
    int Reg;
    int Maxca;
    const unsigned char Pref[12 /*0:11*/] = {7, 10, 8, 6, 9,  11,
                                             5, 4,  2, 3, 12, 1};
    Bestr = -1;
    Bootr = -1;
    Bestca = Ca;
    Bootca = Ca;
    for (R = 0; R <= 11 - Addr; R++) {
      Reg = Pref(R);
      if (Activity(Reg) == 0) {
        Ur = &Use(Reg);
        Us = &Use(Reg + Store);
        Maxca = *Ur->Ca;
        if (*Us->Ca > Maxca) Maxca = *Us->Ca;
        if (Maxca <= Limen) return (Reg);
        if (Maxca < Bestca) {
          Bestca = Maxca;
          Bestr = Reg;
        }
      } else if (0 < Activity(Reg) && Activity(Reg) < 2 && Used(Reg) < Bootca) {
        Bootr = Reg;
        Bootca = Used(Reg);
      }
    }
    if (Bestr >= 0) return (Bestr);
    if (Bootr < 0) Bootr = R1;
    Hazard(Bootr);
    Used(Bootr) = Ca;
    return (Bootr);
  }
  int Evenoddpair(void) {
    const unsigned char Pairs[5 /*1:5*/] = {1, 9, 3, 5, 12};
    const unsigned char Next[5 /*1:5*/] = {2, 10, 4, 6, 8};
    int J;
    int Best;
    int Bestca;
    int Max;
    int Help;
    int Reg;
    int Nreg;
    Usefm *U1;
    Usefm *U2;
    Best = 0;
    Bestca = Ca;
    Help = 0;
    for (J = 1; J <= 5; J++) {
      Reg = Pairs(J);
      Nreg = Next(J);
      U1 = &Use(Reg);
      U2 = &Use(Nreg);
      if (Activity(Reg) == 0)
        if (Activity(Nreg) == 0) {
          Max = *U1->Ca;
          if (*U2->Ca > Max) Max = *U2->Ca;
          if (Max < Bestca) {
            Bestca = Max;
            Best = J;
          }
        } else
          Help = J;
      else if (Activity(Nreg) == 0)
        Help = J;
    }
    if (Best != 0) return (Next(Best));
    if (Help == 0) Help = 2;
    Reg = Pairs(Help);
    Nreg = Next(Help);
    Hazard(Reg);
    Hazard(Nreg);
    return (Nreg);
  }
  int Fpr(void) {
    Usefm *Ur;
    Usefm *Us;
    int R;
    int Bestr;
    int Bestca;
    int Bootr;
    int Bootca;
    int Maxca;
    int Boota;
    Bestr = -1;
    Bestca = Ca;
    Bootr = -1;
    Bootca = Ca;
    Boota = Ca;
    for (R = Fpr0; R <= Fpr14; R++) {
      Ur = &Use(R);
      Us = &Use(R + Store);
      if (Activity(R) == 0) {
        Maxca = *Ur->Ca;
        if (*Us->Ca > Maxca) Maxca = *Us->Ca;
        if (Maxca <= Limen) return (R);
        if (Maxca < Bestca) {
          Bestr = R;
          Bestca = Maxca;
        }
      } else if (0 < Activity(R) && Activity(R) < 2 && Used(R) < Bootca) {
        Bootca = Used(R);
        Bootr = R;
      }
    }
    if (Bestr >= 0) return (Bestr);
    if (Bootr < 0) Bootr = Fpr0;
    Hazard(Bootr);
    return (Bootr);
  }
  void Checkreleased(void) {
    int J;
    for (J = 1; J <= 20; J++)
      if (Activity(J) > 0) Abort(2);
  }
  void Countdiags(void) {
    static int Here = 0;
    if (Here != Currentline) Linesize = Linesize + 4;
    Here = Currentline;
  }
  void Put(short N) {
    Printsymbol(N >> 8);
    Printsymbol(N & 255);
  }
  void Dump(short N) {
    Printsymbol(Loadcode);
    Put(N);
    if (Control < 0) Decode(N);
    Ca = Ca + 2;
  }
  void Ghalf(short N) {
    Printsymbol(Loadgla);
    Put(N);
    Ga = Ga + 2;
  }
  void Gword(int N) {
    Ghalf(N >> 16);
    Ghalf(N & 0xFFFF);
  }
  void Gbyte(short N) {
    static int V = 0;
    static int F = 0;
    F = ~F;
    if (F == 0) {
      Printsymbol(Loadgla);
      Put((V << 8) + N);
    } else
      V = N;
    Ga = Ga + 1;
  }
  void Patch(int What, int Where) {
    Selectoutput(Direct);
    Printsymbol(Patchcode);
    Put(What);
    Put(Where);
    Selectoutput(Object);
  }
  void Gpatch(int What, int Where) {
    Selectoutput(Direct);
    Printsymbol(Patchgla);
    Put(What);
    Put(Where);
    Selectoutput(Object);
  }
  void Gfix(int Alignment) {
    while ((Ga & (Alignment - 1)) != 0) Gbyte(0);
  }
  void Sf(short Op, short R, short L) { Dump(Op + (Actual(R) << 4) + L); }
  void Rr(short Op, short R1, short R2) {
    Dump(Op + (Actual(R1) << 4) + Actual(R2));
    Release(R2);
  }
  void Rx(int Op, int R, int X, int D) {
    if (X == R0 || D < 0 || D > 0x3FFF) Abort(5);
    Release(X);
    Dump(Op + (Actual(R) << 4) + Actual(X));
    Dump(D);
    if (Op == Bal) Countdiags();
    if ((Control & Unassdiag) != 0) {
      if (Op != Lw && Op != Le) return;
      if (X == Local && D >= Mintemp) return;
      if (Op == Lw)
        Op = Cl;
      else
        Op = Ce;
      Dump(Op + (Actual(R) << 4) + Actual(Code));
      Dump(Unasspat);
      Printsymbol(Dline);
      Dump(Enterunass);
      Countdiags();
    }
  }
  void Ri2(int Op, int R, int X, int D) {
    if (X == R0) Abort(5);
    Release(X);
    Dump(Op + (Actual(R) << 4) + Actual(X));
    Dump(D);
    if (Op == Bal) Countdiags();
  }
  void Ri3(int Op, int R, int X, int D) {
    if (X == R0) Abort(5);
    Release(X);
    Dump(Op + (Actual(R) << 4) + Actual(X));
    Dump(D >> 16);
    Dump(D & 0xFFFF);
  }
  void Definetag(short Ref) {
    Selectoutput(Direct);
    Printsymbol(Tagdef);
    Put(Ref);
    Put(Ca);
    Selectoutput(Object);
  }
  void Definereference(int Ref, int Type) {
    Selectoutput(Direct);
    Printsymbol(Type);
    Put(Ref);
    Put(Ca);
    Selectoutput(Object);
  }
  void Setline(void) {
    static int Here = 0;
    Currentline = Tag();
    while (Currentline > Here) {
      Here = Here + 1;
      Printsymbol(Lineflag);
    }
  }
  Envfm *Environment(short Label) {
    int J;
    Envfm *E;
    if (Label <= 0) return (&Nullenv);
    for (J = Maxenvirs; J >= 0; J--) {
      E = &Envir(J);
      if (*E->Label == Label) return (E);
    }
    return (&Nullenv);
  }
  void Rememberenvironment(short Label) {
    int K;
    Envfm *E;
    if (Label <= 0) return;
    E = Environment(Label);
    *E->Label = 0;
    Envp = Envp + 1;
    if (Envp > Maxenvirs) Envp = 0;
    E = &Envir(Envp);
    *E->Label = Label;
    *E->Limen = Limen;
    for (K = 1; K <= 40; K++) *E->E(K) = Use(K);
  }
  void Mergeenvironment(short Label) {
    int J;
    Envfm *E;
    Usefm *U;
    Usefm *V;
    E = Environment(Label);
    if (E != &Nullenv)
      for (J = 1; J <= 40; J++) {
        U = &Use(J);
        V = E->E(J);
        if (*U->Base != *V->Base || *U->Disp != *V->Disp ||
            *U->Form != *V->Form || *U->Type != *V->Type || *U->Ca <= Limen)
          *V->Ca = *E->Limen;
      }
  }
  void Restoreenvironment(short Label) {
    int J;
    Envfm *E;
    E = Environment(Label);
    if (E == &Nullenv)
      Limen = Ca;
    else {
      *E->Label = 0;
      Limen = *E->Limen;
      for (J = 1; J <= 40; J++) Use(J) = *E->E(J);
    }
  }
  void Perm(int N) {
    int Mask;
    int J;
    int R;
    const unsigned char Reg[15 /*1:15*/] = {1,  2,  3,  4,  5,  6,  7, 13,
                                            14, 15, 16, 17, 18, 19, 20};
    Mask = 0x80;
    N = N | 0xFFFF0000;
    for (J = 1; J <= 15; J++) {
      Mask = Mask << 1;
      if ((N & Mask) != 0) {
        R = Reg(J);
        Hazard(R);
        Forget(R);
      }
    }
    Hazard(Link);
    Forget(Link);
    Definereference(N & 255, Pref);
    Ri2(Bal, Link, Code, N & 255);
  }
  void Setdiag(int Base, int Disp, int Type, int Form) {
    int V1;
    int V2;
    int P;
    int Mark;
    void Fill(int *V) {
      int Shift;
      Shift = 0;
      V = 0;
      for (;;) {
        if (P == Vp || Shift == 30) return;
        P = P + 1;
        V = V + ((Vbuf(P) - 32) << Shift);
        Shift = Shift + 6;
      }
    }
    P = 0;
    Mark = 0;
    Fill(V1);
    Fill(V2);
    if (Form == 0) {
      Printsymbol(Dline);
      Mark = 16;
      Form = 1;
      if (Base == 0) {
        V2 = 0;
        V1 = Blockword;
      }
    }
    Base = Actual(Base);
    if (Base >= 8) Base = Base - 8;
    Printsymbol(Diags);
    if (Form == -1) {
      Put(-1);
      Put(-1);
      Da = Da + 4;
      return;
    }
    Put((((((((Mark + Xlevel) << 1) + Form - 1) << 3) + Base) << 3) + Type)
        << 4);
    Put(Disp);
    Put(V1 >> 16);
    Put(V1 & 0xFFFF);
    Put(V2 >> 16);
    Put(V2 & 0xFFFF);
    Da = Da + 12;
  }
  void Assemble(short Amode, short Labs, short Names) {
    static int Asslevel = 0;
    static int Z_sw;
    static void *Z[94 /*33:126*/] = {
        &&Z_33,      &&Z_34,      &&Z_35,      &&Z_36,      &&Z_37,
        &&Z_38,      &&Z_39,      &&Z_40,      &&Z_41,      &&Z_42,
        &&Z_43,      &&Z_default, &&Z_45,      &&Z_46,      &&Z_47,
        &&Z_default, &&Z_default, &&Z_default, &&Z_default, &&Z_default,
        &&Z_default, &&Z_default, &&Z_default, &&Z_default, &&Z_default,
        &&Z_58,      &&Z_59,      &&Z_60,      &&Z_61,      &&Z_62,
        &&Z_63,      &&Z_64,      &&Z_65,      &&Z_66,      &&Z_67,
        &&Z_68,      &&Z_69,      &&Z_70,      &&Z_71,      &&Z_72,
        &&Z_73,      &&Z_74,      &&Z_75,      &&Z_76,      &&Z_77,
        &&Z_78,      &&Z_79,      &&Z_80,      &&Z_81,      &&Z_82,
        &&Z_83,      &&Z_84,      &&Z_85,      &&Z_86,      &&Z_87,
        &&Z_88,      &&Z_default, &&Z_90,      &&Z_91,      &&Z_92,
        &&Z_93,      &&Z_default, &&Z_95,      &&Z_default, &&Z_97,
        &&Z_98,      &&Z_99,      &&Z_100,     &&Z_101,     &&Z_102,
        &&Z_default, &&Z_104,     &&Z_default, &&Z_default, &&Z_107,
        &&Z_default, &&Z_default, &&Z_default, &&Z_default, &&Z_112,
        &&Z_113,     &&Z_default, &&Z_115,     &&Z_116,     &&Z_117,
        &&Z_118,     &&Z_119,     &&Z_120,     &&Z_default, &&Z_122,
        &&Z_default, &&Z_default, &&Z_default, &&Z_126,
    };
    Varfm *V;
    Varfm *Gvar;
    Varfm *Fp;
    Varfm *Ap;
    Stackfm *Lhs;
    Stackfm *Rhs;
    Stackfm *X;
    int Sym;
    int Vlb;
    int Vub;
    int Datasize;
    int Oldframe;
    int Gstart;
    int Wdisp;
    int Newdisp;
    int Sdisp;
    int Opr;
    int N;
    int Sizepatch;
    int Warning;
    static int Gg = 0;
    int J;
    int K;
    int Len;
    int Val;
    int Aparm;
    int Sps;
    int Labelstart;
    int Rtlab;
    const unsigned char Comm[17 /*1:17*/] = {0, 0, 1, 0, 1, 1, 0, 1, 1,
                                             1, 0, 0, 0, 0, 1, 0, 0};
    void Amap(/*C_TYPE_RECORD_FORMAT*/ Stackfm V);
    void Load(/*C_TYPE_RECORD_FORMAT*/ Stackfm V, int Reg);
    int Newtag(void);
    void Join(/*C_TYPE_RECORD_FORMAT*/ Stackfm W);
    void Operate(int N);
    void Compare(/*C_TYPE_RECORD_FORMAT*/ Stackfm L,
                 /*C_TYPE_RECORD_FORMAT*/ Stackfm R);
    void Header(/*C_TYPE_RECORD_FORMAT*/ Varfm V);
    if (Freespace < Minfree) Abort(-1);
    Xlevel = Xlevel + 1;
    Rtlab = 0;
    Labelstart = Labs;
    Oldframe = Frame;
    Wdisp = 0;
    Warning = 0;
    Gvar = Decvar;
    Gstart = Names;
    if (Amode > 0) {
      if (Amode == 1)
        Frame = Reglen;
      else
        Frame = 11 * Reglen;
      if (Asslevel == 5) Abort(-3);
      Asslevel = Asslevel + 1;
      Local = Basereg(Asslevel);
      Activity(Local) = -1;
      if (Amode == 2) Setdiag(R15, 0, 0, 0);
      if (Otype == Permrt) {
        Perms = Perms - 1;
        *Gvar->Disp = Perms;
      }
      if (Gg == Procedure) Setdiag(Local, 0, 0, 0);
    } else if (Amode < 0)
      Frame = 0;
    else {
      Setdiag(0, 0, 0, 0);
    }
    int Lookup(int Name) {
      int P;
      int P1;
      int P2;
      Varfm *V;
      P1 = 1;
      P2 = Names;
      while (P2 >= P1) {
        P = (P1 + P2) >> 1;
        V = &Var(P);
        if (*V->Id == Name) return (P);
        if (*V->Id > Name)
          P2 = P - 1;
        else
          P1 = P + 1;
      }
      Abort(6);
      exit(0);
    }
    void Definevar(void) {
      const unsigned char Vsize[8 /*0:7*/] = {0, 4, 1, 2, 0, 4, 4, 0};
      const unsigned char Round[8 /*0:7*/] = {3, 3, 0, 1, 1, 3, 3, 3};
      int Type;
      int Form;
      int Tf;
      int F;
      int Size;
      int Format;
      int S;
      static int Permno = -1;
      Names = Names + 1;
      if (Names >= Parms) Abort(-4);
      Decvar = &Var(Names);
      *Decvar = 0;
      *Decvar->Id = Tag();
      Vp = 0;
      for (;;) {
        Readsymbol(S);
        if (S == Comma) break;
        if (Vp != 10) {
          Vp = Vp + 1;
          Vbuf(Vp) = S;
        }
      }
      Tf = Tag();
      Type = Tf >> 4;
      Form = Tf & 15;
      Skipsymbol();
      if (Type == Long) Type = Reals;
      Size = Tag();
      *Decvar->Type = Type;
      *Decvar->Form = Form;
      Skipsymbol();
      Otype = Tag();
      if (Nextsymbol() == Comma) {
        Skipsymbol();
        Format = Tag();
        F = Lookup(Format);
        *Decvar->Format = F;
        Size = Var(F).Length;
        *Decvar->Length = Size;
      } else if (Type == String) {
        *Decvar->Size = Size;
        Size = Size + 1;
        if (Form == Array) Size = (Size + 1) & (~1);
      } else
        Size = Vsize(Type);
      if (7 <= Form && Form <= 10) {
        Gtype = 1;
        F = Lookup(*Decvar->Id);
        if (F != Names) {
          Names = Names - 1;
          Decvar = &Var(F);
          return;
        }
        if (Otype != 0 && Otype != 7) {
          Permno = Permno + 1;
          *Decvar->Disp = Permno;
          *Decvar->Base = Link;
          return;
        }
        *Decvar->Disp = Newtag() | 0x4000;
        *Decvar->Base = Code;
        if (Form == 8 && (Type == Byte || Type == Short))
          *Decvar->Type = Integer;
        if (Amode != 1 || Gmode == 0) return;
        Otype = 0;
        Type = 0;
        Form = 1;
        Size = 2 * Reglen;
      }
      Datasize = Size;
      *Decvar->Length = Datasize;
      if (Form != 1)
        if (Type == 0) {
          Type = 10;
          Size = 2 * Reglen;
          *Decvar->Type = 10;
        } else if (Form == Arrayname) {
          Size = 2 * Reglen;
          *Decvar->Extra = -1;
        } else if (Form == Array)
          Size = 0;
        else
          Size = Reglen;
      if (Otype != 0) {
        if (Otype == Con) {
          if (Tf == 0x41) Datasize = 0;
          if ((Type <= Short && (Form <= 2 || Form == 5)) || Tf == 0x52 ||
              Form == Arrayname)
            Otype = 0;
        }
        Owntype = Type;
        Ownform = Form;
        if (Form == Array) {
          Gfix(4);
          *Decvar->Extra = Ga;
          Gword(Vlb);
          Gword(Vub);
          Gword(Datasize);
          *Decvar->Base = Gla;
          *Decvar->Disp = Ga - Vlb * Datasize;
        } else {
          if (Form != 1) {
            Owntype = Integer;
            Datasize = Reglen;
          }
          if (Otype != 0) {
            if (Tf != 0x21)
              if (Tf == 0x31 || Tf == 0x41)
                Gfix(2);
              else
                Gfix(4);
            if (Ownform <= 2 && Type != Record) {
              Setdiag(Gla, Ga + Diaggla, Type, Form);
              Diaggla = Diaggla + Datasize;
            }
          }
        }
        return;
      }
      if (Form == Switch) {
        Gfix(2);
        *Decvar->Base = Gla;
        *Decvar->Disp = Ga;
        Ghalf(Vlb);
        Ghalf(Vub);
        *Decvar->Extra = Ga - Vlb * 2;
        for (F = Vlb; F <= Vub; F++) Ghalf(0);
        return;
      }
      if (Form == 4) {
        Gtype = -1;
        return;
      }
      if (Form == 1)
        F = Round(Type);
      else
        F = Reglen - 1;
      Frame = (Frame + F) & (~F);
      if (Frame <= Reglen) {
        if (Amode == 1 && Gmode != 0)
          if ((Form == 2 && Type != 10) || Tf == 0x11 || Tf == 0x31) {
            *Decvar->Base = Param;
            *Decvar->Disp = Frame;
            if (Tf == 0x31) *Decvar->Disp = *Decvar->Disp + (Reglen - 2);
            Frame = Frame - Reglen;
            if (Frame < 0) Frame = 11 * Reglen;
            goto Decd;
          }
        if (Amode >= 0) Frame = 11 * Reglen;
      }
      *Decvar->Base = Local;
      *Decvar->Disp = Frame;
      Frame = Frame + Size;
    Decd:
      if (Amode == 0 || (Amode == 1 && Gg != Spec))
        if (Type != Record && Type != 10)
          if (Form == 1 || Form == 2) Setdiag(Local, *Decvar->Disp, Type, Form);
    }
    Stackfm *Descriptor(void) {
      Stackfm *V;
      Dfm *D;
      V = Descasl;
      if (V == &Null) Abort(17);
      D = Dasl;
      if (D == &Null) Abort(17);
      Descasl = V->Link;
      *V = 0;
      Dasl = D->Link;
      D->Link = &Using.Link;
      Using.Link = D;
      D->D = V;
      V->Link = &Null;
      return (V);
    }
    void Drop(/*C_TYPE_RECORD_FORMAT*/ Stackfm D) {
      Dfm *P;
      Dfm *Q;
      P = &Using;
      for (;;) {
        Q = P->Link;
        if (Q == &Null) Abort(18);
        if (Q->D == &D) break;
        P = Q;
      }
      P->Link = Q->Link;
      Q->Link = Dasl;
      Dasl = Q;
      D.Link = Descasl;
      Descasl = &D;
    }
    void Stack(int Disp, int Base, int Type, int Form, int Format, int Extra,
               int Length) {
      const unsigned char Fmap[16 /*0:15*/] = {
          0, 3, 2, [3 ... 6] = 0, 16, 17, 19, 19, 3, 2, [13 ... 15] = 0};
      Stackfm *V;
      Stp = Stp + 1;
      if (Stp > Maxdepth) Abort(7);
      V = Descriptor;
      *V->Base = Base;
      *V->Disp = Disp;
      *V->Format = Format;
      *V->Extra = Extra;
      *V->Dv = Extra;
      *V->Type = Type;
      *V->Length = Length;
      *V->Form = Fmap(Form);
      Stacked(Stp).V = V;
      Lhs = V;
      if (Control < 0) Show(*V);
    }
    void Vstack(/*C_TYPE_RECORD_FORMAT*/ Varfm V) {
      Stack(V.Disp, V.Base, V.Type, V.Form, V.Format, V.Extra, V.Length);
    }
    void Sstack(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
      Stackfm *T;
      Stp = Stp + 1;
      if (Stp > Maxdepth) Abort(7);
      T = Descriptor;
      *T = V;
      Stacked(Stp).V = T;
      Claim(*T->Base);
      if (Control < 0) Show(*T);
    }
    void Cstack(int N) {
      Rhs = Descriptor;
      *Rhs->Base = 0;
      *Rhs->Disp = N;
      *Rhs->Type = Integer;
      *Rhs->Form = Constant;
      Stp = Stp + 1;
      if (Stp > Maxdepth) Abort(7);
      Stacked(Stp).V = Rhs;
      if (Control < 0) Show(*Rhs);
    }
    void Fpcstack(float X, /*C_TYPE_RECORD_FORMAT*/ Stackfm R) {
      typedef struct F {
        int Val;
        int Gdisp;
      } F;
      const int L = 31;
      static F Constlist[32 /*0:31*/];
      static short Lastpntr = 0;
      static short Nextpntr = 0;
      int N;
      short I;
      typedef struct Convfm {
        int N;
      } Convfm;
      Convfm Conv;
      Conv.X = X;
      N = Conv.N;
      Ownval = N;
      Realga = Ga;
      I = Nextpntr;
      while (I != Lastpntr) {
        I = (I - 1) & L;
        if (Constlist(I).Val == N) goto Foundit;
      }
      Gfix(4);
      I = Ga;
      Gword(N);
      Constlist(Nextpntr).Val = N;
      Constlist(Nextpntr).Gdisp = I;
      I = Nextpntr;
      Nextpntr = (Nextpntr + 1) & L;
      if (Lastpntr == Nextpntr) Lastpntr = (Lastpntr + 1) & L;
    Foundit:;
      R.Base = Gla;
      R.Disp = Constlist(I).Gdisp;
      R.Type = Reals;
      R.Form = Vins;
      Stp = Stp + 1;
      if (Stp > Maxdepth) Abort(7);
      Stacked(Stp).V = &R;
    }
    void Sset(int Base, int Disp, int Form, int Extra) {
      Rhs = Descriptor;
      *Rhs->Base = Base;
      *Rhs->Disp = Disp;
      *Rhs->Type = Integer;
      *Rhs->Form = Form;
      *Rhs->Extra = Extra;
      Stp = Stp + 1;
      if (Stp > Maxdepth) Abort(7);
      Stacked(Stp).V = Rhs;
    }
    void Setlhs(void) { Lhs = &Stacked(Stp).V; }
    void Setboth(void) {
      if (Stp <= 1) Abort(8);
      Lhs = &Stacked(Stp - 1).V;
      Rhs = &Stacked(Stp).V;
    }
    void Poplhs(void) {
      if (Stp <= 0) Abort(8);
      Lhs = &Stacked(Stp).V;
      Stp = Stp - 1;
    }
    void Dumpstring(int Max) {
      int J;
      Gfix(2);
      if (Max <= 0) {
        if (Activestring == &Null || (Max < 0 && *Cslen == 0)) goto Out;
        *Activestring->Base = Gla;
        *Activestring->Disp = Ga;
        *Activestring->Form = Vins;
        Max = *Cslen;
      } else {
        Max = Max - 1;
        if (Max < *Cslen) Abort(-13);
      }
      for (J = 0; J <= Max; J++) Gbyte(Currentstring(J));
      *Cslen = 0;
    Out:
      Activestring = &Null;
    }
    void Getstring(void) {
      int L;
      int S;
      if (Activestring != &Null) Dumpstring(0);
      L = Tag();
      if (L != 0) Skipsymbol();
      *Cslen = 0;
      while (L > 0) {
        L = L - 1;
        Readsymbol(S);
        *Cslen = *Cslen + 1;
        Currentstring(*Cslen) = S;
      }
      Stack(0, 0, String, 0, 0, 0, 0);
      Activestring = &Stacked(Stp).V;
    }
    int Newtag(void) {
      static int Tag = 0;
      Tag = Tag + 1;
      return (Tag);
    }
    Labelfm *Newlabel(void) {
      Labs = Labs + 1;
      if (Labs > Maxlabels) Abort(-5);
      Flab = &Labels(Labs);
      return (Flab);
    }
    Labelfm *Find(int Label) {
      int Lp;
      Lp = Labs;
      while (Lp != Labelstart) {
        Flab = &Labels(Lp);
        if (*Flab->Id == Label) return (Flab);
        Lp = Lp - 1;
      }
      return (&Null);
    }
    void Definelabel(int Label) {
      Envfm *E;
      Labelfm *L;
      L = Find(Label);
      if (L == &Null) {
        if (Control < 0) {
          Selectoutput(Report);
          Printstring(_imp_str_literal(" DEF:"));
          Write(Label, 2);
          Printstring(_imp_str_literal("  LABS ="));
          Write(Labs, 2);
          Newline();
          Selectoutput(Object);
        }
        L = Newlabel;
        *L->Id = Label;
        *L->Tag = Newtag();
        *L->Reg = 0;
        Limen = Ca;
        E = Environment(Label);
        *E->Label = 0;
      } else if (*L->Tag < 0 && Label >= 0) {
        *L->Tag = Newtag();
        *L->Reg = 0;
        E = Environment(Label);
        *E->Label = 0;
      }
      *L->Tag = *L->Tag | 0x8000;
      Definetag(*L->Tag & 0x7FFF);
      if (Uncondjump != Ca) Mergeenvironment(Label);
      Restoreenvironment(Label);
      if (Label == 0) Rtlab = Ca;
      Ccca = 0;
      Uncondjump = 0;
    }
    void Jumpto(int Label, int Cond, int Def) {
      int Ref;
      int Ltag;
      Labelfm *Lab;
      Usefm *U;
      Invert = 0;
      Lab = Find(Label);
      if (Label == 0 && Rtlab == Ca) {
        *Lab->Tag = *Lab->Tag & 0x7FFF;
        return;
      }
      if (Lab == &Null) {
        Lab = Newlabel;
        *Lab->Id = Label;
        *Lab->Reg = 0;
        *Lab->Tag = Newtag();
        Rememberenvironment(Label);
      } else if (*Lab->Reg != 0 && Sym != 'B') {
        *Lab->Base = *Lab->Base | 128;
        Jumpto(Label + 3, Cond, Def);
        return;
      } else if (*Lab->Tag < 0 && Def == Redefine) {
        *Lab->Reg = 0;
        *Lab->Tag = Newtag();
        Rememberenvironment(Label);
      } else if (*Lab->Tag >= 0)
        Mergeenvironment(Label);
      Ltag = *Lab->Tag & 0x7FFF;
      if (*Lab->Reg != 0) {
        if ((*Lab->Base & 128) != 0) Definelabel(Label + 3);
        Sset(*Lab->Base & 127, *Lab->Disp, Vins, 0);
        Lhs = Rhs;
        Load(*Lhs, *Lab->Reg);
        Sset(0, *Lab->Limit, Constant, 0);
        Compare(*Lhs, *Rhs);
        Cond = 1;
        Stp = Stp - 2;
        Drop(*Lhs);
        Drop(*Rhs);
      }
      if (Cond == Jump)
        Ref = Jref;
      else
        Ref = Cref;
      Definereference(Ltag, Ref);
      Dump(Cond + 0x8000);
      Ccca = Ccca + 2;
      if (Cond == Jump) Uncondjump = Ca;
      if (Known.Ca == 0) {
        Known.Ca = 1;
        U = &Use(Known.Base);
        *U->Type = Known.Type;
        *U->Form = Constant;
        *U->Base = 0;
        *U->Disp = Known.Disp;
        *U->Ca = Ca;
      }
    }
    void Float(/*C_TYPE_RECORD_FORMAT*/ Stackfm V, int Reg) {
      int D;
      if (V.Form == Constant) {
        D = V.Disp;
        if (D == 0) {
          if (Reg == Anyf) Reg = Fpr();
          Claim(Reg);
          Rr(Ser, Reg, Reg);
          Claim(Reg);
          V.Base = Reg;
          V.Disp = 0;
          V.Type = Reals;
          V.Form = Vinr;
        } else {
          Fpcstack(D, V);
          Stp = Stp - 1;
        }
        return;
      }
      if (V.Lop != 0) {
        Load(V, Reg);
        return;
      }
      Load(V, Any);
      if (Reg == Anyf) Reg = Fpr();
      Rr(Flr, Reg, V.Base);
      Claim(Reg);
      V.Type = Reals;
      V.Form = Vinr;
      V.Base = Reg;
      V.Disp = 0;
    }
    void Lrd(/*C_TYPE_RECORD_FORMAT*/ Stackfm V, int Reg) {
      Load(V, Reg);
      Release(V.Base);
      Drop(V);
    }
    void Reduce(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
      int Type;
      int Form;
      int Disp;
      Type = V.Type;
      Form = V.Form - 2;
      if (Form == Avinrec - 2) Form = Avins;
      Disp = V.Disp;
      V.Disp = V.Extra;
      V.Type = Integer;
      V.Form = Vins;
      Load(V, Any0);
      V.Type = Type;
      V.Form = Form;
      V.Disp = Disp;
    }
    void Vmap(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
      int N;
      const unsigned char Map[16 /*0:15*/] = {
          3, 3, 3, 2, 3, 4, 3, 5, [8 ... 15] = 0};
      if (V.Form == Ains || V.Form == Ainrec) Load(V, Any0);
      if (V.Lop != 0)
        if (V.Lop == Add && Const(V.Link)) {
          N = V.Link.Disp;
          V.Lop = 0;
          Drop(V.Link);
          if (V.Form == Avins || V.Form == Avinrec)
            V.Disp = V.Disp + N;
          else {
            Load(V, Any0);
            V.Disp = N;
          }
        } else
          Load(V, Any0);
      V.Form = Map(V.Form);
    }
    void Amap(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
      const short Map[8 /*0:7*/] = {-1, -1, 3, 6, 5, 7, -1, -1};
      V.Form = Map(V.Form);
      if (V.Form == Avins)
        if (V.Base == 0)
          V.Form = Constant;
        else if (V.Disp == 0)
          V.Form = Vinr;
      if (V.Form < 0) Abort(9);
      V.Type = Integer;
    }
    void Optimise(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
      int R;
      if (V.Form == Vinr || V.Lop != 0) return;
      if (V.Form >= Ainrec && V.Form != Avins) Reduce(V);
      R = Finduse(V.Type, V.Form, V.Base, V.Disp);
      if (R != 0) {
        V.Base = R;
        V.Disp = 0;
        V.Form = Vinr;
      } else if (V.Form == Ains) {
        R = Finduse(Integer, Vins, V.Base, V.Disp);
        if (R == 0) return;
        V.Base = R;
        V.Disp = 0;
        V.Form = Vins;
        Optimise(V);
      }
    }
    void Range(short *Base, int *Disp) {
      Stackfm V;
      if (0 <= Disp && Disp <= 0x3FFF) return;
      V.Type = Integer;
      V.Form = Avins;
      V.Base = Base;
      V.Disp = Disp & (~0x3FFF);
      Disp = Disp - V.Disp;
      V.Lop = 0;
      Load(V, Any0);
      Base = V.Base;
    }
    void Address(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
      int Type;
      int Form;
      Form = V.Form;
      Type = V.Type;
      if (Form == Vinrec || Form == Ainrec) {
        Reduce(V);
        Form = V.Form;
      }
      if (Form != Vins && Form != Vinr)
        if (Form == Ains) {
          Form = Vins;
          V.Form = Form;
          V.Type = Integer;
          Load(V, Any0);
        } else {
          Load(V, Any);
          Form = Vinr;
          Type = Integer;
        }
      Range(V.Base, V.Disp);
      V.Type = Type;
      V.Form = Form;
    }
    void Load(/*C_TYPE_RECORD_FORMAT*/ Stackfm V, int R) {
      Stackfm H;
      const short Opkey[17 /*1:17*/] = {-1, 0, 0, 6, 4, 2, 0, 0, 5,
                                        10, 0, 2, 0, 0, 0, 0, 0};
      const short Pm[12 /*0:11*/] = {0x0A00, 0x2600, 0xCA00, 0x5A00,
                                     0x4A00, 0xFA00, 0x0B00, 0x2700,
                                     0xCB00, 0x5B00, 0x4B00, 0xFB00};
      const short Muldiv[6 /*0:5*/] = {0x1D00, 0x5D00, 0x1C00,
                                       0x5C00, 0x1C00, 0x5C00};
      const short Logical[15 /*0:14*/] = {
          0x0400, 0xC400, 0x5400, 0x4400, 0xF400, 0x0600, 0xC600, 0x5600,
          0x4600, 0xF600, 0x0700, 0xC700, 0x5700, 0x4700, 0xF700};
      const short Shift[4 /*0:3*/] = {0x1100, 0xED00, 0x1000, 0xEC00};
      const short Realop[12 /*3:14*/] = {0x2A00, 0x2B00, 0,      0x2C00,
                                         0x2D00, 0,      0,      0x6A00,
                                         0x6B00, 0,      0x6C00, 0x6D00};
      int Pred(int R) {
        const unsigned char Inv[16 /*0:15*/] = {1,  2, 3, 4,  5,  6,  7,  43,
                                                12, 8, 9, 10, 11, 42, 44, 41};
        return (Inv(Actual(R) ^ 1));
      }
      Stackfm *W;
      static int F_sw;
      static void *F[9 /*0:8*/] = {
          &&F_0, &&F_1, &&F_2, &&F_3, &&F_4, &&F_5, &&F_6, &&F_7, &&F_default,
      };
      static int Iop_sw;
      static void *Iop[17 /*1:17*/] = {
          &&Iop_1,  &&Iop_2,  &&Iop_3,  &&Iop_4,  &&Iop_default, &&Iop_6,
          &&Iop_7,  &&Iop_8,  &&Iop_9,  &&Iop_10, &&Iop_11,      &&Iop_12,
          &&Iop_13, &&Iop_14, &&Iop_15, &&Iop_16, &&Iop_17,
      };
      static int Rop_sw;
      static void *Rop[17 /*1:17*/] = {
          &&Rop_1,  &&Rop_2,       &&Rop_3,  &&Rop_4,       &&Rop_default,
          &&Rop_6,  &&Rop_default, &&Rop_8,  &&Rop_9,       &&Rop_10,
          &&Rop_11, &&Rop_12,      &&Rop_13, &&Rop_default, &&Rop_default,
          &&Rop_16, &&Rop_default,
      };
      int Op;
      int T;
      int D;
      int Type;
      int Form;
      int Key;
      int Temp;
      int N;
      static int Addxca = 0;
      static int Addxd = 0;
      static int Addxs = 0;
      static int Addxkey = 0;
      if (Freespace < Minfree) Abort(-2);
      if (Floating(V) || Fpr0 <= R && R <= Fpr14 || R == Anyf) goto Realz;
      Op = V.Lop;
      V.Lop = 0;
      if (Op != 0) {
        W = &V.Link;
        Optimise(V);
        if (W != &Null) Optimise(*W);
        if (Op == Sub && *W->Form == Constant) {
          Op = Add;
          *W->Disp = -*W->Disp;
        }
        if (Comm(Op) != 0) {
          T = 0;
          if (*W->Base == R || (*W->Form == Vinr && V.Form != Vinr)) T = 1;
          if (V.Type != Byte && *W->Type == Byte && V.Base != R) T = 1;
          if (*W->Form == Constant && R < Any && R != V.Base && V.Type != Byte)
            T = 1;
          if (V.Base == R || (*W->Form == Vinr && Activity(*W->Base) < 0))
            T = 0;
          if (T != 0) {
            H = *W;
            *W = V;
            V = H;
          }
        }
        if ((Control & Unassdiag) != 0)
          if (*W->Form != Constant &&
              (*W->Type == Integer || *W->Type == Reals))
            Load(*W, Any0);
        Key = Opkey(Op);
        goto *Iop[Iop_sw = (Op)-1];
      }
      if (V.Type == String || V.Type == 0) Amap(V);
      if (V.Form > Vins && V.Form != Avins) Reduce(V);
      Optimise(V);
      if (R >= Any) {
        if (V.Form == Vinr && (R == Any || V.Base != R0) &&
            Activity(V.Base) >= 0)
          return;
        R = Gpr(R - Any);
      } else if (V.Base != R || Activity(R) != 1)
        Hazard(R);
      goto *F[F_sw = V.Form];
    F_7:;
    F_4:;
    F_5:;
      Claim(R);
      Reduce(V);
      Release(R);
      goto *F[F_sw = V.Form];
    F_6:;
      if (V.Type == Reals) Abort(10);
      if (V.Base != R0) {
        if (-0x8000 <= V.Disp && V.Disp <= 0x7FFF)
          if (V.Disp != 0)
            Ri2(Lhi, R, V.Base, V.Disp);
          else
            Rr(Lr, R, V.Base);
        else
          Ri3(Li, R, V.Base, V.Disp);
        Claim(R);
        Remember(R, V);
        V.Base = R;
        V.Disp = 0;
        V.Type = Integer;
        V.Form = Vinr;
        return;
      }
    F_0:;
      if (V.Type == Reals) Abort(16);
      D = V.Disp;
      if (-15 <= D && D <= 15)
        if (D >= 0)
          Sf(Lis, R, D);
        else
          Sf(Lcs, R, -D);
      else if (-0x8000 <= D && D <= 0x7FFF)
        Ri2(Lhi, R, 0, D);
      else
        Ri3(Li, R, 0, D);
      Claim(R);
      Remember(R, V);
      V.Base = R;
      V.Disp = 0;
      V.Type = Integer;
      V.Form = Vinr;
      return;
    F_1:;
      Op = Lr;
      if (V.Base == R) return;
      if (V.Type == Reals) Op = Ler;
      Rr(Op, R, V.Base);
      Claim(R);
      Ccreg = R;
      Ccca = Ca;
      Forget(R);
      Use(R) = Use(V.Base);
      V.Base = R;
      return;
    F_2:;
      Type = V.Type;
      V.Type = Integer;
      V.Form = Vins;
      Claim(R);
      Load(V, Any0);
      Release(R);
      V.Type = Type;
      V.Form = Vins;
    F_3:;
      Range(V.Base, V.Disp);
      Ccreg = R;
      Ccca = Ca + 4;
      if (V.Type == Integer)
        Op = Lw;
      else if (V.Type == Short)
        Op = Lh;
      else if (V.Type == Byte) {
        Op = Lb;
        Ccca = 0;
      } else if (V.Type == Reals)
        Op = Le;
      else {
        Op = Lhl;
      }
      Rx(Op, R, V.Base, V.Disp);
      Claim(R);
      Remember(R, V);
      V.Base = R;
      V.Disp = 0;
      V.Form = Vinr;
      return;
    Iop_3:;
      if (*W->Form == Vinr && *W->Base != R && V.Form == Constant) {
        D = V.Disp;
        if ((Use(*W->Base).Ca > Limen || Use(*W->Base + Store).Ca > Limen ||
             D < -15 || D > 15) &&
            Ca != Addxca) {
          if (R >= Any)
            R = Gpr(R - Any);
          else if (*W->Base != R || Activity(R) != 1)
            Hazard(R);
          if (-0x8000 <= D && D <= 0x7FFF)
            Ri2(Lhi, R, *W->Base, D);
          else
            Ri3(Li, R, *W->Base, D);
          Ccreg = R;
          Ccca = Ca;
          V.Disp = 0;
          V.Form = Vinr;
          V.Base = R;
          Claim(R);
          goto Endop;
        }
      }
    Iop_15:;
    Iop_4:;
      Load(V, R);
      R = V.Base;
      if (*W->Type == Byte || *W->Type == Unsignedhalfword) Load(*W, Any);
      if (*W->Form == Constant) {
        D = *W->Disp;
        if (-15 <= D && D <= 15) {
          if (D < 0) {
            D = -D;
            Key = 6 - Key;
          }
          Sf(Pm(Key + 1), R, D);
        } else if (-0x8000 <= D && D <= 0x7FFF)
          if (Ca == Addxca && R == Addxd) {
            if (Addxkey != Key) D = -D;
            Dump(D);
            Patch(Pm(Addxkey + 2) + (Actual(R) << 4) + Actual(Addxs),
                  Addxca - 2);
          } else
            Ri2(Pm(Key + 2), R, 0, D);
        else
          Ri3(Pm(Key + 5), R, 0, D);
      } else if (*W->Form == Vinr) {
        Rr(Pm(Key), R, *W->Base);
        Addxca = Ca;
        Addxd = R;
        Addxkey = Key;
        Addxs = *W->Base;
      } else if (*W->Form == Avins)
        Ri2(Pm(Key + 2), R, *W->Base, *W->Disp);
      else {
        Address(*W);
        if (*W->Form == Vinr) Key = Key - 1;
        if (*W->Type == Short) Key = Key + 1;
        Rx(Pm(Key + 3), R, *W->Base, *W->Disp);
      }
      goto Setcc;
    Iop_6:;
    Iop_7:;
    Iop_17:;
      if (R >= Any) {
        if (Key == 0)
          N = 0;
        else
          N = 1;
        if (V.Form == Vinr && (Actual(V.Base) & 1) == N &&
            Activity(Pred(V.Base)) == 0) {
          Temp = V.Base;
          if (Key == 0) Temp = Pred(Temp);
        } else
          Temp = Evenoddpair();
      } else if ((Actual(R) & 1) == 0 || Activity(Pred(R)) != 0)
        Temp = Evenoddpair();
      else
        Temp = R;
      N = Pred(Temp);
      Hazard(N);
      if (Key != 0) {
        Claim(N);
        Load(V, Temp);
      } else {
        Claim(Temp);
        Load(V, N);
        Rr(Lr, Temp, N);
        Use(Temp) = Use(N);
        Use(Temp + Store) = Use(N);
        Claim(N);
        Rx(Sra, N, 0, 31);
        Forget(N);
      }
      if (*W->Form == Constant || *W->Type != Integer) Load(*W, Any);
      Address(*W);
      if (*W->Form == Vinr)
        Rr(Muldiv(Key), N, *W->Base);
      else
        Rx(Muldiv(Key + 1), N, *W->Base, *W->Disp);
      if (Op == Rem) {
        D = Temp;
        Temp = N;
        N = D;
      }
      Release(N);
      Forget(N);
      Forget(Temp);
      V.Base = Temp;
      V.Disp = 0;
      V.Form = Vinr;
      if (Temp != R) Load(V, R);
      goto Endop;
    Iop_8:;
      if (V.Form == Constant && V.Disp == 255) {
        if (*W->Form == Vinr)
          if (R >= Any)
            if (Activity(*W->Base) == 1)
              R = *W->Base;
            else
              R = Gpr(R - Any);
          else if (R != *W->Base || Activity(R) != 1)
            Hazard(R);
          else {
            Load(*W, R);
            R = *W->Base;
          }
        Claim(R);
        Rr(Lbr, R, *W->Base);
        V.Base = R;
        V.Disp = 0;
        V.Form = Vinr;
        goto Fend;
      }
    Iop_9:;
    Iop_10:;
      if (*W->Form == Constant && -15 <= *W->Disp && *W->Disp <= 15)
        if (V.Form != Vinr || (R < Any && V.Base != R)) {
          H = *W;
          *W = V;
          V = H;
        }
      Load(V, R);
      R = V.Base;
      if (*W->Type == Byte) Load(*W, Any);
      if (*W->Form == Constant) {
        if (Key == 0 && *W->Disp == 255) {
          Claim(R);
          Rr(Lbr, R, R);
          goto Fend;
        }
        if (-0x8000 <= *W->Disp && *W->Disp <= 0x7FFF)
          Ri2(Logical(Key + 1), R, 0, *W->Disp);
        else
          Ri3(Logical(Key + 4), R, 0, *W->Disp);
      } else if (*W->Form == Vinr)
        Rr(Logical(Key), R, *W->Base);
      else {
        Address(*W);
        if (*W->Type == Short || *W->Type == Unsignedhalfword) Key = Key + 1;
        Rx(Logical(Key + 2), R, *W->Base, *W->Disp);
      }
      goto Setcc;
    Iop_12:;
    Iop_11:;
      Load(V, R);
      R = V.Base;
      if (*W->Form == Vinr && Use(*W->Base).Ca > Limen &&
          Use(*W->Base).Form == Constant && 0 <= Use(*W->Base).Disp &&
          Use(*W->Base).Disp <= 15) {
        *W->Disp = Use(*W->Base).Disp;
        *W->Form = Constant;
        Release(*W->Base);
      }
      if (*W->Form == Constant)
        if (Key == 0 && *W->Disp == 1) {
          Claim(R);
          Rr(Ar, R, R);
        } else if (*W->Disp > 15)
          Rx(Shift(Key + 1), R, 0, *W->Disp);
        else
          Sf(Shift(Key), R, *W->Disp & 15);
      else {
        Load(*W, Any0);
        Rx(Shift(Key + 1), R, *W->Base, 0);
      }
      goto Setcc;
    Iop_2:;
    Iop_1:;
      if (V.Base == R) {
        Load(V, R);
        Ri2(Xhi, V.Base, 0, -1);
        if (Key == 0) Sf(Ais, V.Base, 1);
      } else {
        W = Rhs;
        Cstack(Key);
        Rhs = W;
        Sstack(V);
        Release(V.Base);
        V.Base = 0;
        Operate(Sub);
        Stp = Stp - 1;
        V = Stacked(Stp + 1).V;
        Drop(Stacked(Stp + 1).V);
        Load(V, R);
      }
      Forget(V.Base);
      Ccreg = V.Base;
      Ccca = Ca;
      return;
    Iop_13:;
      Load(V, R2);
      Load(*W, R3);
      Release(R2);
      Release(R3);
      Perm(Iexp);
      Claim(R1);
      V.Base = R1;
      goto Endop;
    Iop_14:;
      if (V.Type != 0) {
        Load(V, R1);
        Release(R1);
        Hazard(R2);
        if (Wdisp == 0)
          Rr(Lr, R2, Wsp);
        else
          Ri2(Lhi, R2, Wsp, Wdisp);
        Forget(R2);
        Wdisp = Wdisp + 256;
        Perm(Conc1);
      } else {
        Load(V, R2);
        Release(R2);
      }
      Join(*W);
      Claim(R2);
      V.Type = 0;
      V.Form = Vins;
      V.Base = R2;
      V.Disp = 0;
      if (R != Any) {
        Load(V, R);
        V.Type = 0;
        V.Form = Vins;
      }
      return;
    Realz:
      if (R == Any) Abort(11);
      Op = V.Lop;
      V.Lop = 0;
      if (Op != 0) {
        if (Op == Neg) goto Ropneg;
        W = &V.Link;
      Iop_16:;
        if (*W->Type != Reals && Op != Exp) Float(*W, Anyf);
        if (V.Type != Reals) Float(V, R);
        if (Op == Add || Op == Mul) {
          Optimise(V);
          if (W != &Null) Optimise(*W);
          if (*W->Base == R || (V.Form != Vinr && *W->Form == Vinr)) {
            H = *W;
            *W = V;
            V = H;
          }
        }
        if (W != &Null) Address(*W);
        goto *Rop[Rop_sw = (Op)-1];
      Rop_1:
      Rop_11:
      Rop_12:;
      Rop_8:
      Rop_9:
      Rop_10:;
        Realerror(Op);
      Rop_16:
        Op = Div;
      Rop_3:;
      Rop_4:;
      Rop_6:;
        Load(V, R);
        R = V.Base;
        if (*W->Form == Vinr)
          Rr(Realop(Op), R, *W->Base);
        else
          Rx(Realop(Op + 7), R, *W->Base, *W->Disp);
        goto Setcc;
      Ropneg:;
      Rop_2:
        if (V.Base == R) Load(V, Anyf);
        if (R == Anyf) R = Fpr();
        Hazard(R);
        Claim(R);
        Rr(Ser, R, R);
        Claim(R);
        Address(V);
        if (V.Form == Vinr)
          Rr(Ser, R, V.Base);
        else
          Rx(Se, R, V.Base, V.Disp);
        Ccreg = R;
        Ccca = Ca;
        Forget(R);
        V.Base = R;
        V.Disp = 0;
        V.Form = Vinr;
        return;
      }
      if (V.Type != Reals) Float(V, R);
      Optimise(V);
      if (V.Form == Vinr) {
        if (R == Anyf || V.Base == R) return;
        Rr(Ler, R, V.Base);
        Use(R) = Use(V.Base);
        V.Base = R;
        Claim(V.Base);
        Ccreg = R;
        Ccca = Ca;
        return;
      }
      if (R == Anyf) R = Fpr();
      if (Fpr0 > R || R > Fpr14) Abort(12);
      goto *F[F_sw = V.Form];
    Rop_13:;
      if (*W->Type == Reals) {
        Realerror(1);
        *W->Type = Integer;
      }
      Load(V, Fpr2);
      Load(*W, R1);
      Release(Fpr2);
      Release(R1);
      Perm(Rexp);
      Claim(Fpr0);
      V.Base = Fpr0;
      goto Endop;
    Setcc:;
      Ccca = Ca;
      Ccreg = R;
    Fend:
      Forget(R);
    Endop:
      Drop(*W);
      goto Rop_skip;
    Rop_default:
      fprintf(stderr, "Switch label 'Rop(%d):' not set in %s", Rop_sw + 1,
              __PRETTY_FUNCTION__);
      exit(1) /* or %signal ... */;
    Rop_skip:;
      goto Iop_skip;
    Iop_default:
      fprintf(stderr, "Switch label 'Iop(%d):' not set in %s", Iop_sw + 1,
              __PRETTY_FUNCTION__);
      exit(1) /* or %signal ... */;
    Iop_skip:;
      goto F_skip;
    F_default:
      fprintf(stderr, "Switch label 'F(%d):' not set in %s", F_sw,
              __PRETTY_FUNCTION__);
      exit(1) /* or %signal ... */;
    F_skip:;
    }
    void Cop(int Op, int *L, int R) {
      static int S_sw;
      static void *S[17 /*1:17*/] = {
          &&S_1,  &&S_2,  &&S_3,  &&S_4,  &&S_default, &&S_6,
          &&S_7,  &&S_8,  &&S_9,  &&S_10, &&S_11,      &&S_12,
          &&S_13, &&S_14, &&S_15, &&S_16, &&S_17,
      };
      goto *S[S_sw = (Op)-1];
    S_15:;
    S_16:;
    S_2:;
    S_1:;
    S_14:
      Abort(13);
    S_3:
      L = L + R;
      return;
    S_4:
      L = L - R;
      return;
    S_9:
      L = L | R;
      return;
    S_8:
      L = L & R;
      return;
    S_10:
      L = L ^ R;
      return;
    S_11:
      L = L << R;
      return;
    S_6:
      L = L * R;
      return;
    S_12:
      L = L >> R;
      return;
    S_13:
      L = IEXP(L, R);
      return;
    S_7:
      if (R == 0) {
        Abort(-6);
        R = 1;
      }
      L = L / R;
      return;
    S_17:
      if (R == 0) {
        Abort(-6);
        R = 1;
      }
      L = L - L / R * R;
      goto S_skip;
    S_default:
      fprintf(stderr, "Switch label 'S(%d):' not set in %s", S_sw + 1,
              __PRETTY_FUNCTION__);
      exit(1) /* or %signal ... */;
    S_skip:;
    }
    void Join(/*C_TYPE_RECORD_FORMAT*/ Stackfm W) {
      Stackfm *Qw;
      for (;;) {
        Qw = &W.Link;
        W.Lop = 0;
        Lrd(W, R1);
        Perm(Conc2);
        if (Qw == &Null) break;
        W = Qw;
      }
    }
    void Operate(int Oper) {
      const int Nullop[15 /*3:17*/] = {0, 0, 1, 1, 1, -1, [6 ... 9] = 0,
                                       1, 0, 0, 1, 1};
      int Rcon;
      int Lcon;
      int Wcon;
      int Lop;
      int Key;
      int D;
      int S;
      Stackfm *With;
      Stackfm *Lh;
      Stackfm *Rh;
      const unsigned char Trans[17 /*1:17*/] = {
          2, 2, 0, 0, [4 ... 9] = 1, [10 ... 13] = 2, 0, 15, 15};
      void Swop(void) {
        Wcon = Lcon;
        Lcon = Rcon;
        Rcon = Wcon;
        With = Lh;
        Lh = Rh;
        Rh = With;
        Stacked(Stp).V = Lh;
      }
      void Pickup(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
        if (Floating(V))
          Load(V, Anyf);
        else
          Load(V, Any);
      }
      if (Oper <= Neg) {
        Lh = &Stacked(Stp).V;
        if (Const(*Lh))
          *Lh->Disp = ~*Lh->Disp + Oper - 1;
        else {
          if (*Lh->Lop != 0) Pickup(*Lh);
          *Lh->Lop = Oper;
          Lh->Link = &Null;
        }
        return;
      }
      Stp = Stp - 1;
      Lcon = 0;
      Rcon = 0;
      Wcon = 0;
      Lh = &Stacked(Stp).V;
      Rh = &Stacked(Stp + 1).V;
      if (Const(*Lh)) Lcon = 1;
      if (Const(*Rh)) Rcon = 1;
      if (Oper == Sub && Rcon != 0) {
        Oper = Add;
        *Rh->Disp = -*Rh->Disp;
      }
      if (*Lh->Lop != 0) {
        Lop = *Lh->Lop;
        if (Oper == Conc) {
          With = Lh;
          while (*With->Lop != 0) With = With->Link;
          With->Link = Rh;
          *With->Lop = Conc;
          return;
        }
        With = Lh->Link;
        if (Oper > Neg && Const(*With)) Wcon = 1;
        if (Lop == Neg && Oper == Add) {
          *Rh->Lop = Sub;
          Rh->Link = Lh;
          *Lh->Lop = 0;
          Stacked(Stp).V = Rh;
          return;
        }
        if (*With->Type == String) Dumpstring(0);
        if ((Wcon & Rcon) != 0) {
          Key = Trans(Oper) | Trans(Lop);
          if (Key == 0 || (Key == 1 && Oper == Lop)) {
            Cop(Oper, *With->Disp, *Rh->Disp);
            Drop(*Rh);
            if (*With->Disp == Nullop(Oper)) {
              *Lh->Lop = 0;
              Drop(*With);
            }
            return;
          }
        }
        Pickup(*Lh);
      }
      if ((Lcon & Rcon) != 0 && Oper != Rdiv) {
        Cop(Oper, *Lh->Disp, *Rh->Disp);
        Drop(*Rh);
        return;
      }
      if (Lcon != 0 && Comm(Oper) != 0) {
        Swop();
        if (*Lh->Lop != 0) Pickup(*Lh);
      }
      if (Rcon != 0 && (Oper == And || Oper == Rsh) &&
          ((Control & Unassdiag) == 0 || *Lh->Type == Short)) {
        Optimise(*Lh);
        if (*Lh->Form != Vinr && (*Lh->Type == Integer || *Lh->Type == Short)) {
          Address(*Lh);
          if (Oper == And) {
            S = *Lh->Type;
            D = 0;
            if (*Lh->Type == Integer) D = Reglen / 2;
            if (*Rh->Disp == 255) {
              S = Byte;
              D = D + Reglen / 4;
            } else if (*Rh->Disp >> 16 == 0) {
              if (*Rh->Disp >> 15 != 0) *Rh->Disp = *Rh->Disp | 0xFFFF0000;
              *Lh->Type = Unsignedhalfword;
              *Lh->Disp = *Lh->Disp + D;
              D = -1;
            } else
              D = -1;
            if (D >= 0) {
              *Lh->Type = S;
              *Lh->Disp = *Lh->Disp + D;
              Drop(*Rh);
              return;
            }
          } else {
            if (*Rh->Disp == (8 * Reglen) / 2 && *Lh->Type != Short)
              S = Unsignedhalfword;
            else if (*Rh->Disp == 8 * (Reglen - 1))
              S = Byte;
            else
              S = -1;
            if (S >= 0) {
              *Lh->Type = S;
              Drop(*Rh);
              return;
            }
          }
        }
      }
      if (*Rh->Lop != 0) Pickup(*Rh);
      if ((Lcon | Rcon) != 0 && Oper == Mul) {
        if (Lcon != 0) Swop();
        if (Floating(*Lh))
          Key = -1;
        else
          Key = Power(*Rh->Disp);
        if (Key >= 0) {
          *Rh->Disp = Key;
          Oper = Lsh;
        } else
          Swop();
      }
      if (Rcon != 0 && *Rh->Disp == Nullop(Oper)) {
        Drop(*Rh);
        return;
      }
      *Lh->Lop = Oper;
      Lh->Link = Rh;
    }
    int /* boolean */ Different(/*C_TYPE_RECORD_FORMAT*/ Stackfm A,
                                /*C_TYPE_RECORD_FORMAT*/ Stackfm B) {
      while (&B != &Null) {
        if (Same(A, B)) return (0);
        B = &B.Link;
      }
      return (1);
    }
    void Assign(int Assop) {
      Stackfm *Lhs;
      Stackfm *Rhs;
      Stackfm *W;
      Stackfm Temp;
      Stackfm Hold;
      int N;
      int P;
      int T;
      int Op;
      int Val;
      int Size;
      if (Stp < 2) Abort(8);
      Rhs = &Stacked(Stp).V;
      Lhs = &Stacked(Stp - 1).V;
      if (Assop < 0) {
        if (*Lhs->Base == Link) {
          Temp = *Lhs;
          *Lhs = *Rhs;
          *Rhs = Temp;
          Newdisp = 0;
          return;
        }
        *Lhs->Extra = *Lhs->Extra - 1;
        V = &Var(*Lhs->Extra);
        if (Control < 0) Displayvar(*V);
        Vstack(*V);
        Lhs = &Stacked(Stp).V;
        if (*V->Form > 1) Assop = 0;
        Newdisp = *Lhs->Disp + *Lhs->Length;
        if ((*Lhs->Form & 16) != 0) {
          Forget(Link);
          Hazard(R0);
          Newdisp = *Lhs->Disp + 2 * Reglen;
          if ((*Rhs->Disp & 0x4000) != 0) {
            Rx(St, Wsp, Wsp, *Lhs->Disp);
            Definereference(*Rhs->Disp & 0xFFF, Rref);
            Rx(La, Link, Code, 0);
            Rx(St, Link, Wsp, *Lhs->Disp + Reglen);
          } else {
            Rx(Lw, Link, *Rhs->Base, *Rhs->Disp);
            Rx(St, Link, Wsp, *Lhs->Disp);
            Rx(Lw, Link, *Rhs->Base, *Rhs->Base + Reglen);
            Rx(St, Link, Wsp, *Lhs->Disp + Reglen);
          }
          Drop(*Rhs);
          Drop(*Lhs);
          Stp = Stp - 2;
          return;
        }
      }
      if (*Lhs->Dv < 0 && (Control & Arraydiag) != 0) {
        *Lhs->Dv = 0;
        Hold = *Lhs;
        Temp = *Rhs;
        Hold.Disp = Hold.Disp + 4;
        if (Temp.Dv < 0) {
          Temp.Disp = Temp.Disp + 4;
          Temp.Form = Ains;
        } else {
          Temp.Base = Gla;
          Temp.Disp = Temp.Dv;
          Temp.Form = Vins;
        }
        Sstack(Hold);
        Sstack(Temp);
        Assign(0);
      }
      Stp = Stp - 2;
      if (*Lhs->Type == 10) {
        if (Assop != 0) Abort(15);
        T = *Rhs->Type << 13 | (*Rhs->Length & 0x1FFF);
        Amap(*Rhs);
        Lrd(*Rhs, Any);
        Rx(St, *Rhs->Base, *Lhs->Base, *Lhs->Disp);
        Ri2(Lhi, *Rhs->Base, 0, T);
        Claim(*Lhs->Base);
        Rx(St, *Rhs->Base, *Lhs->Base, *Lhs->Disp + Reglen);
        Forget(*Rhs->Base);
        Drop(*Lhs);
        return;
      }
      if (Assop == 0) {
        if (*Rhs->Type == String && *Rhs->Form == Constant) Dumpstring(0);
        Amap(*Lhs);
        Amap(*Rhs);
      }
      if (*Lhs->Type == Record) {
        Amap(*Lhs);
        Load(*Lhs, R2);
        N = *Lhs->Length >> 1;
        if (*Rhs->Type == Record) {
          Amap(*Rhs);
          Load(*Rhs, R1);
          Release(R1);
          P = Rcopy;
        } else
          P = Rclear;
        Drop(*Rhs);
        Drop(*Lhs);
        Cstack(N);
        Stp = Stp - 1;
        Lrd(Stacked(Stp + 1).V, R0);
        Release(R2);
        Perm(P);
        return;
      }
      if (*Lhs->Type == 15) {
        if (Rhs == Activestring) {
          Hazard(R1);
          *Rhs->Base = 17;
          Remember(R1, *Rhs);
          Activestring = &Null;
          T = Newtag();
          Definereference(T, Rref);
          Rx(Bal, R1, Code, T);
          N = 0;
          for (;;) {
            Dump((Currentstring(N) << 8) + Currentstring(N + 1));
            N = N + 2;
            if (N > *Cslen) break;
          }
          *Cslen = 0;
          Definetag(T);
          *Rhs->Form = Vins;
          *Rhs->Base = R1;
          *Rhs->Disp = 0;
          Claim(R1);
        }
        Dumpstring(0);
        if (Wdisp == 0) Wdisp = 44;
        Lrd(*Rhs, R1);
        Drop(*Lhs);
        return;
      }
      if (*Lhs->Type == String) {
        Size = *Lhs->Length - 1;
        if (Size < 0 || Size == 255 || (Control & Assdiag) == 0) Size = 0;
        Dumpstring(-1);
        if (*Rhs->Form == Constant) {
          *Rhs->Type = Integer;
          *Lhs->Type = Byte;
        } else {
          if (*Rhs->Type == 0) Wdisp = Wdisp - 256;
          if (*Rhs->Lop != 0 && Size == 0) {
            W = Rhs->Link;
            *Rhs->Lop = 0;
            if (Same(*Lhs, *Rhs) && Different(*Lhs, *W)) {
              Release(*Lhs->Base);
              Load(*Lhs, R2);
              Release(R2);
              Drop(*Rhs);
              Join(*W);
              Drop(*Lhs);
              return;
            }
            if (Different(*Lhs, *W)) {
              Lrd(*Rhs, R1);
              Lrd(*Lhs, R2);
              Perm(Conc1);
              Join(*W);
              return;
            }
            *Rhs->Lop = Conc;
          }
          if (Wdisp == 0 && *Lhs->Base == Wsp) Wdisp = 44;
          Lrd(*Rhs, R1);
          Lrd(*Lhs, R2);
          if (Size != 0) {
            Cstack(Size);
            Stp = Stp - 1;
            Lrd(Stacked(Stp + 1).V, R0);
            Perm(Stringass);
          }
          Perm(Smove);
          return;
        }
      }
      Address(*Lhs);
      if ((*Lhs->Type == Integer && (Control & Unassdiag) == 0) ||
          *Lhs->Type == Short)
        if (*Rhs->Lop == Add) {
          T = Add;
          if (Same(*Lhs, *Rhs)) T = Sadd;
          *Rhs->Lop = 0;
          Optimise(*Rhs);
          *Rhs->Lop = T;
          if (Same(*Lhs, *Rhs)) {
            W = Rhs->Link;
            Load(*W, Any);
            Release(*Lhs->Base);
            Ccv = *Lhs;
            Ccreg = -2;
            if (*Lhs->Type == Short)
              P = Ahm;
            else
              P = Am;
            Rx(P, *W->Base, *Lhs->Base, *Lhs->Disp);
            if ((Control & Assdiag) != 0 && P == Ahm) Perm(Assth);
            Forgetdest(*Lhs);
            Release(*W->Base);
            Drop(*Rhs);
            Drop(*W);
            Drop(*Lhs);
            Ccca = Ca;
            return;
          }
        }
      if (*Lhs->Base == Param) {
        Newdisp = 0;
        P = *Lhs->Disp;
        if (*Rhs->Lop != 0) Load(*Rhs, P);
        Drop(*Lhs);
        Lhs = &Stacked(Stp).V;
        Rhs->Link = Lhs->Link;
        *Rhs->Lop = *Lhs->Lop;
        Lhs->Link = Rhs;
        *Lhs->Lop = P;
      } else {
        P = Any;
        Val = 0;
        if (*Lhs->Type == Integer)
          Op = St;
        else if (*Lhs->Type == Short) {
          Op = Sth;
          Val = 0xFFFF;
          T = Assth;
        } else if (*Lhs->Type == Byte) {
          Op = Stb;
          Val = 255;
          T = Asstb;
        } else {
          Op = Ste;
          P = Anyf;
        }
        if (Val != 0)
          if (*Rhs->Lop == 0)
            if ((Val == 0xFFFF && *Rhs->Type != Integer) || *Rhs->Type == Byte)
              Val = 0;
            else if (*Rhs->Lop == And)
              if (*Rhs->Link.Form == Constant && *Rhs->Link.Disp == Val) {
                Drop(*Rhs->Link);
                *Rhs->Lop = 0;
                Val = 0;
              }
        if ((Control & Assdiag) != 0 && *Rhs->Form == Constant) {
          if (Val == 255 && *Rhs->Disp >> 8 == 0) Val = 0;
          if (Val == 0xFFFF && 0xFFFF8000 <= *Rhs->Disp &&
              *Rhs->Disp <= 0x10000)
            Val = 0;
        }
        Load(*Rhs, P);
        Forgetdest(*Lhs);
        Rx(Op, *Rhs->Base, *Lhs->Base, *Lhs->Disp);
        Ccca = Ccca + 4;
        Remember(*Rhs->Base + Store, *Lhs);
        if (Val == 0 || (Control & Assdiag) == 0)
          Release(*Rhs->Base);
        else {
          if (T == Assth)
            Rr(Chvr, *Rhs->Base, *Rhs->Base);
          else {
            Hazard(R0);
            Rr(Lbr, R0, *Rhs->Base);
            Claim(*Rhs->Base);
            Rr(Cr, R0, *Rhs->Base);
          }
          Perm(T);
        }
        Drop(*Rhs);
        Drop(*Lhs);
      }
    }
    void Arrayref(void) {
      Stackfm *A;
      static Stackfm T = 0;
      int R;
      int D;
      Setboth();
      T.Base = Code;
      A = Lhs;
      if (*A->Form > Vins && *A->Form != Avins) Reduce(*A);
      D = 0;
      if (*Rhs->Lop == Add && Const(*Rhs->Link)) {
        D = *Rhs->Link.Disp * *A->Length;
        *Rhs->Lop = 0;
        Drop(*Rhs->Link);
      }
      if (*A->Form == Vins)
        if (*Rhs->Lop == 0 && *A->Length <= 256) {
          if (*Rhs->Form != Constant) Address(*Rhs);
          T.Base = *Rhs->Base + (*A->Base << 8);
          T.Disp = *Rhs->Disp;
          T.Type = *A->Length;
          T.Form = *Rhs->Form | 128;
          R = Finduse(T.Type, T.Form, T.Base, T.Disp);
          if (R != 0) {
            Stp = Stp - 1;
            *A->Base = R;
            *A->Disp = *A->Disp + D;
            *A->Form = Vins;
            Drop(*Rhs);
            return;
          }
        }
      Cstack(*A->Length);
      Operate(Mul);
      Lhs = &Stacked(Stp).V;
      Sset(*A->Base, *A->Disp, Vins, 0);
      if (*A->Form == Vins) {
        D = D + *Rhs->Disp;
        *Rhs->Disp = 0;
        *Rhs->Form = Vinr;
      }
      if (Const(*Lhs)) {
        if (*Rhs->Form == Vins) Load(*Rhs, Any0);
        D = D + *Lhs->Disp;
        *Lhs->Base = *Rhs->Base;
        Stp = Stp - 1;
      } else if (*Rhs->Base == 0 && *Rhs->Form == Vinr) {
        Load(*Lhs, Any0);
        Stp = Stp - 1;
      } else {
        Operate(Add);
        Lhs = &Stacked(Stp).V;
        Rhs = Lhs;
      }
      if (*Lhs->Lop != 0) Load(*Lhs, Any0);
      Stp = Stp - 1;
      if (*Lhs->Form == Vinr) Remember(*Lhs->Base, T);
      *A->Form = Vins;
      *A->Base = *Lhs->Base;
      *A->Disp = D;
      if (D < 0) {
        R = *A->Type;
        Amap(*A);
        Load(*A, Any0);
        *A->Type = R;
        *A->Form = Vins;
      }
      if (Rhs != Lhs) Drop(*Rhs);
      Drop(*Lhs);
    }
    void Checkedarrayref(void) {
      int D;
      int Flag;
      Setboth();
      Stp = Stp - 2;
      if (*Lhs->Form > Vins && *Lhs->Form != Avins) Reduce(*Lhs);
      Lrd(*Rhs, R1);
      Hazard(R2);
      Forget(R2);
      if (*Lhs->Dv < 0) {
        Flag = 0;
        D = 0;
        Rx(Lw, R2, *Lhs->Base, *Lhs->Disp + Reglen);
        Claim(*Lhs->Base);
      } else {
        Flag = 1;
        D = *Lhs->Disp;
        Ri2(Lhi, R2, Gla, *Lhs->Dv);
      }
      Perm(Aref);
      Forget(R1);
      if (Flag != 0)
        Rr(Ar, R1, *Lhs->Base);
      else
        Rx(Aw, R1, *Lhs->Base, *Lhs->Disp);
      *Lhs->Base = R1;
      *Lhs->Disp = D;
      *Lhs->Form = Vins;
      *Lhs->Dv = 0;
      Sstack(*Lhs);
      Drop(*Lhs);
    }
    void Know(int Reg, int Value, int Type) {
      Known.Base = Reg + Store;
      Known.Disp = Value;
      Known.Type = Type;
      if (Use(Known.Base).Ca < Limen ||
          Use(Known.Base).Ca == Use(Known.Base - Store).Ca)
        Known.Ca = 0;
    }
    void Testzero(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
      Stackfm *W;
      int Op;
      int Cop;
      int Cr;
      int Ct;
      int Not;
      Not = Nextsymbol() - '#';
      Op = V.Lop;
      Cop = Lr;
      Cr = Any;
      Ct = Integer;
      if (Floating(V)) {
        Cop = Ler;
        Cr = Anyf;
        Ct = Reals;
      } else if (Op != 0 && Sym == '?') {
        W = &V.Link;
        V.Lop = 0;
        if (Op == And && (*W->Form == Constant || *W->Form == Vinr)) {
          if (V.Form != Vinr && Vinr != *W->Form && V.Type == Integer)
            if ((*W->Disp & 0xFFFF) == 0 || *W->Disp >> 16 == 0) {
              Address(V);
              V.Type = Unsignedhalfword;
              *W->Type = Unsignedhalfword;
              if ((*W->Disp & 0xFFFF) == 0)
                *W->Disp = *W->Disp >> 16;
              else
                V.Disp = V.Disp + 2;
            }
          Load(V, Any);
          if (*W->Form == Vinr) {
            *W->Disp = 0;
            *W->Type = 0;
          }
          if (-0x8000 <= *W->Disp && *W->Disp <= 0x7FFF ||
              *W->Type == Unsignedhalfword)
            Ri2(Thi, V.Base, *W->Base, *W->Disp);
          else
            Ri3(Ti, V.Base, *W->Base, *W->Disp);
          Release(V.Base);
          Drop(*W);
          return;
        }
        if (*W->Form == Constant && Op == Add &&
            (*W->Disp < -15 || *W->Disp > 15)) {
          *W->Disp = -*W->Disp;
          Compare(V, *W);
          Drop(*W);
          return;
        }
        V.Lop = Op;
      }
      if (Op == 0 && Ccca == Ca && Limen != Ca) {
        if (Ccreg < 0 && Same(Ccv, V)) {
          Release(V.Base);
          return;
        }
        Optimise(V);
        if (V.Form == Vinr && V.Base == Ccreg) {
          Release(V.Base);
          if (Not == 0) Know(V.Base, 0, Ct);
          return;
        }
      }
      Load(V, Cr);
      if (Ccreg != V.Base || Ccca != Ca)
        Rr(Cop, V.Base, V.Base);
      else
        Release(V.Base);
      if (Not == 0) Know(V.Base, 0, Ct);
    }
    void Comparereals(/*C_TYPE_RECORD_FORMAT*/ Stackfm L,
                      /*C_TYPE_RECORD_FORMAT*/ Stackfm R) {
      Stackfm H;
      if (L.Type != Reals) Float(L, Anyf);
      if (R.Type != Reals) Float(R, Anyf);
      if (L.Lop != 0) Load(L, Anyf);
      if (R.Lop != 0) Load(R, Anyf);
      if (L.Form != Vinr && R.Form == Vinr) {
        H = L;
        L = R;
        R = H;
        Invert = Invert ^ 6;
        Swopped = Swopped ^ 1;
      }
      Load(L, Anyf);
      if ((Control & Unassdiag) != 0) Load(R, Anyf);
      Address(R);
      if (R.Form == Vinr)
        Rr(Cer, L.Base, R.Base);
      else
        Rx(Ce, L.Base, R.Base, R.Disp);
      Release(L.Base);
    }
    void Comparestrings(/*C_TYPE_RECORD_FORMAT*/ Stackfm L,
                        /*C_TYPE_RECORD_FORMAT*/ Stackfm R) {
      void Testnull(/*C_TYPE_RECORD_FORMAT*/ Stackfm R) {
        Activestring = &Null;
        if (R.Lop != 0) Load(R, Any);
        R.Type = Byte;
        Testzero(R);
      }
      if (L.Type == 0 || R.Type == 0 || L.Lop != 0 || R.Lop != 0) Sdisp = 256;
      if (*Cslen == 0) {
        if (R.Form == Constant) {
          Testnull(L);
          L.Type = String;
          L.Form = Vins;
          return;
        }
        if (L.Form == Constant) {
          Testnull(R);
          Invert = Invert ^ 6;
          return;
        }
      }
      Dumpstring(0);
      Load(R, R1);
      Load(L, R2);
      Load(R, R1);
      Release(R1);
      Release(R2);
      Perm(Scomp);
      L.Type = String;
      L.Form = Vins;
      Wdisp = 0;
    }
    void Compare(/*C_TYPE_RECORD_FORMAT*/ Stackfm L,
                 /*C_TYPE_RECORD_FORMAT*/ Stackfm R) {
      Stackfm T;
      int Op;
      int Arith;
      int /* boolean */ Chanced(void) {
        if (L.Lop != Add || Sym == 126) return (0);
        if (L.Link.Form != Constant || L.Base == 0) return (0);
        if (-0x8000 > L.Link.Disp || L.Link.Disp > 0x7FFF) return (0);
        if (L.Type == Reals) return (0);
        Invert = Invert ^ 6;
        Swopped = Swopped ^ 1;
        T = L;
        L = R;
        R = T;
        R.Lop = 0;
        Load(L, Any);
        Load(R, Any0);
        if (-0x8000 <= R.Link.Disp && R.Link.Disp <= 0x7FFF) {
          if (Arith != 0)
            Op = Clhi;
          else
            Op = Chi;
          Ri2(Op, L.Base, R.Base, R.Link.Disp);
        } else {
          if (Arith != 0)
            Op = Cli;
          else
            Op = Ci;
          Ri3(Op, L.Base, R.Base, R.Link.Disp);
        }
        Release(L.Base);
        Drop(R.Link);
        return (1);
      }
      Swopped = 0;
      Sdisp = 0;
      if (*Lhs->Type == 0 || *Lhs->Type == String) {
        Comparestrings(L, R);
        return;
      }
      if (Zero(R)) {
        Testzero(L);
        return;
      }
      if (Zero(L)) {
        Testzero(R);
        Invert = Invert ^ 6;
        return;
      }
      Arith = Nextsymbol();
      if (Arith != '#' && Arith != '=' && Sym != 'F' + 32) Arith = 0;
      if (Chanced()) return;
      Optimise(R);
      Optimise(L);
      if (Floating(L) || Floating(R)) {
        Comparereals(L, R);
        return;
      }
      if (Const(L) || R.Form == Vinr || L.Type == Byte || R.Lop != 0) {
        T = L;
        L = R;
        R = T;
        Invert = Invert ^ 6;
        Swopped = Swopped ^ 1;
        if (Chanced()) return;
      }
      Load(L, Any);
      if (R.Lop != 0 || R.Type == Byte || R.Type == Unsignedhalfword ||
          ((Control & Unassdiag) != 0 && (R.Form == Vins || R.Form == Avins)))
        Load(R, Any);
      if (R.Form == Avinrec) Reduce(R);
      if (R.Form == Constant || R.Form == Avins) {
        if (-0x8000 <= R.Disp && R.Disp <= 0x7FFF) {
          if (Arith != 0)
            Op = Clhi;
          else
            Op = Chi;
          Ri2(Op, L.Base, R.Base, R.Disp);
        } else {
          if (Arith != 0)
            Op = Cli;
          else
            Op = Ci;
          Ri3(Op, L.Base, R.Base, R.Disp);
        }
        if (R.Form == Constant && Arith == '#') Know(L.Base, R.Disp, Integer);
      } else {
        Address(R);
        if (R.Form == Vinr) {
          if (Arith != 0)
            Op = Clr;
          else
            Op = Cr;
          Rr(Op, L.Base, R.Base);
        } else {
          if (R.Type == Byte)
            Op = Clb;
          else if (Arith != 0)
            if (R.Type == Short)
              Op = Clh;
            else
              Op = Cl;
          else if (R.Type == Short)
            Op = Ch;
          else
            Op = C;
          Rx(Op, L.Base, R.Base, R.Disp);
        }
      }
      Release(L.Base);
    }
    void Claimwsp(int *Size) {
      Size = (Wdisp + (Reglen - 1)) & (~(Reglen - 1));
      if (Size == 0) return;
      Wdisp = 0;
      if (Size > 15) Ri2(Ahi, Wsp, 0, Size);
    }
    void Releasewsp(int Size) {
      Wdisp = Size;
      if (Wdisp > 15) Ri2(Shi, Wsp, 0, Wdisp);
    }
    void Header(/*C_TYPE_RECORD_FORMAT*/ Varfm V) {
      Limen = Ca - 2;
      if (Frame < 11 * Reglen) Frame = 11 * Reglen;
      if (&V != &Begin) Definetag(V.Disp & 0xFFF);
      Rx(Stm, P2, Wsp, 0);
      Rr(Lr, Local, Wsp);
      if ((Control & (Unassdiag | Stkdiag)) != 0)
        if ((Control & Unassdiag) != 0) {
          Perm(Exbunass);
          Dump(Frame);
        } else
          Perm(Exb);
      else
        Dump(Ahi + (Actual(Wsp) << 4));
      Sizepatch = Ca;
      Dump(0);
    }
    void Return(void) {
      if (Uncondjump == Ca) return;
      Rx(Lm, Wsp, Local, 2 * Reglen);
      Claim(Link);
      Rr(Bfcr, 0, Link);
      Uncondjump = Ca;
    }
    void Call(/*C_TYPE_RECORD_FORMAT*/ Stackfm V) {
      static int B_sw;
      static void *B[16 /*0:15*/] = {
          &&B_0, &&B_1, &&B_2,  &&B_3,  &&B_4,  &&B_5,  &&B_6,  &&B_7,
          &&B_8, &&B_9, &&B_10, &&B_11, &&B_12, &&B_13, &&B_14, &&B_15,
      };
      static int Intg = 0;
      static int Fracptg = 0;
      int Work;
      int Awork;
      int Reg;
      int Areg;
      int Addr;
      int T;
      int L;
      int Set(int H, int L) {
        Gfix(4);
        Ghalf(H);
        Ghalf(L);
        return (Ga - 4);
      }
      Addr = V.Disp;
      if (Addr < 0)
        Perm(0x1EF00 - Addr);
      else {
        if (V.Base == Link) {
          V.Dv = 0;
          Drop(V);
          Setlhs();
          L = 0;
          T = V.Disp;
          Sym = 0;
          goto *B[B_sw = T];
        B_12:;
          Load(*Lhs, Anyf);
          Reg = *Lhs->Base;
          Areg = Actual(Reg);
          Work = Fpr();
          Awork = Actual(Work);
          Dump(Ler + (Awork << 4) + Areg);
          if (Fracptg == 0) {
            Fracptg = Set(0x4600, 0);
            Addr = Set(0x4110, 0);
          }
          Dump(Ae + (Awork << 4) + Actual(Gla));
          Dump(Fracptg);
          Dump(Ler + (Awork << 4) + Awork);
          Dump(Ser + (Areg << 4) + Awork);
          Dump(0x2313);
          Dump(Ae + (Areg << 4) + Actual(Gla));
          Dump(Fracptg + 4);
          Forget(Reg);
          Forget(Work);
          return;
        B_11:;
          if (Intg == 0) Intg = Set(0x4080, 0);
          Stack(Intg, Gla, Reals, 1, 0, 0, 0);
          Operate(Add);
          Setlhs();
        B_10:;
          Load(*Lhs, Anyf);
          L = Gpr(0);
          Rr(Fxr, L, *Lhs->Base);
          Claim(L);
          *Lhs->Base = L;
          *Lhs->Type = Integer;
          return;
        B_0:;
          Amap(*Lhs);
          return;
        B_7:;
          Cstack(0);
        B_8:;
          Setboth();
          *Lhs->Type = Byte;
          *Lhs->Length = 1;
          Arrayref();
          return;
        B_4:;
          L = 255;
        B_1:;
        B_2:;
        B_3:;
        B_5:;
        B_6:;
          Vmap(*Lhs);
          *Lhs->Type = T;
          *Lhs->Length = L;
          return;
        B_9:;
          Setboth();
          Operate(Rem);
          return;
        B_13:;
          Limen = Ca;
          Perm(Rsym);
          Claim(R1);
          Sset(R1, 0, Vinr, 0);
          Assign(1);
          return;
        B_14:;
          Cstack(255);
          Operate(And);
          Cstack(256);
          Operate(Add);
          Setlhs();
          if (Const(*Lhs)) {
            Gfix(2);
            Addr = Ga;
            Ghalf(*Lhs->Disp);
            *Lhs->Type = String;
            *Lhs->Form = Vins;
            *Lhs->Base = Gla;
            *Lhs->Disp = Addr;
          } else {
            Sstack(*Lhs);
            Setboth();
            *Lhs->Lop = 0;
            Release(*Lhs->Base);
            Frame = (Frame + 1) & (~1);
            *Lhs->Type = Short;
            *Lhs->Form = Vins;
            *Lhs->Base = Local;
            *Lhs->Disp = Frame;
            Assign(1);
            Sset(Local, Frame, Vins, 0);
            *Rhs->Type = String;
            Frame = Frame + 2;
          }
          return;
        B_15:;
          Setboth();
          Stp = Stp - 2;
          Reg = 0;
          Work = *Lhs->Disp;
          if (!Const(*Lhs)) {
            Load(*Lhs, Any0);
            Work = 0;
            Reg = *Lhs->Base;
          }
          Address(*Rhs);
          Rx(Lme, Fpr0, *Rhs->Base, *Rhs->Disp);
          Rx(Svc, 0, Reg, Work);
          Claim(*Rhs->Base);
          Rx(Stme, Fpr0, *Rhs->Base, *Rhs->Disp);
          Drop(*Rhs);
          Drop(*Lhs);
          Limen = Ca;
          return;
        }
        Hazardall();
        if ((Addr & 0x4000) == 0) {
          Addr = Newtag();
          Definereference(Addr, Rref);
          Rx(La, Link, Code, 0);
          Rx(Stm, P2, Wsp, 0);
          Rx(Lw, R2, V.Base, V.Disp);
          Rx(Lw, R3, V.Base, V.Disp + Reglen);
          Claim(R2);
          Rx(Lm, R9, R2, 4 * Reglen);
          Claim(R3);
          Rx(Bal, Link, R3, 4);
          Definetag(Addr);
        } else {
          Definereference(Addr & 0xFFF, Rref);
          Rx(Bal, Link, Code, Addr & 0xFFF);
        }
        Limen = Ca - 1;
      }
      if (V.Type == 0) Drop(V);
    }
    void For(void) {
      Stackfm *Cv;
      Stackfm *Iv;
      Stackfm *Inc;
      Stackfm *Fv;
      int Lab;
      int Reg;
      int Special;
      void Stab(/*C_TYPE_RECORD_FORMAT*/ Stackfm V, int Type) {
        int T;
        int R;
        if (Const(V)) return;
        Load(V, Any);
        R = V.Base;
        T = Temp();
        Rx(St, R, Local, T);
        Release(R);
        V.Base = Local;
        V.Disp = T;
        V.Type = Type;
        V.Form = Vins;
        Remember(R, V);
      }
      int /* boolean */ Checkreqd(void) {
        int I;
        if (!(Const(*Fv) && Const(*Iv) && Const(*Inc))) return (1);
        if (*Inc->Disp != 0) {
          I = (*Fv->Disp - *Iv->Disp) / *Inc->Disp + 1;
          if (I >= 0 && *Iv->Disp + (I - 1) * *Inc->Disp == *Fv->Disp)
            return (0);
        }
        Abort(-12);
        return (1);
      }
      void Set(/*C_TYPE_RECORD_FORMAT*/ Stackfm V, int Reg) {
        Stackfm *R;
        Sstack(V);
        R = &Stacked(Stp).V;
        Lrd(*R, Reg);
        Stp = Stp - 1;
      }
      Special = 0;
      Cv = &Stacked(Stp - 3).V;
      Iv = &Stacked(Stp - 2).V;
      Inc = &Stacked(Stp - 1).V;
      Fv = &Stacked(Stp).V;
      Skipsymbol();
      Lab = Tag();
      Stab(*Inc, Integer);
      Stab(*Fv, Integer);
      if ((Control & Fordiag) != 0 && Checkreqd()) {
        Stab(*Iv, Integer);
        Set(*Iv, R0);
        Set(*Fv, R1);
        Set(*Inc, R2);
        Perm(Fortest);
      }
      if (*Cv->Form != Vins || Activity(*Cv->Base) >= 0) {
        Amap(*Cv);
        Stab(*Cv, *Cv->Type);
        *Cv->Form = Ains;
      }
      if (Const(*Fv) && Const(*Inc) && Const(*Iv) &&
          *Fv->Disp + *Inc->Disp != *Iv->Disp)
        Special = Control & 512;
      Stp = Stp - 4;
      Sstack(*Cv);
      Sstack(*Iv);
      Release(*Iv->Base);
      Sstack(*Inc);
      Drop(*Iv);
      Operate(Sub);
      if (Special != 0) {
        Reg = Gpr(0);
        Setlhs();
        Load(*Lhs, Reg);
      } else {
        Assign(1);
      }
      Definelabel(Lab);
      if (Special != 0) {
        *Flab->Base = *Cv->Base;
        *Flab->Disp = *Cv->Disp;
        *Flab->Reg = Reg;
        *Flab->Limit = *Fv->Disp;
        Sstack(*Inc);
        Operate(Add);
        Assign(1);
        Use(Reg) = Use(Reg + Store);
      } else {
        Sstack(*Cv);
        Sstack(*Cv);
        Compare(*Cv, *Fv);
        Jumpto(Lab - 2, 0, Redefine);
        Sstack(*Inc);
        Operate(Add);
        Assign(1);
      }
      Drop(*Cv);
      Drop(*Fv);
      Drop(*Inc);
    }
    void Adump(void) {
      if (Owntype == Integer)
        Gword(Ownval);
      else if (Owntype == Short)
        Ghalf(Ownval);
      else if (Owntype == Byte)
        Gbyte(Ownval);
      else if (Owntype == String)
        Dumpstring(Datasize);
      else if (Owntype == Reals) {
        if (Realga == Ga) Gword(Ownval);
        Realga = Ga;
      } else
        for (Val = 1; Val <= Datasize >> 1; Val++) Ghalf(0);
    }
  Next:
    Readsymbol(Sym);
    goto *Z[Z_sw = (Sym)-33];
  Z_79:
    if (Stp != 0) Abort(14);
    if (&Using.Link != &Null) Abort(19);
    Checkreleased();
    Setline();
    Mintemp = Frame;
    Diaggla = 0;
    Wdisp = 0;
    if (Frame >= 0x4000 && Warning == 0) {
    Warn:
      Warning = -15;
      Abort(-15);
    }
    goto Next;
  Z_36:
    Definevar();
    goto Next;
  Z_98:
    Aparm = Tag();
  Z_119:
    Stp = Stp - 2;
    Vlb = Stacked(Stp + 1).V->Disp;
    Vub = Stacked(Stp + 2).V->Disp;
    Drop(Stacked(Stp + 1).V);
    Drop(Stacked(Stp + 2).V);
    if (Vlb < -32768 || Vub > 32767) {
      Abort(-10);
      Vub = 0;
      Vlb = 0;
    }
    goto Next;
  Z_73:
    Val = (Vub - Vlb + 1) * Datasize;
    if (Val <= 0) {
      Val = Datasize;
      Abort(-8);
    }
    for (J = 1; J <= Val; J++) Gbyte(0);
    goto Next;
  Z_65:
    Aparm = 1;
    if (Nextsymbol() == Comma) {
      Skipsymbol();
      Aparm = Tag();
    }
    if (Ownform == Array) {
      Ownval = 0;
      if (Stp != 0) {
        Poplhs();
        Ownval = *Lhs->Disp;
        Drop(*Lhs);
      }
      if (Stp != 0) {
        Aparm = Ownval;
        Poplhs();
        Ownval = *Lhs->Disp;
        Drop(*Lhs);
      }
      if (Owntype == Reals)
        if (*Lhs->Type == Integer)
          *Real(Addr(Ownval)) = Ownval;
        else
          *Decvar->Disp = *Decvar->Disp - 4;
      if (Aparm == 0) Aparm = Vub - Vlb + 1;
      if (Aparm <= 0) {
        Vub = Vlb;
        Aparm = 1;
        Abort(-8);
      }
      for (J = 1; J <= Aparm; J++) {
        Vlb = Vlb + 1;
        Adump();
      }
    } else {
      Ownval = 0;
      if (Stp != 0) {
        Poplhs();
        Ownval = *Lhs->Disp;
        Drop(*Lhs);
      }
      Names = Names - Aparm;
      if (Ownform == 5) goto Next;
      for (J = 1; J <= Aparm; J++) {
        Names = Names + 1;
        Decvar = &Var(Names);
        if (Otype == 0) {
          *Decvar->Disp = Ownval;
          *Decvar->Base = 0;
          *Decvar->Form = *Decvar->Form - 1;
        } else {
          *Decvar->Disp = Ga;
          *Decvar->Base = Gla;
          if (Owntype == Reals && *Lhs->Type == Reals)
            *Decvar->Disp = *Decvar->Disp - 4;
          Adump();
        }
      }
    }
    if (Ga > 0x4000 && Warning == 0) goto Warn;
    goto Next;
  Z_39:
    Getstring();
    goto Next;
  Z_78:
    Len = Tag();
    Skipsymbol();
    Cstack(Eval(Len));
    goto Next;
  Z_68:
    Rhs = Descriptor;
    Fpcstack(Realconstant(), *Rhs);
    goto Next;
  Z_64:
    if (Nextsymbol() == Minus) {
      Skipsymbol();
      Len = Tag();
      Setlhs();
      V = &Var(Var(*Lhs->Format).Extra + Len - 1);
      if (Control < 0) Displayvar(*V);
      Vstack(*V);
      Setboth();
      Stp = Stp - 1;
      if (*Lhs->Form == Vins || *Lhs->Form == Vinrec) {
        *Rhs->Disp = *Lhs->Disp + *Rhs->Disp;
        *Lhs->Form = *Lhs->Form - Vins + *Rhs->Form;
      } else if (*Lhs->Form == Ainrec) {
        *Lhs->Form = Vinrec;
        *Lhs->Type = Integer;
        Load(*Lhs, Any0);
        *Lhs->Form = *Rhs->Form;
      } else if (*Lhs->Form <= Vinr)
        *Lhs->Form = *Rhs->Form;
      else {
        *Lhs->Extra = *Lhs->Disp;
        *Lhs->Form = *Rhs->Form + 2;
      }
      *Lhs->Disp = *Rhs->Disp;
      *Lhs->Type = *Rhs->Type;
      *Lhs->Length = *Rhs->Length;
      *Lhs->Format = *Rhs->Format;
      *Lhs->Dv = *Rhs->Dv;
      Drop(*Rhs);
    } else {
      V = &Var(Lookup(Tag()));
      Vstack(*V);
      if ((*Lhs->Form & 16) != 0 && *Lhs->Base != Link &&
          Nextsymbol() != 'P' + 32)
        Claimwsp(*Lhs->Dv);
    }
    goto Next;
  Z_69:
    Poplhs();
    Opr = *Lhs->Lop;
    *Lhs->Lop = 0;
    J = 0;
    while (Opr != 0) {
      X = Lhs->Link;
      Lhs->Link = X->Link;
      N = *X->Lop;
      *X->Lop = 0;
      Load(*X, Opr);
      Drop(*X);
      J = J << 8 | Opr;
      Opr = N;
    }
    Release(J & 255);
    Release(J >> 8);
    X = Lhs;
    Call(*X);
    Dope = *X->Dv;
    if (*X->Type != 0 && Sym != 0) {
      Sstack(*X);
      Drop(*X);
      Setlhs();
      Release(*Lhs->Base);
      if (*Lhs->Type == Reals)
        Opr = Fpr0;
      else
        Opr = R1;
      *Lhs->Base = Opr;
      *Lhs->Disp = 0;
      *Lhs->Form = *Lhs->Form & 15;
      Claim(Opr);
      if (*Lhs->Type == String && *Lhs->Form == Vinr) {
        *Lhs->Form = Vins;
        Sym = Nextsymbol();
        if (Sym != 'S' && Sym != 'P' + 32 && Sym != '?') {
          N = *X->Length;
          if (N == 0) N = 256;
          Frame = (Frame + 1) & (~1);
          *Lhs->Form = Vins;
          *Lhs->Base = Local;
          *Lhs->Disp = Frame;
          Frame = Frame + N;
          Sset(Local, *Lhs->Disp, Vins, 0);
          *Rhs->Type = String;
          *Rhs->Length = N;
          Sset(R1, 0, Vins, 0);
          *Rhs->Type = String;
          Assign(1);
        }
      }
    }
    if (Sym != 0) Releasewsp(Dope);
    goto Next;
  Z_82:
    Return();
    goto Next;
  Z_86:
    Poplhs();
    Dumpstring(0);
    if (*Gvar->Type == Reals)
      Opr = Fpr0;
    else
      Opr = R1;
    Lrd(*Lhs, Opr);
    Return();
    goto Next;
  Z_77:
    Poplhs();
    Amap(*Lhs);
    Lrd(*Lhs, R1);
    Return();
    goto Next;
  Z_84:
    Dump(0x2411);
    Return();
    goto Next;
  Z_75:
    Dump(0x2410);
    Return();
    goto Next;
  Z_97:
    if ((Control & Arraydiag) != 0)
      Checkedarrayref();
    else
      Arrayref();
    goto Next;
  Z_46:
    Opr = Conc;
    goto Arith;
  Z_43:
    Opr = Add;
    goto Arith;
  Z_45:
    Opr = Sub;
    goto Arith;
  Z_33:
    Opr = Ior;
    goto Arith;
  Z_37:
    Opr = Xor;
    goto Arith;
  Z_38:
    Opr = And;
    goto Arith;
  Z_91:
    Opr = Lsh;
    goto Arith;
  Z_93:
    Opr = Rsh;
    goto Arith;
  Z_42:
    Opr = Mul;
    goto Arith;
  Z_47:
    Opr = Div;
    goto Arith;
  Z_81:
    Opr = Rdiv;
    goto Arith;
  Z_85:
    Opr = Neg;
    goto Arith;
  Z_92:
    Opr = Not;
    goto Arith;
  Z_88:;
  Z_120:
    Opr = Exp;
  Arith:
    Operate(Opr);
    goto Next;
  Z_118:
    Setlhs();
    if (Ccreg < 0) Ccreg = 0;
    if (Floating(*Lhs))
      K = Anyf;
    else
      K = Any;
    Load(*Lhs, K);
    Testzero(*Lhs);
    K = *Lhs->Base;
    Jumpto(3, 5, Redefine);
    Claim(*Lhs->Base);
    Operate(Neg);
    Setlhs();
    Load(*Lhs, K);
    Definelabel(3);
    Forget(*Lhs->Base);
    goto Next;
  Z_83:
    Assign(1);
    goto Next;
  Z_90:
    Assign(0);
    goto Next;
  Z_112:
    Assign(-1);
    Wdisp = Newdisp;
    goto Next;
  Z_107:
    Know(R1, 1, Integer);
  Z_61:
    Opr = 0;
    goto Cond;
  Z_116:
    Know(R1, 0, Integer);
  Z_35:
    Opr = 1;
    goto Cond;
  Z_60:
    Opr = 2;
    goto Cond;
  Z_62:
    Opr = 3;
    goto Cond;
  Z_40:
    Opr = 4;
    goto Cond;
  Z_41:
    Opr = 5;
  Cond:
    Val = Tag();
    Jumpto(Val, Opr + Invert, Redefine);
    goto Next;
  Z_67:
    Setboth();
    Amap(*Lhs);
    Amap(*Rhs);
  Z_126:;
  Z_63:
    Setboth();
    Compare(*Lhs, *Rhs);
    Stp = Stp - 2;
    Drop(*Rhs);
    Drop(*Lhs);
    goto Next;
  Z_34:
    Stwork = Stacked(Stp + Swopped + 1).V;
    Sstack(Stwork);
    Wdisp = Sdisp;
    goto Next;
  Z_95:
    Limen = Ca;
    Uncondjump = 0;
    V = &Var(Lookup(Tag()));
    Poplhs();
    Drop(*Lhs);
    Gpatch(Ca, *V->Extra + *Lhs->Disp * 2);
    goto Next;
  Z_87:
    V = &Var(Lookup(Tag()));
    if ((Control & Testswitch) != 0) {
      Half = Gla;
      K = *V->Disp;
      Range(Half, K);
      Poplhs();
      Lrd(*Lhs, R1);
      Ri2(Lhi, R2, Half, K);
      Perm(Swjump);
    } else {
      Cstack(1);
      Operate(Lsh);
      Poplhs();
      Lrd(*Lhs, Any0);
      J = Actual(*Lhs->Base);
      Dump(Lhl + (J << 4) + Actual(Gla));
      K = *V->Extra;
      Dump(0x4000 + (J << 8) + (K >> 16 & 255));
      Dump(K & 0xFFFF);
      Dump(Ar + (J << 4) + Actual(Code));
      Dump(Bfcr + J);
      Limen = Ca;
      Uncondjump = Ca;
    }
    goto Next;
  Z_66:;
  Z_113:;
    Jumpto(Tag(), Jump, Define);
    goto Next;
  Z_70:;
  Z_117:;
    Jumpto(Tag(), Jump, Redefine);
    goto Next;
  Z_74:
    Jumpto(-Tag(), Jump, Define);
    goto Next;
  Z_76:
    Definelabel(-Tag());
    goto Next;
  Z_58:
    Definelabel(Tag());
    goto Next;
  Z_102:
    For();
    goto Next;
  Z_80:
    Poplhs();
    Drop(*Lhs);
    Dump(*Lhs->Disp);
    Limen = Ca;
    goto Next;
  Z_122:
    Poplhs();
    Drop(*Lhs);
    Control = *Lhs->Disp;
    if ((Control & Unassdiag) != 0) {
      Activity(R4) = -1;
      if (Enterunass == 0) Abort(-14);
    } else
      Activity(R4) = 0;
    goto Next;
  Z_100:
    if (Tag() != 1) Abort(-9);
    Setboth();
    Dope = 0;
    if (!(Const(*Lhs) && Const(*Rhs))) {
      Load(*Lhs, P2);
      Load(*Rhs, R3);
      Dope = -Frame;
      Frame = Frame + 12;
      Dynamic = -1;
    } else {
      Dynamic = 0;
      Vlb = *Lhs->Disp;
      Vub = *Rhs->Disp;
      if (Vlb > Vub) {
        Abort(-7);
        Vub = Vlb;
      }
    }
    Stp = Stp - 2;
    Drop(*Rhs);
    Drop(*Lhs);
    goto Next;
  Z_104:
    if (Dynamic != 0) {
      if (Dynamic < 0) {
        Ri2(Lhi, P1, Local, -Dope);
      Bigstatic:
        Cstack(Datasize);
        Poplhs();
        Lrd(*Lhs, R1);
        Release(P2);
        Release(R3);
        Perm(Aset);
        Dynamic = 1;
      }
      *Decvar->Form = Arrayname;
      *Decvar->Disp = Frame;
      Frame = Frame + 8;
      Ri2(Lhi, R3, Local, *Decvar->Disp);
      Perm(Alloc);
    } else {
      if (Dope == 0) {
        Gfix(4);
        Dope = Ga;
        Gword(Vlb);
        Gword(Vub);
        Gword(Datasize);
      }
      K = (Vub - Vlb + 1) * Datasize + Frame;
      if (K > Maxstatic && Gmode == 0) {
        Cstack(Vlb);
        Cstack(Vub);
        Setboth();
        Load(*Lhs, P2);
        Load(*Rhs, R3);
        Drop(*Rhs);
        Drop(*Lhs);
        Stp = Stp - 2;
        Ri2(Lhi, P1, Gla, Dope);
        Forget(P1);
        Dope = -Dope;
        goto Bigstatic;
      }
      *Decvar->Disp = Frame - Vlb * Datasize;
      Frame = K;
    }
    *Decvar->Extra = Dope;
  Z_99:
    goto Next;
  Z_71:
    Readsymbol(Gg);
    Gmode = ~Gmode;
    if (Gmode != 0)
      Assemble(Gtype, Labs, Names);
    else {
      Sps = 0;
      N = P1;
      if (Gg == Formats)
        *Gvar->Length = (Frame + (Reglen - 1)) & (~(Reglen - 1));
      Len = Names - Gstart;
      J = 0;
      if (Gg == Formats) J = Len;
      if (Len > 0) {
        Len = 0;
        *Gvar->Extra = Parms - J;
        for (J = Gstart + 1; J <= Names; J++) {
          Parms = Parms - 1;
          Fp = &Var(Parms);
          Ap = &Var(J);
          *Fp = *Ap;
          if (Gg != Formats)
            if (*Fp->Base == Param) {
              *Ap->Base = Local;
              *Fp->Disp = N;
              if (Gg == Procedure) {
                Vstack(*Ap);
                Poplhs();
                Drop(*Lhs);
                if (*Lhs->Form != Vins) {
                  *Lhs->Type = Integer;
                  *Lhs->Form = Vins;
                }
                Remember(N, *Lhs);
              }
            } else {
              *Fp->Base = Wsp;
              N = P2;
            }
          if (Control < 0) {
            Displayvar(*Fp);
            Displayvar(*Ap);
          }
          N = N - 1;
        }
        if (Parms <= Names) Abort(-4);
        if (Gg != Formats)
          if (*Fp->Type == String && *Fp->Form == 1) {
            *Fp->Type = 15;
            N = 0;
          }
      }
      if (Gg != Procedure) goto Out;
      Header(*Gvar);
      if (N == 0) {
        Rx(Lhi, R2, Local, *Ap->Disp);
        if ((Control & Assdiag) != 0 && *Ap->Size != 255) {
          Cstack(*Ap->Size);
          Poplhs();
          Lrd(*Lhs, R0);
          Perm(Stringass);
        }
        Perm(Smove);
      }
    }
    goto Next;
  Z_72:;
    if (Ca == 0) {
      Enterunass = 0;
      if ((Control & Unassdiag) != 0) {
        Enterunass = 0x0140 + Actual(Code);
        Dump(0x0234);
        Dump(0x0884);
        Dump(0x2401);
        Dump(0x2410);
        Dump(0x2440);
        Dump(0x583D);
        Dump(Signalep);
        Dump(0x0303);
        Dump(0x8080);
        Dump(0x8080);
        Dump(0x8080);
        Dump(0x8080);
      }
      Header(Begin);
    }
    N = Temp();
    Half = Local;
    K = N;
    Range(Half, K);
    Rx(St, Wsp, Half, K);
    Decvar = &Begin;
    Assemble(0, Labs, Names);
    Half = Local;
    K = N;
    Range(Half, K);
    Rx(Lw, Wsp, Half, K);
    goto Next;
  Z_115:;
    Cstack(0);
    Cstack(0);
  Z_101:;
    N = Stp + R0 - 1;
    while (Stp != 0) {
      Poplhs();
      Lrd(*Lhs, N - Stp);
    }
    Perm(Monitor);
    Uncondjump = Ca;
    Stp = 0;
    goto Next;
  Z_59:
    if (Amode == 0)
      Oldframe = Frame;
    else {
      Patch((Frame + (Reglen - 1)) & (~(Reglen - 1)), Sizepatch);
      if (Uncondjump != Ca)
        if (*Gvar->Type != 0) {
          Abort(-11);
        } else
          Return();
    }
    Setdiag(0, 0, 0, -1);
  Out:
    Frame = Oldframe;
    if (Amode > 0) {
      Activity(Local) = 0;
      Asslevel = Asslevel - 1;
      Local = Basereg(Asslevel);
    }
    Xlevel = Xlevel - 1;
    goto Z_skip;
  Z_default:
    fprintf(stderr, "Switch label 'Z(%d):' not set in %s", Z_sw + 33,
            __PRETTY_FUNCTION__);
    exit(1) /* or %signal ... */;
  Z_skip:;
  }
  Faulty = 0;
  if (Maxvars == 1) Abort(0);
  Selectinput(Instream);
  Selectoutput(Direct);
  Printsymbol(Initgla);
  Selectoutput(Object);
  Printsymbol(Start);
  Blockword = 'B' - 32 + (('L' - 32) << 6) + (('O' - 32) << 12) +
              (('C' - 32) << 18) + (('K' - 32) << 24);
  Ca = 0;
  Limen = 0;
  Ga = Initgla;
  Da = 0;
  Linesize = 0;
  Stp = 0;
  Stackasl = 0;
  Envp = 0;
  Gmode = 0;
  Uncondjump = 0;
  Currentline = 0;
  Invert = 0;
  Swopped = 0;
  Parms = Maxvars;
  Cslen = &Currentstring(0);
  *Cslen = 0;
  Activestring = &Null;
  for (J = 0; J <= 44; J++) Activity(J) = 0;
  for (J = 0; J <= 20; J++) Used(J) = 0;
  Activity(Wsp) = -1;
  Activity(Gla) = -1;
  Activity(Code) = -1;
  Activity(0) = -1;
  Known.Ca = -1;
  if ((Control & Unassdiag) != 0) Activity(R4) = -1;
  Enterunass = -1;
  for (J = 0; J <= Maxenvirs; J++) Envir(J) = 0;
  for (J = 1; J <= 44; J++) {
    Use(J) = 0;
    Use(J).Ca = -8;
  }
  for (J = 0; J <= Maxstack - 1; J++) {
    Stak(J).Link = &Stak(J + 1);
    Dlist(J).Link = &Dlist(J + 1);
  }
  Stak(Maxstack).Link = &Null;
  Dlist(Maxstack).Link = &Null;
  Descasl = &Stak(0);
  Dasl = &Dlist(0);
  Using.Link = &Null;
  Decvar = &Begin;
  Assemble(2, 0, 0);
  Gfix(4);
  Printsymbol(Cend);
  Selectoutput(Direct);
  Printsymbol(Dend);
  Put(Ca);
  Put((Ga + 1) & (~1));
  Put(Linesize);
  Put(Da);
  if (Faulty != 0) _imp_signal(15, 3, 0, _imp_str_literal(""));
  exit(0);
  return (1);
}