public static OpCode FromName1W(string op, Reg16 op1)
 {
     switch (op)
     {
         case "push":
             return OpCode.NewBytes(Util.GetBytes2(0x66, (byte)(0x50 + op1)));
         case "pop":
             return OpCode.NewBytes(Util.GetBytes2(0x66, (byte)(0x58 + op1)));
         case "inc":
             return OpCode.NewBytes(Util.GetBytes2(0x66, (byte)(0x40 + op1)));
         case "dec":
             return OpCode.NewBytes(Util.GetBytes2(0x66, (byte)(0x48 + op1)));
         case "not":
             return OpCode.NewBytes(Util.GetBytes3(0x66, 0xf7, (byte)(0xd0 + op1)));
         case "neg":
             return OpCode.NewBytes(Util.GetBytes3(0x66, 0xf7, (byte)(0xd8 + op1)));
         case "mul":
             return OpCode.NewBytes(Util.GetBytes3(0x66, 0xf7, (byte)(0xe0 + op1)));
         case "imul":
             return OpCode.NewBytes(Util.GetBytes3(0x66, 0xf7, (byte)(0xe8 + op1)));
         case "div":
             return OpCode.NewBytes(Util.GetBytes3(0x66, 0xf7, (byte)(0xf0 + op1)));
         case "idiv":
             return OpCode.NewBytes(Util.GetBytes3(0x66, 0xf7, (byte)(0xf8 + op1)));
         default:
             throw new Exception("invalid operator: " + op);
     }
 }

 public static OpCode FromNameW(string op, Reg16 op1)
 {
     switch (op)
     {
         case "push":
             return new OpCode(new byte[] { 0x66, (byte)(0x50 + op1) });
         case "pop":
             return new OpCode(new byte[] { 0x66, (byte)(0x58 + op1) });
         case "inc":
             return new OpCode(new byte[] { 0x66, (byte)(0x40 + op1) });
         case "dec":
             return new OpCode(new byte[] { 0x66, (byte)(0x48 + op1) });
         case "not":
             return new OpCode(new byte[] { 0x66, 0xf7, (byte)(0xd0 + op1) });
         case "neg":
             return new OpCode(new byte[] { 0x66, 0xf7, (byte)(0xd8 + op1) });
         case "mul":
             return new OpCode(new byte[] { 0x66, 0xf7, (byte)(0xe0 + op1) });
         case "imul":
             return new OpCode(new byte[] { 0x66, 0xf7, (byte)(0xe8 + op1) });
         case "div":
             return new OpCode(new byte[] { 0x66, 0xf7, (byte)(0xf0 + op1) });
         case "idiv":
             return new OpCode(new byte[] { 0x66, 0xf7, (byte)(0xf8 + op1) });
         default:
             throw new Exception("invalid operator: " + op);
     }
 }

 public static OpCode FromNameW(string op, Reg32 op1, Reg16 op2)
 {
     byte b;
     switch (op)
     {
         case "movzx":
             b = 0xb7;
             break;
         case "movsx":
             b = 0xbf;
             break;
         default:
             throw new Exception("invalid operator: " + op);
     }
     return OpCode.NewBytes(Util.GetBytes3(0x0f, b, (byte)(0xc0 + (((int)op1) << 3) + op2)));
 }

 public static OpCode FromNameWBA(string op, Reg16 op1, Addr32 op2)
 {
     byte b;
     switch (op)
     {
         case "movzx":
             b = 0xb6;
             break;
         case "movsx":
             b = 0xbe;
             break;
         default:
             throw new Exception("invalid operator: " + op);
     }
     return OpCode.NewA(Util.GetBytes3(0x66, 0x0f, b), Addr32.NewAdM(op2, (byte)op1));
 }

 public static OpCode FromNameB(string op, Reg16 op1, Addr32 op2)
 {
     byte b;
     switch (op)
     {
         case "movzx":
             b = 0xb6;
             break;
         case "movsx":
             b = 0xbe;
             break;
         default:
             throw new Exception("invalid operator: " + op);
     }
     return new OpCode(new byte[] { 0x66, 0x0f, b }, null, new Addr32(op2, (byte)op1));
 }

 public static OpCode ShiftW(string op, Reg16 op1, Reg8 op2)
 {
     byte b;
     switch (op)
     {
         case "shl":
         case "sal":
             b = (byte)(0xe0 + op1);
             break;
         case "shr":
             b = (byte)(0xe8 + op1);
             break;
         case "sar":
             b = (byte)(0xf8 + op1);
             break;
         default:
             throw new Exception("invalid operator: " + op);
     }
     if (op2 != Reg8.CL)
         throw new Exception("invalid register: " + op2);
     else
         return new OpCode(new byte[] { 0x66, 0xd3, b });
 }

 public static OpCode ShiftW(string op, Reg16 op1, byte op2)
 {
     byte b;
     switch (op)
     {
         case "shl":
         case "sal":
             b = (byte)(0xe0 + op1);
             break;
         case "shr":
             b = (byte)(0xe8 + op1);
             break;
         case "sar":
             b = (byte)(0xf8 + op1);
             break;
         default:
             throw new Exception("invalid operator: " + op);
     }
     if (op2 == 1)
         return OpCode.NewBytes(Util.GetBytes3(0x66, 0xd1, b));
     else
         return OpCode.NewB(Util.GetBytes3(0x66, 0xc1, b), op2);
 }

 public static OpCode AndWRA(Reg16 op1, Addr32 op2)
 {
     return FromName2WRA("and", op1, op2);
 }

 public static OpCode CmpW(Reg16 op1, Reg16 op2)
 {
     return FromName2W("cmp", op1, op2);
 }

 public static OpCode AndWAR(Addr32 op1, Reg16 op2)
 {
     return FromName2WAR("and", op1, op2);
 }

 public static OpCode AndWR(Reg16 op1, ushort op2)
 {
     return FromName2WR("and", op1, op2);
 }

 public static OpCode SarWR(Reg16 op1, Reg8 op2)
 {
     return ShiftWR("sar", op1, op2);
 }

 public static OpCode TestWR(Reg16 op1, ushort op2)
 {
     return FromName2WR("test", op1, op2);
 }

 public static OpCode XorWAR(Addr32 op1, Reg16 op2)
 {
     return FromName2WAR("xor", op1, op2);
 }

 public static OpCode ShlWR(Reg16 op1, Reg8 op2)
 {
     return ShiftWR("shl", op1, op2);
 }

 public static OpCode XchgWRA(Reg16 op1, Addr32 op2)
 {
     return FromName2WRA("xchg", op1, op2);
 }

 public static OpCode TestW(Reg16 op1, Reg16 op2)
 {
     return FromName2W("test", op1, op2);
 }

 public static OpCode XchgWAR(Addr32 op1, Reg16 op2)
 {
     return XchgWRA(op2, op1);
 }

 public static OpCode XchgW(Reg16 op1, Reg16 op2)
 {
     return FromName2W("xchg", op1, op2);
 }

 public static OpCode TestWRA(Reg16 op1, Addr32 op2)
 {
     return TestWAR(op2, op1);
 }