C# (CSharp) X86OpcodeVariant Examples

Example #1

File: Movzx.cs Project: Techlord-RCE/SharpAssembler

        static Movzx()
        {
            variants = new X86OpcodeVariant[5];
            int index = 0;

            // MOVZX reg16, reg/mem8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x0F, 0xB6 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit));
            // MOVZX reg32, reg/mem8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x0F, 0xB6 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit));
            // MOVZX reg64, reg/mem8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x0F, 0xB6 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit));

            // MOVZX reg32, reg/mem16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x0F, 0xB7 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit));
            // MOVZX reg64, reg/mem16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x0F, 0xB7 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit));
        }

Example #2

File: Movzx.cs Project: Konctantin/SharpAssembler

        static Movzx()
        {
            variants = new X86OpcodeVariant[5];
            int index = 0;

            // MOVZX reg16, reg/mem8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x0F, 0xB6 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit));
            // MOVZX reg32, reg/mem8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x0F, 0xB6 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit));
            // MOVZX reg64, reg/mem8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x0F, 0xB6 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit));

            // MOVZX reg32, reg/mem16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x0F, 0xB7 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit));
            // MOVZX reg64, reg/mem16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x0F, 0xB7 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit));
        }

Example #3

        static Popa()
        {
            variants = new X86OpcodeVariant[2];
            int index = 0;

            // POPA
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x61 }, DataSize.Bit16);
            // POPAD
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x61 }, DataSize.Bit32);
        }

Example #4

File: Popa.cs Project: Konctantin/SharpAssembler

        static Popa()
        {
            variants = new X86OpcodeVariant[2];
            int index = 0;

            // POPA
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x61 }, DataSize.Bit16);
            // POPAD
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x61 }, DataSize.Bit32);
        }

Example #5

File: Movs.cs Project: Techlord-RCE/SharpAssembler

        static Movs()
        {
            variants = new X86OpcodeVariant[2];
            int index = 0;

            // LODSB
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0xA4 }, DataSize.Bit8);
            // LODSW
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0xA5 }, DataSize.Bit16);
            // LODSD
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0xA5 }, DataSize.Bit32);
            // LODSQ
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0xA5 }, DataSize.Bit64);
        }

Example #6

File: Movs.cs Project: Konctantin/SharpAssembler

        static Movs()
        {
            variants = new X86OpcodeVariant[2];
            int index = 0;

            // LODSB
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0xA4 }, DataSize.Bit8);
            // LODSW
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0xA5 }, DataSize.Bit16);
            // LODSD
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0xA5 }, DataSize.Bit32);
            // LODSQ
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0xA5 }, DataSize.Bit64);
        }

Example #7

File: Sub.cs Project: Techlord-RCE/SharpAssembler

        static Sub()
        {
            variants = new X86OpcodeVariant[19];
            int index = 0;

            // SUB AL, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x2C },
                new OperandDescriptor(Register.AL),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // SUB AX, imm16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x2D },
                new OperandDescriptor(Register.AX),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit16));
            // SUB EAX, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x2D },
                new OperandDescriptor(Register.EAX),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));
            // SUB RAX, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x2D },
                new OperandDescriptor(Register.RAX),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));

            // SUB reg/mem8, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x80 }, 5,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // SUB reg/mem16, imm16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x81 }, 5,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit16));
            // SUB reg/mem32, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x81 }, 5,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));
            // SUB reg/mem64, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x81 }, 5,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));

            // SUB reg/mem16, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x83 }, 5,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // SUB reg/mem32, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x83 }, 5,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // SUB reg/mem64, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x83 }, 5,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));


            // SUB reg/mem8, reg8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x28 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose8Bit));
            // SUB reg/mem16, reg16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x29 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose16Bit));
            // SUB reg/mem32, reg32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x29 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose32Bit));
            // SUB reg/mem64, reg64
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x29 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose64Bit));


            // SUB reg8, reg/mem8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x2A },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose8Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit));
            // SUB reg16, reg/mem16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x2B },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit));
            // SUB reg32, reg/mem32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x2B },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit));
            // SUB reg64, reg/mem64
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x2B },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit));
        }

Example #8

        static Xor()
        {
            variants = new X86OpcodeVariant[19];
            int index = 0;

            // XOR AL, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x34 },
                new OperandDescriptor(Register.AL),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // XOR AX, imm16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x35 },
                new OperandDescriptor(Register.AX),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit16));
            // XOR EAX, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x35 },
                new OperandDescriptor(Register.EAX),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));
            // XOR RAX, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x35 },
                new OperandDescriptor(Register.RAX),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));

            // XOR reg/mem8, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x80 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // XOR reg/mem16, imm16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x81 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit16));
            // XOR reg/mem32, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x81 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));
            // XOR reg/mem64, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x81 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));

            // XOR reg/mem16, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x83 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // XOR reg/mem32, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x83 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // XOR reg/mem64, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x83 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));


            // XOR reg/mem8, reg8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x30 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose8Bit));
            // XOR reg/mem16, reg16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x31 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose16Bit));
            // XOR reg/mem32, reg32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x31 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose32Bit));
            // XOR reg/mem64, reg64
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x31 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose64Bit));


            // XOR reg8, reg/mem8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x32 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose8Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit));
            // XOR reg16, reg/mem16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x33 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit));
            // XOR reg32, reg/mem32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x33 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit));
            // XOR reg64, reg/mem64
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x33 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit));
        }

Example #9

File: Xor.cs Project: Konctantin/SharpAssembler

        static Xor()
        {
            variants = new X86OpcodeVariant[19];
            int index = 0;

            // XOR AL, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x34 },
                new OperandDescriptor(Register.AL),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // XOR AX, imm16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x35 },
                new OperandDescriptor(Register.AX),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit16));
            // XOR EAX, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x35 },
                new OperandDescriptor(Register.EAX),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));
            // XOR RAX, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x35 },
                new OperandDescriptor(Register.RAX),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));

            // XOR reg/mem8, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x80 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // XOR reg/mem16, imm16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x81 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit16));
            // XOR reg/mem32, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x81 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));
            // XOR reg/mem64, imm32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x81 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit32));

            // XOR reg/mem16, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x83 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // XOR reg/mem32, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x83 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));
            // XOR reg/mem64, imm8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x83 }, 6,
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.Immediate, DataSize.Bit8));

            // XOR reg/mem8, reg8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x30 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose8Bit));
            // XOR reg/mem16, reg16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x31 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose16Bit));
            // XOR reg/mem32, reg32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x31 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose32Bit));
            // XOR reg/mem64, reg64
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x31 },
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose64Bit));

            // XOR reg8, reg/mem8
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x32 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose8Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose8Bit));
            // XOR reg16, reg/mem16
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x33 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose16Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose16Bit));
            // XOR reg32, reg/mem32
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x33 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose32Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose32Bit));
            // XOR reg64, reg/mem64
            variants[index++] = new X86OpcodeVariant(
                new byte[] { 0x33 },
                new OperandDescriptor(OperandType.RegisterOperand, RegisterType.GeneralPurpose64Bit),
                new OperandDescriptor(OperandType.RegisterOrMemoryOperand, RegisterType.GeneralPurpose64Bit));
        }