#include <perms.h>
const int Yes = 1;
const int No = 0;
const int Pentium = 4;
const int Mips = 05;
const int Rs6 = 06;
const int M88k = 07;
const int Vax = 08;
const int Unisys = 09;
const int Emas = 10;
const int Ibm = 11;
const int Ibmxa = 12;
const int Wwc = 13;
const int Amdahl = 14;
const int Perq3 = 15;
const int Gould = 16;
const int Vns = 17;
const int Eamd = 18;
const int Drs = 19;
const int Perq = 20;
const int Pnx = 21;
const int Accent = 22;
const int Orn = 23;
const int Unsignedshorts = 1 << Emas | 1 << Pnx | 1 << Vns;
const int Lintavail =
    1 << Ibm | 1 << Ibmxa | 1 << Amdahl | 1 << Emas | 1 << Gould | 1 << Mips;
const int Llrealavail =
    1 << Ibm | 1 << Ibmxa | 1 << Amdahl | 1 << Emas | 1 << Mips;
const int Emachine = 1 << Drs | 1 << Pentium | 1 << Wwc | 1 << Vax |
                     1 << Gould | 1 << Perq3 | 1 << Vns | 1 << Eamd | 1 << Orn |
                     1 << Unisys | 1 << M88k | 1 << Rs6 | 1 << Mips;
const int Ibmfpformat = 1 << Ibm | 1 << Ibmxa | 1 << Amdahl | 1 << Emas |
                        1 << Gould | 1 << Vns | 1 << Eamd;
const int Vaxfpformat = 1 << Vax | 1 << Unisys;
const int Ieeefpformat = 1 << Wwc | 1 << Perq3 | 1 << Drs | 1 << Pentium |
                         1 << Perq | 1 << Accent | 1 << M88k | 1 << Rs6 |
                         1 << Mips;
const int Byteswopped =
    1 << Perq | 1 << Accent | 1 << Wwc | 1 << Vax | 1 << Pnx | 1 << Orn;
const int Halfswopped = 1 << Perq | 1 << Accent | 1 << Wwc | 1 << Vax |
                        1 << Drs | 1 << Pentium | 1 << Orn;
const int Wordswopped = 1 << Perq | 1 << Accent | 1 << Wwc | 1 << Vax |
                        1 << Drs | 1 << Pentium | 1 << Orn;
const int Riskmc = 1 << M88k | 1 << Rs6 | 1 << Mips;
const int Host = M88k;
const int Target = Rs6;
typedef struct Parmf {
  int Bits1;
  int Bits2;
  int Ttoput;
  unsigned char Let;
  unsigned char Dynamic;
  unsigned char Line;
  unsigned char Trace;
  unsigned char Arr;
  unsigned char Dbug;
  unsigned char Chk;
  unsigned char Diag;
  unsigned char Opt;
  unsigned char Free;
  unsigned char List;
  unsigned char Cprmode;
  unsigned char Compiler;
  unsigned char Z;
  unsigned char Y;
  unsigned char Prof;
  unsigned char Inhcode;
  unsigned char Dcomp;
  unsigned char Faulty;
  unsigned char X;
  unsigned char Stack;
  unsigned char Map;
  unsigned char Quotes;
  unsigned char S2;
  int Lpoput;
  int Sp0;
} Parmf;
typedef struct Levelf {
  int Rbase;
  int Diaginf;
  int Ral;
  int Flag;
  int L;
  int M;
  int Nmdecs;
  int Onword;
  int Oninf;
  int Label;
  int Jround;
  int Unattformats;
  int Psize;
  int Entryad;
  int Display;
  int Auxsbase;
  int Names;
  int Snmax;
  int Sn;
  int Ressize;
  int Clevel;
  int Set;
  int Maxpp;
  int Exitlab;
  int Contlab;
  int S3;
  int Avlwsp[5 /*0:4*/];
} Levelf;
#if 1 /* (1<<Host & Unsignedshorts)==0 */
{
  typedef struct Rd {
  } Rd;
  typedef struct Tagf {
    int Link;
  } Tagf;
  typedef struct Tripf {
    unsigned char Opern;
    unsigned char Optype;
    unsigned char Cnt;
    unsigned char Dpth;
    short Flags;
    short Puse;
    short Flink;
    short Blink;
    int X1;
    Rd Opnd1;
    Rd Opnd2;
  } Tripf;
  typedef struct Listf {
    int Link;
  } Listf;
}
#else
{
  typedef struct Rd {
  } Rd;
  typedef struct Tagf {
    int Link;
  } Tagf;
  typedef struct Tripf {
    unsigned char Opern;
    unsigned char Optype;
    unsigned char Cnt;
    unsigned char Dpth;
    unsigned short Flags;
    unsigned short Puse;
    unsigned short Flink;
    unsigned short Blink;
    int X1;
    Rd Opnd1;
    Rd Opnd2;
  } Tripf;
  typedef struct Listf {
    int Link;
  } Listf;
}
#endif
typedef struct Workaf {
  int Nnames;
  int Ccsize;
  int Dsize;
  int Aslmax;
  int Aslcurbtm;
  int Constptr;
  int Constbtm;
  int Lasttrip;
  int Wkfilead;
  int Wkfilek;
  int Fileaddr;
  int Release;
  int Aasl0;
  int Constlimit;
  int Rtcount;
  int Artop;
  int Amainep;
  int Dictbase;
  int Optcnt;
  int Inclhead;
  int S2;
  int S3;
  int S4;
  int *Line;
  int *N;
  int *S5;
  _imp_string255 Ladate;
  unsigned char Cc;
  unsigned char A;
  unsigned char Lett;
  int Word;
  int Tags;
  int Ctable;
  Levelf Levelinf;
  int Plabs[32 /*0:31*/];
  int Plink[32 /*0:31*/];
  Listf Aslist;
} Workaf;
const int Leavestacked = IEXP(2, 0);
const int Loadop1 = IEXP(2, 1);
const int Loadop2 = IEXP(2, 2);
const int Notinreg = IEXP(2, 3);
const int Useestack = IEXP(2, 4);
const int Usemstack = IEXP(2, 5);
const int Constantop = IEXP(2, 6);
const int Commutable = IEXP(2, 7);
const int Bstruct = IEXP(2, 12);
const int Usedlate = IEXP(2, 13);
const int Asslevel = IEXP(2, 14);
const int Dontopt = IEXP(2, 15);
typedef struct Emasfhdrf {
  int Endra;
  int Startra;
  int Fbytesize;
  int W3;
  int W4;
  int W5;
  int W6;
  int W7;
} Emasfhdrf;
const int Sconst = 0;
const int Lconst = 1;
const int Dname = 2;
const int Arname = 3;
const int Viaptr = 4;
const int Indname = 5;
const int Indirect = 6;
const int Localir = 7;
const int Reftrip = 8;
const int Inareg = 9;
const int Developped = 10;
const int Devaddr = 11;
const int Btrefmask = 1 << Reftrip | 1 << Indirect | 1 << Viaptr;
const int Referneeded = 1 << Indirect | 1 << Viaptr;
const int Rthd = 1;
const int Rdspy = 2;
const int Rdarea = 3;
const int Rdptr = 4;
const int Rtbad = 5;
const int Rtxit = 6;
const int Xstop = 7;
const int Notl = 10;
const int Lneg = 11;
const int Ifloat = 12;
const int Modulus = 13;
const int Shrtn = 14;
const int Lngthn = 15;
const int Jamshrtn = 16;
const int Nullt = 18;
const int Preload = 19;
const int Ssptr = 21;
const int Rsptr = 22;
const int Asptr = 23;
const int Darray = 24;
const int Sline = 25;
const int Stpck = 26;
const int Forpre = 27;
const int Forpost = 28;
const int Forpr2 = 29;
const int Precl = 30;
const int Rcall = 31;
const int Rcrfr = 32;
const int Rcrmr = 33;
const int Getad = 35;
const int Rtoi1 = 36;
const int Rtoi2 = 37;
const int Itos1 = 38;
const int Mnitr = 39;
const int Pprof = 40;
const int Rtfp = 41;
const int Onev1 = 42;
const int Onev2 = 43;
const int Dvstt = 44;
const int Dvend = 45;
const int Forend = 46;
const int Dmass = 47;
const int Rtoi3 = 48;
const int Ucnop = 50;
const int Ucb1 = 51;
const int Ucb2 = 52;
const int Ucb3 = 53;
const int Ucw = 54;
const int Ucbw = 55;
const int Ucww = 56;
const int Uclw = 57;
const int Ucb2w = 58;
const int Ucnam = 59;
const int Add = 128;
const int Sub = 129;
const int Noneq = 130;
const int Orl = 131;
const int Mult = 132;
const int Intdiv = 133;
const int Realdiv = 134;
const int Andl = 135;
const int Rshift = 136;
const int Lshift = 137;
const int Rexp = 138;
const int Comp = 139;
const int Dcomp = 140;
const int Vmy = 141;
const int Comb = 142;
const int Vass = 143;
const int Vjass = 144;
const int Iexp = 145;
const int Badj = 146;
const int Aindx = 147;
const int Ifetch = 148;
const int Lass = 149;
const int Forck = 150;
const int Precc = 151;
const int Concat = 152;
const int Iocpc = 153;
const int Pass1 = 154;
const int Pass2 = 155;
const int Pass3 = 156;
const int Pass4 = 157;
const int Pass5 = 158;
const int Pass6 = 159;
const int Bjump = 160;
const int Fjump = 161;
const int Remlb = 162;
const int Tlab = 163;
const int Dclsw = 164;
const int Setsw = 165;
const int Gotosw = 166;
const int Strass1 = 167;
const int Strass2 = 168;
const int Strjt = 169;
const int Ahass = 170;
const int Ptras = 171;
const int Mapres = 172;
const int Fnres = 173;
const int Scomp = 174;
const int Sdcmp = 175;
const int Pres1 = 176;
const int Pres2 = 177;
const int Resln = 178;
const int Resfn = 179;
const int Sigev = 180;
const int Recass = 181;
const int Aainc = 182;
const int Ahadj = 183;
const int Ctgen = 184;
const int Getptr = 185;
const int Sindx = 186;
const int Zcomp = 187;
const int Clshift = 188;
const int Cashift = 189;
const int Dvbpr = 190;
const int Rstore = 191;
const int Multx = 192;
extern Workaf Worka;
extern Parmf Parm;
extern void Impabort(void);
#if 1 /* Host!=Target */
extern void Reformatc(Rd Opnd);
#endif
extern void Movebytes(int L, int Fb, int Fo, int Tb, int To);
extern void Fault(int N, int Data, int Ident);
extern void Printtrips(Tripf Triples);
const unsigned char Bytes[8 /*0:7*/] = {[0 ... 2] = 0, 1, 2, 4, 8, 16};
const unsigned char Words[8 /*0:7*/] = {[0 ... 2] = 0, 1, 1, 1, 2, 4};
void Ctop(int Flag, int Mask, int Xtra, Rd Opnd1, Rd Opnd2) {
  void Extract(Rd Opnd);
  int Debyteswop(int Val);
  const int Utruncmask = 0x00000800;
  const int Btruncmask = 0x00000013;
  int K;
  int Typep;
  int Precp;
  int Op;
  int Maxd;
  int Sval;
  int Sval1;
  int Sval2;
  int C;
  int D;
  int Jj;
  int Kk;
  int Truncmask;
  int Lb;
  int Ub;
  int Mp;
  _imp_string255 Strval;
  _imp_string255 Strval1;
  _imp_string255 Strval2;
  double Lr;
#if 0 /* (1<<Host & Lintavail)!=0 */
{ long long int Val;long long int Val1;long long int Val2; }
#else
  {
    int Val;
    int Val1;
    int Val2;
  }
#endif

#if 0 /* (1<<Host & Llrealavail)!=0 */
{ long double Rval;long double Rval1;long double Rval2; }
#else
  {
    double Rval;
    double Rval1;
    double Rval2;
  }
#endif
  static int Uisw_sw;
  static void *Uisw[39 /*10:48*/] = {
      &&Uisw_10,      &&Uisw_11,      &&Uisw_12,      &&Uisw_13,
      &&Uisw_14,      &&Uisw_15,      &&Uisw_16,      &&Uisw_default,
      &&Uisw_default, &&Uisw_default, &&Uisw_default, &&Uisw_default,
      &&Uisw_default, &&Uisw_default, &&Uisw_default, &&Uisw_default,
      &&Uisw_default, &&Uisw_default, &&Uisw_default, &&Uisw_default,
      &&Uisw_default, &&Uisw_default, &&Uisw_default, &&Uisw_default,
      &&Uisw_default, &&Uisw_default, &&Uisw_default, &&Uisw_default,
      &&Uisw_38,      &&Uisw_default, &&Uisw_default, &&Uisw_default,
      &&Uisw_default, &&Uisw_default, &&Uisw_default, &&Uisw_default,
      &&Uisw_default, &&Uisw_default, &&Uisw_default,
  };
  static int Ursw_sw;
  static void *Ursw[39 /*10:48*/] = {
      &&Ursw_default, &&Ursw_11,      &&Ursw_12,      &&Ursw_default,
      &&Ursw_14,      &&Ursw_15,      &&Ursw_default, &&Ursw_default,
      &&Ursw_default, &&Ursw_default, &&Ursw_default, &&Ursw_default,
      &&Ursw_default, &&Ursw_default, &&Ursw_default, &&Ursw_default,
      &&Ursw_default, &&Ursw_default, &&Ursw_default, &&Ursw_default,
      &&Ursw_default, &&Ursw_default, &&Ursw_default, &&Ursw_default,
      &&Ursw_default, &&Ursw_default, &&Ursw_36,      &&Ursw_37,
      &&Ursw_default, &&Ursw_default, &&Ursw_default, &&Ursw_default,
      &&Ursw_default, &&Ursw_default, &&Ursw_default, &&Ursw_default,
      &&Ursw_default, &&Ursw_default, &&Ursw_48,
  };
  static int Bisw_sw;
  static void *Bisw[48 /*0:47*/] = {
      &&Bisw_0,       &&Bisw_1,       &&Bisw_2,       &&Bisw_3,
      &&Bisw_4,       &&Bisw_5,       &&Bisw_6,       &&Bisw_7,
      &&Bisw_8,       &&Bisw_9,       &&Bisw_10,      &&Bisw_11,
      &&Bisw_12,      &&Bisw_13,      &&Bisw_14,      &&Bisw_default,
      &&Bisw_default, &&Bisw_17,      &&Bisw_18,      &&Bisw_default,
      &&Bisw_default, &&Bisw_default, &&Bisw_default, &&Bisw_default,
      &&Bisw_24,      &&Bisw_default, &&Bisw_default, &&Bisw_default,
      &&Bisw_default, &&Bisw_default, &&Bisw_default, &&Bisw_default,
      &&Bisw_default, &&Bisw_default, &&Bisw_default, &&Bisw_default,
      &&Bisw_default, &&Bisw_default, &&Bisw_default, &&Bisw_default,
      &&Bisw_default, &&Bisw_default, &&Bisw_default, &&Bisw_default,
      &&Bisw_default, &&Bisw_default, &&Bisw_46,      &&Bisw_47,
  };
  static int Brsw_sw;
  static void *Brsw[48 /*0:47*/] = {
      &&Brsw_0,       &&Brsw_1,       &&Brsw_default, &&Brsw_default,
      &&Brsw_4,       &&Brsw_default, &&Brsw_6,       &&Brsw_default,
      &&Brsw_default, &&Brsw_default, &&Brsw_10,      &&Brsw_11,
      &&Brsw_12,      &&Brsw_13,      &&Brsw_default, &&Brsw_default,
      &&Brsw_default, &&Brsw_default, &&Brsw_default, &&Brsw_default,
      &&Brsw_default, &&Brsw_default, &&Brsw_default, &&Brsw_default,
      &&Brsw_default, &&Brsw_default, &&Brsw_default, &&Brsw_default,
      &&Brsw_default, &&Brsw_default, &&Brsw_default, &&Brsw_default,
      &&Brsw_default, &&Brsw_default, &&Brsw_default, &&Brsw_default,
      &&Brsw_default, &&Brsw_default, &&Brsw_default, &&Brsw_default,
      &&Brsw_default, &&Brsw_default, &&Brsw_default, &&Brsw_default,
      &&Brsw_default, &&Brsw_default, &&Brsw_46,      &&Brsw_47,
  };
  if (_imp_on_event(1, 2)) return;
  Typep = Opnd1.Ptype & 7;
  Precp = Opnd1.Ptype >> 4 & 15;
  Op = Flag;
  if ((1 << Host & Lintavail) == 0 && Opnd1.Ptype == 0x61) return;
  if ((1 << Host & Llrealavail) == 0 && Opnd1.Ptype == 0x72) return;
  if ((Opnd1.Ptype & 0x8) != 0) return;
  Extract(Opnd1);
  Val1 = Val;
  Rval1 = Rval;
  Strval1 = Strval;
  Sval1 = Val1;
  if (Op < 128) {
    if (10 > Op || Op > 48) return;
    Truncmask = Utruncmask;
    if (Typep == 2)
      goto *Ursw[Ursw_sw = (Op)-10];
    else
      goto *Uisw[Uisw_sw = (Op)-10];
  }
  Op = Op - 128;
  if (Op > 47) return;
  if ((Opnd2.Ptype & 8) != 0) return;
  Extract(Opnd2);
  Val2 = Val;
  Rval2 = Rval;
  Strval2 = Strval;
  Sval2 = Val2;
  Truncmask = Btruncmask;
  if (Typep == 2)
    goto *Brsw[Brsw_sw = Op];
  else
    goto *Bisw[Bisw_sw = Op];
Uisw_10:;
  Val1 = ~Val1;
Intend:;
  if ((1 << Host & Lintavail) != 0 && Precp == 6) {
    Opnd1.D = Val1 >> 32;
    Opnd1.Xtra = Val1;
    Flag = 0;
  } else {
    Sval = Val1;
    if (Sval == Val1 || (1 << Op & Truncmask) == 0) {
      Flag = 0;
      Opnd1.D = Sval;
    }
  }
  if (Flag == 0) {
    Opnd1.Ptype = Precp << 4 | 1;
    Opnd1.Flag = 0;
  }
  return;
Uisw_11:;
  Val1 = -Val1;
  goto Intend;
Uisw_13:;
  Val1 = Imod(Val1);
  goto Intend;
Uisw_12:;
  Rval1 = Val1;
  Precp = Precp + 1;
  goto Realend;
Ursw_15:;
  Precp = Precp + 1;
Realend:
  Opnd1.Flag = Sconst;
  if (Precp == 5)
    Opnd1.R = Rval1;
  else if (Precp == 6) {
    Lr = Rval1;
    Movebytes(8, Addr(Lr), 0, Addr(Opnd1.D), 0);
  } else {
    Opnd1.Flag = Lconst;
    Opnd1.D = Worka.Artop;
    Opnd1.Xtra = *Integer(Addr(Rval1));
    Worka.Artop = Worka.Artop + 16;
    Movebytes(16, Addr(Rval1), 0, Addr(Worka.A(0)), Opnd1.D);
  }
  Flag = 0;
  Opnd1.Ptype = 16 * Precp + 2;
  return;
Uisw_15:;
  if ((1 << Host & Lintavail) != 0 && Precp == 5) {
    Precp = 6;
    goto Intend;
  }
  if (Precp == 4) {
    Precp = 5;
    goto Intend;
  }
  return;
Uisw_14:;
  if (Precp == 4 && 0 <= Val1 && Val1 <= 255) {
    Precp = 3;
    goto Intend;
  }
  if (Precp == 5 && Imod(Val1) <= 0x7FFF) {
    Precp = 4;
    goto Intend;
  }
  if (Precp == 6 && Val1 == Sval1) {
    Precp = 5;
    goto Intend;
  }
  return;
Ursw_14:;
  Precp = Precp - 1;
  goto Realend;
Ursw_12:;
  Impabort();
Uisw_16:;
  if (Precp == 5) {
    Val1 = Val1 & 0xFFFF;
    Precp = 4;
    goto Intend;
  }
  return;
Ursw_36:;
  if (Mod(Rval1) >= 0x7FFFFFFE) return;
  Val1 = Int(Rval1);
  Precp = 5;
  goto Intend;
Ursw_37:;
  if (Mod(Rval1) >= 0x7FFFFFFE) return;
  Val1 = Intpt(Rval1);
  Precp = 5;
  goto Intend;
Uisw_38:;
  Strval1 = Tostring(Val1);
  goto Strend;
Ursw_48:;
  if (Mod(Rval1) >= 0x7ffffffe) return;
  if (Rval >= 0)
    Val1 = Intpt(Rval1);
  else
    Val1 = -Intpt(Mod(Rval1));
  Precp = 5;
  goto Intend;
Bisw_0:;
Bisw_14:;
  Val1 = Val1 + Val2;
  goto Intend;
Bisw_1:;
  Val1 = Val1 - Val2;
  goto Intend;
Bisw_2:;
  Val1 = Val1 ^ Val2;
  goto Intend;
Bisw_3:;
  Val1 = Val1 | Val2;
  goto Intend;
Bisw_4:;
  Val1 = Val1 * Val2;
  goto Intend;
Bisw_6:
  return;
Bisw_5:
  if (Val2 == 0) return;
  Val1 = Val1 / Val2;
  goto Intend;
Bisw_7:;
  Val1 = Val1 & Val2;
  goto Intend;
Bisw_9:;
  if (Precp == 6)
    Val1 = Val1 << Sval2;
  else
    Val1 = Sval1 << Sval2;
  goto Intend;
Bisw_8:;
  if (Precp == 6)
    Val1 = Val1 >> Sval2;
  else
    Val1 = Sval1 >> Sval2;
  goto Intend;
Bisw_13:;
  Maxd = Xtra >> 24 & 15;
  C = Xtra >> 28;
  D = Opnd2.D & 0xFFFF;
#if 1 /* Target==Pnx || Target==Perq || Target==Accent || (1<<Target & \
         Emachine)!=0 */
  {
    Lb = Debyteswop(Worka.Ctable(D + 3 * C + 1));
    Ub = Debyteswop(Worka.Ctable(D + 3 * C));
    Mp = Debyteswop(Worka.Ctable(D + 3 * C - 1));
    if (Val1 < Lb || Val1 > Ub) Fault(50, Val1, Xtra & 0xFFFF);
    if (C != 1) Val1 = Val1 * Mp;
    goto Intend;
  }
#endif

#if 0 /* Target==Emas */
{ C = 3*(Maxd + 1 - C);Jj = (Val1 - Worka.Ctable(D + C))*Worka.Ctable(D + C + 1);if (Jj < 0 || Jj > Worka.Ctable(D + C + 2)) Fault(50,Val1,Xtra & 0xFFFF);Val1 = Jj;goto Intend;
 }
#endif

#if 0 /* Target==Ibm || Target==Amdahl || Target==Ibmxa */
{ if (Val1 < Worka.Ctable(D + 3*C) || Val1 > Worka.Ctable(D + 3*C + 1)) Fault(50,Val1,Xtra & 0xFFFF);Val1 = Val1*Worka.Ctable(D + 3*C + 2);goto Intend;
 }
#endif
  return;
Bisw_18:;
#if 1 /* Target==Perq || (1<<Target & Emachine)!=0 || Target==Accent || \
         Target==Pnx */
  {
    D = Xtra >> 24 & 15;
    Kk = Val2;
    if (Kk <= 0) return;
    Jj = Debyteswop(Worka.Ctable(Kk));
    Val1 = Val1 + Jj;
  }
#endif
  goto Intend;
Bisw_46:;
Bisw_47:;
Brsw_46:;
Brsw_47:;
Bisw_11:;
Bisw_12:;
Brsw_11:;
Brsw_12:;
  Mask = Xtra;
  Flag = 0;
  if (Typep == 2) goto Rcomp;
  if (Typep == 5) goto Scomp;
  if (((Mask & 8) != 0 && Val1 == Val2) || ((Mask & 4) != 0 && Val1 < Val2) ||
      ((Mask & 2) != 0 && Val1 > Val2))
    Mask = 15;
  else
    Mask = 0;
  if (Op == 12) Opnd1 = Opnd2;
  return;
Rcomp:;
  if (((Mask & 8) != 0 && Rval1 == Rval2) ||
      ((Mask & 4) != 0 && Rval1 < Rval2) || ((Mask & 2) != 0 && Rval1 > Rval2))
    Mask = 15;
  else
    Mask = 0;
  if (Op == 12) Opnd1 = Opnd2;
  return;
Scomp:;
  if (((Mask & 8) != 0 && Strval1 == Strval2) ||
      ((Mask & 4) != 0 && Strval1 < Strval2) ||
      ((Mask & 2) != 0 && Strval1 > Strval2))
    Mask = 15;
  else
    Mask = 0;
  if (Op == 47) Opnd1 = Opnd2;
  return;
Ursw_11:;
  Rval1 = -Rval1;
  goto Realend;
Brsw_13:;
  Rval1 = Mod(Rval1);
  goto Realend;
Brsw_0:;
  Rval1 = Rval1 + Rval2;
  goto Realend;
Brsw_1:;
  Rval1 = Rval1 - Rval2;
  goto Realend;
Brsw_4:;
  Rval1 = Rval1 * Rval2;
  goto Realend;
Brsw_6:;
  if (Rval2 == 0) return;
  Rval1 = Rval1 / Rval2;
  goto Realend;
Bisw_10:;
Brsw_10:;
  if ((Opnd2.Ptype & 7) != 1 || -77 > Val2 || Val2 > 75) return;
  Rval2 = 1;
  for (Jj = 1; Jj <= Imod(Val2); Jj++) Rval2 = Rval2 * Rval1;
  if (Val2 < 0)
    Rval1 = 1.0 / Rval2;
  else
    Rval1 = Rval2;
  goto Realend;
Bisw_17:;
  if (0 > Val2 || Val2 > 63) return;
  Val2 = 1;
  while (Sval2 > 0) {
    Val2 = Val2 * Val1;
    Sval2 = Sval2 - 1;
  }
  Val1 = Val2;
  goto Intend;
Bisw_24:;
  if (*Length(Strval1) + *Length(Strval2) > 255) return;
  Strval1 = _imp_join(Strval1, Strval2);
Strend:;
  Opnd1.Ptype = 0x35;
  Opnd1.Flag = Lconst;
  Opnd1.Xtra = *Length(Strval1);
  Jj = Worka.Artop;
  Worka.A(Jj) = Opnd1.Xtra;
  for (K = 1; K <= Opnd1.Xtra; K++) Worka.A(Jj + K) = *Charno(Strval1, K);
  Opnd1.D = Jj;
  Worka.Artop = (Jj + Opnd1.Xtra + 2) & (-2);
  Flag = 0;
  return;
Ursw_default:;
Uisw_default:;
Brsw_default:;
Bisw_default:;
  return;
  void Extract(Rd Opnd) {
    int Type;
    int Prec;
    int I;
    int Ad;
    Type = Opnd.Ptype;
    Prec = Type >> 4;
    Type = Type & 15;
    Val = 0;
    Rval = 0;
    Strval = _imp_str_literal("");
    if (Type == 5) {
      Length(Strval) = Worka.A(Opnd.D);
      for (I = 1; I <= Opnd.Xtra; I++) Charno(Strval, I) = Worka.A(Opnd.D + I);
    } else if (Type == 1) {
      if ((1 << Host & Lintavail) != 0 && Prec == 6)
        Val = Lengtheni(Opnd.D) << 32 | (Opnd.Xtra & (Lengtheni(-1) >> 32));
      else
        Val = Opnd.D;
      Rval = Val;
    } else if (Prec == 5)
      Rval = Opnd.R;
    else if (Prec == 6) {
      Movebytes(8, Addr(Opnd.D), 0, Addr(Lr), 0);
      Rval = Lr;
    } else
      Movebytes(16, Addr(Worka.A(0)), Opnd.D, Addr(Rval), 0);
  }
  int Debyteswop(int Val) {
    Rd Opnd;
    Opnd = 0;
    Opnd.Ptype = 0x51;
    Opnd.D = Val;
#if 1 /* Host!=Target */
    Reformatc(Opnd);
#endif
    return (Opnd.D);
  }
}
void Tripopt(Tripf Triples, int Inptr) {
  int Changes;
  int Dups;
  int Duptno;
  int Ptr;
  int I;
  int J;
  int K;
  int Val;
  int Xval;
  int Curr;
  int Next;
  int Op1;
  int Op2;
  int Ctopop;
  int Revop;
  int Aptype;
  int Foldagain;
  unsigned char A;
  Tripf *Currt;
  Tripf *Newt;
  Tripf *Nextt;
  Rd *Opnd1;
  Rd *Opnd2;
  Rd *Popnd;
  Rd *Ropnd;
  void Swopoperands(Tripf Currt);
  int Powerof2(int Val);
  int Preloadplace(int Trip);
  void Indopt(Rd Opnd);
  void Vmyopt(int Curr);
  int Sameopnd(Rd Opnd1, Rd Opnd2, int Assn);
  void Invertdiv(Tripf Currt);
  void Checkdups(int Stripno, int Stripno);
  void Propagatecass(int Stripno, Rd N, Rd C);
  void Duplicatetrip(int Tripno, int Dtripno, int Flagbits);
  void Decuse(int Tripleno);
  void Deletetriple(int Tripleno);
#if 0 /* Target==Amdahl || Target==Ibm || Target==Ibmxa */
const unsigned char Foldnoopinfo[200 /*0:199*/] =  {
[0 ... 127] = 0,0x89,0x41,0x89,0x89,0xB6,2,0,0xA4,1,1,2,0,0,32,0x89,0,0,2,0,0,0,[149 ... 151] = 0,0x40,[153 ... 199] = 0
};

#elif 0 /* Target==Emas */
  const unsigned char Foldnoopinfo[200 /*0:199*/] = {[0 ... 127] = 0,
                                                     0x89,
                                                     0x41,
                                                     0x89,
                                                     0x89,
                                                     0xB6,
                                                     2,
                                                     0,
                                                     0xA4,
                                                     1,
                                                     1,
                                                     2,
                                                     0,
                                                     0,
                                                     3,
                                                     0x89,
                                                     0,
                                                     0,
                                                     2,
                                                     0,
                                                     0,
                                                     0,
                                                     [149 ... 151] = 0,
                                                     0x40,
                                                     [153 ... 199] = 0};

#else
  const unsigned char Foldnoopinfo[200 /*0:199*/] = {[0 ... 127] = 0,
                                                     0x89,
                                                     0x41,
                                                     0x89,
                                                     0x89,
                                                     0xB6,
                                                     2,
                                                     0,
                                                     0xA4,
                                                     1,
                                                     1,
                                                     2,
                                                     0,
                                                     0,
                                                     3,
                                                     0x89,
                                                     0,
                                                     0,
                                                     2,
                                                     0,
                                                     1,
                                                     0,
                                                     [149 ... 151] = 0,
                                                     0x40,
                                                     [153 ... 199] = 0};

#endif
  A = &Worka.A;
  Changes = 0;
  Dups = 0;
  if (Parm.Dcomp != 0) {
    Printstring(_imp_str_literal("Optimising triples "));
    Printtrips(Triples);
  }
  Ptr = Inptr;
  while (Ptr > 0) {
    Currt = &Triples(Ptr);
    Ptr = Currt->Flink;
    Nextt = &Triples(Ptr);
    if (Ptr == 0) break;
    if (Nextt->Opern != Vass || Nextt->Optype != 0x51 ||
        0x51 != Currt->Optype ||
        (Nextt->Opnd1->Flag != Dname && Nextt->Opnd1->Flag != Indname &&
         Nextt->Opnd1->Flag != Arname) ||
        Nextt->Opnd2->Flag != Reftrip || Currt->Puse != Ptr || Currt->Cnt != 1)
      continue;
    if (Add > Currt->Opern || Currt->Opern > Andl) continue;
    if ((Currt->Flags & Commutable) != 0 &&
        Sameopnd(Currt->Opnd2, Nextt->Opnd1, No) == Yes)
      Swopoperands(*Currt);
    else if (Sameopnd(Currt->Opnd1, Nextt->Opnd1, No) != Yes)
      continue;
    Nextt->X1 = Currt->Opern;
    Nextt->Opern = Rstore;
    Nextt->Puse = 0;
    Nextt->Flags = Dontopt | Currt->Flags & (~Loadop1);
    Nextt->Opnd2 = Currt->Opnd2;
    Triples(Nextt->Blink).Opern = Nullt;
    Changes = Changes + 1;
  }
  if (Changes > 0 && Parm.Dcomp != 0) Printtrips(Triples);
  Worka.Optcnt = Worka.Optcnt + Changes;
  return;
  int Powerof2(int Val) {
    int I;
    int J;
    for (I = 1; I <= 30; I++) {
      J = 1 << I;
      if (J == Val) return (I);
      if (J > Val) return (0);
    }
    return (0);
  }
  void Swopoperands(Tripf Currt) {
    Rd Topnd;
    int Flags;
    int Newflags;
    Topnd = Currt.Opnd1;
    Currt.Opnd1 = Currt.Opnd2;
    Currt.Opnd2 = Topnd;
    Flags = Currt.Flags;
    Newflags = Flags & (~(Loadop1 + Loadop2));
    if ((Flags & Loadop1) != 0) Newflags = Newflags | Loadop2;
    if ((Flags & Loadop2) != 0) Newflags = Newflags | Loadop1;
    Currt.Flags = Newflags;
    Changes = Changes + 1;
  }
  int Preloadplace(int Trip) {
    const int Triprefs = 0x140;
    Rd *Opnd1;
    Rd *Opnd2;
    Tripf *Currt;
    Currt = &Triples(Trip);
    Opnd1 = &Currt->Opnd1;
    Opnd2 = &Currt->Opnd2;
    if (Currt->Opern < 128 || (1 << Currt->Opnd2->Flag & Triprefs) == 0) {
      if ((1 << Currt->Opnd1->Flag & Triprefs) == 0) return (Trip);
      return (Preloadplace(Opnd1->D));
    }
    if ((1 << Currt->Opnd1->Flag & Triprefs) == 0 || Opnd1->D == Currt->Blink)
      return (Preloadplace(Opnd2->D));
    if (Currt->Blink == Opnd2->D) return (Preloadplace(Opnd1->D));
    return (-1);
  }
  void Indopt(Rd Opnd) {
    int Cop;
    int X;
    int Val;
    int Op;
    int Limit;
    Tripf *Rtrip;
    Rd *Copnd;
#if 0   /* Target==Ibm || Target==Amdahl || Target==Ibmxa */
Limit = 4096;
#elif 0 /* Target==Emas */
    Limit = 0x7FFFFFFF;
#else
    Limit = 1 << 16;
#endif
    Rtrip = &Triples(Opnd.D);
    if (Rtrip->Cnt != 1 || (Rtrip->Flags & Constantop) == 0) return;
    Op = Rtrip->Opern;
    if (Op != Add && Op != Sub) return;
    if ((Rtrip->Optype & 7) != 1 || Rtrip->Optype >> 4 >= 6) return;
    if (Rtrip->Opnd1->Flag <= 1) {
      Cop = 1;
      Copnd = &Rtrip->Opnd1;
    } else {
      Cop = 2;
      Copnd = &Rtrip->Opnd2;
    }
    X = Opnd.Xtra;
    if (X < 0) X = 0;
    Val = Copnd->D;
    if (Op == Add && Limit > X + Val && X + Val >= 0) {
      Copnd->D = 0;
      Opnd.Xtra = X + Val;
      return;
    }
    if (Op == Sub && Limit > X - Val && X - Val >= 0 && Cop == 2) {
      Copnd->D = 0;
      Opnd.Xtra = X - Val;
    }
  }
  void Vmyopt(int Curr) {
    Tripf *Currt;
    Rd *Opnd2;
    int C;
    int D;
    int Value;
    int Aptype;
    int Dv;
    int I;
    int J;
    int Dvname;
    Currt = &Triples(Curr);
    Opnd2 = &Currt->Opnd2;
    C = Currt->X1 >> 28;
    D = Currt->X1 >> 24 & 15;
    Dv = 0;
    if (Opnd2->Flag == Sconst) Dv = Opnd2->D;
    if ((Target == Pnx || Target == Perq || Target == Accent) && C == 1) {
      Value = 1;
      goto Tomult;
    }
    Aptype = -1;
    Dvname = Currt->X1 & 0xFFFF;
    if (Dvname > 0) Aptype = Worka.Aslist(Worka.Tags(Dvname)).Ptype;
#if 0 /* Target==Emas */
{ if (Dv > 0) { I = 3*(D + 1 - C);if (Worka.Ctable(Dv + I)==0) { Value = Worka.Ctable(Dv + I + 1);goto Tomult;
 }  } if (Aptype>>8==2 && C==1 && (Aptype & 7)<=2 && (Aptype & 255)!=0x41) { Value = 1;goto Tomult;
 }  }
#endif

#if 0 /* Target==Ibm || Target==Amdahl || Target==Ibmxa */
{ if (C==1 && 1==D && Currt->Opnd1->Flag==Reftrip) Ibmvmy(Curr);if (Opnd1->Flag==Sconst && Opnd1->D==0) { Value = 1;goto Tomult;
 } if (Dv > 0) { Value = Worka.Ctable(Dv + 3*C + 2);goto Tomult;
 } if (C==1) { if ((Aptype & 7)<=2) { Value = Bytes(Aptype>>4 & 7);goto Tomult;
 } if ((Aptype & 0x0C00)==0) if (Dvname > 0) { Value = Worka.Aslist(Worka.Tags(Dvname)).Acc;goto Tomult;
 }  }  }
#endif
    return;
  Tomult:;
    Currt->Opern = Mult;
    Currt->Flags = Currt->Flags | Constantop;
    Opnd2->Ptype = Currt->Optype;
    Opnd2->Flag = Sconst;
    Opnd2->D = Value;
    Changes = Changes + 1;
  }
  void Decuse(int Tripleno) {
    Tripf *Currt;
    Currt = &Triples(Tripleno);
    if (Currt->Cnt == 0) {
      Printstring(_imp_str_literal("dec use???\n"));
      Printtrips(Triples);
      _imp_monitor();
    }
    Currt->Cnt = Currt->Cnt - 1;
    if (Currt->Cnt == 1) Dups = Dups - 1;
    if (Currt->Cnt == 0 && Currt->Opern != Rstore && Currt->Opern != Nullt)
      Deletetriple(Tripleno);
  }
  void Deletetriple(int Tripleno) {
    Tripf *Delt;
    Delt = &Triples(Tripleno);
    if ((1 << Delt->Opnd1->Flag & Btrefmask) != 0) Decuse(Delt->Opnd1->D);
    if (Delt->Opern >= 128 && (1 << Delt->Opnd2->Flag & Btrefmask) != 0)
      Decuse(Delt->Opnd2->D);
    Delt->X1 = Delt->Opern;
    Delt->Opern = Nullt;
    Changes = Changes + 1;
    Delt->Flags = Delt->Flags | Dontopt;
  }
  void Duplicatetrip(int Tripno, int Dtripno, int Flagbits) {
    Rd *Opnd1;
    Rd *Opnd2;
    Tripf *Master;
    Tripf *Currt;
    Tripf *Dupt;
    int Cnt;
    int Ptr;
    Dups = Dups + 1;
    Duptno = Tripno;
    Master = &Triples(Tripno);
    Dupt = &Triples(Dtripno);
    Master->Flags = Master->Flags | Flagbits;
    Cnt = Dupt->Cnt;
    Ptr = Dupt->Flink;
    while (Cnt > 0 && Ptr > 0) {
      Currt = &Triples(Ptr);
      Ptr = Currt->Flink;
      if (Currt->Opern == Nullt) continue;
      Opnd1 = &Currt->Opnd1;
      Opnd2 = &Currt->Opnd2;
      if (Opnd1->D == Dtripno && (1 << Opnd1->Flag & Btrefmask) != 0) {
        Master->Cnt = Master->Cnt + 1;
        Opnd1->D = Tripno;
        Currt->Flags = Currt->Flags | Loadop1;
        Cnt = Cnt - 1;
      }
      if (Currt->Opern >= 128 && Opnd2->D == Dtripno &&
          (1 << Opnd2->Flag & Btrefmask) != 0) {
        Master->Cnt = Master->Cnt + 1;
        Opnd2->D = Tripno;
        Currt->Flags = Currt->Flags | Loadop2;
        Cnt = Cnt - 1;
      }
    }
    Deletetriple(Dtripno);
  }
  void Invertdiv(Tripf Currt) {
    int Op;
    int Prec;
    int Flag;
    int J;
    Rd Wopnd;
    Rd Copnd;
    double Lr;
    Copnd = Currt.Opnd2;
    Prec = Currt.Optype >> 4;
    Wopnd.S1 = Copnd.S1;
    if (Prec == 5)
      Wopnd.R = 1.0;
    else if (Prec == 6) {
      Lr = 1.0;
      Movebytes(8, Addr(Lr), 0, Addr(Wopnd.D), 0);
    } else {
      Wopnd.Ptype = 0x61;
      Wopnd.D = 0;
      Wopnd.Xtra = 1;
      Op = Ifloat;
      Ctop(Op, J, 0, Wopnd, Copnd);
      if (Op != 0) return;
    }
    Op = Realdiv;
    Ctop(Op, J, 0, Wopnd, Copnd);
    if (Op != 0) return;
    Currt.Opern = Mult;
    Currt.Opnd2 = Wopnd;
  }
  void Checkdups(int Tripno, int Stripno) {
    Tripf *Currt;
    Tripf *Dupt;
    Tripf *Workt;
    Rd Aopnd;
    Rd Dopnd1;
    Rd Dopnd2;
    Rd Wopnd1;
    Rd Wopnd2;
    const int Lmax = 4;
    int Labs[5 /*0:4*/];
    int Op;
    int Next;
    int Lptr;
    int I;
    int J;
    int Ctripno;
    int Opern;
    int F;
    int C11;
    int C12;
    int C21;
    int C22;
    int W12;
    int W22;
    int Labp;
    Dupt = &Triples(Tripno);
    Dopnd1 = Dupt->Opnd1;
    Dopnd2 = Dupt->Opnd2;
    Opern = Dupt->Opern;
    if (Opern == Comp || Opern == Dcomp || Opern == Scomp || Opern == Sdcmp)
      return;
    if (Opern == Precc || Opern == Concat || Opern == Pres1 || Opern == Pres2)
      return;
    if (Opern == Precl || Pass1 <= Opern && Opern <= Pass6) return;
    if (Opern == Getptr && Dupt->Optype == 0x61) return;
    F = Dupt->Flags;
    Lptr = 0;
    Labp = 0;
    while (Stripno > 0) {
      Currt = &Triples(Stripno);
      if ((Currt->Flags & Asslevel) != 0) break;
      Op = Currt->Opern;
      if (Op == Fjump && Lptr <= Lmax) {
        J = Currt->Opnd1->D;
        I = J & 0xFFFF;
        if (J < 0 && I > Worka.Nnames) {
          Labs(Lptr) = I;
          Lptr = Lptr + 1;
        }
      }
      if (Op == Tlab) {
        Labp = Usedlate;
        J = Currt->Opnd1->D & 0xFFFF;
        for (I = 0; I <= Lptr - 1; I++)
          if (J == Labs(I)) goto Jseen;
        break;
      Jseen:;
      }
      if (Op == Rtxit || Op == Rcall) break;
      if (Op == Setsw || Op == Ahass || Op == Ptras || Op == Lass) break;
      if (Op == Vass || Op == Vjass || Strass1 <= Op && Op <= Strjt ||
          Op == Dmass || Op == Rstore) {
        Aopnd = Currt->Opnd1;
        if (Aopnd.Flag == Indirect &&
            (Dopnd1.Flag == Indirect || Dopnd2.Flag == Indirect))
          break;
        else {
          if (Sameopnd(Aopnd, Dopnd1, Yes) == Yes) break;
          if (Opern >= 128 && Sameopnd(Aopnd, Dopnd2, Yes) == Yes) break;
        }
      }
      if (Op == Getad || Op == Getptr) {
        Aopnd = Currt->Opnd1;
        if (Sameopnd(Aopnd, Dopnd1, Yes) == Yes) break;
        if (Opern >= 128 && Sameopnd(Aopnd, Dopnd2, Yes) == Yes) break;
      }
      Ctripno = Stripno;
      Stripno = Currt->Flink;
      if (Op == Opern && (Op != Vmy || Dupt->X1 == Currt->X1)) {
        C11 = Sameopnd(Dopnd1, Currt->Opnd1, No);
        if (Opern < 128) {
          if (C11 == Yes) Duplicatetrip(Tripno, Ctripno, Labp);
          continue;
        }
        C22 = Sameopnd(Dopnd2, Currt->Opnd2, No);
        C12 = No;
        C21 = No;
        if ((F & Commutable) != 0) {
          C12 = Sameopnd(Dopnd1, Currt->Opnd2, No);
          C21 = Sameopnd(Dopnd2, Currt->Opnd1, No);
        }
        if (C11 == Yes && Yes == C22 || C21 == Yes && Yes == C12) {
          Duplicatetrip(Tripno, Ctripno, Labp);
          continue;
        }
        if ((C12 | C11 | C22 | C21) == Yes) {
          Workt = &Triples(Currt->Puse);
          Wopnd1 = Workt->Opnd1;
          Wopnd2 = Workt->Opnd2;
          if (Op == Workt->Opern && Workt->Cnt == 1 && (F & Commutable) != 0) {
            W22 = Sameopnd(Dopnd2, Wopnd2, No);
            W12 = Sameopnd(Dopnd1, Wopnd2, No);
            if (C12 == Yes && Yes == W22 || C22 == Yes && Yes == W12 ||
                C21 == Yes && Yes == W12 || C11 == Yes && Yes == W22) {
              if (C12 == Yes || C22 == Yes) {
                Workt->Opnd2 = Currt->Opnd1;
                Currt->Opnd1 = Wopnd2;
              } else {
                Workt->Opnd2 = Currt->Opnd2;
                Currt->Opnd2 = Wopnd2;
              }
              Duplicatetrip(Tripno, Ctripno, Labp);
              continue;
            }
          }
        }
      }
    }
  }
  void Propagatecass(int Stripno, Rd Nopnd, Rd Copnd) {
    Tripf *Currt;
    Rd Aopnd;
    const int Lmax = 4;
    int Labs[5 /*0:4*/];
    int Op;
    int Next;
    int Lptr;
    int I;
    int J;
    int Ctripno;
    int Labp;
    Lptr = 0;
    while (Stripno > 0) {
      Currt = &Triples(Stripno);
      if ((Currt->Flags & Asslevel) != 0) break;
      Op = Currt->Opern;
      if (Op == Fjump && Lptr <= Lmax) {
        J = Currt->Opnd1->D;
        I = J & 0xFFFF;
        if (J < 0 && I > Worka.Nnames) {
          Labs(Lptr) = I;
          Lptr = Lptr + 1;
        }
      }
      if (Op == Tlab) {
        J = Currt->Opnd1->D & 0xFFFF;
        for (I = 0; I <= Lptr - 1; I++)
          if (J == Labs(I)) goto Jseen;
        break;
      Jseen:;
      }
      if (Op == Rtxit || Op == Rcall) break;
      if (Op == Setsw || Op == Ptras) break;
      if (Op == Vass || Op == Strass2 || Op == Vjass || Op == Dmass ||
          Op == Rstore || Op == Getad || Op == Getptr) {
        Aopnd = Currt->Opnd1;
        if (Sameopnd(Aopnd, Nopnd, Yes) == Yes) break;
      }
      if (Sameopnd(Currt->Opnd1, Nopnd, No) == Yes) {
        Changes = Changes + 1;
        if (Op < 128 || (Currt->Flags & Constantop) != 0) Foldagain = Yes;
        Currt->Flags = Currt->Flags | Constantop;
        Currt->Opnd1 = Copnd;
      }
      if (Op >= 128 && Sameopnd(Currt->Opnd2, Nopnd, No) == Yes) {
        Changes = Changes + 1;
        if ((Currt->Flags & Constantop) != 0) Foldagain = Yes;
        Currt->Flags = Currt->Flags | Constantop;
        Currt->Opnd2 = Copnd;
      }
      Stripno = Currt->Flink;
    }
  }
  int Sameopnd(Rd Opnd1, Rd Opnd2, int Assn) {
    int F;
    int I;
    int B1;
    int B2;
    F = Opnd1.Flag;
    if (F == 3) {
      if (F != Opnd2.Flag) return (No);
      B1 = Opnd1.D;
      B2 = Opnd2.D;
      if (A(B1) == A(B2) && A(B1 + 1) == A(B2 + 1) && A(B1 + 2) == 2 &&
          A(B2 + 2) == 2 && A(B1 + 3) == 2 && A(B2 + 3) == 2)
        return (Yes);
      return (No);
    }
    if (F == 2 || F == 5) {
      if (F != Opnd2.Flag) return (No);
      if (Opnd1.D != Opnd2.D || (Opnd1.Ptype & 0x3000) != 0) return (No);
      if (Assn == No && Opnd1.Ptype != Opnd2.Ptype) return (No);
      if (Opnd1.Xtra == Opnd2.Xtra) return (Yes);
      B1 = Bytes(Opnd1.Ptype >> 4 & 15);
      B2 = Bytes(Opnd2.Ptype >> 4 & 15);
      I = Imod((Opnd1.Xtra & 0xFFFF) - (Opnd2.Xtra & 0xFFFF));
      if (Assn == Yes && (I <= B1 || I <= B2)) return (Yes);
      return (No);
    }
    if ((Opnd1.S1 & 0xFFFF00FF) != (Opnd2.S1 & 0xFFFF00FF)) return (No);
    if (F <= 1) {
      if (Opnd1.Ptype == 0x35) {
        if (Opnd1.Xtra != Opnd2.Xtra) return (No);
        for (I = 1; I <= Opnd1.Xtra; I++)
          if (A(Opnd1.D + I) != A(Opnd2.D + I)) return (No);
        return (Yes);
      }
      if (Opnd1.D == Opnd2.D &&
          (Opnd1.Xtra == Opnd2.Xtra || (Opnd1.Ptype & 0xF0) <= 0x50))
        return (Yes);
      return (No);
    }
    if (Opnd1.D == Opnd2.D && Opnd1.Xtra == Opnd2.Xtra) return (Yes);
    return (No);
  }
}