#include <perms.h>
int _imp_mainep(int _imp_argc, char **_imp_argv) {
  const int Maxvars = 1024;
  const int Maxstack = 16;
  const int Maxlabs = 50;
  const int Maxlevel = 16;
  const int Maxgp = 120;
  const _imp_string255 Programip = _imp_str_literal("Main Program");
  const _imp_string255 Programep = _imp_str_literal("__impmain");
  const _imp_string255 Systemprefix = _imp_str_literal("_imp_");
  const int Icode = 1;
  const int Source = 2;
  const int Report = 0;
  const int Objout = 1;
  const int Listout = 2;
  const int Passid = 2;
  const int Checkcapacity = 1;
  const int Checkunass = 2;
  const int Checkarray = 4;
  const int Checkbits = Checkarray;
  const int Ax = 1;
  const int Cx = 2;
  const int Dx = 3;
  const int Bx = 4;
  const int Sp = 5;
  const int Bp = 6;
  const int Si = 7;
  const int Di = 8;
  const int Fr0 = 9;
  const int Fr7 = 16;
  const int Al = 17;
  const int Cl = 18;
  const int Dl = 19;
  const int Bl = 20;
  const int Ah = 21;
  const int Ch = 22;
  const int Dh = 23;
  const int Bh = 24;
  const int Any = 25;
  const int Anyg = 26;
  const int Anyp = 27;
  const int Anyf = 28;
  const int Simple = 1;
  const int Name = 2;
  const int Label = 3;
  const int Recordformat = 4;
  const int Switch = 6;
  const int Array = 11;
  const int Arrayname = 12;
  const int Namearray = 13;
  const int Namearrayname = 14;
  const int Constant = 0;
  const int Vinr = 1;
  const int Avinr = 2;
  const int Ainr = 3;
  const int Vins = 4;
  const int Avins = 5;
  const int Ains = 6;
  const int Vinrec = 7;
  const int Avinrec = 8;
  const int Ainrec = 9;
  const int Pgmlabel = 10;
  const int General = 0;
  const int Integer = 1;
  const int Real = 2;
  const int String = 3;
  const int Record = 4;
  const int Byte = 5;
  const int Short = 6;
  const int Long = 7;
  const int Lreal = 8;
  const int Tarray = 9;
  const int Tlabel = 10;
  const int Xarray = 11;
  const int Xarrayname = 12;
  const int Xnamearray = 13;
  const int Xnamearrayname = 14;
  const unsigned char Vsize[15 /*0:14*/] = {0, 4, 4, 0, 0, 1, 2, 4,
                                            8, 0, 0, 0, 0, 0, 0};
  const unsigned char Genmap[15 /*0:14*/] = {0, 1, 2,  3, 4, 5, 6, 7,
                                             8, 9, 10, 9, 9, 9, 9};
  const int Align = 3;
  const int Wordsize = 4;
  const int Own = 1;
  const int Con = 2;
  const int External = 3;
  const int System = 4;
  const int Dynamic = 5;
  const int Primrt = 6;
  const int Permrt = 7;
  const int Map = -2;
  const int Fn = -1;
  const int Routine = 0;
  const int True = 1;
  const int False = 2;
  const int Iexp = 1;
  const int Fexp = 2;
  const int Smove = 3;
  const int Sjam = 4;
  const int Sconc = 5;
  const int Sjconc = 6;
  const int Sresln = 7;
  const int Scomp = 8;
  const int Aref = 9;
  const int Adef = 10;
  const int Signal = 11;
  const int Stop = 12;
  const int Lastperm = Stop;
  const _imp_string255 Permname[12 /*1:12*/] = {
      _imp_str_literal("_IMPIEXP"),   _imp_str_literal("_IMPFEXP"),
      _imp_str_literal("_IMPSTRCPY"), _imp_str_literal("_IMPSTRJAM"),
      _imp_str_literal("_IMPSTRCAT"), _imp_str_literal("_IMPSTRJCAT"),
      _imp_str_literal("_IMPSTRRES"), _imp_str_literal("_IMPSTRCMP"),
      _imp_str_literal("_IMPAREF"),   _imp_str_literal("_IMPADEF"),
      _imp_str_literal("_IMPSIGNAL"), _imp_str_literal("_IMPSTOP")};
  const int Addx = 1;
  const int Subx = 2;
  const int Mulx = 3;
  const int Divx = 4;
  const int Concx = 5;
  const int Andx = 6;
  const int Orx = 7;
  const int Xorx = 8;
  const int Lshx = 9;
  const int Rshx = 10;
  const int Remx = 11;
  const int Expx = 12;
  const int Rexpx = 13;
  const int Rdivx = 14;
  const int Notx = 15;
  const int Negx = 16;
  const int Absx = 17;
  const int Unaries = 15;
  const int Nop = 0;
  const int Cwd = 1;
  const int Ret = 2;
  const int Sahf = 3;
  const int Leave = 4;
  const int Dec = 5;
  const int Inc = 6;
  const int Neg = 7;
  const int Not = 8;
  const int Pop = 9;
  const int Push = 10;
  const int Lea = 11;
  const int Mov = 12;
  const int Xchg = 13;
  const int Adc = 14;
  const int Add = 15;
  const int And = 16;
  const int Cmp = 17;
  const int Or = 18;
  const int Sub = 19;
  const int Xor = 20;
  const int Shl = 21;
  const int Shr = 22;
  const int Idiv = 23;
  const int Imul = 24;
  const int Call = 25;
  const int Je = 26;
  const int Jne = 27;
  const int Jg = 28;
  const int Jge = 29;
  const int Jl = 30;
  const int Jle = 31;
  const int Ja = 32;
  const int Jae = 33;
  const int Jb = 34;
  const int Jbe = 35;
  const int Jmp = 36;
  const int Fild = 37;
  const int Fldd = 38;
  const int Fldq = 39;
  const int Fsti = 40;
  const int Fstd = 41;
  const int Fstq = 42;
  const int Fadd = 43;
  const int Fsub = 44;
  const int Fsubr = 45;
  const int Fmul = 46;
  const int Fdiv = 47;
  const int Fdivr = 48;
  const int Fcmp = 49;
  const int Fchs = 50;
  const int Fabs = 51;
  const int Fstsw = 52;
  const int Fldz = 53;
  const int Fldpi = 54;
  const int Data = 0x10;
  const int Cot = 0x20;
  const int Bss = 0x30;
  const int Display = 0x40;
  const int Ext = 0x50;
  const int Swt = 0x60;
  const int Code = 0x70;
  const _imp_string255 Opname[37 /*0:36*/] = {
      _imp_str_literal("NOP"),   _imp_str_literal("CWD"),
      _imp_str_literal("RET"),   _imp_str_literal("SAHF"),
      _imp_str_literal("LEAVE"), _imp_str_literal("DEC"),
      _imp_str_literal("INC"),   _imp_str_literal("NEG"),
      _imp_str_literal("NOT"),   _imp_str_literal("POP"),
      _imp_str_literal("PUSH"),  _imp_str_literal("LEA"),
      _imp_str_literal("MOV"),   _imp_str_literal("XCHG"),
      _imp_str_literal("ADC"),   _imp_str_literal("ADD"),
      _imp_str_literal("AND"),   _imp_str_literal("CMP"),
      _imp_str_literal("OR"),    _imp_str_literal("SUB"),
      _imp_str_literal("XOR"),   _imp_str_literal("SHL"),
      _imp_str_literal("SHR"),   _imp_str_literal("IDIV"),
      _imp_str_literal("IMUL"),  _imp_str_literal("CALL"),
      _imp_str_literal("JE"),    _imp_str_literal("JNE"),
      _imp_str_literal("JG"),    _imp_str_literal("JGE"),
      _imp_str_literal("JL"),    _imp_str_literal("JLE"),
      _imp_str_literal("JA"),    _imp_str_literal("JAE"),
      _imp_str_literal("JB"),    _imp_str_literal("JBE"),
      _imp_str_literal("JMP")};
  const unsigned char Opvalue[37 /*0:36*/] = {
      0x90, 0x99, 0xC3, 0x9E, 0xC9, 0xFf, 0xFf, 0xF7, 0xF7, 0x8F,
      0xFf, 0x8B, 0x89, 0x87, 0x11, 0x01, 0x21, 0x39, 0x09, 0x29,
      0x31, 0xD1, 0xD1, 0xF7, 0xF7, 0xE8, 0x74, 0x75, 0x7F, 0x7D,
      0x7C, 0x7E, 0x77, 0x73, 0x72, 0x76, 0xEB};
  const unsigned char Op8value[37 /*0:36*/] = {
      0x90, 0x99, 0xC3, 0x9E, 0xC9, 0xFE, 0xFE, 0xF6, 0xF6, 0x8F,
      0xFf, 0x8B, 0x88, 0x86, 0x10, 0x00, 0x20, 0x38, 0x08, 0x28,
      0x30, 0xD0, 0xD0, 0xF6, 0xF6, 0xE8, 0x74, 0x75, 0x7F, 0x7D,
      0x7C, 0x7E, 0x77, 0x73, 0x72, 0x76, 0xEB};
  const int Never = 0;
  const int Eq = 1;
  const int Lt = 2;
  const int Le = 3;
  const int Gt = 4;
  const int Ge = 5;
  const int Ne = 6;
  const int Always = 7;
  const int Tt = 8;
  const int Ff = 9;
  const unsigned char Reverse[10 /*0:9*/] = {0, 1, 4, 5, 2, 3, 6, 7, 8, 9};
  const unsigned char Negated[10 /*0:9*/] = {7, 6, 5, 4, 3, 2, 1, 0, 9, 8};
  const unsigned char Testtoop[10 /*0:9*/] = {36, 26, 30, 31, 28,
                                              29, 27, 36, 27, 26};
  const unsigned char Testtounsignedop[10 /*0:9*/] = {36, 26, 34, 35, 32,
                                                      33, 27, 36, 27, 26};
  int Icodecount = 0;
  int Icodeinst;
  int Showicode = 0;
  typedef struct Varfm {
    _imp_string255 Idname;
    unsigned char Level;
    unsigned char Type;
    unsigned char Form;
    unsigned char Scope;
    unsigned char Dim;
    int Disp;
    int Extdisp;
    int Format;
    int Size;
    int Pbase;
    int Extra;
  } Varfm;
  Varfm Var[1025 /*0:1024*/];
  Varfm *Decvar;
  Varfm Begin;
  typedef struct Stackfm {
    int Varno;
    unsigned char Aform;
    unsigned char Base;
    unsigned char Type;
    unsigned char Form;
    unsigned char Scope;
    unsigned char Dim;
    int Disp;
    int Extdisp;
    int Format;
    int Size;
    int Pbase;
    int Extra;
  } Stackfm;
  Stackfm Stack[16 /*1:16*/];
  Stackfm Null;
  Stackfm *Top;
  typedef struct Labelfm {
    int Id;
    int Tag;
  } Labelfm;
  Labelfm Labels[50 /*1:50*/];
  int Jtag;
  static int Activity[17 /*0:16*/] = {0, 0, 0, 0, 0, -1, -1, 0, 0,
                                      0, 0, 0, 0, 0, 0,  0,  0};
  static int Claimed = 0;
  static int Displayhint[8 /*1:8*/] = {0, 0, 0, 0, 0, 0, 0, 0};
  static int Fpustack = 0;
  typedef struct Gptag {
    int Info;
    int Addr;
    int Flags;
    int Link;
  } Gptag;
  Gptag Gptags[121 /*0:120*/];
  int Gpasl;
  static int Control = Checkbits;
  static int Diagnose = 0;
  static int Languageflags = 0;
  static int Nextcad = 0;
  static int Level = 0;
  int Sym;
  int Pending;
  int Vlb;
  int Vub;
  static int Currentline = 0;
  static int Stp = 0;
  int Datasize;
  int Arrayentrytype;
  static int Frame = 0;
  int Parms;
  static int Invert = 0;
  static int Compareunsign = 0;
  static int Uncondjump = 0;
  static int Blocktype = 1;
  static int Inparams = 0;
  int Otype;
  int Owntype;
  int Ownform;
  int Spec;
  int Potype;
  static int Fpresultloc = -1;
  const int Maxswitch = 1000;
  int Swtab[1001 /*0:1000*/];
  static int Swtp = 0;
  static _imp_string255 Externalid = _imp_str_literal("");
  static _imp_string255 Alias = _imp_str_literal("");
  static _imp_string255 Blockname = _imp_str_literal("");
  unsigned char Currentstring[256 /*0:255*/];
  unsigned char Xsymbuff[256 /*0:255*/];
  int Xlen;
  static int Worklist[16 /*1:16*/] = {0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0};
  double Rvalue;
  static int Ownval = 0;
  _imp_string255 Getownstring(int Flags) {
    _imp_string255 S;
    label Esac;
    static int Sw_sw;
    static void *Sw[16 /*0:15*/] = {
        &&Sw_0,       &&Sw_1,       &&Sw_2,       &&Sw_3,
        &&Sw_4,       &&Sw_5,       &&Sw_6,       &&Sw_7,
        &&Sw_default, &&Sw_default, &&Sw_default, &&Sw_default,
        &&Sw_default, &&Sw_default, &&Sw_default, &&Sw_default,
    };
    goto *Sw[Sw_sw = Flags & 7];
  Sw_0:
    S = _imp_str_literal("auto");
    goto Esac;
  Sw_1:
    S = _imp_str_literal("own");
    goto Esac;
  Sw_2:
    S = _imp_str_literal("constant");
    goto Esac;
  Sw_3:
    S = _imp_str_literal("external");
    goto Esac;
  Sw_4:
    S = _imp_str_literal("system");
    goto Esac;
  Sw_5:
    S = _imp_str_literal("dynamic");
    goto Esac;
  Sw_6:
    S = _imp_str_literal("primitive");
    goto Esac;
  Sw_7:
    S = _imp_str_literal("permanent");
    goto Esac;
  Esac:;
    return (S);
    goto Sw_skip;
  Sw_default:
    fprintf(stderr, "Switch label 'Sw(%d):' not set in %s", Sw_sw,
            __PRETTY_FUNCTION__);
    exit(1) /* or %signal ... */;
  Sw_skip:;
  }
  _imp_string255 Getflagsstring(int Flags) {
    _imp_string255 S;
    S = _imp_str_literal("");
    if ((Flags & 1) != 0) {
      if (*Length(S) > 0) S = _imp_join(S, _imp_str_literal(","));
      S = _imp_join(S, _imp_str_literal("spec"));
    }
    if ((Flags & 2) != 0) {
      if (*Length(S) > 0) S = _imp_join(S, _imp_str_literal(","));
      S = _imp_join(S, _imp_str_literal("indirect"));
    }
    if ((Flags & 4) != 0) {
      if (*Length(S) > 0) S = _imp_join(S, _imp_str_literal(","));
      S = _imp_join(S, _imp_str_literal("check"));
    }
    if ((Flags & 8) != 0) {
      if (*Length(S) > 0) S = _imp_join(S, _imp_str_literal(","));
      S = _imp_join(S, _imp_str_literal("b6flag"));
    }
    if ((Flags & 16) != 0) {
      if (*Length(S) > 0) S = _imp_join(S, _imp_str_literal(","));
      S = _imp_join(S, _imp_str_literal("b7flag"));
    }
    return (S);
  }
  _imp_string255 Gettypedef(int Type, int Size) {
    _imp_string255 S;
    _imp_string255 So;
    label Esac;
    static int Sw_sw;
    static void *Sw[16 /*0:15*/] = {
        &&Sw_0,       &&Sw_1,       &&Sw_2,       &&Sw_3,
        &&Sw_4,       &&Sw_5,       &&Sw_6,       &&Sw_7,
        &&Sw_8,       &&Sw_9,       &&Sw_10,      &&Sw_11,
        &&Sw_default, &&Sw_default, &&Sw_default, &&Sw_default,
    };
    So = Itos(Size, 0);
    S = _imp_str_literal("");
    goto *Sw[Sw_sw = Type & 15];
  Sw_0:;
    S = _imp_str_literal("void");
    goto Esac;
  Sw_1:;
    if (Size == 1)
      S = _imp_str_literal("integer");
    else if (Size == 2)
      S = _imp_str_literal("byte");
    else if (Size == 3)
      S = _imp_str_literal("short");
    else if (Size == 4)
      S = _imp_str_literal("long");
    else if (Size == 5)
      S = _imp_str_literal("quad");
    else
      S = _imp_join(_imp_str_literal("type=1 (integer) has an unknown size="),
                    So);
    goto Esac;
  Sw_2:;
    if (Size == 1)
      S = _imp_str_literal("real");
    else if (Size == 4)
      S = _imp_str_literal("longreal");
    else
      S = _imp_join(_imp_str_literal("type=2 (float) has an unknown size="),
                    So);
    goto Esac;
  Sw_3:;
    if (Size == 0)
      S = _imp_str_literal("string(*)");
    else
      S = _imp_join(_imp_str_literal("string("),
                    _imp_join(So, _imp_str_literal(")")));
    goto Esac;
  Sw_4:;
    if (Size == 0)
      S = _imp_str_literal("record(*)");
    else
      S = _imp_join(_imp_str_literal("record(\""),
                    _imp_join(Var(Size).Idname, _imp_str_literal("\")")));
    goto Esac;
  Sw_5:;
    S = _imp_str_literal("boolean");
    goto Esac;
  Sw_6:;
    S = _imp_str_literal("set");
    goto Esac;
  Sw_7:;
    S = _imp_join(_imp_str_literal("enum8(\""),
                  _imp_join(Var(Size).Idname, _imp_str_literal("\")")));
    goto Esac;
  Sw_8:;
    S = _imp_join(_imp_str_literal("enum16(\""),
                  _imp_join(Var(Size).Idname, _imp_str_literal("\")")));
    goto Esac;
  Sw_9:;
    S = _imp_str_literal("pointer");
    goto Esac;
  Sw_10:;
    S = _imp_str_literal("char");
    goto Esac;
  Sw_11:;
    if (Size == 1)
      S = _imp_str_literal("unsigned");
    else if (Size == 2)
      S = _imp_str_literal("ubyte");
    else if (Size == 3)
      S = _imp_str_literal("ushort");
    else if (Size == 4)
      S = _imp_str_literal("ulong");
    else if (Size == 5)
      S = _imp_str_literal("uquad");
    else
      S = _imp_join(_imp_str_literal("unknown size for type 11="), So);
    goto Esac;
  Sw_default:;
    S = _imp_join(_imp_str_literal("unknown type "), So);
    goto Esac;
  Esac:;
    return (S);
  }
  int Getentrytype(int Type, int Size) {
    label Esac;
    static int Sw_sw;
    static void *Sw[16 /*0:15*/] = {
        &&Sw_default, &&Sw_1,       &&Sw_2,       &&Sw_3,
        &&Sw_4,       &&Sw_default, &&Sw_default, &&Sw_default,
        &&Sw_default, &&Sw_default, &&Sw_default, &&Sw_default,
        &&Sw_default, &&Sw_default, &&Sw_default, &&Sw_default,
    };
    int T;
    T = 0;
    goto *Sw[Sw_sw = Type & 15];
  Sw_1:;
    if (Size == 1)
      T = 1;
    else if (Size == 2)
      T = 5;
    else if (Size == 3)
      T = 1;
    else if (Size == 4)
      T = 1;
    goto Esac;
  Sw_2:;
    if (Size == 1)
      T = 2;
    else if (Size == 4)
      T = 8;
    goto Esac;
  Sw_3:;
    T = 3;
    goto Esac;
  Sw_4:;
    T = 4;
    goto Esac;
  Sw_default:;
    T = 0;
    goto Esac;
  Esac:;
    return (T);
  }
  _imp_string255 Gettypeofstring(int Type) {
    _imp_string255 S;
    label Esac;
    static int Sw_sw;
    static void *Sw[16 /*0:15*/] = {
        &&Sw_0,  &&Sw_1,       &&Sw_2,       &&Sw_3,
        &&Sw_4,  &&Sw_5,       &&Sw_6,       &&Sw_7,
        &&Sw_8,  &&Sw_9,       &&Sw_10,      &&Sw_default,
        &&Sw_12, &&Sw_default, &&Sw_default, &&Sw_default,
    };
    goto *Sw[Sw_sw = Type & 15];
  Sw_0:
    S = _imp_str_literal("void");
    goto Esac;
  Sw_1:
    S = _imp_str_literal("integer");
    goto Esac;
  Sw_2:
    S = _imp_str_literal("real");
    goto Esac;
  Sw_3:
    S = _imp_str_literal("string");
    goto Esac;
  Sw_4:
    S = _imp_str_literal("record");
    goto Esac;
  Sw_5:
    S = _imp_str_literal("byteinteger");
    goto Esac;
  Sw_6:
    S = _imp_str_literal("shortinteger");
    goto Esac;
  Sw_7:
    S = _imp_str_literal("longinteger");
    goto Esac;
  Sw_8:
    S = _imp_str_literal("longreal");
    goto Esac;
  Sw_9:
    S = _imp_str_literal("array");
    goto Esac;
  Sw_10:
    S = _imp_str_literal("label");
    goto Esac;
  Sw_12:
    S = _imp_str_literal("arrayname");
    goto Esac;
  Sw_default:
    S = _imp_str_literal("**type ??**");
    goto Esac;
  Esac:;
    return (S);
  }
  _imp_string255 Gettypename(int Type) {
    _imp_string255 Name;
    label Esac;
    static int N_sw;
    static void *N[16 /*0:15*/] = {
        &&N_0, &&N_1, &&N_2,  &&N_3,  &&N_4,  &&N_5,  &&N_6,  &&N_7,
        &&N_8, &&N_9, &&N_10, &&N_11, &&N_12, &&N_13, &&N_14, &&N_default,
    };
    goto *N[N_sw = Type & 15];
  N_0:
    Name = _imp_str_literal("general");
    goto Esac;
  N_1:
    Name = _imp_str_literal("integer");
    goto Esac;
  N_2:
    Name = _imp_str_literal("real");
    goto Esac;
  N_3:
    Name = _imp_str_literal("string");
    goto Esac;
  N_4:
    Name = _imp_str_literal("record");
    goto Esac;
  N_5:
    Name = _imp_str_literal("byte");
    goto Esac;
  N_6:
    Name = _imp_str_literal("short");
    goto Esac;
  N_7:
    Name = _imp_str_literal("long");
    goto Esac;
  N_8:
    Name = _imp_str_literal("lreal");
    goto Esac;
  N_9:
    Name = _imp_str_literal("array");
    goto Esac;
  N_10:
    Name = _imp_str_literal("label");
    goto Esac;
  N_11:
    Name = _imp_str_literal("?array");
    goto Esac;
  N_12:
    Name = _imp_str_literal("arrayname");
    goto Esac;
  N_13:
    Name = _imp_str_literal("namearray");
    goto Esac;
  N_14:
    Name = _imp_str_literal("namearrayname");
    goto Esac;
  N_default:
    Name = _imp_str_literal("????");
    goto Esac;
  Esac:;
    return (Name);
  }
  _imp_string255 Getexternalformname(int Form) {
    _imp_string255 Name;
    label Esac;
    static int N_sw;
    static void *N[16 /*0:15*/] = {
        &&N_0, &&N_1, &&N_2,  &&N_3,  &&N_4,  &&N_default, &&N_6,  &&N_7,
        &&N_8, &&N_9, &&N_10, &&N_11, &&N_12, &&N_13,      &&N_14, &&N_default,
    };
    goto *N[N_sw = Form & 15];
  N_0:
    Name = _imp_str_literal("void");
    goto Esac;
  N_1:
    Name = _imp_str_literal("simple");
    goto Esac;
  N_2:
    Name = _imp_str_literal("name");
    goto Esac;
  N_3:
    Name = _imp_str_literal("label");
    goto Esac;
  N_4:
    Name = _imp_str_literal("recordformat");
    goto Esac;
  N_6:
    Name = _imp_str_literal("switch");
    goto Esac;
  N_7:
    Name = _imp_str_literal("routine");
    goto Esac;
  N_8:
    Name = _imp_str_literal("function");
    goto Esac;
  N_9:
    Name = _imp_str_literal("map");
    goto Esac;
  N_10:
    Name = _imp_str_literal("predicate");
    goto Esac;
  N_11:
    Name = _imp_str_literal("array");
    goto Esac;
  N_12:
    Name = _imp_str_literal("arrayname");
    goto Esac;
  N_13:
    Name = _imp_str_literal("namearray");
    goto Esac;
  N_14:
    Name = _imp_str_literal("namearrayname");
    goto Esac;
  N_default:
    Name = _imp_str_literal("????");
    goto Esac;
  Esac:;
    return (Name);
  }
  _imp_string255 Getinternalformname(int Form) {
    _imp_string255 Name;
    label Esac;
    static int N_sw;
    static void *N[16 /*0:15*/] = {
        &&N_0,       &&N_1,       &&N_2,       &&N_3,       &&N_4,  &&N_5,
        &&N_6,       &&N_7,       &&N_8,       &&N_9,       &&N_10, &&N_default,
        &&N_default, &&N_default, &&N_default, &&N_default,
    };
    goto *N[N_sw = Form & 15];
  N_0:
    Name = _imp_str_literal("Constant");
    goto Esac;
  N_1:
    Name = _imp_str_literal("V in R");
    goto Esac;
  N_2:
    Name = _imp_str_literal("A V in R");
    goto Esac;
  N_3:
    Name = _imp_str_literal("A in R");
    goto Esac;
  N_4:
    Name = _imp_str_literal("V in S");
    goto Esac;
  N_5:
    Name = _imp_str_literal("A V in S");
    goto Esac;
  N_6:
    Name = _imp_str_literal("A in S");
    goto Esac;
  N_7:
    Name = _imp_str_literal("V in REC");
    goto Esac;
  N_8:
    Name = _imp_str_literal("A V in REC");
    goto Esac;
  N_9:
    Name = _imp_str_literal("A in REC");
    goto Esac;
  N_10:
    Name = _imp_str_literal("PgmLabel");
    goto Esac;
  N_default:
    Name = _imp_str_literal("????");
    goto Esac;
  Esac:;
    return (Name);
  }
  _imp_string255 Geticodename(int Code) {
    _imp_string255 S;
    label Esac;
    static int C_sw;
    static void *C[256 /*0:255*/] = {
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_10,      &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_33,      &&C_34,
        &&C_35,      &&C_36,      &&C_37,      &&C_38,      &&C_39,
        &&C_40,      &&C_41,      &&C_42,      &&C_43,      &&C_default,
        &&C_45,      &&C_46,      &&C_47,      &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_58,      &&C_59,
        &&C_60,      &&C_61,      &&C_62,      &&C_63,      &&C_64,
        &&C_65,      &&C_66,      &&C_67,      &&C_68,      &&C_69,
        &&C_70,      &&C_71,      &&C_72,      &&C_73,      &&C_74,
        &&C_75,      &&C_76,      &&C_77,      &&C_78,      &&C_79,
        &&C_80,      &&C_81,      &&C_82,      &&C_83,      &&C_84,
        &&C_85,      &&C_86,      &&C_87,      &&C_88,      &&C_89,
        &&C_90,      &&C_91,      &&C_92,      &&C_93,      &&C_94,
        &&C_95,      &&C_default, &&C_97,      &&C_98,      &&C_99,
        &&C_100,     &&C_101,     &&C_102,     &&C_103,     &&C_104,
        &&C_105,     &&C_106,     &&C_107,     &&C_108,     &&C_109,
        &&C_110,     &&C_111,     &&C_112,     &&C_113,     &&C_114,
        &&C_115,     &&C_116,     &&C_117,     &&C_118,     &&C_119,
        &&C_120,     &&C_121,     &&C_122,     &&C_123,     &&C_124,
        &&C_125,     &&C_126,     &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default,
    };
    goto *C[C_sw = Code & 255];
  C_10:
    S = _imp_str_literal("ENDOFFILE");
    goto Esac;
  C_33:
    S = _imp_str_literal("OR");
    goto Esac;
  C_34:
    S = _imp_str_literal("COMPARED");
    goto Esac;
  C_35:
    S = _imp_str_literal("JNE");
    goto Esac;
  C_36:
    S = _imp_str_literal("DEF");
    goto Esac;
  C_37:
    S = _imp_str_literal("XOR");
    goto Esac;
  C_38:
    S = _imp_str_literal("AND");
    goto Esac;
  C_39:
    S = _imp_str_literal("PUSHS");
    goto Esac;
  C_40:
    S = _imp_str_literal("JLE");
    goto Esac;
  C_41:
    S = _imp_str_literal("JGE");
    goto Esac;
  C_42:
    S = _imp_str_literal("MUL");
    goto Esac;
  C_43:
    S = _imp_str_literal("ADD");
    goto Esac;
  C_45:
    S = _imp_str_literal("SUB");
    goto Esac;
  C_46:
    S = _imp_str_literal("CONCAT");
    goto Esac;
  C_47:
    S = _imp_str_literal("QUOT");
    goto Esac;
  C_58:
    S = _imp_str_literal("LOCATE");
    goto Esac;
  C_59:
    S = _imp_str_literal("END");
    goto Esac;
  C_60:
    S = _imp_str_literal("JL");
    goto Esac;
  C_61:
    S = _imp_str_literal("JE");
    goto Esac;
  C_62:
    S = _imp_str_literal("JG");
    goto Esac;
  C_63:
    S = _imp_str_literal("COMPARE");
    goto Esac;
  C_64:
    S = _imp_str_literal("PUSH");
    goto Esac;
  C_65:
    S = _imp_str_literal("INIT");
    goto Esac;
  C_66:
    S = _imp_str_literal("REPEAT");
    goto Esac;
  C_67:
    S = _imp_str_literal("COMPAREA");
    goto Esac;
  C_68:
    S = _imp_str_literal("PUSHR");
    goto Esac;
  C_69:
    S = _imp_str_literal("CALL");
    goto Esac;
  C_70:
    S = _imp_str_literal("GOTO");
    goto Esac;
  C_71:
    S = _imp_str_literal("ALIAS");
    goto Esac;
  C_72:
    S = _imp_str_literal("BEGIN");
    goto Esac;
  C_73:
    S = _imp_str_literal("UNUSED_I");
    goto Esac;
  C_74:
    S = _imp_str_literal("JUMP");
    goto Esac;
  C_75:
    S = _imp_str_literal("FALSE");
    goto Esac;
  C_76:
    S = _imp_str_literal("LABEL");
    goto Esac;
  C_77:
    S = _imp_str_literal("MAP");
    goto Esac;
  C_78:
    S = _imp_str_literal("PUSHI");
    goto Esac;
  C_79:
    S = _imp_str_literal("LINE");
    goto Esac;
  C_80:
    S = _imp_str_literal("PLANT");
    goto Esac;
  C_81:
    S = _imp_str_literal("DIVIDE");
    goto Esac;
  C_82:
    S = _imp_str_literal("RETURN");
    goto Esac;
  C_83:
    S = _imp_str_literal("ASSVAL");
    goto Esac;
  C_84:
    S = _imp_str_literal("TRUE");
    goto Esac;
  C_85:
    S = _imp_str_literal("NEGATE");
    goto Esac;
  C_86:
    S = _imp_str_literal("RESULT");
    goto Esac;
  C_87:
    S = _imp_str_literal("SJUMP");
    goto Esac;
  C_88:
    S = _imp_str_literal("IEXP");
    goto Esac;
  C_89:
    S = _imp_str_literal("UNUSED_Y");
    goto Esac;
  C_90:
    S = _imp_str_literal("ASSREF");
    goto Esac;
  C_91:
    S = _imp_str_literal("LSH");
    goto Esac;
  C_92:
    S = _imp_str_literal("NOT");
    goto Esac;
  C_93:
    S = _imp_str_literal("RSH");
    goto Esac;
  C_94:
    S = _imp_str_literal("SETFORMAT");
    goto Esac;
  C_95:
    S = _imp_str_literal("SLABEL");
    goto Esac;
  C_97:
    S = _imp_str_literal("ACCESS");
    goto Esac;
  C_98:
    S = _imp_str_literal("BOUNDS");
    goto Esac;
  C_99:
    S = _imp_str_literal("UNUSED_c");
    goto Esac;
  C_100:
    S = _imp_str_literal("DIM");
    goto Esac;
  C_101:
    S = _imp_str_literal("EVENT");
    goto Esac;
  C_102:
    S = _imp_str_literal("FOR");
    goto Esac;
  C_103:
    S = _imp_str_literal("UNUSED_g");
    goto Esac;
  C_104:
    S = _imp_str_literal("UNUSED_h");
    goto Esac;
  C_105:
    S = _imp_str_literal("INDEX");
    goto Esac;
  C_106:
    S = _imp_str_literal("JAM");
    goto Esac;
  C_107:
    S = _imp_str_literal("JZ");
    goto Esac;
  C_108:
    S = _imp_str_literal("LANG");
    goto Esac;
  C_109:
    S = _imp_str_literal("MONITOR");
    goto Esac;
  C_110:
    S = _imp_str_literal("SELECT");
    goto Esac;
  C_111:
    S = _imp_str_literal("ON");
    goto Esac;
  C_112:
    S = _imp_str_literal("ASSPAR");
    goto Esac;
  C_113:
    S = _imp_str_literal("SUBA");
    goto Esac;
  C_114:
    S = _imp_str_literal("RESOLVE");
    goto Esac;
  C_115:
    S = _imp_str_literal("STOP");
    goto Esac;
  C_116:
    S = _imp_str_literal("JNZ");
    goto Esac;
  C_117:
    S = _imp_str_literal("ADDA");
    goto Esac;
  C_118:
    S = _imp_str_literal("MOD");
    goto Esac;
  C_119:
    S = _imp_str_literal("MCODE");
    goto Esac;
  C_120:
    S = _imp_str_literal("REXP");
    goto Esac;
  C_121:
    S = _imp_str_literal("DIAG");
    goto Esac;
  C_122:
    S = _imp_str_literal("CONTROL");
    goto Esac;
  C_123:
    S = _imp_str_literal("START");
    goto Esac;
  C_124:
    S = _imp_str_literal("ALT_PSR");
    goto Esac;
  C_125:
    S = _imp_str_literal("FINISH");
    goto Esac;
  C_126:
    S = _imp_str_literal("ALT");
    goto Esac;
  C_default:
    S = _imp_str_literal("ILLEGAL");
    goto Esac;
  Esac:;
    return (S);
  }
  void Listicode(void) {
    Selectoutput(Listout);
    Printstring(_imp_str_literal("icode("));
    Printstring(Itos(Icodecount, 5));
    Printstring(_imp_str_literal("): "));
    Printstring(Geticodename(Icodeinst));
  }
  void Listicodenoop(void) {
    Listicode();
    Newline();
  }
  const _imp_string255 Regname[8 /*1:8*/] = {
      _imp_str_literal("EAX"), _imp_str_literal("ECX"), _imp_str_literal("EDX"),
      _imp_str_literal("EBX"), _imp_str_literal("ESP"), _imp_str_literal("EBP"),
      _imp_str_literal("ESI"), _imp_str_literal("EDI")};
  const _imp_string255 Reg8name[8 /*17:24*/] = {
      _imp_str_literal("AL"), _imp_str_literal("CL"), _imp_str_literal("DL"),
      _imp_str_literal("BL"), _imp_str_literal("AH"), _imp_str_literal("CH"),
      _imp_str_literal("DH"), _imp_str_literal("BH")};
  const _imp_string255 Relocname[7 /*0:6*/] = {
      _imp_str_literal(""),        _imp_str_literal("DATA"),
      _imp_str_literal("COT"),     _imp_str_literal("BSS"),
      _imp_str_literal("DISPLAY"), _imp_str_literal("EXTERN"),
      _imp_str_literal("SWTAB")};
  _imp_string255 Hexint(int Nn, int Places) {
    const int Base = 16;
    static _imp_string255 Basechar = _imp_str_literal("0123456789ABCDEF");
    _imp_string255 Reversed;
    _imp_string255 Human;
    int N;
    int I;
    Length(Reversed) = 0;
    N = Nn;
    while (N != 0) {
      Length(Reversed) = *Length(Reversed) + 1;
      Charno(Reversed, *Length(Reversed)) = *Charno(Basechar, 1 + (N & 15));
      N = N >> 4;
    }
    if (Places > *Length(Reversed))
      while (*Length(Reversed) < Places) {
        Length(Reversed) = *Length(Reversed) + 1;
        Charno(Reversed, *Length(Reversed)) = '0';
      }
    Length(Human) = 0;
    for (I = *Length(Reversed); I >= 1; I--) {
      Length(Human) = *Length(Human) + 1;
      Charno(Human, *Length(Human)) = *Charno(Reversed, I);
    }
    return (Human);
  }
  void Writenibble(int N) {
    N = N & 0xF;
    if (0 <= N && N <= 9)
      Printsymbol(N + '0');
    else
      Printsymbol(N + ('A' - 10));
  }
  void Writehex(int N, int Places) {
    int P;
    int Shift;
    Shift = (Places - 1) * 4;
    while (Shift > 0) {
      P = N >> Shift;
      Writenibble(P);
      Shift = Shift - 4;
    }
    Writenibble(N);
  }
  void Show(Stackfm V) {
    Write(V.Varno, 4);
    Printstring(_imp_str_literal(" : Typ="));
    Write(V.Type, 1);
    Printstring(_imp_str_literal(" Frm="));
    Write(V.Form, 1);
    Printstring(_imp_str_literal(" Bse="));
    Write(V.Base, 3);
    Printstring(_imp_str_literal(" Dsp="));
    Write(V.Disp, 5);
    Printstring(_imp_str_literal(" ExtDsp="));
    Write(V.Extdisp, 4);
    Printstring(_imp_str_literal(" Siz="));
    Write(V.Size, 3);
    Printstring(_imp_str_literal(" Xtr="));
    Write(V.Extra, 3);
    Printstring(_imp_str_literal(" Fmt="));
    Write(V.Format, 2);
    Printstring(_imp_str_literal(" Dim="));
    Write(V.Dim, 1);
    Printstring(_imp_str_literal(" Pba="));
    Write(V.Pbase, 4);
    if (*Length(Var(V.Varno).Idname) != 0)
      Printstring(
          _imp_join(_imp_str_literal(" Name='"),
                    _imp_join(Var(V.Varno).Idname, _imp_str_literal("'"))));
    Newline();
  }
  void Dumptagvar(int Tag, _imp_string255 Prefix) {
    Varfm *V;
    V = &Var(Tag);
    Printstring(_imp_str_literal(" VAR entry"));
    Newline();
    Printstring(_imp_join(
        _imp_str_literal(" "),
        _imp_join(Prefix,
                  _imp_join(_imp_str_literal("     tag="), Itos(Tag, 0)))));
    Newline();
    Printstring(_imp_join(
        _imp_str_literal(" "),
        _imp_join(Prefix,
                  _imp_join(_imp_str_literal("    name="), V->Idname))));
    Newline();
    Printstring(_imp_join(
        _imp_str_literal(" "),
        _imp_join(Prefix,
                  _imp_join(_imp_str_literal("    type="), Itos(V->Type, 0)))));
    Printstring(_imp_join(_imp_str_literal(" "), Gettypename(V->Type)));
    Newline();
    Printstring(_imp_join(
        _imp_str_literal(" "),
        _imp_join(Prefix,
                  _imp_join(_imp_str_literal("    form="), Itos(V->Form, 0)))));
    Printstring(_imp_join(_imp_str_literal(" "), Getexternalformname(V->Form)));
    Newline();
    Printstring(
        _imp_join(_imp_str_literal(" "),
                  _imp_join(Prefix, _imp_join(_imp_str_literal("   level="),
                                              Itos(V->Level, 0)))));
    Newline();
    Printstring(
        _imp_join(_imp_str_literal(" "),
                  _imp_join(Prefix, _imp_join(_imp_str_literal("   scope="),
                                              Itos(V->Scope, 0)))));
    Printstring(_imp_join(_imp_str_literal(" "), Relocname(V->Scope >> 4)));
    Newline();
    Printstring(_imp_join(
        _imp_str_literal(" "),
        _imp_join(Prefix,
                  _imp_join(_imp_str_literal("     dim="), Itos(V->Dim, 0)))));
    Newline();
    Printstring(_imp_join(
        _imp_str_literal(" "),
        _imp_join(Prefix,
                  _imp_join(_imp_str_literal("    disp="), Itos(V->Disp, 0)))));
    Spaces(4);
    Printstring(Hexint(V->Disp, 8));
    Newline();
    Printstring(
        _imp_join(_imp_str_literal(" "),
                  _imp_join(Prefix, _imp_join(_imp_str_literal(" extdisp="),
                                              Itos(V->Extdisp, 0)))));
    Newline();
    Printstring(
        _imp_join(_imp_str_literal(" "),
                  _imp_join(Prefix, _imp_join(_imp_str_literal("  format="),
                                              Itos(V->Format, 0)))));
    Newline();
    Printstring(_imp_join(
        _imp_str_literal(" "),
        _imp_join(Prefix,
                  _imp_join(_imp_str_literal("    size="), Itos(V->Size, 0)))));
    Newline();
    Printstring(
        _imp_join(_imp_str_literal(" "),
                  _imp_join(Prefix, _imp_join(_imp_str_literal("   pbase="),
                                              Itos(V->Pbase, 0)))));
    Newline();
    Printstring(
        _imp_join(_imp_str_literal(" "),
                  _imp_join(Prefix, _imp_join(_imp_str_literal("   extra="),
                                              Itos(V->Extra, 0)))));
    Newline();
    Newline();
  }
  void Abort(_imp_string255 Message) {
    int J;
    Selectoutput(Report);
    Printstring(_imp_str_literal("Pass 2 abandoned at line "));
    Write(Currentline, 0);
    Printstring(_imp_str_literal(" : "));
    Printstring(Message);
    Newline();
    if (Stp != 0) {
      Printstring(_imp_str_literal("STACK:"));
      Newline();
      for (J = 1; J <= Stp; J++) {
        Spaces(11);
        Show(Stack(J));
      }
    }
    _imp_signal(0, -1, 0, _imp_str_literal(""));
  }
  void Warn(int N) {
    _imp_string255 Warning;
    static int W_sw;
    static void *W[8 /*1:8*/] = {
        &&W_1, &&W_2, &&W_3, &&W_4, &&W_5, &&W_6, &&W_7, &&W_8,
    };
    goto *W[W_sw = (N)-1];
  W_1:
    Warning = _imp_str_literal("Division by zero");
    goto At;
  W_2:
    Warning = _imp_str_literal("Illegal FOR");
    goto At;
  W_3:
    Warning = _imp_str_literal("Non-local control variable?");
    goto At;
  W_4:
    Warning = _imp_str_literal("Invalid parameter for READ SYMBOL");
    goto At;
  W_5:
    Warning = _imp_str_literal("String constant too long");
    goto At;
  W_6:
    Warning = _imp_str_literal("No. of shifts outwith 0..31");
    goto At;
  W_7:
    Warning = _imp_str_literal("Illegal constant exponent");
    goto At;
  W_8:
    Warning = _imp_str_literal("Numerical constant too big");
    goto At;
  At:;
    Selectoutput(Report);
    Printstring(_imp_str_literal("*WARNING: line"));
    Write(Currentline, 0);
    Printstring(_imp_str_literal(": "));
    Printstring(Warning);
    Newline();
    Selectoutput(Objout);
  }
  void Monitor(Stackfm V, _imp_string255 Text) {
    Selectoutput(Report);
    Printstring(Text);
    Printsymbol(':');
    Spaces(10 - *Length(Text));
    Show(V);
    Selectoutput(Objout);
  }
  int Getgptag(void) {
    int L;
    if (Gpasl == 0) Abort(_imp_str_literal("GP Tags"));
    L = Gpasl;
    Gpasl = Gptags(L).Link;
    return (L);
  }
  int Retgptag(int Index) {
    int Link;
    Link = Gptags(Index).Link;
    Gptags(Index).Link = Gpasl;
    Gpasl = Index;
    return (Link);
  }
  const int Ifobj = 0;
  const int Ifdata = 1;
  const int Ifconst = 2;
  const int Ifdisplay = 3;
  const int Ifjump = 4;
  const int Ifjcond = 5;
  const int Ifcall = 6;
  const int Iflabel = 7;
  const int Iffixup = 8;
  const int Ifsetfix = 9;
  const int Ifreqext = 10;
  const int Ifreflabel = 11;
  const int Ifrefext = 12;
  const int Ifbss = 13;
  const int Ifcotword = 14;
  const int Ifdatword = 15;
  const int Ifswtword = 16;
  const int Ifsource = 17;
  const int Ifdefextcode = 18;
  const int Ifdefextdata = 19;
  const int Ifswt = 20;
  const int Ifline = 21;
  const int Ifabsext = 22;
  void Writeifrecord(int Type, int Length, unsigned char Buffer) {
    int C1;
    int C2;
    int I;
    Selectoutput(Objout);
    Printsymbol('A' + Type);
    if (Length > 255)
      Abort(_imp_str_literal("Intermediate file record too long"));
    Writenibble(Length >> 4);
    Writenibble(Length & 15);
    I = 0;
    while (Length > 0) {
      C1 = Buffer(I) >> 4;
      C2 = Buffer(I) & 15;
      Writenibble(C1);
      Writenibble(C2);
      I = I + 1;
      Length = Length - 1;
    }
    Newline();
  }
  static int Objectptr = 0;
  const int Objbufmax = 20;
  static unsigned char Objectbytes[21 /*0:20*/];
  static int Listptr = 0;
  const int Lstbufmax = 11;
  static unsigned char Listbytes[12 /*0:11*/];
  void Clearobjectbuffer(void) {
    int I;
    for (I = 0; I <= Objbufmax; I++) Objectbytes(I) = 0;
    Objectptr = 0;
  }
  void Listpreamble(void) {
    int I;
    Selectoutput(Listout);
    Space();
    Writehex(Nextcad, 4);
    Space();
    for (I = 0; I <= 9; I++)
      if (I < Listptr) {
        Writehex(Listbytes(I), 2);
        Space();
      } else
        Spaces(3);
    Spaces(8);
    Nextcad = Nextcad + Listptr;
    Listptr = 0;
  }
  void Flushcode(void) {
    if (Objectptr != 0) {
      Writeifrecord(Ifobj, Objectptr, Objectbytes);
      Clearobjectbuffer();
    }
  }
  void Putcodebyte(int B) {
    Objectbytes(Objectptr) = B;
    Objectptr = Objectptr + 1;
  }
  void Putlistbyte(int B) {
    Listbytes(Listptr) = B;
    Listptr = Listptr + 1;
  }
  void Putbyte(int B) {
    Putlistbyte(B);
    Putcodebyte(B);
  }
  int Issmall(int I) {
    if (-128 < I && I < 128) return (1);
    return (0);
  }
  void Modrmreg(int Reg1, int Reg2) { Putbyte(0xC0 | (Reg1 << 3) | (Reg2)); }
  const int Reltag[7 /*0:6*/] = {0, 1, 2, 13, 3, 22, 20};
  void Norelocateoffset(int Offset) {
    int I;
    for (I = 1; I <= Wordsize; I++) {
      Putbyte(Offset & 255);
      Offset = Offset >> 8;
    }
  }
  void Relocateoffset(int Reloc, int Offset, int Extdisp) {
    int Tag;
    int I;
    if (Reloc == 0)
      Norelocateoffset(Offset);
    else {
      Flushcode();
      Tag = Reltag(Reloc);
      if (Tag == Ifabsext) {
        Putbyte(Offset & 255);
        Offset = Offset >> 8;
        Putbyte(Offset & 255);
        Offset = Offset >> 8;
        Putbyte(Extdisp & 255);
        Extdisp = Extdisp >> 8;
        Putbyte(Extdisp & 255);
        Extdisp = Extdisp >> 8;
        Writeifrecord(Tag, Wordsize, Objectbytes);
        Clearobjectbuffer();
      } else {
        for (I = 1; I <= Wordsize; I++) {
          Putbyte(Offset & 255);
          Offset = Offset >> 8;
        }
        Writeifrecord(Tag, Wordsize, Objectbytes);
        Clearobjectbuffer();
      }
    }
  }
  void Modrmmem(int Reg1, int Base, int Disp, int Extdisp) {
    int Mod;
    int Reloc;
    Reloc = Base >> 4;
    Base = Base & 15;
    if (Base == 0) {
      Putbyte((Reg1 << 3) | 5);
      Relocateoffset(Reloc, Disp, Extdisp);
    } else {
      if ((Disp == 0) && (Base != Bp))
        Mod = 0;
      else if (Issmall(Disp) != 0)
        Mod = 1;
      else
        Mod = 2;
      if (Reloc != 0) Mod = 2;
      if ((Base > Di) || (Base == Sp))
        Abort(_imp_str_literal("Internal address mode error"));
      Putbyte((Mod << 6) | (Reg1 << 3) | (Base - 1));
      if (Mod == 1)
        Putbyte(Disp);
      else if (Mod == 2)
        Relocateoffset(Reloc, Disp, Extdisp);
    }
  }
  void Printmemref(int Base, int Disp) {
    int Reloc;
    Reloc = Base >> 4;
    Base = Base & 15;
    Selectoutput(Listout);
    Printsymbol('[');
    if (Base != 0) {
      Printstring(Regname(Base));
      if (Reloc != 0) {
        Printsymbol('+');
        Printstring(Relocname(Reloc));
      }
      if (Disp != 0) {
        if (Disp > 0) Printsymbol('+');
        Write(Disp, 0);
      }
    } else {
      if (Reloc != 0) {
        Printstring(Relocname(Reloc));
        Printsymbol('+');
      }
      Writehex(Disp, 4);
    }
    Printsymbol(']');
  }
  void Dumpsimple(int Opn) {
    Putbyte(Opvalue(Opn));
    Listpreamble();
    Printstring(Opname(Opn));
    Newline();
    Flushcode();
  }
  void Dumprepmovsb(void) {
    Putbyte(0xF3);
    Putbyte(0xA4);
    Listpreamble();
    Printstring(_imp_str_literal("REP MOVSB"));
    Newline();
    Flushcode();
  }
  void Dumprepstosb(void) {
    Putbyte(0xF3);
    Putbyte(0xAA);
    Listpreamble();
    Printstring(_imp_str_literal("REP STOSB"));
    Newline();
    Flushcode();
  }
  void Dumpur(int Opn, int Reg) {
    static int Ops_sw;
    static void *Ops[20 /*5:24*/] = {
        &&Ops_5,       &&Ops_6,       &&Ops_7,       &&Ops_8,
        &&Ops_9,       &&Ops_10,      &&Ops_default, &&Ops_default,
        &&Ops_default, &&Ops_default, &&Ops_default, &&Ops_default,
        &&Ops_default, &&Ops_default, &&Ops_default, &&Ops_default,
        &&Ops_default, &&Ops_default, &&Ops_23,      &&Ops_24,
    };
    Displayhint(Reg) = 0;
    goto *Ops[Ops_sw = (Opn)-5];
  Ops_5:
    Putbyte(0x48 + Reg - Ax);
    goto Break;
  Ops_6:
    Putbyte(0x40 + Reg - Ax);
    goto Break;
  Ops_7:
    Putbyte(0xF7);
    Modrmreg(3, Reg - Ax);
    goto Break;
  Ops_8:
    Putbyte(0xF7);
    Modrmreg(2, Reg - Ax);
    goto Break;
  Ops_9:
    Putbyte(0x58 + Reg - Ax);
    goto Break;
  Ops_10:
    Putbyte(0x50 + Reg - Ax);
    goto Break;
  Ops_23:
    Putbyte(0xF7);
    Modrmreg(7, Reg - Ax);
    goto Break;
  Ops_24:
    Putbyte(0xF7);
    Modrmreg(5, Reg - Ax);
    goto Break;
  Break:;
    Listpreamble();
    Printstring(Opname(Opn));
    Space();
    Printstring(Regname(Reg));
    Newline();
    Flushcode();
    goto Ops_skip;
  Ops_default:
    fprintf(stderr, "Switch label 'Ops(%d):' not set in %s", Ops_sw + 5,
            __PRETTY_FUNCTION__);
    exit(1) /* or %signal ... */;
  Ops_skip:;
  }
  void Dumpum(int Opn, int Base, int Disp, int Extdisp) {
    static int Ops_sw;
    static void *Ops[32 /*5:36*/] = {
        &&Ops_5,       &&Ops_6,       &&Ops_7,       &&Ops_8,
        &&Ops_9,       &&Ops_10,      &&Ops_default, &&Ops_default,
        &&Ops_default, &&Ops_default, &&Ops_default, &&Ops_default,
        &&Ops_default, &&Ops_default, &&Ops_default, &&Ops_default,
        &&Ops_default, &&Ops_default, &&Ops_23,      &&Ops_24,
        &&Ops_25,      &&Ops_default, &&Ops_default, &&Ops_default,
        &&Ops_default, &&Ops_default, &&Ops_default, &&Ops_default,
        &&Ops_default, &&Ops_default, &&Ops_default, &&Ops_36,
    };
    goto *Ops[Ops_sw = (Opn)-5];
  Ops_5:
    Putbyte(0xFF);
    Modrmmem(1, Base, Disp, Extdisp);
    goto Break;
  Ops_6:
    Putbyte(0xFF);
    Modrmmem(0, Base, Disp, Extdisp);
    goto Break;
  Ops_7:
    Putbyte(0xF7);
    Modrmmem(3, Base, Disp, Extdisp);
    goto Break;
  Ops_8:
    Putbyte(0xF7);
    Modrmmem(2, Base, Disp, Extdisp);
    goto Break;
  Ops_9:
    Putbyte(0x8F);
    Modrmmem(0, Base, Disp, Extdisp);
    goto Break;
  Ops_10:
    Putbyte(0xFF);
    Modrmmem(6, Base, Disp, Extdisp);
    goto Break;
  Ops_23:
    Putbyte(0xF7);
    Modrmmem(7, Base, Disp, Extdisp);
    goto Break;
  Ops_24:
    Putbyte(0xF7);
    Modrmmem(5, Base, Disp, Extdisp);
    goto Break;
  Ops_36:
    Putbyte(0xFF);
    Modrmmem(4, Base, Disp, Extdisp);
    goto Break;
  Ops_25:
    Putbyte(0xFF);
    Modrmmem(2, Base, Disp, Extdisp);
    goto Break;
  Break:;
    Listpreamble();
    Printstring(Opname(Opn));
    Printstring(_imp_str_literal(" WORD "));
    Printmemref(Base, Disp);
    Newline();
    Flushcode();
    goto Ops_skip;
  Ops_default:
    fprintf(stderr, "Switch label 'Ops(%d):' not set in %s", Ops_sw + 5,
            __PRETTY_FUNCTION__);
    exit(1) /* or %signal ... */;
  Ops_skip:;
  }
  void Dumpum8(int Opn, int Base, int Disp, int Extdisp) {
    int Baseop;
    int Index;
    if ((Opn == Dec) || (Opn == Inc)) {
      Baseop = 0xFE;
      if (Opn == Dec)
        Index = 1;
      else
        Index = 0;
    } else if ((Opn == Not) || (Opn == Neg)) {
      Baseop = 0xF6;
      if (Opn == Not)
        Index = 2;
      else
        Index = 3;
    } else
      Abort(_imp_str_literal("Invalid UM8"));
    Putbyte(Baseop);
    Modrmmem(Index, Base, Disp, Extdisp);
    Listpreamble();
    Printstring(Opname(Opn));
    Printstring(_imp_str_literal(" BYTE "));
    Printmemref(Base, Disp);
    Newline();
    Flushcode();
  }
  void Dumpmr(int Opn, int Base, int Disp, int Extdisp, int Reg) {
    if (Opn == Shl) {
      Putbyte(0xD3);
      Modrmmem(4, Base, Disp, Extdisp);
    } else if (Opn == Shr) {
      Putbyte(0xD3);
      Modrmmem(5, Base, Disp, Extdisp);
    } else {
      Putbyte(Opvalue(Opn));
      Modrmmem(Reg - Ax, Base, Disp, Extdisp);
    }
    Listpreamble();
    Printstring(Opname(Opn));
    Space();
    Printmemref(Base, Disp);
    Printsymbol(',');
    Printstring(Regname(Reg));
    Newline();
    Flushcode();
  }
  void Dumpmr8(int Opn, int Base, int Disp, int Extdisp, int Reg) {
    if (Opn == Shl) {
      Putbyte(0xD2);
      Modrmmem(4, Base, Disp, Extdisp);
    } else if (Opn == Shr) {
      Putbyte(0xD2);
      Modrmmem(5, Base, Disp, Extdisp);
    } else {
      Putbyte(Op8value(Opn));
      Modrmmem(Reg - Al, Base, Disp, Extdisp);
    }
    Listpreamble();
    Printstring(Opname(Opn));
    Space();
    Printmemref(Base, Disp);
    Printsymbol(',');
    Printstring(Reg8name(Reg));
    Newline();
    Flushcode();
  }
  void Dumprm(int Opn, int Reg, int Base, int Disp, int Extdisp) {
    if ((Reg == Ax) && (Opn == Mov) && ((Base & 15) == 0)) {
      Putbyte(0xA1);
      Relocateoffset(Base >> 4, Disp, Extdisp);
    } else {
      Displayhint(Reg) = 0;
      Putbyte(Opvalue(Opn) + 2);
      Modrmmem(Reg - Ax, Base, Disp, Extdisp);
    }
    Listpreamble();
    Printstring(Opname(Opn));
    Space();
    Printstring(Regname(Reg));
    Printsymbol(',');
    Printmemref(Base, Disp);
    Newline();
    Flushcode();
  }
  void Dumprm8(int Opn, int Reg, int Base, int Disp, int Extdisp) {
    Putbyte(Op8value(Opn) + 2);
    Modrmmem(Reg - Al, Base, Disp, Extdisp);
    Listpreamble();
    Printstring(Opname(Opn));
    Space();
    Printstring(Reg8name(Reg));
    Printsymbol(',');
    Printmemref(Base, Disp);
    Newline();
    Flushcode();
  }
  void Dumprr(int Opn, int Reg1, int Reg2) {
    Displayhint(Reg1) = 0;
    if (Opn == Shl) {
      Putbyte(0xD3);
      Modrmreg(4, Reg1 - Ax);
    } else if (Opn == Shr) {
      Putbyte(0xD3);
      Modrmreg(5, Reg1 - Ax);
    } else {
      Putbyte(Opvalue(Opn));
      Modrmreg(Reg2 - Ax, Reg1 - Ax);
    }
    Listpreamble();
    Printstring(Opname(Opn));
    Space();
    Printstring(Regname(Reg1));
    Printsymbol(',');
    Printstring(Regname(Reg2));
    Newline();
    Flushcode();
  }
  void Dumprr8(int Opn, int Reg1, int Reg2) {
    if (Opn == Shl) {
      Putbyte(0xD2);
      Modrmreg(4, Reg1 - Al);
    } else if (Opn == Shr) {
      Putbyte(0xD2);
      Modrmreg(5, Reg1 - Al);
    } else {
      Putbyte(Op8value(Opn));
      Modrmreg(Reg2 - Al, Reg1 - Al);
    }
    Listpreamble();
    Printstring(Opname(Opn));
    Space();
    Printstring(Reg8name(Reg1));
    Printsymbol(',');
    Printstring(Reg8name(Reg2));
    Newline();
    Flushcode();
  }
  const unsigned char Aximmediatevalue[21 /*0:20*/] = {
      0, 0,    0, 0,    0,    0,    0,    0,    0,    0,   0,
      0, 0xB8, 0, 0x15, 0x05, 0x25, 0x3D, 0x0D, 0x2D, 0x35};
  void Dumprioffset(int Opn, int Reg, int Reloc, int Immed, int Extdisp) {
    int Subop;
    static int Ops_sw;
    static void *Ops[11 /*12:22*/] = {
        &&Ops_12, &&Ops_default, &&Ops_14, &&Ops_15, &&Ops_16, &&Ops_17,
        &&Ops_18, &&Ops_19,      &&Ops_20, &&Ops_21, &&Ops_22,
    };
    Displayhint(Reg) = 0;
    Reloc = Reloc >> 4;
    if ((Reg == Ax) && (Opn <= Xor)) {
      Putbyte(Aximmediatevalue(Opn));
      Relocateoffset(Reloc, Immed, Extdisp);
      goto Break;
    } else
      goto *Ops[Ops_sw = (Opn)-12];
  Ops_12:;
    Putbyte(0xB8 + Reg - Ax);
    Relocateoffset(Reloc, Immed, Extdisp);
    goto Break;
  Ops_15:;
    Subop = 0;
    if ((Issmall(Immed) != 0) && (Reloc == 0)) {
      Putbyte(0x83);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmreg(Subop, Reg - Ax);
      Relocateoffset(Reloc, Immed, Extdisp);
    }
    goto Break;
  Ops_14:;
    Subop = 2;
    if ((Issmall(Immed) != 0) && (Reloc == 0)) {
      Putbyte(0x83);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmreg(Subop, Reg - Ax);
      Relocateoffset(Reloc, Immed, Extdisp);
    }
    goto Break;
  Ops_17:;
    Subop = 7;
    if ((Issmall(Immed) != 0) && (Reloc == 0)) {
      Putbyte(0x83);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmreg(Subop, Reg - Ax);
      Relocateoffset(Reloc, Immed, Extdisp);
    }
    goto Break;
  Ops_19:;
    Subop = 5;
    if ((Issmall(Immed) != 0) && (Reloc == 0)) {
      Putbyte(0x83);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmreg(Subop, Reg - Ax);
      Relocateoffset(Reloc, Immed, Extdisp);
    }
    goto Break;
  Ops_16:;
    Subop = 4;
    Putbyte(0x81);
    Modrmreg(Subop, Reg - Ax);
    Relocateoffset(Reloc, Immed, Extdisp);
    goto Break;
  Ops_18:;
    Subop = 1;
    Putbyte(0x81);
    Modrmreg(Subop, Reg - Ax);
    Relocateoffset(Reloc, Immed, Extdisp);
    goto Break;
  Ops_20:;
    Subop = 6;
    Putbyte(0x81);
    Modrmreg(Subop, Reg - Ax);
    Relocateoffset(Reloc, Immed, Extdisp);
    goto Break;
  Ops_21:;
    Subop = 4;
    if (Immed == 1) {
      Putbyte(0xD1);
      Modrmreg(Subop, Reg - Ax);
    } else {
      Putbyte(0xC1);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed);
    }
    goto Break;
  Ops_22:;
    Subop = 5;
    if (Immed == 1) {
      Putbyte(0xD1);
      Modrmreg(Subop, Reg - Ax);
    } else {
      Putbyte(0xC1);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed);
    }
    goto Break;
  Break:;
    Listpreamble();
    Printstring(Opname(Opn));
    Space();
    Printstring(Regname(Reg));
    Printsymbol(',');
    if (Reloc != 0) {
      Printstring(Relocname(Reloc));
      Printsymbol('+');
    }
    Write(Immed, 0);
    Newline();
    Flushcode();
    goto Ops_skip;
  Ops_default:
    fprintf(stderr, "Switch label 'Ops(%d):' not set in %s", Ops_sw + 12,
            __PRETTY_FUNCTION__);
    exit(1) /* or %signal ... */;
  Ops_skip:;
  }
  void Dumpri(int Opn, int Reg, int Immed) {
    int Subop;
    static int Ops_sw;
    static void *Ops[11 /*12:22*/] = {
        &&Ops_12, &&Ops_default, &&Ops_14, &&Ops_15, &&Ops_16, &&Ops_17,
        &&Ops_18, &&Ops_19,      &&Ops_20, &&Ops_21, &&Ops_22,
    };
    Displayhint(Reg) = 0;
    if ((Reg == Ax) && (Opn <= Xor)) {
      Putbyte(Aximmediatevalue(Opn));
      Norelocateoffset(Immed);
      goto Break;
    } else
      goto *Ops[Ops_sw = (Opn)-12];
  Ops_12:;
    Putbyte(0xB8 + Reg - Ax);
    Norelocateoffset(Immed);
    goto Break;
  Ops_15:;
    Subop = 0;
    if (Issmall(Immed) != 0) {
      Putbyte(0x83);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmreg(Subop, Reg - Ax);
      Norelocateoffset(Immed);
    }
    goto Break;
  Ops_14:;
    Subop = 2;
    if (Issmall(Immed) != 0) {
      Putbyte(0x83);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmreg(Subop, Reg - Ax);
      Norelocateoffset(Immed);
    }
    goto Break;
  Ops_17:;
    Subop = 7;
    if (Issmall(Immed) != 0) {
      Putbyte(0x83);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmreg(Subop, Reg - Ax);
      Norelocateoffset(Immed);
    }
    goto Break;
  Ops_19:;
    Subop = 5;
    if (Issmall(Immed) != 0) {
      Putbyte(0x83);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmreg(Subop, Reg - Ax);
      Norelocateoffset(Immed);
    }
    goto Break;
  Ops_16:;
    Subop = 4;
    Putbyte(0x81);
    Modrmreg(Subop, Reg - Ax);
    Norelocateoffset(Immed);
    goto Break;
  Ops_18:;
    Subop = 1;
    Putbyte(0x81);
    Modrmreg(Subop, Reg - Ax);
    Norelocateoffset(Immed);
    goto Break;
  Ops_20:;
    Subop = 6;
    Putbyte(0x81);
    Modrmreg(Subop, Reg - Ax);
    Norelocateoffset(Immed);
    goto Break;
  Ops_21:;
    Subop = 4;
    if (Immed == 1) {
      Putbyte(0xD1);
      Modrmreg(Subop, Reg - Ax);
    } else {
      Putbyte(0xC1);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed);
    }
    goto Break;
  Ops_22:;
    Subop = 5;
    if (Immed == 1) {
      Putbyte(0xD1);
      Modrmreg(Subop, Reg - Ax);
    } else {
      Putbyte(0xC1);
      Modrmreg(Subop, Reg - Ax);
      Putbyte(Immed);
    }
    goto Break;
  Break:;
    Listpreamble();
    Printstring(Opname(Opn));
    Space();
    Printstring(Regname(Reg));
    Printsymbol(',');
    Write(Immed, 0);
    Newline();
    Flushcode();
    goto Ops_skip;
  Ops_default:
    fprintf(stderr, "Switch label 'Ops(%d):' not set in %s", Ops_sw + 12,
            __PRETTY_FUNCTION__);
    exit(1) /* or %signal ... */;
  Ops_skip:;
  }
  void Dumpmi(int Opn, int Base, int Disp, int Extdisp, int Immed) {
    int Subop;
    static int Ops_sw;
    static void *Ops[11 /*12:22*/] = {
        &&Ops_12, &&Ops_default, &&Ops_14, &&Ops_15, &&Ops_16, &&Ops_17,
        &&Ops_18, &&Ops_19,      &&Ops_20, &&Ops_21, &&Ops_22,
    };
    goto *Ops[Ops_sw = (Opn)-12];
  Ops_12:;
    Putbyte(0xC7);
    Modrmmem(0, Base, Disp, Extdisp);
    Norelocateoffset(Immed);
    goto Break;
  Ops_15:;
    Subop = 0;
    if (Issmall(Immed) != 0) {
      Putbyte(0x83);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Norelocateoffset(Immed);
    }
    goto Break;
  Ops_14:;
    Subop = 2;
    if (Issmall(Immed) != 0) {
      Putbyte(0x83);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Norelocateoffset(Immed);
    }
    goto Break;
  Ops_17:;
    Subop = 7;
    if (Issmall(Immed) != 0) {
      Putbyte(0x83);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Norelocateoffset(Immed);
    }
    goto Break;
  Ops_19:;
    Subop = 5;
    if (Issmall(Immed) != 0) {
      Putbyte(0x83);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x81);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Norelocateoffset(Immed);
    }
    goto Break;
  Ops_16:;
    Subop = 4;
    Putbyte(0x81);
    Modrmmem(Subop, Base, Disp, Extdisp);
    Norelocateoffset(Immed);
    goto Break;
  Ops_18:;
    Subop = 1;
    Putbyte(0x81);
    Modrmmem(Subop, Base, Disp, Extdisp);
    Norelocateoffset(Immed);
    goto Break;
  Ops_20:;
    Subop = 6;
    Putbyte(0x81);
    Modrmmem(Subop, Base, Disp, Extdisp);
    Norelocateoffset(Immed);
    goto Break;
  Ops_21:;
    Subop = 4;
    if (Immed == 1) {
      Putbyte(0xD1);
      Modrmmem(Subop, Base, Disp, Extdisp);
    } else {
      Putbyte(0xC1);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Putbyte(Immed);
    }
    goto Break;
  Ops_22:;
    Subop = 5;
    if (Immed == 1) {
      Putbyte(0xD1);
      Modrmmem(Subop, Base, Disp, Extdisp);
    } else {
      Putbyte(0xC1);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Putbyte(Immed);
    }
    goto Break;
  Break:;
    Listpreamble();
    Printstring(Opname(Opn));
    Printstring(_imp_str_literal(" LONG "));
    Printmemref(Base, Disp);
    Printsymbol(',');
    Write(Immed, 0);
    Newline();
    Flushcode();
    goto Ops_skip;
  Ops_default:
    fprintf(stderr, "Switch label 'Ops(%d):' not set in %s", Ops_sw + 12,
            __PRETTY_FUNCTION__);
    exit(1) /* or %signal ... */;
  Ops_skip:;
  }
  void Dumpmi8(int Opn, int Base, int Disp, int Extdisp, int Immed) {
    int Subop;
    static int Ops_sw;
    static void *Ops[11 /*12:22*/] = {
        &&Ops_12, &&Ops_default, &&Ops_14, &&Ops_15, &&Ops_16, &&Ops_17,
        &&Ops_18, &&Ops_19,      &&Ops_20, &&Ops_21, &&Ops_22,
    };
    goto *Ops[Ops_sw = (Opn)-12];
  Ops_12:;
    Subop = 0;
    Putbyte(0xC6);
    Modrmmem(Subop, Base, Disp, Extdisp);
    Putbyte(Immed & 255);
    goto Break;
  Ops_15:;
    Subop = 0;
    Putbyte(0x80);
    Modrmmem(Subop, Base, Disp, Extdisp);
    Putbyte(Immed & 255);
    goto Break;
  Ops_14:;
    Subop = 2;
    Putbyte(0x80);
    Modrmmem(Subop, Base, Disp, Extdisp);
    Putbyte(Immed & 255);
    goto Break;
  Ops_17:;
    Subop = 7;
    Putbyte(0x80);
    Modrmmem(Subop, Base, Disp, Extdisp);
    Putbyte(Immed & 255);
    goto Break;
  Ops_19:;
    Subop = 5;
    Putbyte(0x80);
    Modrmmem(Subop, Base, Disp, Extdisp);
    Putbyte(Immed & 255);
    goto Break;
  Ops_16:;
    Subop = 4;
    Putbyte(0x80);
    Modrmmem(Subop, Base, Disp, Extdisp);
    Putbyte(Immed & 255);
    goto Break;
  Ops_18:;
    Subop = 1;
    Putbyte(0x80);
    Modrmmem(Subop, Base, Disp, Extdisp);
    Putbyte(Immed & 255);
    goto Break;
  Ops_20:;
    Subop = 6;
    Putbyte(0x80);
    Modrmmem(Subop, Base, Disp, Extdisp);
    Putbyte(Immed & 255);
    goto Break;
  Ops_21:;
    Subop = 4;
    if (Immed == 1) {
      Putbyte(0xD0);
      Modrmmem(Subop, Base, Disp, Extdisp);
    } else {
      Putbyte(0xC0);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Putbyte(Immed);
    }
    goto Break;
  Ops_22:;
    Subop = 5;
    if (Immed == 1) {
      Putbyte(0xD0);
      Modrmmem(Subop, Base, Disp, Extdisp);
    } else {
      Putbyte(0xC0);
      Modrmmem(Subop, Base, Disp, Extdisp);
      Putbyte(Immed);
    }
    goto Break;
  Break:;
    Listpreamble();
    Printstring(Opname(Opn));
    Printstring(_imp_str_literal(" BYTE "));
    Printmemref(Base, Disp);
    Printsymbol(',');
    Write(Immed, 0);
    Newline();
    Flushcode();
    goto Ops_skip;
  Ops_default:
    fprintf(stderr, "Switch label 'Ops(%d):' not set in %s", Ops_sw + 12,
            __PRETTY_FUNCTION__);
    exit(1) /* or %signal ... */;
  Ops_skip:;
  }
  void Dumprv(int Opn, int Reg, Stackfm V) {
    if (V.Form == Vinr)
      Dumprr(Opn, Reg, V.Base);
    else if (V.Form == Vins)
      Dumprm(Opn, Reg, V.Base | V.Scope, V.Disp, V.Extdisp);
    else if (V.Form == Constant)
      Dumprioffset(Opn, Reg, V.Scope, V.Disp, V.Extdisp);
    else
      Abort(_imp_str_literal("Address Mode"));
  }
  void Dumppushi(int Reloc, int Immed, int Extdisp) {
    Reloc = Reloc >> 4;
    if ((Reloc == 0) && (Issmall(Immed) != 0)) {
      Putbyte(0x6A);
      Putbyte(Immed & 255);
    } else {
      Putbyte(0x68);
      Relocateoffset(Reloc, Immed, Extdisp);
    }
    Listpreamble();
    Printstring(_imp_str_literal("PUSH"));
    Space();
    if (Reloc != 0) {
      Printstring(Relocname(Reloc));
      Printsymbol('+');
    }
    Write(Immed, 0);
    Newline();
    Flushcode();
  }
  void Dumpvpush(Stackfm V) {
    if (V.Form == Vinr)
      Dumpur(Push, V.Base);
    else if (V.Form == Vins)
      Dumpum(Push, V.Base | V.Scope, V.Disp, V.Extdisp);
    else if (V.Form == Constant)
      Dumppushi(V.Scope, V.Disp, V.Extdisp);
    else
      Abort(_imp_str_literal("Push Mode"));
  }
  const _imp_string255 Flopname[18 /*37:54*/] = {
      _imp_str_literal("FILD"),       _imp_str_literal("FLD DWORD"),
      _imp_str_literal("FLD QWORD"),  _imp_str_literal("FISTP"),
      _imp_str_literal("FSTP DWORD"), _imp_str_literal("FSTP QWORD"),
      _imp_str_literal("FADDP"),      _imp_str_literal("FSUBP"),
      _imp_str_literal("FSUBRP"),     _imp_str_literal("FMULP"),
      _imp_str_literal("FDIVP"),      _imp_str_literal("FDIVRP"),
      _imp_str_literal("FCOMPP"),     _imp_str_literal("FCHS"),
      _imp_str_literal("FABS"),       _imp_str_literal("FSTSW AX"),
      _imp_str_literal("FLDZ"),       _imp_str_literal("FLDPI")};
  const unsigned char Flprefix[18 /*37:54*/] = {
      0xDB, 0xD9, 0xDD, 0xDB, 0xD9, 0xDD, 0xDE, 0xDE, 0xDE,
      0xDE, 0xDE, 0xDE, 0xDE, 0xD9, 0xD9, 0xDF, 0xD9, 0xD9};
  const unsigned char Flindex[18 /*37:54*/] = {
      0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0xC0, 0xE8, 0xE0,
      0xC8, 0xF8, 0xF0, 0xD8, 0xE0, 0xE1, 0xE0, 0xEE, 0xEB};
  void Dumpfloprm(int Opn, int Base, int Disp, int Extdisp) {
    if (Opn <= Fldq) {
      Fpustack = Fpustack + 1;
      if (Fpustack > 8) Abort(_imp_str_literal("FPU Stack Overflow"));
    } else {
      Fpustack = Fpustack - 1;
      if (Fpustack < 0) Abort(_imp_str_literal("FPU Stack Underflow"));
    }
    Putbyte(Flprefix(Opn));
    Modrmmem(Flindex(Opn), Base, Disp, Extdisp);
    Listpreamble();
    Printstring(Flopname(Opn));
    Space();
    Printmemref(Base, Disp);
    Newline();
    Flushcode();
  }
  void Dumpfloprr(int Opn, int Reg1, int Reg2) {
    int Top;
    Top = Fpustack + (Fr0 - 1);
    if (Reg2 != Top) Abort(_imp_str_literal("FPU Stack Address"));
    if (Opn < Fchs) {
      Fpustack = Fpustack - 1;
      if (Opn == Fcmp) Fpustack = Fpustack - 1;
      if (Fpustack < 0) Abort(_imp_str_literal("FPU Stack Underflow"));
    }
    Putbyte(Flprefix(Opn));
    Putbyte(Flindex(Opn) | (Top - Reg1));
    Listpreamble();
    Printstring(Flopname(Opn));
    Space();
    Printstring(_imp_str_literal("ST("));
    Write(Top - Reg1, 0);
    Printstring(_imp_str_literal("),ST"));
    Newline();
    Flushcode();
  }
  void Dumpflopspec(int Opn) {
    if (Opn >= Fldz) {
      Fpustack = Fpustack + 1;
      if (Fpustack > 8) Abort(_imp_str_literal("FPU Stack Overflow"));
    }
    Putbyte(Flprefix(Opn));
    Putbyte(Flindex(Opn));
    Listpreamble();
    Printstring(Flopname(Opn));
    Newline();
    Flushcode();
  }
  void Dumpjump(int Opn, int Labelid) {
    Putbyte(Opvalue(Opn));
    Putbyte(0);
    if (Opn == Call) Putbyte(0);
    Listpreamble();
    Printstring(Opname(Opn));
    Space();
    if (Opn == Call) {
      Printstring(_imp_str_literal("'"));
      if (Top->Varno == 0) {
        Printstring(_imp_str_literal("$L"));
        Write(Labelid, 0);
      } else
        Printstring(Var(Top->Varno).Idname);
      Printstring(_imp_str_literal("' (INTERNAL "));
      Printsymbol('L');
      Write(Labelid, 0);
      Printstring(_imp_str_literal(" )"));
    } else {
      Printsymbol('L');
      Write(Labelid, 0);
    }
    Newline();
    Clearobjectbuffer();
    if (Opn == Jmp) {
      Putcodebyte(Labelid & 255);
      Putcodebyte(Labelid >> 8);
      Writeifrecord(Ifjump, 2, Objectbytes);
      Clearobjectbuffer();
    } else if (Opn == Call) {
      Putcodebyte(0xE8);
      Writeifrecord(Ifobj, 1, Objectbytes);
      Clearobjectbuffer();
      Putcodebyte(Labelid & 255);
      Putcodebyte(Labelid >> 8);
      Putcodebyte(0);
      Putcodebyte(0);
      Writeifrecord(Ifreflabel, 4, Objectbytes);
      Clearobjectbuffer();
    } else {
      Putcodebyte(Opn - Je);
      Putcodebyte(Labelid & 255);
      Putcodebyte(Labelid >> 8);
      Writeifrecord(Ifjcond, 3, Objectbytes);
      Clearobjectbuffer();
    }
    if (Opn == Call) {
      Displayhint(Bx) = 0;
      Displayhint(Si) = 0;
      Displayhint(Di) = 0;
    }
  }
  void Dumpextcall(int Labelid) {
    Displayhint(Bx) = 0;
    Displayhint(Si) = 0;
    Displayhint(Di) = 0;
    Putbyte(Opvalue(Call));
    Flushcode();
    Putbyte(Labelid & 255);
    Putbyte(Labelid >> 8);
    Listpreamble();
    Printstring(_imp_str_literal("CALL "));
    if (Labelid <= Lastperm)
      Printstring(
          _imp_join(_imp_str_literal("'"),
                    _imp_join(Permname(Labelid), _imp_str_literal("'"))));
    else
      Printstring(
          _imp_join(_imp_str_literal("'"),
                    _imp_join(Var(Top->Varno).Idname, _imp_str_literal("'"))));
    Printstring(_imp_str_literal(" (EXTERN "));
    Write(Labelid, 0);
    Printstring(_imp_str_literal(")"));
    Newline();
    Writeifrecord(Ifrefext, Wordsize, Objectbytes);
    Clearobjectbuffer();
  }
  void Dumplabel(int Labelid) {
    Selectoutput(Listout);
    Space();
    Writehex(Nextcad, 4);
    Spaces(22);
    Printsymbol('L');
    Write(Labelid, 0);
    Printstring(_imp_str_literal("  EQU $"));
    Newline();
    Clearobjectbuffer();
    Putcodebyte(Labelid & 255);
    Putcodebyte(Labelid >> 8);
    Writeifrecord(Iflabel, 2, Objectbytes);
    Clearobjectbuffer();
    Displayhint(Bx) = 0;
    Displayhint(Si) = 0;
    Displayhint(Di) = 0;
  }
  void Dumpstaticalloc(int Which, int Level, _imp_string255 Name) {
    int I;
    int Len;
    Putbyte(0xC8);
    Putbyte(0x00);
    Putbyte(0x00);
    Putbyte(Level);
    Listpreamble();
    Printstring(_imp_str_literal("ENTER 0000,"));
    Write(Level, 0);
    Newline();
    Clearobjectbuffer();
    Putcodebyte(Which & 255);
    Putcodebyte(Which >> 8);
    Putcodebyte(Level);
    Len = *Length(Name);
    if (Len > 16) Len = 16;
    for (I = 1; I <= Len; I++) Putcodebyte(*Charno(Name, I));
    Writeifrecord(Iffixup, Len + 3, Objectbytes);
    Clearobjectbuffer();
  }
  void Dumpstaticfill(int Which, int Size, int Events, int Evep, int Evfrom) {
    Clearobjectbuffer();
    Putcodebyte(Which & 255);
    Putcodebyte(Which >> 8);
    Putcodebyte(Size & 255);
    Putcodebyte(Size >> 8);
    Putcodebyte(Events & 255);
    Putcodebyte(Events >> 8);
    Putcodebyte(Evep & 255);
    Putcodebyte(Evep >> 8);
    Putcodebyte(Evfrom & 255);
    Putcodebyte(Evfrom >> 8);
    Writeifrecord(Ifsetfix, 10, Objectbytes);
    Clearobjectbuffer();
  }
  void Dumpcdword(int Word, int Which) {
    int Tag;
    int Tmpcad;
    int Hi;
    int Lo;
    static int Cptr = 0;
    static int Dptr = 0;
    static int Sptr = 0;
    Tmpcad = Nextcad;
    if (Which == 2) {
      Tag = Ifswtword;
      Nextcad = Sptr;
      Sptr = Sptr + 2;
    } else if (Which == 1) {
      Tag = Ifcotword;
      Nextcad = Cptr;
      Cptr = Cptr + 2;
    } else {
      Tag = Ifdatword;
      Nextcad = Dptr;
      Dptr = Dptr + 2;
    }
    Hi = Word >> 8;
    Lo = Word & 255;
    Putbyte(Lo);
    Putbyte(Hi);
    Listpreamble();
    Printstring(_imp_str_literal("db "));
    Writehex(Lo, 2);
    Printsymbol(',');
    Writehex(Hi, 2);
    Printstring(_imp_str_literal(" ; "));
    if (32 < Lo && Lo < 127)
      Printsymbol(Lo);
    else
      Printsymbol('.');
    if (32 < Hi && Hi < 127)
      Printsymbol(Hi);
    else
      Printsymbol('.');
    Newline();
    Writeifrecord(Tag, 2, Objectbytes);
    Clearobjectbuffer();
    Nextcad = Tmpcad;
  }
  void Dumplinenumber(int Line) {
    unsigned char Buffer[2 /*0:1*/];
    Buffer(0) = (Line & 255);
    Buffer(1) = (Line >> 8);
    Writeifrecord(Ifline, 2, Buffer);
  }
  void Strtoxsym(_imp_string255 S) {
    int L;
    L = *Length(S);
    Xlen = 0;
    while (Xlen < L) {
      Xsymbuff(Xlen) = *Charno(S, Xlen + 1);
      Xlen = Xlen + 1;
    }
  }
  void Dumpsourcename(_imp_string255 Filename) {
    Strtoxsym(Filename);
    Writeifrecord(Ifsource, Xlen, Xsymbuff);
  }
  int Externalref(_imp_string255 Extname) {
    static int Nextextref = 1;
    Strtoxsym(Extname);
    Writeifrecord(Ifreqext, Xlen, Xsymbuff);
    Nextextref = Nextextref + 1;
    return (Nextextref - 1);
  }
  void Fillexternal(int Seg, int Offset, _imp_string255 Extname) {
    Strtoxsym(Extname);
    if (Seg == Code)
      Writeifrecord(Ifdefextcode, Xlen, Xsymbuff);
    else {
      Writeifrecord(Ifdefextdata, Xlen, Xsymbuff);
    }
  }
  const int Cotsize = 2000;
  static unsigned char Contable[2001 /*0:2000*/];
  static int Cotp = 0;
  static int Cotoffset = 0;
  void Flushcot(void) {
    int I;
    Selectoutput(Listout);
    Printstring(_imp_str_literal("      _TEXT  ENDS"));
    Newline();
    Printstring(_imp_str_literal("      CONST  SEGMENT WORD PUBLIC 'CONST'"));
    Newline();
    I = 0;
    while (I < Cotp) {
      Dumpcdword((Contable(I + 1) << 8) | Contable(I), 1);
      I = I + 2;
    }
    Cotp = 0;
    Cotoffset = Cotoffset + I;
    Selectoutput(Listout);
    Printstring(_imp_str_literal("      CONST  ENDS"));
    Newline();
    Printstring(_imp_str_literal("      _TEXT  SEGMENT WORD PUBLIC 'CODE'"));
    Newline();
  }
  int Getcotb(unsigned char B) {
    int I;
    I = 0;
    while (I < Cotp) {
      if (Contable(I) == B) return (I + Cotoffset);
      I = I + 1;
    }
    if (Cotp == Cotsize) Flushcot();
    Contable(Cotp) = B;
    Cotp = Cotp + 1;
    return ((Cotp - 1) + Cotoffset);
  }
  int Getcotw(int W) {
    int I;
    int Cw;
    I = 0;
    while (I < Cotp - 3) {
      Cw = 0;
      Cw = Cw | (Contable(I) << 0);
      Cw = Cw | (Contable(I + 1) << 8);
      Cw = Cw | (Contable(I + 2) << 16);
      Cw = Cw | (Contable(I + 3) << 24);
      if (Cw == W) return (I + Cotoffset);
      I = I + Wordsize;
    }
    if (Cotp > Cotsize - Wordsize) Flushcot();
    Cotp = (Cotp + Align) & (~Align);
    for (I = 1; I <= Wordsize; I++) {
      Contable(Cotp) = W & 255;
      W = W >> 8;
      Cotp = Cotp + 1;
    }
    return ((Cotp - Wordsize) + Cotoffset);
  }
  int Getcotdouble(double Double) {
    int I;
    I = 0;
    while (I < Cotp - 7) {
      if ((Contable(I) == *Byteinteger(Addr(Double))) &&
          (Contable(I + 1) == *Byteinteger(Addr(Double) + 1)) &&
          (Contable(I + 2) == *Byteinteger(Addr(Double) + 2)) &&
          (Contable(I + 3) == *Byteinteger(Addr(Double) + 3)) &&
          (Contable(I + 4) == *Byteinteger(Addr(Double) + 4)) &&
          (Contable(I + 5) == *Byteinteger(Addr(Double) + 5)) &&
          (Contable(I + 6) == *Byteinteger(Addr(Double) + 6)) &&
          (Contable(I + 7) == *Byteinteger(Addr(Double) + 7)))
        return (I + Cotoffset);
      I = I + 4;
    }
    if (Cotp > Cotsize - 8) Flushcot();
    Cotp = (Cotp + Align) & (~Align);
    for (I = 0; I <= 7; I++) {
      Contable(Cotp) = *Byteinteger(Addr(Double) + I);
      Cotp = Cotp + 1;
    }
    return ((Cotp - 8) + Cotoffset);
  }
  int Getcot4(int Q0, int Q1, int Q2, int Q3) {
    int I;
    int Cw0;
    int Cw1;
    int Cw2;
    int Cw3;
    I = 0;
    Cw0 = 0;
    Cw0 = Cw0 | (Contable(I + 0) << 0);
    Cw0 = Cw0 | (Contable(I + 1) << 8);
    Cw0 = Cw0 | (Contable(I + 2) << 16);
    Cw0 = Cw0 | (Contable(I + 3) << 24);
    Cw1 = 0;
    Cw1 = Cw1 | (Contable(I + 4) << 0);
    Cw1 = Cw1 | (Contable(I + 5) << 8);
    Cw1 = Cw1 | (Contable(I + 6) << 16);
    Cw1 = Cw1 | (Contable(I + 7) << 24);
    Cw2 = 0;
    Cw2 = Cw2 | (Contable(I + 8) << 0);
    Cw2 = Cw2 | (Contable(I + 9) << 8);
    Cw2 = Cw2 | (Contable(I + 10) << 16);
    Cw2 = Cw2 | (Contable(I + 11) << 24);
    while (I < Cotp - 15) {
      Cw3 = 0;
      Cw3 = Cw3 | (Contable(I + 12) << 0);
      Cw3 = Cw3 | (Contable(I + 13) << 8);
      Cw3 = Cw3 | (Contable(I + 14) << 16);
      Cw3 = Cw3 | (Contable(I + 15) << 24);
      if ((Cw0 == Q0) && (Cw1 == Q1) && (Cw2 == Q2) && (Cw3 == Q3))
        return (I + Cotoffset);
      I = I + Wordsize;
      Cw0 = Cw1;
      Cw1 = Cw2;
      Cw2 = Cw3;
    }
    if (Cotp > Cotsize - 16) Flushcot();
    Cotp = (Cotp + Align) & (~Align);
    for (I = 1; I <= Wordsize; I++) {
      Contable(Cotp) = Q0 & 255;
      Q0 = Q0 >> 8;
      Cotp = Cotp + 1;
    }
    for (I = 1; I <= Wordsize; I++) {
      Contable(Cotp) = Q1 & 255;
      Q1 = Q1 >> 8;
      Cotp = Cotp + 1;
    }
    for (I = 1; I <= Wordsize; I++) {
      Contable(Cotp) = Q2 & 255;
      Q2 = Q2 >> 8;
      Cotp = Cotp + 1;
    }
    for (I = 1; I <= Wordsize; I++) {
      Contable(Cotp) = Q3 & 255;
      Q3 = Q3 >> 8;
      Cotp = Cotp + 1;
    }
    return ((Cotp - 16) + Cotoffset);
  }
  static int Nullstring = -1;
  int Getcots(unsigned char B) {
    int I;
    int First;
    int Slen;
    int Match;
    Slen = B(0);
    if (Slen == 0) {
      Nullstring = Getcotb(0);
      return (Nullstring);
    }
    First = 0;
    while (First + Slen < Cotp) {
      Match = 1;
      if (Slen != Contable(First)) {
        Match = 0;
        break;
      }
      for (I = 1; I <= Slen; I++)
        if (B(I) != Contable(First + I)) {
          Match = 0;
          break;
        }
      if (Match == 1) return (First + Cotoffset);
      First = First + 1;
    }
    if ((Cotp + Slen + 1) >= Cotsize) Flushcot();
    First = Cotp;
    Contable(Cotp) = Slen;
    Cotp = Cotp + 1;
    for (I = 1; I <= Slen; I++) {
      Contable(Cotp) = B(I);
      Cotp = Cotp + 1;
    }
    return (First + Cotoffset);
  }
  const int Datatlimit = 1999;
  unsigned char Datat[2000 /*0:1999*/];
  static int Datatp = 0;
  static int Datatoffset = 0;
  void Flushdata(void) {
    int I;
    int Limit;
    Selectoutput(Listout);
    Printstring(_imp_str_literal("            ENDS"));
    Newline();
    Printstring(_imp_str_literal("      DATA  SEGMENT WORD PUBLIC 'DATA'"));
    Newline();
    I = 0;
    Limit = Datatp - Datatoffset;
    while (I < Limit) {
      Dumpcdword((Datat(I + 1) << 8) | Datat(I), 0);
      I = I + 2;
    }
    Datatoffset = Datatp;
    Selectoutput(Listout);
    Printstring(_imp_str_literal("      DATA    ENDS"));
    Newline();
  }
  void Gbyte(int N) {
    if (Datatp - Datatoffset > Datatlimit) Flushdata();
    Datat(Datatp - Datatoffset) = N & 255;
    Datatp = Datatp + 1;
  }
  void Gput(int N) {
    int I;
    for (I = 1; I <= Wordsize; I++) {
      Gbyte(N);
      N = N >> 8;
    }
  }
  void Gfix(int Align) {
    while ((Datatp & Align) != 0) Gbyte(0);
  }
  void Flushswitch(void) {
    int I;
    Selectoutput(Listout);
    Printstring(_imp_str_literal("              ENDS"));
    Newline();
    Printstring(_imp_str_literal("      _SWTAB  SEGMENT WORD PUBLIC '_SWTAB'"));
    Newline();
    I = 0;
    while (I < Swtp) {
      Dumpcdword(Swtab(I), 2);
      I = I + 1;
    }
    Selectoutput(Listout);
    Printstring(_imp_str_literal("      _SWTAB   ENDS"));
    Newline();
  }
  static int Echoline = 0;
  void Echosourceline(void) {
    int Ch;
    static int Sourceeof = 0;
    Echoline = Echoline + 1;
    if (Sourceeof != 0) return;
    Selectinput(Source);
    Selectoutput(Listout);
    for (;;) {
      Readsymbol(Ch);
      Printsymbol(Ch);
      if ((Ch == 10) || (Ch < 0)) break;
    }
    if (Ch < 0) Sourceeof = 1;
    Selectinput(Icode);
    Selectoutput(Objout);
  }
  int Floating(Stackfm V) {
    if (V.Type == Real) return (1);
    if (V.Type == Lreal) return (1);
    return (0);
  }
  int Zero(Stackfm V) {
    if (V.Disp != 0) return (0);
    if (V.Base != 0) return (0);
    if ((V.Form != Constant) && (V.Form != Avins)) return (0);
    return (1);
  }
  int Const(Stackfm V) {
    if ((V.Form != Constant)) return (0);
    if (V.Type > Byte) return (0);
    return (1);
  }
  int Minrecordsize(Stackfm A, Stackfm B) {
    int N;
    int M;
    N = A.Format;
    if (N != 0) N = Var(N).Size & 0x7FFF;
    M = B.Format;
    if (M != 0) M = Var(M).Size & 0x7FFF;
    if ((N == 0) || ((M != 0) && (M < N))) N = M;
    if (N > 0) return (N);
    Abort(_imp_str_literal("Min Rec Size"));
  }
  int Mulshift(int N) {
    int Shift;
    int Ref;
    Ref = 1;
    for (Shift = 1; Shift <= 14; Shift++) {
      Ref = Ref << 1;
      if (Ref >= N)
        if (Ref == N)
          return (Shift);
        else
          return (-1);
    }
    return (-1);
  }
  int Same(Stackfm V, Stackfm W) {
    if (V.Disp != W.Disp) return (0);
    if (V.Base != W.Base) return (0);
    if (V.Type != W.Type) return (0);
    if (V.Form != W.Form) return (0);
    if (V.Extra != W.Extra) return (0);
    if (V.Scope != W.Scope) return (0);
    return (1);
  }
  int Getwork(int Size) {
    int Cell;
    Cell = Worklist(Level);
    while (Cell != 0) {
      if ((Gptags(Cell).Info == Size) && (Gptags(Cell).Flags == 0)) {
        Gptags(Cell).Flags = 1;
        return (Gptags(Cell).Addr);
      }
      Cell = Gptags(Cell).Link;
    }
    Cell = Getgptag;
    Frame = (Frame - Size) & (~Align);
    Gptags(Cell).Addr = Frame;
    Gptags(Cell).Info = Size;
    Gptags(Cell).Link = Worklist(Level);
    Worklist(Level) = Cell;
    Gptags(Cell).Flags = 1;
    return (Frame);
  }
  void Returnwork(int Addr) {
    int Cell;
    Cell = Worklist(Level);
    while (Cell != 0) {
      if (Gptags(Cell).Addr == Addr) {
        if (Gptags(Cell).Flags == 0) Abort(_imp_str_literal("Return Work"));
        Gptags(Cell).Flags = 0;
        return;
      }
      Cell = Gptags(Cell).Link;
    }
  }
  int Iswork(Stackfm V) {
    int Cell;
    if (V.Base != Bp) return (0);
    if (V.Disp >= 0) return (0);
    if (V.Scope != 0) return (0);
    if (V.Form != Vins) return (0);
    Cell = Worklist(Level);
    while (Cell != 0) {
      if (Gptags(Cell).Addr == V.Disp) {
        if (Gptags(Cell).Flags == 0) Abort(_imp_str_literal("Is Work"));
        if (Gptags(Cell).Info != 256) return (0);
        return (1);
      }
      Cell = Gptags(Cell).Link;
    }
    return (0);
  }
  void Release(int Reg) {
    if (Reg == 0) return;
    if (Reg > Fr7) return;
    if (Activity(Reg) < 0) return;
    Activity(Reg) = Activity(Reg) - 1;
    if (Activity(Reg) < 0) Abort(_imp_str_literal("Release inactive"));
    Claimed = Claimed - 1;
  }
  void Claim(int Reg) {
    if (Reg > Fr7) Abort(_imp_str_literal("Claim bad register"));
    if (Reg == 0) return;
    if (Activity(Reg) < 0) return;
    Activity(Reg) = Activity(Reg) + 1;
    Claimed = Claimed + 1;
  }
  void Hazard(int Reg) {
    int I;
    int N;
    int T;
    int Type;
    void Mod(Stackfm V) {
      static int Sw_sw;
      static void *Sw[10 /*0:9*/] = {
          &&Sw_0, &&Sw_1, &&Sw_default, &&Sw_default, &&Sw_4,
          &&Sw_5, &&Sw_6, &&Sw_7,       &&Sw_8,       &&Sw_9,
      };
      V.Base = Bp;
      N = N - 1;
      goto *Sw[Sw_sw = V.Form];
    Sw_9:;
    Sw_8:;
    Sw_7:;
    Sw_0:;
      Abort(_imp_str_literal("Mod"));
    Sw_4:;
      if ((V.Disp == 0) && (V.Scope == 0)) {
        V.Disp = T;
        V.Form = Ains;
      } else {
        V.Form = V.Form + 3;
        V.Extra = T;
      }
      goto Out1;
    Sw_6:;
    Sw_5:;
      V.Form = V.Form + 3;
      V.Extra = T;
      goto Out1;
    Sw_1:;
      V.Form = Vins;
      V.Disp = T;
      V.Type = Type;
      goto Out1;
    Out1:;
      goto Sw_skip;
    Sw_default:
      fprintf(stderr, "Switch label 'Sw(%d):' not set in %s", Sw_sw,
              __PRETTY_FUNCTION__);
      exit(1) /* or %signal ... */;
    Sw_skip:;
    }
    N = Activity(Reg);
    if (N <= 0) return;
    Claimed = Claimed - N;
    Activity(Reg) = 0;
    if (Reg >= Fr0) {
      if (Reg - Fr0 >= Fpustack) Hazard(Reg + 1);
      Type = Lreal;
      T = Getwork(8);
      Dumpfloprm(Fstq, Bp, T, 0);
    } else {
      Type = Integer;
      T = Getwork(Wordsize);
      Dumpmr(Mov, Bp, T, 0, Reg);
    }
    for (I = 1; I <= Stp; I++)
      if (Stack(I).Base == Reg) Mod(Stack(I));
    if (N != 0) Abort(_imp_str_literal("Usage Outstanding"));
  }
  void Hazardall(void) {
    int J;
    if (Claimed != 0)
      for (J = Ax; J <= Fr7; J++) Hazard(J);
  }
  int Gpreg(void) {
    int R;
    for (R = Ax; R <= Bx; R++)
      if (Activity(R) == 0) return (R);
    for (R = Ax; R <= Bx; R++)
      if (Activity(R) > 0) {
        Hazard(R);
        return (R);
      }
    Abort(_imp_str_literal("Get Reg"));
  }
  int Ptreg(void) {
    const unsigned char Ptpref[3 /*0:2*/] = {7, 8, 4};
    static int Next = 0;
    int R;
    int J;
    for (J = 1; J <= 3; J++) {
      R = Ptpref(Next);
      Next = Next + 1;
      if (Next == 3) Next = 0;
      if (Activity(R) == 0) return (R);
    }
    for (J = 1; J <= 3; J++) {
      R = Ptpref(J);
      if (Activity(R) > 0) {
        Hazard(R);
        return (R);
      }
    }
    Abort(_imp_str_literal("Get PT Reg"));
  }
  int Getdisplay(int L) {
    int R;
    int Lev;
    Lev = L & 15;
    if (Lev == 0) return (L);
    if (Lev == Level) return (Bp);
    if (Displayhint(Bx) == Lev) return (Bx);
    if (Displayhint(Si) == Lev) return (Si);
    if (Displayhint(Di) == Lev) return (Di);
    R = Ptreg;
    Dumprm(Mov, R, Bp, -(Lev * Wordsize), 0);
    Displayhint(R) = Lev;
    return (R);
  }
  int Setdopevector(int Size, int Type) {
    int Entries;
    int Dv;
    int Descriptor;
    Descriptor = (Size << 5) | (Type << 1) | 1;
    Entries = Vub - Vlb + 1;
    Dv = Getcot4(1, Vlb, Vub, Descriptor);
    Vub = Entries * Size;
    Vlb = Vlb * Size;
    return (Dv);
  }
  void Perm(int N, int Space) {
    Hazard(Ax);
    Hazard(Cx);
    Hazard(Dx);
    Hazard(Bx);
    Hazard(Si);
    Hazard(Di);
    Dumpextcall(N);
    if (Space != 0) Dumpri(Add, Sp, Space * Wordsize);
  }
  void Loadperm(int N, int Space) {
    if (Showicode == 1) Listicodenoop();
    Perm(N, Space);
  }
  void Assemble(int Amode, int Labs, int Names) {
    static int C_sw;
    static void *C[95 /*33:127*/] = {
        &&C_33,      &&C_34,      &&C_35,      &&C_36,      &&C_37,
        &&C_38,      &&C_39,      &&C_40,      &&C_41,      &&C_42,
        &&C_43,      &&C_default, &&C_45,      &&C_46,      &&C_47,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
        &&C_58,      &&C_59,      &&C_60,      &&C_61,      &&C_62,
        &&C_63,      &&C_64,      &&C_65,      &&C_66,      &&C_67,
        &&C_68,      &&C_69,      &&C_70,      &&C_71,      &&C_72,
        &&C_73,      &&C_74,      &&C_75,      &&C_76,      &&C_77,
        &&C_78,      &&C_79,      &&C_80,      &&C_81,      &&C_82,
        &&C_83,      &&C_84,      &&C_85,      &&C_86,      &&C_87,
        &&C_88,      &&C_default, &&C_90,      &&C_91,      &&C_92,
        &&C_93,      &&C_94,      &&C_95,      &&C_default, &&C_97,
        &&C_98,      &&C_default, &&C_100,     &&C_101,     &&C_102,
        &&C_103,     &&C_104,     &&C_105,     &&C_106,     &&C_107,
        &&C_108,     &&C_109,     &&C_110,     &&C_111,     &&C_112,
        &&C_113,     &&C_114,     &&C_115,     &&C_116,     &&C_117,
        &&C_118,     &&C_119,     &&C_120,     &&C_121,     &&C_122,
        &&C_123,     &&C_default, &&C_125,     &&C_126,     &&C_default,
    };
    Varfm *V;
    Varfm *Procvar;
    Varfm *Ap;
    Varfm *Fp;
    Stackfm *Lhs;
    Stackfm *Rhs;
    int Maxframe;
    int Firstname;
    int Staticalloc;
    int Skipproc;
    int Lastskip;
    int Events;
    int Evep;
    int Evfrom;
    int Firstlabel;
    int Oldframe;
    int J;
    int T;
    int Dv;
    void Compiletostring(Stackfm V);
    void Loadreg(Stackfm V, int Reg);
    void Storereg(Stackfm V, int Reg);
    void Assign(int Assop);
    void Arrayref(int Mode);
    void Operation(int N);
    void Compare(Stackfm L, Stackfm R);
    void Testzero(Stackfm V);
    int Newtag(void);
    int Readtag(void) {
      int S1;
      int S2;
      S1 = Pending;
      Readsymbol(S2);
      Readsymbol(Pending);
      return (S1 << 8 | S2);
    }
    int Readtagcomma(void) {
      int T;
      T = Readtag;
      Readsymbol(Pending);
      return (T);
    }
    int Readinteger(void) {
      int S1;
      int S2;
      int S3;
      int S4;
      S1 = Pending;
      Readsymbol(S2);
      Readsymbol(S3);
      Readsymbol(S4);
      Readsymbol(Pending);
      return ((S1 << 24) | (S2 << 16) | (S3 << 8) | S4);
    }
    int Readbyte(void) {
      int S1;
      S1 = Pending;
      Readsymbol(Pending);
      return (S1);
    }
    double Readreal(void) {
      int N;
      double P;
      double R;
      N = Readtagcomma;
      R = 0;
      for (;;) {
        Sym = Pending;
        Readsymbol(Pending);
        if (Sym == '.') break;
        N = N - 1;
        if (Sym == '@') goto Power;
        R = R * 10 + (Sym - '0');
        if (N == 0) goto Sign;
      }
      P = 1;
      for (;;) {
        N = N - 1;
        if (N == 0) goto Sign;
        Sym = Pending;
        Readsymbol(Pending);
        if (Sym == '@') goto Power;
        P = P / 10;
        R = R + (Sym - '0') * P;
      }
    Power:;
      N = Readtag;
      if (N != 0)
        if (0 < N && N < 32768)
          while (N > 0) {
            R = R * 10;
            N = N - 1;
          }
        else {
          N = N - 65536;
          while (N < 0) {
            R = R / 10;
            N = N + 1;
          }
        }
    Sign:;
      if (Pending == 'U') {
        Readsymbol(Pending);
        R = -R;
      }
      return (R);
    }
    _imp_string255 Readstring(void) {
      const int Limit = 255;
      int J;
      int Sym;
      _imp_string255 S;
      S = _imp_str_literal("");
      for (J = Pending; J >= 1; J--) {
        Readsymbol(Sym);
        if (*Length(S) < Limit) S = _imp_join(S, Tostring(Sym));
      }
      Readsymbol(Pending);
      return (S);
    }
    _imp_string255 Getascii(int Terminator) {
      _imp_string255 A;
      int Sym;
      A = _imp_str_literal("");
      for (;;) {
        Sym = Pending;
        Readsymbol(Pending);
        if (Sym == Terminator) break;
        if (*Length(A) != 255) A = _imp_join(A, Tostring(Sym));
      }
      return (A);
    }
    void Loadlanguageflags(int Flags) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Flags, 0));
        Newline();
      }
      Languageflags = Flags;
    }
    void Definevar(int Decl, _imp_string255 Internalid, int Tf, int Size,
                   int Scope) {
      int Type;
      int Form;
      int Format;
      int S;
      int New;
      int Round;
      int Dimension;
      int Dv;
      static int Primno = 0;
      int Flags;
      _imp_string255 Sx;
      _imp_string255 Flagstring;
      Type = (Tf >> 4);
      Form = Tf & 15;
      Arrayentrytype = Getentrytype(Type, Size);
      Dimension = (Scope >> 8) & 255;
      Flags = (Scope >> 3) & 31;
      Spec = (Scope >> 3) & 1;
      Otype = Scope & 7;
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Decl, 0));
        Printsymbol(',');
        Printsymbol('"');
        Printstring(Internalid);
        Printsymbol('"');
        Printsymbol(',');
        Printstring(Itos(Tf, 0));
        Printsymbol(',');
        Printstring(Itos(Size, 0));
        Printsymbol(',');
        Printstring(Itos(Scope, 0));
        Spaces(4);
        Sx = _imp_str_literal("");
        Sx = _imp_join(Sx,
                       _imp_join(_imp_str_literal(" "), Getownstring(Otype)));
        Sx = _imp_join(
            Sx, _imp_join(_imp_str_literal(" "), Gettypedef(Type, Size)));
        Sx = _imp_join(
            Sx, _imp_join(_imp_str_literal(" "), Getexternalformname(Form)));
        Flagstring = Getflagsstring(Flags);
        if (*Length(Flagstring) > 0)
          Sx = _imp_join(
              Sx, _imp_join(_imp_str_literal(" ["),
                            _imp_join(Flagstring, _imp_str_literal("]"))));
        Printsymbol('(');
        Printstring(Sx);
        Space();
        Printsymbol(')');
        Newline();
      }
      New = 0;
      Round = Align;
      if (Decl == 0) {
        Parms = Parms - 1;
        if (Parms <= Names) Abort(_imp_str_literal("Def Var Parms"));
        Decvar = &Var(Parms);
        Decvar = 0;
      } else {
        if (Decl >= Parms)
          Abort(_imp_join(
              _imp_str_literal("Def Var Names (decl="),
              _imp_join(Itos(Decl, 0),
                        _imp_join(_imp_str_literal(" parms="),
                                  _imp_join(Itos(Parms, 0),
                                            _imp_str_literal(")"))))));
        Decvar = &Var(Decl);
        if (Decl > Names) {
          Names = Decl;
          New = 1;
          Decvar = 0;
        }
      }
      if ((Type == Integer) && (Size != 1)) {
        if (Size == 2) {
          Type = Byte;
          Round = 0;
        }
        Size = Vsize(Type);
      } else if (Type == Real) {
        if (Size == 4) Type = Lreal;
        Size = Vsize(Type);
      } else if (Type == Record) {
        Format = Size;
        Decvar->Format = Format;
        if (Format <= Names) Size = Var(Format).Size;
      } else if (Type == String) {
        Round = 0;
        Decvar->Size = Size;
        Size = Size + 1;
      } else
        Size = Vsize(Type);
      Var(Decl).Idname = Internalid;
      if (Type != String) Decvar->Size = Size;
      Decvar->Type = Type;
      Decvar->Form = Form;
      if (Otype != 0)
        if (Otype >= External) {
          if (*Length(Alias) != 0)
            Externalid = Alias;
          else if (Otype == System)
            Externalid = _imp_join(Systemprefix, Internalid);
          else
            Externalid = _imp_join(_imp_str_literal("_"), Internalid);
          if (Otype <= Dynamic) Otype = External;
        }
      Alias = _imp_str_literal("");
      Decvar->Extdisp = 0;
      if ((Switch < Form) && (Form < Array)) {
        Blocktype = 1 + Spec;
        if ((Otype != 0) && (Spec != 0)) {
          if (Otype == Primrt) {
            Primno = Primno + 1;
            Decvar->Level = 128;
            Decvar->Disp = Primno;
            return;
          }
          Decvar->Disp = Externalref(Externalid);
          Decvar->Extdisp = Decvar->Disp;
          Decvar->Level = 0;
          Decvar->Scope = Ext;
          return;
        }
        if (Inparams == 0) {
          Potype = Otype;
          if (New != 0) {
            Decvar->Disp = Newtag;
          }
          if (Spec == 0) Blockname = Internalid;
          return;
        }
        Otype = 0;
        Size = Wordsize;
        Datasize = Wordsize;
      } else {
        Datasize = Size;
        if (Form != Simple) {
          Round = Align;
          if (Type == General) {
            Decvar->Extra = Inparams;
            Size = Wordsize * 2;
          } else if ((Form == Array) || (Form == Namearray)) {
            Size = 0;
            if (Form == Namearray) Datasize = Wordsize;
          } else if ((Form == Arrayname) || (Form == Namearrayname)) {
            Decvar->Dim = Dimension;
            Size = Wordsize * 2;
            Round = Align;
          } else {
            Size = Wordsize;
          }
        }
      }
      if (Otype != 0) {
        if (Otype == Con) {
          if ((Type == String) && (Form == Simple)) Datasize = 0;
          if ((Form == Name) || (Form == Arrayname) || (Form == Namearrayname))
            Otype = 0;
        } else
          Gfix(Round);
        Owntype = Type;
        Ownform = Form;
        if (Form == 2) {
          Owntype = Integer;
          Datasize = Wordsize;
        }
        if (Spec == 0) {
          if ((Form == Array) || (Form == Namearray)) {
            Gfix(Align);
            Dv = Setdopevector(Datasize, Arrayentrytype);
            Gfix(Align);
            Decvar->Disp = Datatp - Vlb;
            Decvar->Level = 0;
            Decvar->Scope = Data;
            Decvar->Pbase = Dv;
            Decvar->Dim = 1;
          }
          if (Otype == External) Fillexternal(Data, Decvar->Disp, Externalid);
        } else {
          Decvar->Level = 0;
          Decvar->Scope = Ext;
          Decvar->Disp = Externalref(Externalid);
          Decvar->Extdisp = Decvar->Disp;
        }
      } else if (Form == Label)
        Decvar->Disp = Newtag;
      else if (Form == Switch) {
        Size = Vub - Vlb;
        if (Swtp + Size > Maxswitch)
          Abort(_imp_str_literal("Switch Table Full"));
        Decvar->Scope = Swt;
        Decvar->Disp = Swtp - Vlb;
        Decvar->Extra = Setdopevector(Datasize, Switch);
        for (S = Swtp; S <= Swtp + Size; S++) Swtab(S) = 0;
        Swtp = Swtp + Size + 1;
      } else if (Form == Recordformat)
        if (Inparams != 0)
          if (Decvar->Size > Frame)
            Frame = Decvar->Size;
          else {
            Blocktype = -1;
            Spec = -1;
          }
        else {
          Decvar->Level = Level;
          if (Inparams == 0) {
            Frame = (Frame - Size) & (~Round);
            Decvar->Disp = Frame;
          } else if (Blocktype > 0) {
            Frame = (Frame + Size + Align) & (~Align);
            Decvar->Disp = Frame;
          } else {
            Frame = (Frame + Round) & (~Round);
            Decvar->Disp = Frame;
            Frame = Frame + Size;
            Decvar->Level = 0;
          }
        }
    }
    void Popstack(void) {
      if (Stp == 0) Abort(_imp_str_literal("Pop"));
      if ((Diagnose & 1) != 0) Monitor(*Top, _imp_str_literal("Pop"));
      Stp = Stp - 1;
      if (Stp != 0)
        Top = &Stack(Stp);
      else
        Top = &Null;
    }
    void Poprel(void) {
      Release(Top->Base);
      Popstack();
    }
    const unsigned char Fmap[16 /*0:15*/] = {0, 4, 6, 10, 4, 0, 6, 0,
                                             1, 4, 1, 4,  6, 4, 6, 0};
    void Stackvar(int Varno) {
      Varfm *W;
      if (0 > Varno || Varno > Maxvars)
        Abort(_imp_str_literal("Stack Var Idx"));
      W = &Var(Varno);
      Stp = Stp + 1;
      if (Stp > Maxstack) Abort(_imp_str_literal("Push V Stack Overflow"));
      Top = &Stack(Stp);
      Top = 0;
      if (W->Level != 0)
        if (W->Level == Level)
          Top->Base = Bp;
        else
          Top->Base = W->Level + 16;
      else
        Top->Base = 0;
      Top->Aform = W->Form;
      Top->Form = Fmap(W->Form);
      Top->Dim = W->Dim;
      Top->Type = W->Type;
      Top->Disp = W->Disp;
      Top->Extdisp = W->Disp;
      Top->Scope = W->Scope;
      Top->Format = W->Format;
      Top->Size = W->Size;
      Top->Extra = W->Extra;
      Top->Pbase = W->Pbase;
      Top->Varno = Varno;
      if ((Diagnose & 1) != 0) Monitor(*Top, _imp_str_literal("Var stack"));
    }
    void Loadvar(int Varno) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Varno, 0));
        Printsymbol(',');
        Printsymbol('"');
        Printstring(Var(Varno).Idname);
        Printsymbol('"');
        Newline();
      }
      Stackvar(Varno);
    }
    void Pushcopy(Stackfm V) {
      Stp = Stp + 1;
      if (Stp > Maxstack) Abort(_imp_str_literal("Stack Copy"));
      Top = &Stack(Stp);
      Top = V;
      if ((Diagnose & 1) != 0) Monitor(*Top, _imp_str_literal("Stack Copy"));
    }
    void Pushconst(int N) {
      Stp = Stp + 1;
      if (Stp > Maxstack) Abort(_imp_str_literal("Stack Const"));
      Top = &Stack(Stp);
      Top = 0;
      Top->Disp = N;
      Top->Extdisp = 0;
      Top->Type = Integer;
      Top->Form = Constant;
      if ((Diagnose & 1) != 0) Monitor(*Top, _imp_str_literal("push const"));
    }
    void Loadconst(int N) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(N, 0));
        Newline();
      }
      Pushconst(N);
    }
    void Inputstringvalue(_imp_string255 S) {
      int I;
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printsymbol('"');
        Printstring(S);
        Printsymbol('"');
        Newline();
      }
      Currentstring(0) = *Length(S);
      for (I = 1; I <= *Length(S); I++) Currentstring(I) = *Charno(S, I);
      if ((Pending != 'A') && (Pending != '$')) {
        Otype = Con;
        Pushconst(Getcots(Currentstring));
        Top->Type = String;
        Top->Base = 0;
        Top->Scope = Cot;
        Top->Form = Vins;
        Top->Format = Currentstring(0) + 1;
      } else
        Pushconst(0);
    }
    void Getaliasvalue(_imp_string255 S) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printsymbol('"');
        Printstring(S);
        Printsymbol('"');
        Newline();
      }
      Alias = S;
    }
    void Inputrealvalue(double R) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Print(R, 8);
        Newline();
      }
      if (R == 0)
        Pushconst(0);
      else if (Pending != 'A') {
        Otype = Con;
        Pushconst(0);
        Top->Type = Lreal;
        Top->Scope = Cot;
        Top->Disp = Getcotdouble(R);
        Top->Extdisp = 0;
        Top->Form = Vins;
      }
      Rvalue = R;
    }
    int Newtag(void) {
      static int Freetag = 999;
      Freetag = Freetag + 1;
      return (Freetag);
    }
    int Newlabel(void) {
      Labs = Labs + 1;
      if (Labs > Maxlabs) Abort(_imp_str_literal("Labels"));
      return (Labs);
    }
    int Findlabel(int Label) {
      int Lp;
      Lp = Labs;
      while (Lp != Firstlabel) {
        if (Labels(Lp).Id == Label) return (Lp);
        Lp = Lp - 1;
      }
      return (0);
    }
    void Definelabel(int Label) {
      int Lp;
      Labelfm *L;
      Lp = Findlabel(Label);
      if (Lp == 0) {
        Lp = Newlabel;
        L = &Labels(Lp);
        L->Id = Label;
        L->Tag = Newtag;
      } else {
        L = &Labels(Lp);
        if (((L->Tag & 0x8000) != 0) && (Label > 0)) L->Tag = Newtag;
      }
      Dumplabel(L->Tag);
      L->Tag = L->Tag | 0x8000;
      Uncondjump = 0;
    }
    void Jumpto(int Label, int Op, int Flag) {
      Labelfm *L;
      int Lp;
      Lp = Findlabel(Label);
      if (Lp == 0) {
        Lp = Newlabel;
        L = &Labels(Lp);
        L->Id = Label;
        L->Tag = Newtag;
      } else {
        L = &Labels(Lp);
        if ((Flag != 0) && ((L->Tag & 0x8000) != 0)) L->Tag = Newtag;
      }
      Jtag = L->Tag & 0x7FFF;
      Dumpjump(Op, Jtag);
      if (Op == Jmp) Uncondjump = Nextcad;
    }
    void Jumpforward(int Val, int Test) {
      int Opr;
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printsymbol('L');
        Printstring(Itos(Val, 0));
        Newline();
      }
      if ((Test == Ff) || (Test == Tt)) Dumpri(Cmp, Ax, 0);
      Opr = Testtoop(Test);
      if (Val == 0)
        if (Lastskip != Nextcad) {
          Skipproc = Newtag;
          Dumpjump(Opr, Skipproc);
        } else {
          if (Invert != 0) Test = Reverse(Test);
          Invert = 0;
          if (Compareunsign != 0)
            Opr = Testtounsignedop(Test);
          else
            Opr = Testtoop(Test);
          Compareunsign = 0;
          Jumpto(Val, Opr, 1);
        }
    }
    void Jumpbackward(int Val) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printsymbol('L');
        Printstring(Itos(Val, 0));
        Newline();
      }
      Jumpto(Val, Jmp, 0);
    }
    void Reduce(Stackfm V) {
      int Type;
      int Form;
      int Disp;
      int Scope;
      int Extdisp;
      Form = V.Form - 3;
      Type = V.Type;
      Disp = V.Disp;
      Extdisp = V.Extdisp;
      if (V.Base == Bp) {
        Scope = V.Scope;
        V.Scope = 0;
      } else
        Scope = 0;
      V.Disp = V.Extra;
      V.Type = Integer;
      V.Form = Vins;
      Loadreg(V, Anyp);
      V.Type = Type;
      V.Form = Form;
      V.Disp = Disp;
      V.Extdisp = Extdisp;
      V.Scope = Scope;
    }
    void Amap(Stackfm V) {
      int F;
      const int Addrmap[16 /*0:15*/] = {-1, -2, -3, -4, 5,  -5,  4,   8,
                                        -6, 7,  -7, -8, -9, -10, -11, -12};
      F = Addrmap(V.Form);
      if (F < 0) {
        Monitor(V, _imp_str_literal("AMAP target"));
        Abort(_imp_str_literal("AMAP"));
      }
      if ((V.Disp == 0) && (V.Scope == 0))
        if (F == Avins)
          if (V.Base == 0)
            F = Constant;
          else
            F = Vinr;
        else if ((F == Vinrec) || (F == Avinrec)) {
          if (F == Vinrec)
            F = Ains;
          else
            F = Vins;
          V.Disp = V.Extra;
        }
      V.Type = Integer;
      V.Form = F;
    }
    void Vmap(Stackfm V) {
      int F;
      int T;
      const int Varmap[9 /*0:8*/] = {4, 4, -1, -2, 6, 4, -3, 9, 7};
      if ((V.Form == Ains) || (V.Form == Ainrec)) {
        T = V.Type;
        Amap(V);
        Loadreg(V, Anyp);
        V.Type = T;
        V.Form = Vins;
      }
      F = Varmap(V.Form);
      V.Form = F;
      if (F < 0) Abort(_imp_str_literal("VMap"));
    }
    void Address(Stackfm V) {
      int Type;
      int Form;
      if ((Diagnose & 2) != 0) Monitor(V, _imp_str_literal("ADDRESS"));
      Form = V.Form;
      Type = V.Type;
      if (Form >= Vinrec) {
        Reduce(V);
        Form = V.Form;
      }
      if (V.Base > 16) {
        V.Base = Getdisplay(V.Base - 16);
        Claim(V.Base);
      }
      if ((Form == Vinr) || (Form == Constant)) return;
      if (Form == Avins) {
        if (V.Base == 0)
          V.Form = Constant;
        else if ((V.Disp == 0) && (V.Scope == 0))
          V.Form = Vinr;
        else
          Loadreg(V, Any);
        return;
      }
      if (Form == Vins) return;
      if (Form == Ains) {
        V.Form = Vins;
        V.Type = Integer;
        Loadreg(V, Anyp);
        V.Type = Type;
        V.Form = Vins;
        V.Disp = 0;
      }
    }
    void Loadreg(Stackfm V, int R) {
      static int F_sw;
      static void *F[10 /*0:9*/] = {
          &&F_0, &&F_1, &&F_2, &&F_3, &&F_4, &&F_5, &&F_6, &&F_7, &&F_8, &&F_9,
      };
      int Ptr;
      int Op;
      if ((Diagnose & 2) != 0) Monitor(V, _imp_str_literal("LOAD"));
      if (R == Anyf) {
        Address(V);
        if (V.Type == Byte) Loadreg(V, Any);
        if (V.Form == Vinr) {
          if (V.Base >= Fr0) return;
          V.Disp = Getwork(Wordsize);
          Dumpmr(Mov, Bp, V.Disp, V.Extdisp, V.Base);
          Release(V.Base);
          V.Base = Bp;
          V.Scope = 0;
          V.Form = Vins;
        }
        if (V.Form == Constant) {
          if (V.Disp == 0) {
            R = Fr0 + Fpustack;
            Dumpflopspec(Fldz);
            V.Base = R;
            Claim(R);
            V.Disp = 0;
            V.Form = Vinr;
            V.Type = Real;
            return;
          }
          V.Disp = Getcotw(V.Disp);
          V.Form = Vins;
          V.Base = 0;
          V.Scope = Cot;
        }
        if (V.Type == Integer)
          Op = Fild;
        else if (V.Type == Real)
          Op = Fldd;
        else
          Op = Fldq;
        R = Fr0 + Fpustack;
        Dumpfloprm(Op, V.Base | V.Scope, V.Disp, V.Extdisp);
        Release(V.Base);
        V.Base = R;
        Claim(R);
        V.Disp = 0;
        V.Form = Vinr;
        V.Type = Real;
        return;
      }
      if (V.Type == Byte) {
        if (R == Any) R = Anyg;
        if (R == Anyp) R = Bx;
      }
      if (V.Base > 16) {
        V.Base = Getdisplay(V.Base - 16);
        Claim(V.Base);
      }
      if (R == Any)
        if ((V.Base != 0) && (Activity(V.Base) == 1) &&
            (Displayhint(V.Base) == 0))
          R = V.Base;
        else
          R = Gpreg;
      else if (R == Anyg)
        if ((0 < V.Base && V.Base <= Bx) && (Activity(V.Base) == 1))
          R = V.Base;
        else
          R = Gpreg;
      else if (R == Anyp)
        if ((Activity(V.Base) == 1) &&
            ((V.Base == Bx) || (V.Base == Si) || (V.Base == Di)))
          R = V.Base;
        else
          R = Ptreg;
      else if (V.Base == R)
        if (Activity(R) > 1) {
          Release(R);
          V.Base = 0;
          Hazard(R);
          Claim(R);
          V.Base = R;
        } else
          Hazard(R);
      goto *F[F_sw = V.Form];
    F_7:;
      Reduce(V);
      goto *F[F_sw = V.Form];
    F_8:;
      Reduce(V);
      goto *F[F_sw = V.Form];
    F_9:;
      Reduce(V);
      goto *F[F_sw = V.Form];
    F_2:
      Abort(_imp_str_literal("Unexpected Stack Form"));
    F_3:
      Abort(_imp_str_literal("Unexpected Stack Form"));
    F_0:;
      if ((V.Disp == 0) && (V.Scope == 0))
        Dumprr(Xor, R, R);
      else
        Dumprioffset(Mov, R, V.Scope, V.Disp, V.Extdisp);
      V.Base = R;
      V.Disp = 0;
      V.Scope = 0;
      V.Form = Vinr;
      Claim(R);
      return;
    F_1:;
      if (V.Base == R) return;
      Dumprr(Mov, R, V.Base);
      Release(V.Base);
      V.Base = R;
      V.Disp = 0;
      V.Scope = 0;
      V.Form = Vinr;
      Claim(R);
      return;
    F_6:;
      if ((R == Bx) || (R == Si) || (R == Di))
        Ptr = R;
      else
        Ptr = Ptreg;
      Dumprm(Mov, Ptr, V.Base | V.Scope, V.Disp, V.Extdisp);
      Release(V.Base);
      Claim(Ptr);
      V.Base = Ptr;
      V.Disp = 0;
      V.Scope = 0;
      if (V.Type == Integer)
        Dumprm(Mov, R, V.Base | V.Scope, V.Disp, V.Extdisp);
      else if (V.Type == Byte) {
        if (R != V.Base) Dumprr(Xor, R, R);
        Dumprm8(Mov, R + 16, V.Base | V.Scope, V.Disp, V.Extdisp);
        if (R == V.Base) Dumpri(And, R, 255);
        V.Type = Integer;
      } else
        Abort(_imp_str_literal("Load Real"));
      Release(V.Base);
      V.Base = R;
      V.Disp = 0;
      V.Scope = 0;
      V.Form = Vinr;
      Claim(R);
      return;
    F_4:;
      if (V.Type == Integer)
        Dumprm(Mov, R, V.Base | V.Scope, V.Disp, V.Extdisp);
      else if (V.Type == Byte) {
        if (R != V.Base) Dumprr(Xor, R, R);
        Dumprm8(Mov, R + 16, V.Base | V.Scope, V.Disp, V.Extdisp);
        if (R == V.Base) Dumpri(And, R, 255);
        V.Type = Integer;
      } else
        Abort(_imp_str_literal("Load Real"));
      Release(V.Base);
      V.Base = R;
      V.Disp = 0;
      V.Scope = 0;
      V.Form = Vinr;
      Claim(R);
      return;
    F_5:;
      if (V.Base != 0) {
        Dumprm(Lea, R, V.Base | V.Scope, V.Disp, V.Extdisp);
        Release(V.Base);
        V.Type = Integer;
      } else if ((V.Disp == 0) && (V.Scope == 0))
        Dumprr(Xor, R, R);
      else
        Dumprioffset(Mov, R, V.Scope, V.Disp, V.Extdisp);
      V.Base = R;
      V.Disp = 0;
      V.Scope = 0;
      V.Form = Vinr;
      Claim(R);
      return;
    }
    void Storereg(Stackfm Lhs, int Reg) {
      if (Lhs.Base == Sp)
        if ((Lhs.Type == Integer) || (Lhs.Type == Byte))
          Dumpur(Push, Reg);
        else if (Lhs.Type == Integer)
          Dumpmr(Mov, Lhs.Base | Lhs.Scope, Lhs.Disp, Lhs.Extdisp, Reg);
        else if (Lhs.Type == Byte)
          Dumpmr8(Mov, Lhs.Base | Lhs.Scope, Lhs.Disp, Lhs.Extdisp, Reg + 16);
        else if (Lhs.Type == Record)
          Dumpmr(Mov, Lhs.Base | Lhs.Scope, Lhs.Disp, Lhs.Extdisp, Reg);
    }
    void Operation(int Op) {
      Stackfm *Lhs;
      Stackfm *Rhs;
      int Assignpending;
      int Work;
      int Value;
      int S;
      static int Oper_sw;
      static void *Oper[17 /*1:17*/] = {
          &&Oper_1,  &&Oper_2,  &&Oper_3,  &&Oper_4,  &&Oper_5,  &&Oper_6,
          &&Oper_7,  &&Oper_8,  &&Oper_9,  &&Oper_10, &&Oper_11, &&Oper_12,
          &&Oper_13, &&Oper_14, &&Oper_15, &&Oper_16, &&Oper_17,
      };
      static int Roper_sw;
      static void *Roper[17 /*1:17*/] = {
          &&Roper_1,  &&Roper_2,  &&Roper_3,  &&Roper_4,  &&Roper_default,
          &&Roper_6,  &&Roper_7,  &&Roper_8,  &&Roper_9,  &&Roper_10,
          &&Roper_11, &&Roper_12, &&Roper_13, &&Roper_14, &&Roper_15,
          &&Roper_16, &&Roper_17,
      };
      static int Fold_sw;
      static void *Fold[17 /*1:17*/] = {
          &&Fold_1,  &&Fold_2,  &&Fold_3,  &&Fold_4,  &&Fold_5,  &&Fold_6,
          &&Fold_7,  &&Fold_8,  &&Fold_9,  &&Fold_10, &&Fold_11, &&Fold_12,
          &&Fold_13, &&Fold_14, &&Fold_15, &&Fold_16, &&Fold_17,
      };
      const int Opmap[17 /*1:17*/] = {15, 19, 24, 23, 0, 16, 18, 20, 21,
                                      22, 23, 0,  0,  0, 8,  7,  0};
      const int Flopmap[17 /*1:17*/] = {43, 44, 46, 47, 0,  0, 0,  0, 0,
                                        0,  0,  0,  0,  47, 0, 50, 51};
      const int Indec[3 /*-1:1*/] = {5, 0, 6};
      void Swap(void) {
        Stackfm Temp;
        Temp = *Lhs;
        Lhs = *Rhs;
        Rhs = Temp;
      }
      Assignpending = 0;
      Rhs = Top;
      if (Op < Unaries) {
        Lhs = &Stack(Stp - 1);
        if ((Lhs->Type == Real) || (Lhs->Type == Lreal) || (Op >= Rexpx))
          goto Reals;
      }
      if ((Rhs->Type == Real) || (Rhs->Type == Lreal)) goto Reals;
      if ((Rhs->Form == Constant) &&
          ((Op >= Unaries) || (Lhs->Form == Constant)))
        goto *Fold[Fold_sw = (Op)-1];
      if ((Pending == 'S') || (Pending == 'j'))
        if (Op >= Unaries)
          if (Same(*Top, Stack(Stp - 1)) != 0)
            Assignpending = 1;
          else if (Same(*Lhs, Stack(Stp - 2)) != 0)
            Assignpending = 1;
      goto *Oper[Oper_sw = (Op)-1];
    Oper_15:;
    Oper_16:;
      if (Assignpending != 0) {
        Readsymbol(Pending);
        Address(*Rhs);
        if (Rhs->Type == Byte)
          Dumpum8(Opmap(Op), Rhs->Base | Rhs->Scope, Rhs->Disp, Rhs->Extdisp);
        else
          Dumpum(Opmap(Op), Rhs->Base | Rhs->Scope, Rhs->Disp, Rhs->Extdisp);
        Poprel();
        Poprel();
        return;
      }
      Loadreg(*Rhs, Any);
      Dumpur(Opmap(Op), Rhs->Base);
      return;
    Oper_17:;
      Loadreg(*Rhs, Any);
      Dumpri(Cmp, Rhs->Base, 0);
      Work = Newtag;
      Dumpjump(Jge, Work);
      Dumpur(Neg, Rhs->Base);
      Dumplabel(Work);
      return;
    Oper_1:;
      if (Lhs->Form == Constant) Swap();
    Oper_2:;
      if ((Assignpending != 0) &&
          ((Lhs->Type == Integer) || ((Control & Checkcapacity) == 0) ||
           (Pending == 'j'))) {
        Readsymbol(Pending);
        Address(*Lhs);
        if (Rhs->Form == Constant) {
          Value = Rhs->Disp;
          if (Value != 0) {
            if (Op == Subx) Value = -Value;
            if (-2 < Value && Value < 2)
              if (Lhs->Type == Byte)
                Dumpum8(Indec(Value), Lhs->Base | Lhs->Scope, Lhs->Disp,
                        Lhs->Extdisp);
              else
                Dumpum(Indec(Value), Lhs->Base | Lhs->Scope, Lhs->Disp,
                       Lhs->Extdisp);
            else if (Lhs->Type == Byte)
              Dumpmi8(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp,
                      Lhs->Extdisp, Rhs->Disp);
            else
              Dumpmi(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp, Lhs->Extdisp,
                     Rhs->Disp);
          }
        } else {
          Loadreg(*Rhs, Any);
          if (Lhs->Type == Byte)
            Dumpmr8(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp, Lhs->Extdisp,
                    Rhs->Base + 16);
          else
            Dumpmr(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp, Lhs->Extdisp,
                   Rhs->Base);
        }
        Poprel();
        Poprel();
        Poprel();
        return;
      }
      if (Rhs->Form == Constant) {
        Value = Rhs->Disp;
        if (Op == Subx) Value = -Value;
        if ((Lhs->Form == Avins) || (Lhs->Form == Avinrec))
          Lhs->Disp = Lhs->Disp + Value;
        else {
          Loadreg(*Lhs, Any);
          if (Lhs->Base == Bx) {
            Lhs->Form = Avins;
            Lhs->Disp = Value;
          } else if (-2 < Value && Value < 2)
            if (Value != 0)
              Dumpur(Indec(Value), Lhs->Base);
            else
              Dumpri(Opmap(Op), Lhs->Base, Rhs->Disp);
        }
      } else {
        if ((Op == Addx) && (Rhs->Form == Vinr)) Swap();
        Loadreg(*Lhs, Any);
        if (Rhs->Type == Byte)
          Loadreg(*Rhs, Any);
        else
          Address(*Rhs);
        Dumprv(Opmap(Op), Lhs->Base, *Rhs);
      }
      Poprel();
      return;
    Oper_6:;
    Oper_7:;
    Oper_8:;
      if (Lhs->Form == Constant) Swap();
      if (Assignpending != 0) {
        Readsymbol(Pending);
        Address(*Lhs);
        if (Rhs->Form == Constant) {
          Value = Rhs->Disp;
          if (Lhs->Type == Byte) {
            if ((Rhs->Disp & (~255)) != 0) Warn(8);
            Dumpmi8(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp, Lhs->Extdisp,
                    Rhs->Disp);
          } else
            Dumpmi(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp, Lhs->Extdisp,
                   Rhs->Disp);
        } else {
          Loadreg(*Rhs, Any);
          if (Lhs->Type == Byte)
            Dumpmr8(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp, Lhs->Extdisp,
                    Rhs->Base + 16);
          else
            Dumpmr(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp, Lhs->Extdisp,
                   Rhs->Base);
        }
        Poprel();
        Poprel();
        Poprel();
        return;
      }
      if (Rhs->Form == Constant) {
        Value = Rhs->Disp;
        Loadreg(*Lhs, Any);
        Dumpri(Opmap(Op), Lhs->Base, Value);
      } else {
        if (Rhs->Form == Vinr) Swap();
        Loadreg(*Lhs, Any);
        if ((Rhs->Type == Byte) && (Op == Andx))
          Loadreg(*Rhs, Any);
        else
          Address(*Rhs);
        if (Rhs->Type == Byte)
          Dumprm8(Opmap(Op), Lhs->Base + 16, Rhs->Scope | Rhs->Base, Rhs->Disp,
                  Rhs->Extdisp);
        else
          Dumprv(Opmap(Op), Lhs->Base, *Rhs);
      }
      Poprel();
      return;
    Oper_3:;
      if ((Lhs->Form == Constant) || (Rhs->Base == Ax)) Swap();
      if (Rhs->Form == Constant) {
        Value = Rhs->Disp;
        if (Value == 0) {
          Release(Lhs->Base);
          Lhs = *Rhs;
          Popstack();
          return;
        }
        if (Value == 1) {
          Popstack();
          return;
        }
        S = Mulshift(Value);
        if (S > 0) {
          Rhs->Disp = S;
          Op = Lshx;
          goto Shiftit;
        }
        Rhs->Base = 0;
        Rhs->Scope = Cot;
        Rhs->Disp = Getcotw(Value);
        Rhs->Form = Vins;
      }
    Domul:;
      Loadreg(*Lhs, Ax);
      Address(*Rhs);
      Hazard(Dx);
      if (Rhs->Form == Vinr)
        Dumpur(Imul, Rhs->Base);
      else
        Dumpum(Imul, Rhs->Base | Rhs->Scope, Rhs->Disp, Rhs->Extdisp);
      Poprel();
      return;
    Oper_4:;
    Oper_11:;
      Loadreg(*Lhs, Ax);
      Address(*Rhs);
      Hazard(Dx);
      Dumpsimple(Cwd);
      if (Rhs->Form == Constant) {
        if (Rhs->Disp == 0) Warn(1);
        Rhs->Base = 0;
        Rhs->Scope = Cot;
        Rhs->Disp = Getcotw(Rhs->Disp);
        Rhs->Form = Vins;
      }
      if (Rhs->Form == Vinr)
        Dumpur(Idiv, Rhs->Base);
      else
        Dumpum(Idiv, Rhs->Base | Rhs->Scope, Rhs->Disp, Rhs->Extdisp);
      Poprel();
      if (Op == Divx)
        Lhs->Base = Ax;
      else {
        Lhs->Base = Dx;
        Release(Ax);
        Claim(Dx);
      }
      return;
    Oper_9:;
    Oper_10:;
    Shiftit:;
      if ((Assignpending != 0) &&
          ((Op == Rshx) || (Lhs->Type == Integer) ||
           ((Control & Checkcapacity) == 0) || (Pending == 'j'))) {
        Readsymbol(Pending);
        Address(*Lhs);
        if (Rhs->Form == Constant) {
          if ((0 > Rhs->Disp || Rhs->Disp > 31)) Warn(6);
          if (Rhs->Disp != 0)
            if (Lhs->Type == Byte)
              Dumpmi8(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp,
                      Lhs->Extdisp, Rhs->Disp);
            else
              Dumpmi(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp, Lhs->Extdisp,
                     Rhs->Disp);
        } else {
          if (Rhs->Type == Byte) {
            Hazard(Cx);
            Address(*Rhs);
            Dumprm8(Mov, Cl, Rhs->Scope | Rhs->Base, Rhs->Disp, Rhs->Extdisp);
          } else
            Loadreg(*Rhs, Cx);
          if (Lhs->Type == Byte)
            Dumpmr8(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp, Lhs->Extdisp,
                    Cl);
          else
            Dumpmr(Opmap(Op), Lhs->Base | Lhs->Scope, Lhs->Disp, Lhs->Extdisp,
                   Cx);
        }
        Poprel();
        Poprel();
        Poprel();
        return;
      }
      if (Rhs->Form == Constant) {
        Value = Rhs->Disp;
        if ((0 > Value || Value > 31)) Warn(6);
        if (Value != 0) {
          Loadreg(*Lhs, Any);
          Dumpri(Opmap(Op), Lhs->Base, Value);
        }
      } else {
        if (Rhs->Type == Byte) {
          Hazard(Cx);
          Address(*Rhs);
          Dumprm8(Mov, Cl, Rhs->Scope | Rhs->Base, Rhs->Disp, Rhs->Extdisp);
          Release(Rhs->Base);
          Rhs->Base = Cx;
          Claim(Cx);
        } else
          Loadreg(*Rhs, Cx);
        Loadreg(*Lhs, Any);
        Dumprr(Opmap(Op), Lhs->Base, Cx);
      }
      Poprel();
      return;
    Oper_12:;
      if (Rhs->Form == Constant) {
        if (Rhs->Disp == 0) {
          Poprel();
          Poprel();
          Pushconst(1);
          return;
        }
        if (Rhs->Disp == 1) {
          Poprel();
          return;
        }
        if (Rhs->Disp == 2) {
          Rhs = *Lhs;
          Claim(Rhs->Base);
          goto Domul;
        }
      }
      Loadreg(*Rhs, Any);
      Dumpur(Push, Rhs->Base);
      Poprel();
      Loadreg(*Lhs, Any);
      Dumpur(Push, Lhs->Base);
      Release(Lhs->Base);
      Perm(Iexp, 2);
      Lhs->Base = Ax;
      Claim(Ax);
      Lhs->Form = Vinr;
      return;
    Oper_13:;
    Oper_14:;
      Abort(_imp_str_literal("Oper unexpected op"));
    Fold_16:;
      Value = -Rhs->Disp;
      goto Setunary;
    Fold_15:;
      Value = ~Rhs->Disp;
      goto Setunary;
    Fold_17:;
      Value = Rhs->Disp;
      if (Value < 0) Value = -Value;
      goto Setvalue;
    Fold_1:;
      Value = Lhs->Disp + Rhs->Disp;
      goto Setvalue;
    Fold_2:;
      Value = Lhs->Disp - Rhs->Disp;
      goto Setvalue;
    Fold_7:;
      Value = Lhs->Disp | Rhs->Disp;
      goto Setvalue;
    Fold_6:;
      Value = Lhs->Disp & Rhs->Disp;
      goto Setvalue;
    Fold_8:;
      Value = Lhs->Disp ^ Rhs->Disp;
      goto Setvalue;
    Fold_9:;
      Value = Lhs->Disp << Rhs->Disp;
      goto Setvalue;
    Fold_3:;
      Value = Lhs->Disp * Rhs->Disp;
      goto Setvalue;
    Fold_10:;
      Value = Lhs->Disp >> Rhs->Disp;
      goto Setvalue;
    Fold_12:;
      if (Rhs->Disp < 0) Abort(_imp_str_literal("Fold -ve Exp"));
      Value = 1;
      for (Op = 1; Op <= Rhs->Disp; Op++) Value = Value * Lhs->Disp;
      goto Setvalue;
    Fold_11:;
    Fold_4:;
      Value = Rhs->Disp;
      if (Value == 0) {
        Warn(1);
        Value = 1;
      }
      Value = Lhs->Disp / Value;
      if (Op == Divx) goto Setvalue;
      Value = Lhs->Disp - (Rhs->Disp * Value);
      goto Setvalue;
    Fold_13:;
      Abort(_imp_str_literal("Fold REXPx - Not implemented"));
    Fold_14:;
      Abort(_imp_str_literal("Fold RDIVx - Not implemented"));
    Setvalue:;
      Popstack();
    Setunary:;
      Top->Disp = Value;
      return;
    Fold_5:;
      Abort(_imp_str_literal("Fold CONCx - Not implemented"));
    Oper_5:;
      if (Assignpending != 0) {
        Amap(*Lhs);
        Loadreg(*Lhs, Any);
        Dumpur(Push, Lhs->Base);
        Amap(*Rhs);
        Loadreg(*Rhs, Any);
        Dumpur(Push, Rhs->Base);
        Poprel();
        Poprel();
        Dumppushi(0, Lhs->Size, 0);
        if (Pending == 'S')
          Perm(Sconc, 3);
        else
          Perm(Sjconc, 3);
        Readsymbol(Pending);
        Poprel();
        return;
      }
      if (Iswork(*Lhs) == 0) {
        Work = Getwork(256);
        Pushconst(Work);
        Top->Form = Avins;
        Top->Base = Bp;
        Loadreg(*Top, Any);
        Dumpur(Push, Top->Base);
        Poprel();
        Amap(*Lhs);
        Loadreg(*Lhs, Any);
        Dumpur(Push, Lhs->Base);
        Release(Lhs->Base);
        Dumppushi(0, 255, 0);
        Perm(Smove, 3);
        Lhs = 0;
        Lhs->Type = String;
        Lhs->Form = Vins;
        Lhs->Base = Bp;
        Lhs->Disp = Work;
        Lhs->Size = 255;
      }
      Pushcopy(*Lhs);
      Amap(*Top);
      Loadreg(*Top, Any);
      Dumpur(Push, Top->Base);
      Poprel();
      Amap(*Rhs);
      Loadreg(*Rhs, Any);
      Dumpur(Push, Rhs->Base);
      Poprel();
      Dumppushi(0, Lhs->Size, 0);
      Perm(Sconc, 3);
      return;
    Reals:;
      if (Op < Unaries) Loadreg(*Lhs, Anyf);
      if (Op != Rexpx) Loadreg(*Rhs, Anyf);
      goto *Roper[Roper_sw = (Op)-1];
    Roper_16:;
    Roper_17:;
      Dumpfloprr(Flopmap(Op), Rhs->Base, Rhs->Base);
      return;
    Roper_1:;
    Roper_3:;
      if (Lhs->Base > Rhs->Base) Swap();
      Dumpfloprr(Flopmap(Op), Lhs->Base, Rhs->Base);
      Poprel();
      return;
    Roper_2:;
    Roper_4:;
    Roper_14:;
      Op = Flopmap(Op);
      if (Lhs->Base > Rhs->Base) {
        Swap();
        Op = Op + 1;
      }
      Dumpfloprr(Op, Lhs->Base, Rhs->Base);
      Poprel();
      return;
    Roper_13:;
      Loadreg(*Rhs, Any);
      Dumpur(Push, Rhs->Base);
      Poprel();
      Work = Ptreg;
      Dumpri(Sub, Sp, 8);
      Dumprr(Mov, Work, Sp);
      Dumpfloprm(Fstq, Work, 0, 0);
      Release(Lhs->Base);
      Perm(Fexp, 1 + (8 / Wordsize));
      Lhs->Base = Fr0;
      Claim(Fr0);
      Fpustack = 1;
      Lhs->Form = Vinr;
      Lhs->Type = Lreal;
      return;
    Roper_15:;
      Abort(_imp_str_literal("NOTx: Unsupported Real Operation"));
    Roper_6:;
      Abort(_imp_str_literal("ANDx: Unsupported Real Operation"));
    Roper_7:;
      Abort(_imp_str_literal("ORx: Unsupported Real Operation"));
    Roper_8:;
      Abort(_imp_str_literal("XORx: Unsupported Real Operation"));
    Roper_11:;
      Abort(_imp_str_literal("REMx: Unsupported Real Operation"));
    Roper_9:;
      Abort(_imp_str_literal("LSHx: Unsupported Real Operation"));
    Roper_10:;
      Abort(_imp_str_literal("RSHx: Unsupported Real Operation"));
    Roper_12:;
      Abort(_imp_str_literal("EXPx: Unsupported Real Operation"));
      goto Roper_skip;
    Roper_default:
      fprintf(stderr, "Switch label 'Roper(%d):' not set in %s", Roper_sw + 1,
              __PRETTY_FUNCTION__);
      exit(1) /* or %signal ... */;
    Roper_skip:;
    }
    void Loadoperation(int Op) {
      if (Showicode == 1) Listicodenoop();
      Operation(Op);
    }
    void Store(Stackfm Lhs, Stackfm Rhs) {
      int Pt;
      int S;
      int Op;
      if (Lhs.Base == Sp) {
        if ((Lhs.Type == Integer) || (Lhs.Type == Byte)) {
          if (Rhs.Type == Byte)
            Loadreg(Rhs, Any);
          else
            Address(Rhs);
          Dumpvpush(Rhs);
        } else {
          if (Lhs.Type == Real) {
            S = 4;
            Op = Fstd;
          } else {
            S = 8;
            Op = Fstq;
          }
          Loadreg(Rhs, Anyf);
          Pt = Ptreg;
          Dumpri(Sub, Sp, S);
          Dumprr(Mov, Pt, Sp);
          Dumpfloprm(Op, Pt, 0, 0);
        }
        return;
      }
      if (Lhs.Type == Integer)
        if ((Rhs.Form == Constant) && (Rhs.Scope == 0))
          Dumpmi(Mov, Lhs.Base | Lhs.Scope, Lhs.Disp, Lhs.Extdisp, Rhs.Disp);
        else {
          Loadreg(Rhs, Any);
          Dumpmr(Mov, Lhs.Base | Lhs.Scope, Lhs.Disp, Lhs.Extdisp, Rhs.Base);
        }
      else if (Lhs.Type == Byte)
        if ((Rhs.Form == Constant) && (Rhs.Scope == 0))
          Dumpmi8(Mov, Lhs.Base | Lhs.Scope, Lhs.Disp, Lhs.Extdisp, Rhs.Disp);
        else {
          if (Rhs.Type == Byte) {
            Address(Rhs);
            Pt = Gpreg;
            Dumprm8(Mov, Pt + 16, Rhs.Base | Rhs.Scope, Rhs.Disp, Rhs.Extdisp);
            Release(Rhs.Base);
            Rhs.Base = Pt;
            Rhs.Form = Vinr;
            Rhs.Type = Integer;
            Claim(Pt);
          } else {
            Loadreg(Rhs, Any);
          }
          Dumpmr8(Mov, Lhs.Base | Lhs.Scope, Lhs.Disp, Lhs.Extdisp,
                  Rhs.Base + 16);
        }
      else {
        Loadreg(Rhs, Anyf);
        if (Lhs.Type == Real)
          Op = Fstd;
        else
          Op = Fstq;
        Dumpfloprm(Op, Lhs.Base | Lhs.Scope, Lhs.Disp, Lhs.Extdisp);
      }
    }
    void Assign(int Assop) {
      Stackfm *Lh;
      Stackfm *Rh;
      Stackfm Temp;
      int N;
      int P;
      int Form;
      int R;
      if (Stp < 2) Abort(_imp_str_literal("Assign Stack"));
      Rh = Top;
      Lh = &Stack(Stp - 1);
      Form = Lh->Form;
      if ((Diagnose & 4) != 0) {
        Monitor(*Lh, _imp_str_literal("ASS LH"));
        Monitor(*Rh, _imp_str_literal("ASS RH"));
      }
      if (Same(*Lh, *Rh) != 0) {
        Poprel();
        Poprel();
        return;
      }
      if (Assop < 0) {
        if (Lh->Base >= 128) {
          Temp = *Lh;
          Lh = *Rh;
          Rh = Temp;
          return;
        }
        Lh->Pbase = Lh->Pbase - 1;
        Stackvar(Lh->Pbase);
        Lh = Top;
        Lh->Base = Sp;
        if (Lh->Form != Vins) Assop = 0;
        if (7 <= Lh->Aform && Lh->Aform <= 10) {
          Assop = 1;
          Rh->Type = Integer;
          Lh->Type = Integer;
          Lh->Form = Vins;
          if (Rh->Base != 0)
            Rh->Form = Vins;
          else if (Rh->Scope == Ext)
            Rh->Form = Avins;
          else {
            if (Swtp >= Maxswitch)
              Abort(_imp_str_literal("Proc - Switch Table Full"));
            Swtab(Swtp) = Rh->Disp;
            Rh->Disp = Swtp * Wordsize;
            Swtp = Swtp + 1;
            Rh->Scope = Swt;
            Rh->Form = Vins;
          }
        }
      }
      if (Array <= Rh->Aform && Rh->Aform <= Namearrayname) {
        Amap(*Lh);
        Address(*Lh);
        Amap(*Rh);
        Address(*Rh);
        if ((Rh->Aform == Array) || (Rh->Aform == Namearray)) {
          Temp = 0;
          Temp.Form = Avins;
          Temp.Type = Integer;
          Temp.Disp = Rh->Pbase;
          Temp.Scope = Cot;
        } else {
          Temp = *Rh;
          Claim(Temp.Base);
          Temp.Disp = Temp.Disp + Wordsize;
        }
        Lh->Disp = Lh->Disp + Wordsize;
        Store(*Lh, Temp);
        Release(Temp.Base);
        Lh->Disp = Lh->Disp - Wordsize;
        Store(*Lh, *Rh);
        Poprel();
        Poprel();
        return;
      }
      if (Lh->Type == General) {
        if ((Assop != 0)) Abort(_imp_str_literal("Assign GenName"));
        Amap(*Lh);
        Address(*Lh);
        if (Rh->Type == General) {
          Temp = *Rh;
          Claim(Temp.Base);
          Temp.Disp = Temp.Disp + Wordsize;
          Amap(Temp);
        } else {
          Temp = 0;
          Temp.Type = Integer;
          if (Rh->Type == String)
            Temp.Disp = (Rh->Size + 1) << 4;
          else
            Temp.Disp = (Rh->Size << 4);
          Temp.Disp = Temp.Disp + Genmap(Rh->Type);
          Temp.Disp = (Temp.Disp << 1) + 1;
        }
        Lh->Disp = Lh->Disp + Wordsize;
        Store(*Lh, Temp);
        Release(Temp.Base);
        Lh->Disp = Lh->Disp - Wordsize;
        Amap(*Rh);
        Store(*Lh, *Rh);
        Poprel();
        Poprel();
        return;
      }
      if (Assop == 0) {
        Amap(*Lh);
        Amap(*Rh);
      }
      if (Lh->Type == Record) {
        if (Lh->Base == Sp) {
          N = Lh->Size;
          Hazard(Di);
          Dumpri(Sub, Sp, Lh->Size);
          Dumprr(Mov, Di, Sp);
          Claim(Di);
          Lh->Base = Di;
        } else {
          N = Minrecordsize(*Lh, *Rh);
          Amap(*Lh);
          Loadreg(*Lh, Di);
        }
        Hazard(Cx);
        Dumpri(Mov, Cx, N);
        if (Rh->Form == Constant) {
          Hazard(Ax);
          Dumprr(Xor, Ax, Ax);
          Dumprepstosb();
        } else {
          Amap(*Rh);
          Loadreg(*Rh, Si);
          Dumprepmovsb();
        }
        Poprel();
        Poprel();
        return;
      }
      if (Lh->Type == String) {
        if ((Assop > 0) && (Rh->Format == 1)) {
          Lh->Type = Byte;
          Poprel();
          Pushconst(0);
          Assign(Assop);
          return;
        }
        if (Lh->Base == Sp) {
          P = Lh->Size + 1;
          P = (P + Align) & (~Align);
          Dumpri(Sub, Sp, P);
          R = Gpreg;
          Dumprr(Mov, R, Sp);
          Dumpur(Push, R);
        } else {
          Amap(*Lh);
          Loadreg(*Lh, Any);
          Dumpur(Push, Lh->Base);
        }
        Returnwork(Rh->Disp);
        Amap(*Rh);
        Loadreg(*Rh, Any);
        Dumpur(Push, Rh->Base);
        Poprel();
        Poprel();
        Dumppushi(0, Lh->Size, 0);
        if (Assop == 2)
          Perm(Sjam, 3);
        else
          Perm(Smove, 3);
        return;
      }
      Address(*Lh);
      Store(*Lh, *Rh);
      Poprel();
      Poprel();
    }
    void Loadassign(int Assop) {
      if (Showicode == 1) Listicodenoop();
      Assign(Assop);
    }
    void Arrayref(int Mode) {
      Stackfm *Av;
      int Type;
      int Form;
      int Size;
      int Format;
      if (Mode != 0) {
        if (Top->Type == Byte)
          Loadreg(*Top, Any);
        else
          Address(*Top);
        Dumpvpush(*Top);
        Poprel();
        return;
      }
      Av = &Stack(Stp - 1);
      Size = Av->Size;
      if (Av->Type == String) Size = Size + 1;
      Form = Av->Aform;
      if ((Form == Namearray) || (Form == Namearrayname)) Size = Wordsize;
      if (((Control & Checkarray) == 0) && (Av->Dim == 1))
        if (Size != 1) {
          Pushconst(Size);
          Operation(Mulx);
        } else {
          if (Top->Type == Byte)
            Loadreg(*Top, Any);
          else
            Address(*Top);
          Dumpvpush(*Top);
          Poprel();
        }
      if ((Form == Arrayname) || (Form == Namearrayname)) {
        Type = Av->Type;
        Format = Av->Format;
        Size = Av->Size;
        if (Form == Arrayname)
          Form = Vins;
        else
          Form = Ains;
        Amap(*Av);
        if (((Control & Checkarray) != 0) || (Av->Dim > 1)) {
          Address(*Av);
          Pushcopy(*Av);
          Claim(Top->Base);
          Top->Disp = Top->Disp + Wordsize;
          Dumpvpush(*Top);
          Poprel();
          Perm(Aref, Av->Dim + 1);
          Pushconst(0);
          Top->Form = Vinr;
          Top->Base = Ax;
          Claim(Ax);
        }
        Loadreg(*Top, Anyp);
        Operation(Addx);
        Top->Type = Type;
        Top->Form = Form;
        Top->Format = Format;
        Top->Size = Size;
        Top->Disp = 0;
      } else {
        if ((Control & Checkarray) != 0) {
          Dumppushi(Cot, Av->Pbase, 0);
          Perm(Aref, 2);
          Pushconst(0);
          Top->Form = Vinr;
          Top->Base = Ax;
          Claim(Ax);
        }
        Address(*Av);
        if (Av->Form != Vins) Abort(_imp_str_literal("Aref Form"));
        if (Top->Form == Constant)
          Av->Disp = Av->Disp + Top->Disp;
        else {
          Loadreg(*Top, Anyp);
          if (Av->Base != 0) {
            Dumprr(Add, Top->Base, Av->Base);
            Release(Av->Base);
          }
          Av->Base = Top->Base;
        }
        if (Form == Array)
          Av->Form = Vins;
        else
          Av->Form = Ains;
        Popstack();
      }
      Top->Aform = 0;
    }
    void Loadarrayref(int Mode) {
      if (Showicode == 1) Listicodenoop();
      Arrayref(Mode);
    }
    void Testzero(Stackfm V) {
      if ((V.Type == Integer) || (V.Type == Byte)) {
        Loadreg(V, Any);
        Dumpri(Cmp, V.Base, 0);
      } else
        Abort(_imp_str_literal("Test Zero"));
    }
    void Comparerecords(Stackfm L, Stackfm R, int N) {
      Abort(_imp_str_literal("Compare Records"));
    }
    void Comparereals(Stackfm L, Stackfm R) {
      Loadreg(L, Anyf);
      Loadreg(R, Anyf);
      Hazard(Ax);
      if (L.Base > R.Base)
        Dumpfloprr(Fcmp, R.Base, L.Base);
      else {
        Dumpfloprr(Fcmp, L.Base, R.Base);
        Invert = Invert ^ 1;
      }
      Dumpflopspec(Fstsw);
      Dumpsimple(Sahf);
      Compareunsign = 1;
    }
    void Comparestrings(Stackfm L, Stackfm R) {
      Stackfm *Temp;
      if ((L.Base == Cot) && (L.Disp == Nullstring)) {
        Temp = &R;
        R = &L;
        L = Temp;
        Invert = Invert ^ 1;
      }
      if ((R.Base == Cot) && (R.Disp == Nullstring)) {
        L.Type = Byte;
        Testzero(L);
      } else {
        Amap(L);
        Loadreg(L, Any);
        Dumpur(Push, L.Base);
        Amap(R);
        Loadreg(R, Any);
        Dumpur(Push, R.Base);
        Perm(Scomp, 2);
        Dumpri(Cmp, Ax, 0);
      }
    }
    void Compare(Stackfm L, Stackfm R) {
      if ((L.Type == 0) || (L.Type == String)) {
        Comparestrings(L, R);
        return;
      }
      if ((Floating(L) != 0) || (Floating(R) != 0)) {
        Comparereals(L, R);
        return;
      }
      if (Zero(R) != 0) {
        Testzero(L);
        return;
      }
      if (Zero(L) != 0) {
        Testzero(R);
        Invert = Invert ^ 1;
        return;
      }
      if (L.Type == Record) {
        Comparerecords(L, R, Minrecordsize(L, R));
        return;
      }
      Loadreg(L, Any);
      if (R.Type == Byte)
        Loadreg(R, Anyg);
      else
        Address(R);
      Dumprv(Cmp, L.Base, R);
    }
    void Resolve(int Flag) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Flag, 0));
        Newline();
      }
      if ((Flag & 1) == 0)
        Pushconst(0);
      else
        Amap(*Top);
      Loadreg(*Top, Any);
      Dumpur(Push, Top->Base);
      Poprel();
      Amap(*Top);
      Loadreg(*Top, Any);
      Dumpur(Push, Top->Base);
      Poprel();
      if ((Flag & 2) == 0)
        Pushconst(0);
      else
        Amap(*Top);
      Loadreg(*Top, Any);
      Dumpur(Push, Top->Base);
      Poprel();
      Amap(*Top);
      Loadreg(*Top, Any);
      Dumpur(Push, Top->Base);
      Poprel();
      Perm(Sresln, 4);
      if ((Flag & 4) != 0) Dumpri(Cmp, Ax, 0);
    }
    int Enter(void) {
      int Cad;
      Uncondjump = -1;
      if (Potype >= External) Fillexternal(Code, Nextcad, Externalid);
      Cad = Nextcad;
      Dumpstaticalloc(Cad, Level, Blockname);
      return (Cad);
    }
    void Dumpreturn(void) {
      if (Uncondjump == Nextcad) return;
      Dumpsimple(Leave);
      Dumpsimple(Ret);
      Uncondjump = Nextcad;
    }
    void Compiletostring(Stackfm V) {
      int Tmp;
      if (Const(V) != 0) {
        Currentstring(0) = 1;
        Currentstring(1) = V.Disp & 255;
        V.Base = 0;
        V.Scope = Cot;
        V.Disp = Getcots(Currentstring);
      } else {
        Tmp = Getwork(Wordsize);
        Loadreg(V, Anyg);
        Dumpmi(Mov, Bp, Tmp, 0, 1);
        Dumpmr8(Mov, Bp, Tmp + 1, 0, V.Base + 16);
        Release(V.Base);
        V.Base = Bp;
        V.Scope = 0;
        V.Disp = Tmp;
      }
      V.Type = String;
      V.Form = Vins;
      V.Size = 1;
    }
    void Compilecall(Stackfm V) {
      label Formnewtype;
      static int B_sw;
      static void *B[13 /*1:13*/] = {
          &&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,
      };
      _imp_string255 Tname;
      int I;
      const _imp_string255 Macroname[13 /*1:13*/] = {
          _imp_str_literal("REM"),       _imp_str_literal("FLOAT"),
          _imp_str_literal("TO STRING"), _imp_str_literal("ADDR"),
          _imp_str_literal("INTEGER"),   _imp_str_literal("BYTE INTEGER"),
          _imp_str_literal("STRING"),    _imp_str_literal("RECORD"),
          _imp_str_literal("REAL"),      _imp_str_literal("LONG REAL"),
          _imp_str_literal("LENGTH"),    _imp_str_literal("CHARNO"),
          _imp_str_literal("INT")};
      const unsigned char Newtype[8 /*5:12*/] = {1, 5, 3, 4, 2, 8, 5, 5};
      int T;
      int L;
      int P;
      if (V.Base >= 128) {
        L = 0;
        T = V.Disp;
        Sym = 0;
        Poprel();
        if ((0 >= T || T >= 16)) T = 0;
        if ((0 >= T || T >= 15)) Abort(_imp_str_literal("Illegal %prim macro"));
        Selectoutput(Listout);
        Spaces(38);
        Printstring(_imp_str_literal("Generating CODE for '"));
        Printstring(Macroname(T));
        Printstring(_imp_join(_imp_str_literal("' (MACRO "),
                              _imp_join(Itos(T, 0), _imp_str_literal(")"))));
        Newline();
        goto *B[B_sw = (T)-1];
      B_1:;
        Operation(Remx);
        goto Esac;
      B_2:;
        Loadreg(*Top, Anyf);
        goto Esac;
      B_3:;
        Compiletostring(*Top);
        goto Esac;
      B_4:;
        Amap(*Top);
        goto Esac;
      B_5:;
      B_6:;
      B_7:;
      B_8:;
      B_9:;
      B_10:;
      Formnewtype:;
        Vmap(*Top);
        Top->Type = Newtype(T);
        Top->Size = Vsize(Top->Type);
        goto Esac;
      B_11:;
        Pushconst(0);
        Amap(Stack(Stp - 1));
        Operation(Addx);
        goto Formnewtype;
      B_12:;
        Amap(Stack(Stp - 1));
        Operation(Addx);
        goto Formnewtype;
      B_13:;
        Loadreg(*Top, Anyf);
        Release(Top->Base);
        P = Getwork(Wordsize);
        Dumpfloprm(Fsti, Bp, P, 0);
        Top->Type = Integer;
        Top->Form = Vins;
        Top->Base = Bp;
        Top->Disp = P;
        goto Esac;
      Esac:;
        Selectoutput(Listout);
        Spaces(38);
        Printstring(_imp_str_literal("CALL '"));
        Printstring(Macroname(T));
        Printstring(_imp_join(_imp_str_literal("' (MACRO "),
                              _imp_join(Itos(T, 0), _imp_str_literal(")"))));
        Newline();
      } else {
        if ((V.Type == String) && (V.Aform == 8)) {
          T = Getwork(V.Size + 1);
          P = Gpreg;
          Dumprm(Lea, P, Bp, T, 0);
          Dumpur(Push, P);
        }
        Hazardall();
        if (V.Scope == Ext)
          Dumpextcall(V.Disp);
        else if (V.Base != 0)
          Dumpum(Call, V.Base, V.Disp, V.Extdisp);
        else
          Dumpjump(Call, V.Disp);
        if (V.Extra != 0) Dumpri(Add, Sp, V.Extra);
        if (V.Type == 0)
          Poprel();
        else {
          V.Scope = 0;
          if ((V.Type == String) && (V.Aform == 8)) {
            V.Base = Bp;
            V.Disp = T;
            V.Form = Vins;
          } else if (((V.Type == Real) || (V.Type == Lreal)) &&
                     (V.Aform == 8)) {
            V.Form = Vinr;
            V.Base = Fr0;
            Claim(Fr0);
            Fpustack = 1;
          } else {
            V.Base = Ax;
            V.Disp = 0;
            Claim(Ax);
          }
        }
      }
    }
    void Loadcompilecall(Stackfm V) {
      if (Showicode == 1) Listicodenoop();
      Compilecall(V);
    }
    void Compilefor(int Lab) {
      Stackfm *Cv;
      Stackfm *Iv;
      Stackfm *Inc;
      Stackfm *Fv;
      int N;
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Lab, 0));
        Newline();
      }
      void Stab(Stackfm V, int Type) {
        int T;
        int R;
        if (Const(V) != 0) return;
        Loadreg(V, Any);
        R = V.Base;
        T = Getwork(Wordsize);
        Dumpmr(Mov, Bp, T, 0, R);
        V.Base = Bp;
        V.Disp = T;
        V.Scope = 0;
        V.Type = Type;
        V.Form = Vins;
        Release(R);
      }
      Iv = Top;
      Fv = &Stack(Stp - 1);
      Inc = &Stack(Stp - 2);
      Cv = &Stack(Stp - 3);
      Stab(*Fv, Integer);
      Stab(*Inc, Integer);
      if ((Cv->Form != Vins) ||
          ((0 < Cv->Base && Cv->Base <= Di) && (Cv->Base != Bp))) {
        N = Cv->Type;
        Amap(*Cv);
        Stab(*Cv, N);
        Cv->Form = Ains;
      }
      Pushcopy(*Cv);
      Pushcopy(*Iv);
      Pushcopy(*Inc);
      Operation(Subx);
      Assign(1);
      Definelabel(Lab);
      Popstack();
      Pushcopy(*Cv);
      Compare(*Top, *Fv);
      Jumpto(Lab + 1, Je, 1);
      Invert = 0;
      Release(Fv->Base);
      Fv = *Top;
      Popstack();
      Operation(Addx);
      Assign(1);
    }
    void Endofblock(void) {
      if (Amode >= 0) {
        Dumpreturn();
        Dumpstaticfill(Staticalloc, Frame + (Level * Wordsize), Events, Evep,
                       Evfrom);
      }
    }
    void Loadendofblock(void) {
      if (Showicode == 1) Listicodenoop();
      Endofblock();
    }
    void Compilebegin(void) {
      Decvar = &Begin;
      Decvar->Disp = Newtag;
      Otype = 0;
      Spec = 0;
      Potype = 0;
      if (Level != 0) {
        Pushconst(Decvar->Disp);
        Top->Type = 0;
        Compilecall(*Top);
        Skipproc = Newtag;
        Dumpjump(Jmp, Skipproc);
        Dumplabel(Decvar->Disp);
      }
      Assemble(0, Labs, Names);
      if (Level != 0) {
        Dumplabel(Skipproc);
        Lastskip = Nextcad;
        Uncondjump = 0;
      }
    }
    void Loadcompilebegin(void) {
      if (Showicode == 1) Listicodenoop();
      Compilebegin();
    }
    void Adump(void) {
      int I;
      float Rv32;
      static int Ot_sw;
      static void *Ot[11 /*0:10*/] = {
          &&Ot_0, &&Ot_1, &&Ot_2, &&Ot_3, &&Ot_4,  &&Ot_5,
          &&Ot_6, &&Ot_7, &&Ot_8, &&Ot_9, &&Ot_10,
      };
      goto *Ot[Ot_sw = Owntype];
    Ot_0:;
      Abort(_imp_str_literal("General Own?"));
    Ot_1:;
      Gput(Ownval);
      goto Done;
    Ot_2:;
      Rv32 = Rvalue;
      for (I = 0; I <= 3; I++) Gbyte(*Byteinteger(Addr(Rv32) + I));
      goto Done;
    Ot_3:;
      if (Currentstring(0) + 1 > Datasize) {
        Warn(5);
        Currentstring(0) = Datasize - 1;
      }
      for (I = 0; I <= Datasize - 1; I++) Gbyte(Currentstring(I));
      goto Done;
    Ot_4:;
      for (I = 1; I <= Datasize; I++) Gbyte(0);
      goto Done;
    Ot_5:;
      Gbyte(Ownval);
      goto Done;
    Ot_6:;
      Gput(Ownval);
      goto Done;
    Ot_7:;
      Gput(Ownval);
      goto Done;
    Ot_8:;
      for (I = 0; I <= 7; I++) Gbyte(*Byteinteger(Addr(Rvalue) + I));
      goto Done;
    Ot_9:;
      for (I = 1; I <= Datasize; I++) Gbyte(0);
      goto Done;
    Ot_10:;
      Gput(Ownval);
      goto Done;
    Done:;
    }
    int Userlabel(int Lab) {
      Varfm *V;
      if (Lab > Names) {
        Names = Lab;
        V = &Var(Lab);
        V = 0;
        V->Form = Pgmlabel;
        V->Disp = Newtag;
        return (V->Disp);
      }
      return (Var(Lab).Disp);
    }
    void Comparedouble(void) {
      Lhs = &Stack(Stp - 1);
      Rhs = Top;
      Loadreg(*Rhs, Any);
      Compare(*Rhs, *Lhs);
      Invert = 1;
      Release(Lhs->Base);
      Lhs = *Rhs;
      Popstack();
    }
    void Loadcomparedouble(void) {
      if (Showicode == 1) Listicodenoop();
      Comparedouble();
    }
    void Comparevalues(void) {
      Lhs = &Stack(Stp - 1);
      Rhs = Top;
      Compare(*Lhs, *Rhs);
      Poprel();
      Poprel();
    }
    void Loadcomparevalues(void) {
      if (Showicode == 1) Listicodenoop();
      Comparevalues();
    }
    void Compareaddresses(void) {
      Amap(*Top);
      Amap(Stack(Stp - 1));
      Comparevalues();
    }
    void Loadcompareaddresses(void) {
      if (Showicode == 1) Listicodenoop();
      Compareaddresses();
    }
    void Definecompilerlabel(int Label) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Label, 0));
        Newline();
      }
      if (Label == 0) {
        Dumplabel(Skipproc);
        Lastskip = Nextcad;
        Uncondjump = 0;
      } else {
        Definelabel(Label);
      }
    }
    void Init(int N) {
      int J;
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(N, 0));
        Newline();
      }
      if (Stp != 0) {
        Ownval = Top->Disp;
        if ((Owntype == Real) || (Owntype == Lreal)) {
          if (Top->Type == Integer) Rvalue = Ownval;
        }
        Popstack();
      } else {
        Ownval = 0;
        Currentstring(0) = 0;
      }
      if ((Ownform == Array) || (Ownform == Namearray))
        for (J = 1; J <= N; J++) Adump();
      else if (Otype == 0) {
        Decvar->Scope = Cot;
        Decvar->Level = 0;
        Decvar->Disp = Ownval;
      } else {
        Decvar->Level = 0;
        if (Otype == Con) {
          Decvar->Scope = Cot;
          if (Owntype == String)
            Decvar->Disp = Getcots(Currentstring);
          else if ((Owntype == Real) || (Owntype == Lreal))
            Decvar->Disp = Getcotdouble(Rvalue);
          else
            Abort(_imp_str_literal("Init?"));
        } else {
          Decvar->Scope = Data;
          Decvar->Disp = Datatp;
          Adump();
        }
      }
    }
    void Userjump(int Label) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Label, 0));
        Newline();
      }
      Dumpjump(Jmp, Userlabel(Label));
    }
    void Defineuserlabel(int Label) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Label, 0));
        Newline();
      }
      Dumplabel(Userlabel(Label));
    }
    void Return(int Mode) {
      int I;
      if (Mode == False) Dumpri(Mov, Ax, 0);
      if (Mode == True) Dumpri(Mov, Ax, -1);
      if (Mode == Map) {
        Amap(*Top);
        Loadreg(*Top, Ax);
        Poprel();
      }
      if (Mode == Fn)
        if (Procvar->Type == Integer) {
          Loadreg(*Top, Ax);
          Poprel();
        } else if ((Procvar->Type == Real) || (Procvar->Type == Lreal)) {
          Loadreg(*Top, Anyf);
          Poprel();
        } else {
          Pushcopy(*Top);
          Lhs = &Stack(Stp - 1);
          Lhs->Type = Procvar->Type;
          Lhs->Size = Procvar->Size;
          Lhs->Format = Procvar->Format;
          Lhs->Base = Bp;
          Lhs->Disp = Wordsize * 2;
          Lhs->Form = Ains;
          Assign(1);
        }
      if (Mode == Routine)
        ;
      Dumpreturn();
    }
    void Loadreturn(int Mode) {
      if (Showicode == 1) Listicodenoop();
      Return(Mode);
    }
    void Dimension(int Dim, int N) {
      int I;
      int J;
      int Usecot;
      int Descriptor;
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Dim, 0));
        Printsymbol(',');
        Printstring(Itos(N, 0));
        Newline();
      }
      if ((0 >= Dim || Dim >= 6)) Abort(_imp_str_literal("Array Dim"));
      if (Inparams != 0) {
        Parms = Parms + N;
        Vub = Top->Disp;
        Popstack();
        Vlb = Top->Disp;
        Popstack();
        if (Vlb > Vub) Abort(_imp_str_literal("Array Bounds"));
        Dv = Setdopevector(Datasize, Arrayentrytype);
      } else {
        Names = Names - N;
        Usecot = 1;
        J = 0;
        for (I = 1; I <= Dim * 2; I++) {
          J = J + 1;
          Lhs = &Stack(J);
          if (Lhs->Form != Constant) Usecot = 0;
        }
        Frame = (Frame - 2 * Wordsize * (Dim + 1)) & (~Align);
        Dv = Frame;
        Dumpmi(Mov, Bp, Dv, 0, Dim);
        J = 0;
        for (I = 1; I <= Dim * 2; I++) {
          J = J + 1;
          Lhs = &Stack(J);
          if (Lhs->Form == Constant)
            Dumpmi(Mov, Bp, Dv + (I * Wordsize), 0, Lhs->Disp);
          else {
            Loadreg(*Lhs, Any);
            Dumpmr(Mov, Bp, Dv + (I * Wordsize), 0, Lhs->Base);
          }
        }
        Descriptor = (Datasize << 5) | ((Arrayentrytype & 15) << 1) | 1;
        Dumpmi(Mov, Bp, Dv + (2 * Dim + 1) * Wordsize, 0, Descriptor);
        if ((Dim > 1) || ((Control & Checkarray) != 0)) {
          while (Stp != 0) Poprel();
          Dumprm(Lea, Ax, Bp, Dv, 0);
          Dumpur(Push, Ax);
          Perm(Adef, 1);
          Pushconst(0);
          Lhs = Top;
          Pushconst(0);
          Rhs = Top;
          Lhs->Base = Ax;
          Lhs->Form = Vinr;
          Claim(Ax);
          Rhs->Base = Dx;
          Rhs->Form = Vinr;
          Claim(Dx);
          Popstack();
          Popstack();
        } else {
          Pushconst(1);
          Operation(Addx);
          Pushconst(Datasize);
          Operation(Mulx);
          Pushcopy(Stack(Stp - 1));
          Pushconst(Datasize);
          Operation(Mulx);
          Loadreg(*Top, Any);
          Lhs = Top;
          Popstack();
          Loadreg(*Top, Any);
          Rhs = Top;
          Popstack();
          Popstack();
        }
        T = Gpreg;
        Dumprm(Lea, T, Bp, Dv, 0);
        Dv = T;
        Claim(Dv);
        T = Gpreg;
        Dumprr(Mov, T, Sp);
      }
      for (I = 1; I <= N; I++) {
        Decvar->Dim = Dim;
        if (Inparams == 0) {
          Names = Names + 1;
          Decvar = &Var(Names);
          Decvar->Level = Level;
          Frame = Frame - (Wordsize * 2);
          Decvar->Disp = Frame;
          if ((Decvar->Form == Array) || (Decvar->Form == Namearray))
            Decvar->Form = Decvar->Form + 1;
          Dumprr(Sub, T, Rhs->Base);
          Dumpmr(Mov, Bp, Frame, 0, T);
          Dumpmr(Mov, Bp, Frame + Wordsize, 0, Dv);
          Dumprr(Add, T, Lhs->Base);
        } else {
          Parms = Parms - 1;
          Decvar = &Var(Parms);
          Decvar->Disp = Frame - Vlb;
          Frame = Frame + Vub;
          Decvar->Pbase = Dv;
        }
      }
      if (Inparams == 0) {
        if ((Datasize & Align) != 0) Dumpri(And, T, ~Align);
        Dumprr(Mov, Sp, T);
        Release(Lhs->Base);
        Release(Rhs->Base);
        Release(Dv);
      }
    }
    void Updateline(int Line) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Line, 0));
        Newline();
      }
      Currentline = Line;
      if (Stp != 0) Abort(_imp_str_literal("Stack?"));
      if (Claimed != 0) Abort(_imp_str_literal("Claimed"));
      if (Echoline < Currentline) {
        Dumplinenumber(Currentline);
        while (Echoline < Currentline) Echosourceline();
      }
    }
    void Switchjump(int Switchid) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Switchid, 0));
        Printsymbol(',');
        Printsymbol('=');
        Printsymbol('"');
        Printstring(Var(Switchid).Idname);
        Printsymbol('"');
        Newline();
      }
      V = &Var(Switchid);
      Pushconst(Wordsize);
      Operation(Mulx);
      Loadreg(*Top, Anyp);
      Dumpum(Jmp, Swt | Top->Base, V->Disp * Wordsize, 0);
      Poprel();
      Uncondjump = Nextcad;
    }
    void Setrecordformat(int Formatid) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Formatid, 0));
        Printsymbol(',');
        Printsymbol('=');
        Printsymbol('"');
        Printstring(Var(Formatid).Idname);
        Printsymbol('"');
        Newline();
      }
      Top->Format = Formatid;
      Top->Type = Record;
    }
    void Switchlabel(int Switchlabel) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Switchlabel, 0));
        Printsymbol(',');
        Printsymbol('=');
        Printsymbol('"');
        Printstring(Var(Switchlabel).Idname);
        Printsymbol('"');
        Newline();
      }
      V = &Var(Switchlabel);
      Uncondjump = 0;
      J = Top->Disp;
      Popstack();
      T = Newtag;
      Dumplabel(T);
      Swtab(V->Disp + J) = T;
    }
    void Constantbounds(void) {
      Vub = Top->Disp;
      Popstack();
      Vlb = Top->Disp;
      Popstack();
    }
    void Loadconstantbounds(void) {
      if (Showicode == 1) Listicodenoop();
      Constantbounds();
    }
    void Internalhandler(int Id) {
      Stackfm *Lh;
      Stackfm *Rh;
      Stackfm Temp;
      while (Stp < 2) Pushconst(0);
      Rh = Top;
      Lh = &Stack(Stp - 1);
      Temp = *Lh;
      Lh = *Rh;
      Rh = Temp;
      Pushconst(Id);
      Pushconst(Currentline);
      Loadreg(*Top, Any);
      Dumpur(Push, Top->Base);
      Poprel();
      Loadreg(*Top, Any);
      Dumpur(Push, Top->Base);
      Poprel();
      Loadreg(*Top, Any);
      Dumpur(Push, Top->Base);
      Poprel();
      Loadreg(*Top, Any);
      Dumpur(Push, Top->Base);
      Poprel();
      Perm(Signal, 4);
      if (Id != -1) Uncondjump = Nextcad;
    }
    void Signalevent(int Eventid) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Eventid, 0));
        Newline();
      }
      Internalhandler(Eventid);
    }
    void Monitor(void) { Internalhandler(-1); }
    void Loadmonitor(void) {
      if (Showicode == 1) Listicodenoop();
      Monitor();
    }
    void Selectfield(int Fieldindex) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Fieldindex, 0));
        Newline();
      }
      Lhs = Top;
      Stackvar(Var(Top->Format).Pbase - Fieldindex);
      if (Top->Aform != Recordformat) {
        if ((Lhs->Form == Vins) || (Lhs->Form == Vinrec)) {
          Top->Disp = Top->Disp + Lhs->Disp;
          Lhs->Form = Lhs->Form - Vins + Top->Form;
        } else if (Lhs->Form == Ainrec) {
          Lhs->Form = Vinrec;
          Lhs->Type = Integer;
          Loadreg(*Lhs, Any);
          Lhs->Form = Top->Form;
        } else if (Lhs->Form <= Vinr) {
          Lhs->Form = Top->Form;
        } else {
          Lhs->Extra = Lhs->Disp;
          Lhs->Form = Top->Form + 3;
        }
        Lhs->Disp = Top->Disp;
        Lhs->Type = Top->Type;
        Lhs->Aform = Top->Aform;
        Lhs->Dim = Top->Dim;
      }
      Lhs->Size = Top->Size;
      Lhs->Format = Top->Format;
      Popstack();
    }
    void Eventtrap(int Anevent, int Evfrom) {
      int Temp;
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Anevent, 0));
        Printsymbol(',');
        Printstring(Itos(Evfrom, 0));
        Newline();
      }
      Events = Anevent;
      Temp = Getwork(Wordsize);
      Dumpmr(Mov, Bp, Temp, 0, Sp);
      Jumpto(Evfrom, Jmp, 1);
      Evfrom = Jtag;
      Evep = Newtag;
      Dumplabel(Evep);
      Dumprm(Mov, Sp, Bp, Temp, 0);
    }
    void Doubleop(int Opr) {
      int J;
      int T;
      Lhs = &Stack(Stp - 1);
      T = Lhs->Type;
      J = Lhs->Size;
      if (T == String) J = J + 1;
      Amap(*Lhs);
      if (J == 0) Abort(_imp_str_literal("++/-- size"));
      Pushconst(J);
      Operation(Mulx);
      Operation(Opr);
      Vmap(*Top);
      Top->Type = T;
    }
    void Setcd(int Value, int Cd) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printstring(Itos(Value, 0));
        Newline();
      }
      if ((Value & 0xC000) == (Passid & 3) << 14) Cd = Value & 0x3FFF;
    }
    int /* boolean */ Finishparams(void) {
      int J;
      if (Showicode == 1) Listicodenoop();
      Inparams = 0;
      if (Amode < 0) return (1);
      if (Procvar->Level == 128) return (1);
      if (Names > Firstname) {
        Procvar->Pbase = Parms;
        Frame = (Frame + Align) & (~Align);
        if ((Procvar->Type == String) && (Procvar->Form == 8)) {
          Frame = Frame + Wordsize;
        }
        Procvar->Extra = Frame;
        Procvar->Dim = Names - Firstname;
        Frame = Frame + (2 * Wordsize);
        for (J = Firstname + 1; J <= Names; J++) {
          Ap = &Var(J);
          Parms = Parms - 1;
          Fp = &Var(Parms);
          Fp = *Ap;
          Fp->Level = 0;
          Ap->Disp = Frame - Ap->Disp;
        }
        if (Parms < Names) Abort(_imp_str_literal("Params"));
      }
      if (Amode == 2) return (1);
      Dumplabel(Procvar->Disp);
      Staticalloc = Enter;
      Frame = -(Level * Wordsize);
      return (0);
    }
    void Startparams(void) {
      if (Showicode == 1) Listicodenoop();
      Inparams = -1;
      Assemble(Blocktype, Labs, Names);
    }
    int /* boolean */ Alternateformat(int N) {
      if (Showicode == 1) {
        Listicode();
        Spaces(4);
        Printsymbol(N);
        Newline();
      }
      if ((N != 'A') && (N != 'B') && (N != 'C'))
        Abort(_imp_join(_imp_str_literal("Alt Record '"),
                        _imp_join(Tostring(Sym), _imp_str_literal("'."))));
      if (N == 'B') return (1);
      if (N == 'A') {
        Decvar = Procvar;
        Assemble(-2, Labs, Names);
      }
      if (N == 'C') {
        if (Frame > Maxframe) Maxframe = Frame;
        Frame = Oldframe;
      }
      return (0);
    }
    void Plant(void) {
      int J;
      if (Stp != 1) Abort(_imp_str_literal("Machine Literal"));
      for (J = 1; J <= Stp; J++)
        ;
      Stp = 0;
    }
    void Loadplant(void) {
      if (Showicode == 1) Listicodenoop();
      Plant();
    }
    const int Opgenericid[37 /*0:36*/] = {
        -1, -1, -1, -1, -1, -1, -1, 16, 15, 9,  10, -1, -1,
        -1, -1, 1,  6,  -1, 7,  2,  8,  9,  10, 4,  3,  -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
    const _imp_string255 Opgenericname[37 /*0:36*/] = {
        _imp_str_literal("NOP"),   _imp_str_literal("CWD"),
        _imp_str_literal("RET"),   _imp_str_literal("SAHF"),
        _imp_str_literal("LEAVE"), _imp_str_literal("DEC"),
        _imp_str_literal("INC"),   _imp_str_literal("NEGx"),
        _imp_str_literal("NOT"),   _imp_str_literal("POP"),
        _imp_str_literal("PUSH"),  _imp_str_literal("LEA"),
        _imp_str_literal("MOV"),   _imp_str_literal("XCHG"),
        _imp_str_literal("ADC"),   _imp_str_literal("ADD"),
        _imp_str_literal("AND"),   _imp_str_literal("CMP"),
        _imp_str_literal("OR"),    _imp_str_literal("SUB"),
        _imp_str_literal("XOR"),   _imp_str_literal("SHL"),
        _imp_str_literal("SHR"),   _imp_str_literal("IDIV"),
        _imp_str_literal("IMUL"),  _imp_str_literal("CALL"),
        _imp_str_literal("JE"),    _imp_str_literal("JNE"),
        _imp_str_literal("JG"),    _imp_str_literal("JGE"),
        _imp_str_literal("JL"),    _imp_str_literal("JLE"),
        _imp_str_literal("JA"),    _imp_str_literal("JAE"),
        _imp_str_literal("JB"),    _imp_str_literal("JBE"),
        _imp_str_literal("JMP")};
    void Machinecode(_imp_string255 Code) {
      const int Unknown = 0;
      const int Variable = 1;
      const int Register = 2;
      const int Number = 3;
      const int Mask = 4;
      const int Name = 5;
      const int Pointer = 6;
      const int Paramlimit = 8;
      const int Registerlimit = 8;
      typedef struct Paramfm {
        _imp_string255 Data;
        _imp_string255 Paramname;
        int Scomma;
        int Pcomma;
        int Start;
        int End;
        int Paramtype;
        int Paramvalue;
        int Paramoffset;
      } Paramfm;
      _imp_string255 Instruction;
      int Paramscount;
      Paramfm Params[8 /*1:8*/];
      void Dumpparameter(int Index) {
        _imp_string255 T;
        int Tag;
        int N;
        _imp_string255 Paramname;
        int Paramvalue;
        int Paramoffset;
        static int Sw_sw;
        static void *Sw[7 /*0:6*/] = {
            &&Sw_default, &&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4, &&Sw_5, &&Sw_6,
        };
        Paramname = Params(Index).Paramname;
        Paramvalue = Params(Index).Paramvalue;
        Paramoffset = Params(Index).Paramoffset;
        Printstring(_imp_join(
            _imp_str_literal("Parameter("),
            _imp_join(Itos(Index, 0),
                      _imp_join(_imp_str_literal(")='"),
                                _imp_join(Paramname, _imp_str_literal("'"))))));
        Newline();
        goto *Sw[Sw_sw = Params(Index).Paramtype];
      Sw_1:;
        Dumptagvar(Paramvalue, _imp_str_literal("VAR"));
        goto Esac;
      Sw_2:;
        Printstring(
            _imp_join(_imp_str_literal(" REG   id="), Itos(Paramvalue, 0)));
        Newline();
        Printstring(_imp_join(_imp_str_literal(" REG name="), Paramname));
        Newlines(2);
        goto Esac;
      Sw_3:;
        Printstring(
            _imp_join(_imp_str_literal(" NUMBER value="), Itos(Paramvalue, 0)));
        Newlines(2);
        goto Esac;
      Sw_4:;
        Printstring(_imp_join(_imp_str_literal(" MASK value=2_"),
                              Int2ascii(Paramvalue, 2, 0)));
        Newlines(2);
      Sw_5:;
        Printstring(_imp_join(_imp_str_literal(" NAME  name="), Paramname));
        Newline();
        Printstring(_imp_join(_imp_str_literal(" NAME value=2_"),
                              Int2ascii(Paramvalue, 2, 0)));
        Newlines(2);
        goto Esac;
      Sw_6:;
        Printstring(
            _imp_join(_imp_str_literal(" PTR   id="), Itos(Paramvalue, 0)));
        Newline();
        Printstring(_imp_join(_imp_str_literal(" PTR name=["), Paramname));
        if (Paramoffset != 0) Printstring(Itos(Paramoffset, 0));
        Printstring(_imp_str_literal("]"));
        Newline();
        Printstring(
            _imp_join(_imp_str_literal(" PTR offset="), Itos(Paramoffset, 0)));
        Newlines(2);
        goto Esac;
      Sw_default:;
        goto Esac;
      Esac:;
      }
      void Parsemachinecode(_imp_string255 Code) {
        _imp_string255 S;
        _imp_string255 T;
        _imp_string255 Parameters;
        unsigned char Ch;
        unsigned char Inrbflag;
        unsigned char Insbflag;
        unsigned char Inabflag;
        unsigned char Hashflag;
        unsigned char Plusflag;
        unsigned char Minusflag;
        static int C_sw;
        static void *C[128 /*0:127*/] = {
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_32,      &&C_default, &&C_default,
            &&C_35,      &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_40,      &&C_41,      &&C_default, &&C_43,      &&C_44,
            &&C_45,      &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_60,      &&C_default, &&C_62,      &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_78,      &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_91,      &&C_default, &&C_93,      &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
            &&C_default, &&C_default, &&C_default,
        };
        label Esac;
        label Default;
        int I;
        int J;
        int K;
        int N;
        int Plen;
        int Tag;
        if (!_imp_cond_resolve(Code, Instruction, _imp_str_literal("_"),
                               Parameters))
          _imp_signal(7, 0, 0);
        S = _imp_str_literal("");
        if (Parameters != _imp_str_literal("")) {
          Paramscount = 1;
          Plen = *Length(Parameters);
          Inrbflag = 0;
          Insbflag = 0;
          Inabflag = 0;
          Hashflag = 0;
          Plusflag = 0;
          Minusflag = 0;
          I = 1;
          while (I <= Plen) {
            Ch = *Charno(Parameters, I);
            if (Ch < 128) goto *C[C_sw = Ch];
            T = _imp_str_literal("%");
            while (*Charno(Parameters, I) > 127) {
              Length(T) = *Length(T) + 1;
              Charno(T, *Length(T)) = *Charno(Parameters, I) - 128;
              I = I + 1;
            }
            Params(Paramscount).Paramtype = Name;
            Params(Paramscount).Paramvalue = 0;
            Params(Paramscount).Paramname = T;
            S = _imp_join(S, _imp_join(T, _imp_str_literal(" ")));
            goto Esac;
          C_32:;
            N = (*Charno(Parameters, I + 1) << 8) + *Charno(Parameters, I + 2);
            T = Var(N).Idname;
            if (Insbflag == 1)
              Params(Paramscount).Paramtype = Pointer;
            else
              Params(Paramscount).Paramtype = Variable;
            Params(Paramscount).Paramvalue = N;
            Params(Paramscount).Paramname = T;
            S = _imp_join(S, T);
            I = I + 3;
            goto Esac;
          C_78:;
            N = 0;
            N = N + *Charno(Parameters, I + 1);
            N = N << 8;
            N = N + *Charno(Parameters, I + 2);
            N = N << 8;
            N = N + *Charno(Parameters, I + 3);
            N = N << 8;
            N = N + *Charno(Parameters, I + 4);
            if (Params(Paramscount).Paramtype == Name) {
              Hashflag = 0;
              Params(Paramscount).Paramvalue = N;
              if (N > 127)
                T = _imp_join(_imp_str_literal("16_"), Int2ascii(N, 16, 0));
              else
                T = Itos(N, 0);
              S = _imp_join(S, T);
            } else if ((Hashflag != 0) &&
                       (Params(Paramscount).Paramtype == Unknown)) {
              Hashflag = 0;
              Params(Paramscount).Paramtype = Number;
              Params(Paramscount).Paramvalue = N;
              Params(Paramscount).Paramname = _imp_str_literal("");
              if (N > 127)
                T = _imp_join(_imp_str_literal("16_"), Int2ascii(N, 16, 0));
              else
                T = Itos(N, 0);
              S = _imp_join(S, T);
              Params(Paramscount).Paramname = T;
            } else if (Params(Paramscount).Paramtype == Mask) {
              if (0 < N && N <= Registerlimit)
                K = 1 << (N - 1);
              else if (0 < N && N <= 32)
                K = 1 << (N - 1);
              else
                K = 0;
              Params(Paramscount).Paramvalue =
                  Params(Paramscount).Paramvalue | K;
              if (0 < N && N <= Registerlimit)
                S = _imp_join(S, Regname(N));
              else
                S = _imp_join(S, _imp_str_literal("R??"));
            } else {
              if (Insbflag == 1)
                Params(Paramscount).Paramtype = Pointer;
              else
                Params(Paramscount).Paramtype = Register;
              if (Plusflag == 1) {
                Params(Paramscount).Paramoffset = N;
                T = Itos(N, 0);
              } else if (Minusflag == 1) {
                Params(Paramscount).Paramoffset = -N;
                T = Itos(N, 0);
              } else {
                Params(Paramscount).Paramvalue = N;
                if (0 < N && N <= Registerlimit)
                  T = Regname(N);
                else
                  T = _imp_str_literal("R??");
                Params(Paramscount).Paramname = T;
              }
              S = _imp_join(S, T);
            }
            I = I + 5;
            goto Esac;
          C_35:;
            Hashflag = 1;
            goto Default;
          C_44:;
            if ((Inabflag + Inrbflag + Insbflag) == 0) {
              Params(Paramscount).Scomma = *Length(S) + 1;
              Params(Paramscount).Pcomma = I;
              Paramscount = Paramscount + 1;
              Params(Paramscount).Paramtype = Unknown;
              Params(Paramscount).Paramoffset = 0;
            }
            goto Default;
          C_43:;
            Plusflag = 1;
            Minusflag = 0;
            goto Default;
          C_45:;
            Plusflag = 0;
            Minusflag = 1;
            goto Default;
          C_40:;
            Inrbflag = 1;
            goto Default;
          C_41:;
            Inrbflag = 0;
            goto Default;
          C_91:;
            Params(Paramscount).Paramtype = Pointer;
            Params(Paramscount).Paramname = _imp_str_literal("");
            Params(Paramscount).Paramvalue = 0;
            Params(Paramscount).Paramoffset = 0;
            Insbflag = 1;
            goto Default;
          C_93:;
            Plusflag = 0;
            Minusflag = 0;
            Insbflag = 0;
            goto Default;
          C_60:;
            Params(Paramscount).Paramtype = Mask;
            Params(Paramscount).Paramname = _imp_str_literal("");
            Params(Paramscount).Paramvalue = 0;
            Params(Paramscount).Paramoffset = 0;
            Inabflag = 1;
            goto Default;
          C_62:;
            Inabflag = 0;
            goto Default;
          Default:;
          C_default:;
            S = _imp_join(S, Tostring(*Charno(Parameters, I)));
            I = I + 1;
            goto Esac;
          Esac:;
          }
        } else
          Paramscount = 0;
        if (Paramscount != 0)
          for (I = 1; I <= Paramscount; I++) {
            if (I == 1)
              Params(I).Start = 1;
            else
              Params(I).Start = Params(I - 1).Scomma + 1;
            if (I == Paramscount)
              Params(I).End = *Length(S);
            else
              Params(I).End = Params(I).Scomma - 1;
            Params(I).Data = _imp_str_literal("");
            for (J = Params(I).Start; J <= Params(I).End; J++)
              Params(I).Data =
                  _imp_join(Params(I).Data, Tostring(*Charno(S, J)));
          }
        if (Showicode == 1) {
          Listicode();
          Spaces(4);
          Printstring(Instruction);
          if (Paramscount != 0) {
            Printsymbol(' ');
            for (I = 1; I <= Paramscount; I++) {
              if (I > 1) Printsymbol(',');
              Printstring(Params(I).Data);
            }
          }
          Newline();
        }
      }
      int Validatemachinecode(_imp_string255 Instruction) {
        _imp_string255 Opnamex;
        int I;
        int Opid;
        int Opidx;
        Opid = -1;
        Opidx = -1;
        for (I = Nop; I <= Jmp; I++)
          if (Instruction == Opgenericname(I)) {
            Opid = I;
            Opidx = Opgenericid(Opid);
            if (Opidx != -1)
              Opnamex = Instruction;
            else
              Opnamex = Itos(Opid, 0);
          }
        if (Opid == -1)
          Abort(_imp_str_literal("MCODE has illegal/unknown instruction name"));
        return (Opid);
      }
      void Insertmachinecode(_imp_string255 Instruction, int Opid) {
        int Opidx;
        Opidx = Opgenericid(Opid);
        if (Paramscount == 0) {
          Selectoutput(Listout);
          Printstring(_imp_str_literal(
              "**** Instructions with no parameters not yet implemented"));
          Newline();
        } else if (Paramscount == 1)
          if (Opid != -1)
            if (Params(1).Paramtype == Variable) {
              Stackvar(Params(1).Paramvalue);
              Operation(Opidx);
            } else if (Params(1).Paramtype == Register)
              Dumpur(Opid, Params(1).Paramvalue);
            else if (Params(1).Paramtype == Pointer)
              Abort(_imp_join(
                  _imp_str_literal("Opcode "),
                  _imp_join(Instruction,
                            _imp_join(_imp_str_literal(
                                          " with one parameter can only "
                                          "operate on an address/register "),
                                      Params(1).Paramname))));
            else
              Abort(_imp_join(
                  _imp_str_literal("Opcode "),
                  _imp_join(
                      Instruction,
                      _imp_join(_imp_str_literal(" is attempting to operate on "
                                                 "unexpected location "),
                                Params(1).Paramname))));
          else
            Abort(_imp_join(
                _imp_str_literal("Attempting to apply unknown opcode "),
                Instruction));
        else if (Paramscount == 2)
          if (Opid == Mov)
            if (Params(1).Paramtype == Variable)
              if (Params(2).Paramtype == Register) {
                Stackvar(Params(1).Paramvalue);
                if ((Top->Type == General) || (Top->Type == Integer) ||
                    (Top->Type == Byte) || (Top->Type == Record)) {
                  Storereg(*Top, Params(2).Paramvalue);
                  Poprel();
                } else {
                  Poprel();
                  Abort(_imp_join(
                      _imp_str_literal("Attempting to store reg "),
                      _imp_join(
                          Params(2).Paramname,
                          _imp_str_literal(" in a non-integer variable"))));
                }
              } else if (Params(2).Paramtype == Number) {
                Stackvar(Params(1).Paramvalue);
                Pushconst(Params(2).Paramvalue);
                Assign(1);
              } else if ((Params(2).Paramtype == Variable) ||
                         (Params(2).Paramtype == Pointer))
                Abort(_imp_str_literal(
                    " No INTEL instruction can have indirect pointers for both "
                    "source and destination"));
              else
                Abort(_imp_join(
                    _imp_str_literal(
                        "Attempting to store unexpected type in variable "),
                    Params(1).Paramname));
            else if (Params(1).Paramtype == Pointer)
              if (Params(2).Paramtype == Register)
                Dumpmr(Opid, Params(1).Paramvalue, Params(1).Paramoffset, 0,
                       Params(2).Paramvalue);
              else if (Params(2).Paramtype == Number) {
                Selectoutput(Listout);
                Printstring(_imp_str_literal(" EXPERIMENTAL IMPLEMENTATION"));
                Newline();
                Dumpmi(Opid, Params(1).Paramvalue, Params(1).Paramoffset, 0,
                       Params(2).Paramvalue);
                Printstring(_imp_str_literal(" NOT YET IMPLEMENTED"));
                Newline();
              } else if ((Params(2).Paramtype == Variable) ||
                         (Params(2).Paramtype == Pointer))
                Abort(_imp_str_literal(
                    " No INTEL instruction can have indirect pointers for both "
                    "source and destination"));
              else
                Abort(_imp_join(
                    _imp_str_literal(
                        "Attempting to store unexpected type in variable "),
                    Params(1).Paramname));
            else if (Params(1).Paramtype == Register)
              if (Params(2).Paramtype == Variable) {
                Stackvar(Params(2).Paramvalue);
                Loadreg(*Top, Params(1).Paramvalue);
                Poprel();
              } else if (Params(2).Paramtype == Pointer)
                Dumprm(Opid, Params(1).Paramvalue, Params(2).Paramvalue,
                       Params(2).Paramoffset, 0);
              else if (Params(2).Paramtype == Register)
                Dumprr(Opid, Params(1).Paramvalue, Params(2).Paramvalue);
              else if (Params(2).Paramtype == Number) {
                Pushconst(Params(2).Paramvalue);
                Loadreg(*Top, Params(1).Paramvalue);
                Poprel();
              } else
                Abort(_imp_join(
                    _imp_str_literal(
                        "Attempting to store unexpected type in register "),
                    Params(1).Paramname));
            else
              Abort(_imp_join(
                  _imp_str_literal("Attempting to "),
                  _imp_join(Instruction,
                            _imp_str_literal(
                                " into non-variable/register location"))));
          else if (Opidx != -1)
            if (Params(1).Paramtype == Variable)
              if (Params(2).Paramtype == Register) {
                Stackvar(Params(1).Paramvalue);
                Dumpmr(Opid, Top->Base | Top->Scope, Top->Disp, Top->Extdisp,
                       Top->Base);
                Poprel();
              } else if (Params(2).Paramtype == Number) {
                Stackvar(Params(1).Paramvalue);
                Stackvar(Params(1).Paramvalue);
                Pushconst(Params(2).Paramvalue);
                Operation(Opidx);
                Assign(1);
              } else if ((Params(2).Paramtype == Variable) ||
                         (Params(2).Paramtype == Pointer))
                Abort(_imp_str_literal(
                    " No INTEL instruction can have indirect pointers for both "
                    "source and destination"));
              else
                Abort(_imp_join(
                    _imp_str_literal("Opcode "),
                    _imp_join(Instruction,
                              _imp_join(_imp_str_literal(
                                            " is attempting to store "
                                            "unexpected type in variable "),
                                        Params(1).Paramname))));
            else if (Params(1).Paramtype == Pointer)
              if (Params(2).Paramtype == Register)
                Dumpmr(Opid, Params(1).Paramvalue, Params(1).Paramoffset, 0,
                       Params(2).Paramvalue);
              else if (Params(2).Paramtype == Number) {
                Selectoutput(Listout);
                Printstring(_imp_str_literal(" EXPERIMENTAL IMPLEMENTATION"));
                Newline();
                Dumpmi(Opid, Params(1).Paramvalue, Params(1).Paramoffset, 0,
                       Params(2).Paramvalue);
                Printstring(_imp_str_literal(" NOT YET IMPLEMENTED"));
                Newline();
              } else if ((Params(2).Paramtype == Variable) ||
                         (Params(2).Paramtype == Pointer))
                Abort(_imp_str_literal(
                    " No INTEL instruction can have indirect pointers for both "
                    "source and destination"));
              else
                Abort(_imp_join(
                    _imp_str_literal(
                        "Attempting to store unexpected type in variable "),
                    Params(1).Paramname));
            else if (Params(1).Paramtype == Register)
              if (Params(2).Paramtype == Variable) {
                Stackvar(Params(2).Paramvalue);
                Dumprv(Opid, Params(1).Paramvalue, *Top);
                Poprel();
              } else if (Params(2).Paramtype == Pointer) {
                Selectoutput(Listout);
                Printstring(_imp_str_literal(" EXPERIMENTAL IMPLEMENTATION"));
                Newline();
                Dumprm(Opid, Params(1).Paramvalue, Params(2).Paramvalue,
                       Params(1).Paramoffset, 0);
                Printstring(_imp_str_literal(" NOT YET IMPLEMENTED"));
                Newline();
              } else if (Params(2).Paramtype == Register)
                Dumprr(Opid, Params(1).Paramvalue, Params(2).Paramvalue);
              else if (Params(2).Paramtype == Number)
                Dumpri(Opid, Params(1).Paramvalue, Params(2).Paramvalue);
              else
                Abort(_imp_join(
                    _imp_str_literal("Opcode "),
                    _imp_join(Instruction,
                              _imp_join(_imp_str_literal(
                                            " is attempting to store "
                                            "unexpected type in register "),
                                        Params(1).Paramname))));
            else
              Abort(_imp_join(
                  _imp_str_literal("Opcode "),
                  _imp_join(
                      Instruction,
                      _imp_join(_imp_str_literal(" is attempting to store in "
                                                 "unexpected location "),
                                Params(1).Paramname))));
          else
            Abort(_imp_join(
                _imp_str_literal("Attempting to apply unknown opcode "),
                Instruction));
        else
          Abort(_imp_join(
              _imp_str_literal("Opcode "),
              _imp_join(
                  Instruction,
                  _imp_join(_imp_str_literal(" has unexpected number "),
                            _imp_join(Itos(Paramscount, 0),
                                      _imp_str_literal("of parameters."))))));
      }
      int Opid;
      Parsemachinecode(Code);
      Opid = Validatemachinecode(Instruction);
      Insertmachinecode(Instruction, Opid);
    }
    Firstname = Names;
    Firstlabel = Labs;
    Procvar = Decvar;
    Lastskip = -1;
    Oldframe = Frame;
    Frame = 0;
    Events = 0;
    Evep = 0;
    Evfrom = 0;
    if (Amode >= 0) {
      Level = Level + 1;
      if ((Level > Maxlevel) && (Spec == 0)) Abort(_imp_str_literal("Level"));
      Worklist(Level) = 0;
      if (Amode == 0) {
        if (Level == 1) {
          Blockname = Programip;
          Externalid = Programep;
          Otype = External;
          Potype = Otype;
        } else
          Blockname = _imp_str_literal("%begin block");
        Staticalloc = Enter;
        Frame = -(Level * Wordsize);
      }
    } else {
      if (Amode == -1) {
        Procvar->Pbase = Parms;
      } else if (Amode == -2)
        Frame = Oldframe;
      Maxframe = Frame;
    }
    for (;;) {
      Sym = Pending;
      Readsymbol(Pending);
      Icodecount = Icodecount + 1;
      if (Geticodename(Sym) == _imp_str_literal("ILLEGAL")) {
        Selectoutput(0);
        Printsymbol('(');
        Write(Sym, 0);
        Printsymbol(',');
        Write(Pending, 0);
        Printsymbol(')');
        Abort(_imp_str_literal("Bad I Code"));
      }
      Icodeinst = Sym;
      goto *C[C_sw = (Icodeinst)-33];
    C_33:
      Loadoperation(Orx);
      continue;
    C_34:
      Loadcomparedouble();
      continue;
    C_35:
      Jumpforward(Readtag, Ne);
      continue;
    C_36:
      Definevar(Readtag, Getascii(','), Readtagcomma, Readtagcomma, Readtag);
      continue;
    C_37:
      Loadoperation(Xorx);
      continue;
    C_38:
      Loadoperation(Andx);
      continue;
    C_39:
      Inputstringvalue(Readstring);
      continue;
    C_40:
      Jumpforward(Readtag, Le);
      continue;
    C_41:
      Jumpforward(Readtag, Ge);
      continue;
    C_42:
      Loadoperation(Mulx);
      continue;
    C_43:
      Loadoperation(Addx);
      continue;
    C_45:
      Loadoperation(Subx);
      continue;
    C_46:
      Loadoperation(Concx);
      continue;
    C_47:
      Loadoperation(Divx);
      continue;
    C_58:
      Definecompilerlabel(Readtag);
      continue;
    C_59:
      Loadendofblock();
      break;
    C_60:
      Jumpforward(Readtag, Lt);
      continue;
    C_61:
      Jumpforward(Readtag, Eq);
      continue;
    C_62:
      Jumpforward(Readtag, Gt);
      continue;
    C_63:
      Loadcomparevalues();
      continue;
    C_64:
      Loadvar(Readtag);
      continue;
    C_65:
      Init(Readtag);
      continue;
    C_66:
      Jumpbackward(Readtag);
      continue;
    C_67:
      Loadcompareaddresses();
      continue;
    C_68:
      Inputrealvalue(Readreal);
      continue;
    C_69:
      Loadcompilecall(*Top);
      continue;
    C_70:
      Jumpforward(Readtag, Always);
      continue;
    C_71:
      Getaliasvalue(Readstring);
      continue;
    C_72:
      Loadcompilebegin();
      continue;
    C_73:
      Abort(_imp_str_literal("Pascal?"));
    C_74:
      Userjump(Readtag);
      continue;
    C_75:
      Loadreturn(False);
      continue;
    C_76:
      Defineuserlabel(Readtag);
      continue;
    C_77:
      Loadreturn(Map);
      continue;
    C_78:
      Loadconst(Readinteger);
      continue;
    C_79:
      Updateline(Readtag);
      continue;
    C_80:
      Loadplant();
      continue;
    C_81:
      Loadoperation(Rdivx);
      continue;
    C_82:
      Loadreturn(Routine);
      continue;
    C_83:
      Loadassign(1);
      continue;
    C_84:
      Loadreturn(True);
      continue;
    C_85:
      Loadoperation(Negx);
      continue;
    C_86:
      Loadreturn(Fn);
      continue;
    C_87:
      Switchjump(Readtag);
      continue;
    C_88:
      Loadoperation(Expx);
      continue;
    C_90:
      Loadassign(0);
      continue;
    C_91:
      Loadoperation(Lshx);
      continue;
    C_92:
      Loadoperation(Notx);
      continue;
    C_93:
      Loadoperation(Rshx);
      continue;
    C_94:
      Setrecordformat(Readtag);
      continue;
    C_95:
      Switchlabel(Readtag);
      continue;
    C_97:
      Loadarrayref(0);
      continue;
    C_98:
      Loadconstantbounds();
      continue;
    C_100:
      Dimension(Readtagcomma, Readtag);
      continue;
    C_101:
      Signalevent(Readtag);
      continue;
    C_102:
      Compilefor(Readtag);
      continue;
    C_103:
      Dimension(Readtagcomma, Readtag);
      continue;
    C_104:;
      continue;
    C_105:
      Loadarrayref(1);
      continue;
    C_106:
      Loadassign(2);
      continue;
    C_107:
      Jumpforward(Readtag, Ff);
      continue;
    C_108:
      Loadlanguageflags(Readtag);
      continue;
    C_109:
      Loadmonitor();
      continue;
    C_110:
      Selectfield(Readtag);
      continue;
    C_111:
      Eventtrap(Readtagcomma, Readtag);
      continue;
    C_112:
      Loadassign(-1);
      continue;
    C_113:
      Doubleop(Subx);
      continue;
    C_114:
      Resolve(Readtag);
      continue;
    C_115:
      Loadperm(Stop, 0);
      continue;
    C_116:
      Jumpforward(Readtag, Tt);
      continue;
    C_117:
      Doubleop(Addx);
      continue;
    C_118:
      Loadoperation(Absx);
      continue;
    C_119:
      Machinecode(Getascii(';'));
      continue;
    C_120:
      Loadoperation(Rexpx);
      continue;
    C_121:
      Setcd(Readtag, Diagnose);
      continue;
    C_122:
      Setcd(Readtag, Control);
      continue;
    C_123:
      Startparams();
      continue;
    C_125:
      if (Finishparams()) break;
      continue;
    C_126:
      if (Alternateformat(Alternateformat(Readbyte))) break;
      continue;
    C_default:
      Abort(_imp_str_literal("Bad I Code"));
    }
    if (Amode >= 0) {
      while (Worklist(Level) != 0) Worklist(Level) = Retgptag(Worklist(Level));
      Level = Level - 1;
    } else if (Amode == -2) {
      if (Maxframe > Frame) Frame = Maxframe;
      Oldframe = Frame;
    } else {
      Frame = (Frame + Align) & (~Align);
      Procvar->Size = Frame;
    }
    Frame = Oldframe;
  }
  void Initialisepass2(void) {
    _imp_string255 Thesourcefilename;
    int I;
    int J;
    Blockeofevent();
    if (*Length(Getenv(Getenvindex(_imp_str_literal("IMP_ICODE")))) != 0)
      Showicode = 1;
    Selectinput(Source);
    Thesourcefilename = Inputname;
    Selectinput(Icode);
    Selectoutput(Objout);
    Var(0) = 0;
    Parms = Maxvars;
    for (I = 1; I <= Maxgp; I++) Gptags(I).Link = I - 1;
    Gpasl = Maxgp;
    Dumpsourcename(Thesourcefilename);
    for (I = 1; I <= Lastperm; I++) J = Externalref(Permname(I));
  }
  Initialisepass2();
  Readsymbol(Pending);
  Spec = 0;
  Decvar = &Begin;
  Assemble(-3, 0, 0);
  Flushcot();
  Flushdata();
  Flushswitch();
  exit(0);
  return (1);
}