LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: lea_GvM
void __bea_callspec__ lea_GvM(PDISASM pMyDisasm)
{

    /* if MOD == 11b, invalid instruction */
    /* or VEX Prefix - implemented in next release (AVX) */

    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+MISCELLANEOUS_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lea ");
    #endif
    if (GV.OperandSize >= 32) {
        if (GV.OperandSize == 64) {
            GV.MemDecoration = Arg2qword;
        }
        else {
            GV.MemDecoration = Arg2dword;
        }
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.EIP_+= GV.DECALAGE_EIP+2;
    }
    else {
        GV.MemDecoration = Arg2word;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.EIP_+= GV.DECALAGE_EIP+2;
    }
    (*pMyDisasm).Argument2.AccessMode = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1000c, 0x60(%rax)    # imm = 0x1000C
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x3215b(%rip), %rsi     # 0x51685
callq 0x81c0
movq -0x8(%rbp), %rax
cmpl $0x20, 0x20c(%rax)
jl 0x1f5b4
movq -0x8(%rbp), %rax
cmpl $0x40, 0x20c(%rax)
jne 0x1f559
movq -0x8(%rbp), %rax
movl $0x68, 0x210(%rax)
jmp 0x1f567
movq -0x8(%rbp), %rax
movl $0x67, 0x210(%rax)
movq -0x8(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
movq -0x8(%rbp), %rsi
callq 0x4dd40
movq -0x8(%rbp), %rax
movl 0x244(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
jmp 0x1f60d
movq -0x8(%rbp), %rax
movl $0x66, 0x210(%rax)
movq -0x8(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
movq -0x8(%rbp), %rsi
callq 0x4dd40
movq -0x8(%rbp), %rax
movl 0x244(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x150(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cwde_
void __bea_callspec__ cwde_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    if (GV.OperandSize == 64) {
        if (GV.SYNTAX_ == ATSyntax) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cltq ");
            #endif
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cdqe ");
            #endif
        }
        (*pMyDisasm).Argument1.ArgSize = 64;
    }
    else if (GV.OperandSize == 32) {
        if (GV.SYNTAX_ == ATSyntax) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cwtl ");
            #endif
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cwde ");
            #endif
        }
        (*pMyDisasm).Argument1.ArgSize = 32;
    }
    else {
        if (GV.SYNTAX_ == ATSyntax) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cbtw ");
            #endif
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cbw ");
            #endif
        }
        (*pMyDisasm).Argument1.ArgSize = 16;
    }
    GV.EIP_++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10001, 0x60(%rax)    # imm = 0x10001
movq -0x8(%rbp), %rax
movl $0x20020001, 0xdc(%rax) # imm = 0x20020001
movq -0x8(%rbp), %rax
cmpl $0x40, 0x20c(%rax)
jne 0x20ca7
movq -0x8(%rbp), %rax
cmpl $0x400, 0x24c(%rax)     # imm = 0x400
jne 0x20c7c
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x30902(%rip), %rsi     # 0x51577
callq 0x81c0
jmp 0x20c94
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x308ee(%rip), %rsi     # 0x5157d
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x40, 0xe0(%rax)
jmp 0x20d58
movq -0x8(%rbp), %rax
cmpl $0x20, 0x20c(%rax)
jne 0x20d06
movq -0x8(%rbp), %rax
cmpl $0x400, 0x24c(%rax)     # imm = 0x400
jne 0x20cde
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x308ac(%rip), %rsi     # 0x51583
callq 0x81c0
jmp 0x20cf6
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x30898(%rip), %rsi     # 0x51589
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x20, 0xe0(%rax)
jmp 0x20d56
movq -0x8(%rbp), %rax
cmpl $0x400, 0x24c(%rax)     # imm = 0x400
jne 0x20d30
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x30866(%rip), %rsi     # 0x5158f
callq 0x81c0
jmp 0x20d48
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x30852(%rip), %rsi     # 0x51595
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x10, 0xe0(%rax)
jmp 0x20d58
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sahf_
void __bea_callspec__ sahf_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sahf ");
    #endif
    GV.EIP_++;
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 32;
    (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument2.ArgSize = 8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1000a, 0x60(%rax)    # imm = 0x1000A
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x301a0(%rip), %rsi     # 0x517ba
callq 0x81c0
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
movq -0x8(%rbp), %rax
movl $0x20400001, 0xdc(%rax) # imm = 0x20400001
movq -0x8(%rbp), %rax
movl $0x20, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x20020001, 0x144(%rax) # imm = 0x20020001
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: lahf_
void __bea_callspec__ lahf_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lahf ");
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1000a, 0x60(%rax)    # imm = 0x1000A
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2ffc4(%rip), %rsi     # 0x5166e
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x20020001, 0xdc(%rax) # imm = 0x20020001
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x20400001, 0x144(%rax) # imm = 0x20400001
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: movs_
void __bea_callspec__ movs_(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsb ");
    #endif
    (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
    (*pMyDisasm).Argument2.ArgSize = 8;
    (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6+REG7;
    GV.EIP_++;
    FillFlags(pMyDisasm, 68);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1df(%rax), %eax
cmpl $0x2, %eax
jne 0x22317
movq -0x8(%rbp), %rax
movb $0x1, 0x1df(%rax)
movq -0x8(%rbp), %rax
movzbl 0x1e0(%rax), %eax
cmpl $0x2, %eax
jne 0x22332
movq -0x8(%rbp), %rax
movb $0x1, 0x1e0(%rax)
movq -0x8(%rbp), %rax
movl $0x10007, 0x60(%rax)    # imm = 0x10007
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2f384(%rip), %rsi     # 0x516d4
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x40000000, 0xdc(%rax) # imm = 0x40000000
movq -0x8(%rbp), %rax
movl $0x80, 0xec(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x40000000, 0x144(%rax) # imm = 0x40000000
movq -0x8(%rbp), %rax
movl $0x40, 0x154(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movl $0x200c0, 0x98(%rax)    # imm = 0x200C0
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
movq -0x8(%rbp), %rdi
movl $0x44, %esi
callq 0x4d560
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmpsb_
void __bea_callspec__ cmpsb_(PDISASM pMyDisasm)
{

    /* ========= 0xf3 */
    if (GV.PrefRepe == 1) {
        (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
    }
    /* ========= 0xf2 */
    if (GV.PrefRepne == 1) {
        (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpsb ");
    #endif
    (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
    (*pMyDisasm).Argument1.AccessMode = READ;
    (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument2.ArgSize = 8;
    (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
    FillFlags(pMyDisasm,21);
    GV.EIP_++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x268(%rax)
jne 0x22674
movq -0x8(%rbp), %rax
movb $0x1, 0x1e0(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x26c(%rax)
jne 0x2268c
movq -0x8(%rbp), %rax
movb $0x1, 0x1df(%rax)
movq -0x8(%rbp), %rax
movl $0x10007, 0x60(%rax)    # imm = 0x10007
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2eeb1(%rip), %rsi     # 0x5155b
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x40000000, 0xdc(%rax) # imm = 0x40000000
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x80, 0xec(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xe8(%rax)
movq -0x8(%rbp), %rax
movl $0x40000000, 0x144(%rax) # imm = 0x40000000
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movl $0x40, 0x154(%rax)
movq -0x8(%rbp), %rdi
movl $0x15, %esi
callq 0x4d560
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmps_
void __bea_callspec__ cmps_(PDISASM pMyDisasm)
{
    /* ========= 0xf3 */
    if (GV.PrefRepe == 1) {
        (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
    }
    /* ========= 0xf2 */
    if (GV.PrefRepne == 1) {
        (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
    (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
    (*pMyDisasm).Argument1.AccessMode = READ;
    (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
    if (GV.Architecture == 64) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpsq ");
        #endif
        (*pMyDisasm).Argument1.ArgSize = 64;
        (*pMyDisasm).Argument2.ArgSize = 64;
    }
    else if (GV.OperandSize == 32) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpsd ");
        #endif
        (*pMyDisasm).Argument1.ArgSize = 32;
        (*pMyDisasm).Argument2.ArgSize = 32;
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpsw ");
        #endif
        (*pMyDisasm).Argument1.ArgSize = 16;
        (*pMyDisasm).Argument2.ArgSize = 16;
    }
    FillFlags(pMyDisasm,21);
    GV.EIP_++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x268(%rax)
jne 0x22764
movq -0x8(%rbp), %rax
movb $0x1, 0x1e0(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x26c(%rax)
jne 0x2277c
movq -0x8(%rbp), %rax
movb $0x1, 0x1df(%rax)
movq -0x8(%rbp), %rax
movl $0x10007, 0x60(%rax)    # imm = 0x10007
movq -0x8(%rbp), %rax
movl $0x40000000, 0xdc(%rax) # imm = 0x40000000
movq -0x8(%rbp), %rax
movl $0x80, 0xec(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xe8(%rax)
movq -0x8(%rbp), %rax
movl $0x40000000, 0x144(%rax) # imm = 0x40000000
movq -0x8(%rbp), %rax
movl $0x40, 0x154(%rax)
movq -0x8(%rbp), %rax
cmpl $0x40, 0x25c(%rax)
jne 0x22810
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2ed75(%rip), %rsi     # 0x51562
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x40, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x40, 0x148(%rax)
jmp 0x22889
movq -0x8(%rbp), %rax
cmpl $0x20, 0x20c(%rax)
jne 0x22853
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2ed39(%rip), %rsi     # 0x51569
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x20, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x20, 0x148(%rax)
jmp 0x22887
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2ed0a(%rip), %rsi     # 0x51570
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x10, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x10, 0x148(%rax)
jmp 0x22889
movq -0x8(%rbp), %rdi
movl $0x15, %esi
callq 0x4d560
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: test_ALIb
void __bea_callspec__ test_ALIb(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
    #endif
    (*pMyDisasm).Argument1.AccessMode = READ;
    ALIb(pMyDisasm);
    FillFlags(pMyDisasm,104);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10005, 0x60(%rax)    # imm = 0x10005
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2fb70(%rip), %rsi     # 0x5245a
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x1, 0xe8(%rax)
movq -0x8(%rbp), %rdi
callq 0x4d790
movq -0x8(%rbp), %rdi
movl $0x68, %esi
callq 0x4d560
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: test_eAX_Iv
void __bea_callspec__ test_eAX_Iv(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
    #endif
    (*pMyDisasm).Argument1.AccessMode = READ;
    eAX_Iv(pMyDisasm);
    FillFlags(pMyDisasm,104);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10005, 0x60(%rax)    # imm = 0x10005
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2fb10(%rip), %rsi     # 0x5245a
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x1, 0xe8(%rax)
movq -0x8(%rbp), %rdi
callq 0x4d870
movq -0x8(%rbp), %rdi
movl $0x68, %esi
callq 0x4d560
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: stos_
void __bea_callspec__ stos_(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "stosb ");
    #endif
    (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument2.ArgSize = 8;
    (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
    GV.EIP_++;
    FillFlags(pMyDisasm, 101);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1df(%rax), %eax
cmpl $0x2, %eax
jne 0x229a7
movq -0x8(%rbp), %rax
movb $0x1, 0x1df(%rax)
movq -0x8(%rbp), %rax
movzbl 0x1e0(%rax), %eax
cmpl $0x2, %eax
jne 0x229c2
movq -0x8(%rbp), %rax
movb $0x1, 0x1e0(%rax)
movq -0x8(%rbp), %rax
movl $0x10007, 0x60(%rax)    # imm = 0x10007
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2ee0c(%rip), %rsi     # 0x517ec
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x20020001, 0x144(%rax) # imm = 0x20020001
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movl $0x40000000, 0xdc(%rax) # imm = 0x40000000
movq -0x8(%rbp), %rax
movl $0x80, 0xec(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x20080, 0x98(%rax)    # imm = 0x20080
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
movq -0x8(%rbp), %rdi
movl $0x65, %esi
callq 0x4d560
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: lodsb_
void __bea_callspec__ lodsb_(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lodsb ");
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
    (*pMyDisasm).Argument2.ArgSize = 8;
    (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6;
    GV.EIP_++;
    FillFlags(pMyDisasm, 59);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1df(%rax), %eax
cmpl $0x2, %eax
jne 0x22cd7
movq -0x8(%rbp), %rax
movb $0x1, 0x1df(%rax)
movq -0x8(%rbp), %rax
movzbl 0x1e0(%rax), %eax
cmpl $0x2, %eax
jne 0x22cf2
movq -0x8(%rbp), %rax
movb $0x1, 0x1e0(%rax)
movq -0x8(%rbp), %rax
movl $0x10007, 0x60(%rax)    # imm = 0x10007
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2e97f(%rip), %rsi     # 0x5168f
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x20020001, 0xdc(%rax) # imm = 0x20020001
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x40000000, 0x144(%rax) # imm = 0x40000000
movq -0x8(%rbp), %rax
movl $0x40, 0x154(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movl $0x20040, 0x98(%rax)    # imm = 0x20040
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
callq 0x4d560
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: scasb_
void __bea_callspec__ scasb_(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "scasb ");
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument1.AccessMode = READ;
    (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument2.Memory.BaseRegister = REG7;
    (*pMyDisasm).Argument2.ArgSize = 8;
    (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
    GV.EIP_++;
    FillFlags(pMyDisasm, 94);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1df(%rax), %eax
cmpl $0x2, %eax
jne 0x23007
movq -0x8(%rbp), %rax
movb $0x1, 0x1df(%rax)
movq -0x8(%rbp), %rax
movzbl 0x1e0(%rax), %eax
cmpl $0x2, %eax
jne 0x23022
movq -0x8(%rbp), %rax
movb $0x1, 0x1e0(%rax)
movq -0x8(%rbp), %rax
movl $0x10007, 0x60(%rax)    # imm = 0x10007
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2e786(%rip), %rsi     # 0x517c6
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x20020001, 0xdc(%rax) # imm = 0x20020001
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xe8(%rax)
movq -0x8(%rbp), %rax
movl $0x40000000, 0x144(%rax) # imm = 0x40000000
movq -0x8(%rbp), %rax
movl $0x80, 0x154(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movl $0x20080, 0x98(%rax)    # imm = 0x20080
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
movq -0x8(%rbp), %rdi
movl $0x5e, %esi
callq 0x4d560
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_CLIb
void __bea_callspec__ mov_CLIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[1]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10001, 0x60(%rax)    # imm = 0x10001
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2e325(%rip), %rsi     # 0x516cf
callq 0x81c0
movq -0x8(%rbp), %rsi
movl $0x2, %edi
callq 0x4d340
cmpl $0x0, %eax
jne 0x233c7
jmp 0x2347b
movq -0x8(%rbp), %rax
movl $0x8, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movzbl 0x1(%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x104, %rsi            # imm = 0x104
movq -0x10(%rbp), %rcx
leaq 0x2e059(%rip), %rdx     # 0x5145b
callq 0x4d3a0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
leaq 0x3f91c(%rip), %rsi     # 0x62d44
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x20020002, 0xdc(%rax) # imm = 0x20020002
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x88000000, 0x144(%rax) # imm = 0x88000000
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_DLIb
void __bea_callspec__ mov_DLIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[2]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10001, 0x60(%rax)    # imm = 0x10001
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2e215(%rip), %rsi     # 0x516cf
callq 0x81c0
movq -0x8(%rbp), %rsi
movl $0x2, %edi
callq 0x4d340
cmpl $0x0, %eax
jne 0x234d7
jmp 0x2358b
movq -0x8(%rbp), %rax
movl $0x8, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movzbl 0x1(%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x104, %rsi            # imm = 0x104
movq -0x10(%rbp), %rcx
leaq 0x2df49(%rip), %rdx     # 0x5145b
callq 0x4d3a0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
leaq 0x3f810(%rip), %rsi     # 0x62d48
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x20020004, 0xdc(%rax) # imm = 0x20020004
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x88000000, 0x144(%rax) # imm = 0x88000000
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_BLIb
void __bea_callspec__ mov_BLIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[3]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG3;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10001, 0x60(%rax)    # imm = 0x10001
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2e105(%rip), %rsi     # 0x516cf
callq 0x81c0
movq -0x8(%rbp), %rsi
movl $0x2, %edi
callq 0x4d340
cmpl $0x0, %eax
jne 0x235e7
jmp 0x2369b
movq -0x8(%rbp), %rax
movl $0x8, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movzbl 0x1(%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x104, %rsi            # imm = 0x104
movq -0x10(%rbp), %rcx
leaq 0x2de39(%rip), %rdx     # 0x5145b
callq 0x4d3a0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
leaq 0x3f704(%rip), %rsi     # 0x62d4c
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x20020008, 0xdc(%rax) # imm = 0x20020008
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x88000000, 0x144(%rax) # imm = 0x88000000
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_AHIb
void __bea_callspec__ mov_AHIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[4]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgPosition = HighPosition;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10001, 0x60(%rax)    # imm = 0x10001
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2dff5(%rip), %rsi     # 0x516cf
callq 0x81c0
movq -0x8(%rbp), %rsi
movl $0x2, %edi
callq 0x4d340
cmpl $0x0, %eax
jne 0x236f7
jmp 0x237b9
movq -0x8(%rbp), %rax
movl $0x8, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movzbl 0x1(%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x104, %rsi            # imm = 0x104
movq -0x10(%rbp), %rcx
leaq 0x2dd29(%rip), %rdx     # 0x5145b
callq 0x4d3a0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
leaq 0x3f5f8(%rip), %rsi     # 0x62d50
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x20020001, 0xdc(%rax) # imm = 0x20020001
movq -0x8(%rbp), %rax
movl $0x1, 0xe4(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x88000000, 0x144(%rax) # imm = 0x88000000
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_CHIb
void __bea_callspec__ mov_CHIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[5]);
    #endif
    (*pMyDisasm).Argument1.ArgPosition = HighPosition;
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10001, 0x60(%rax)    # imm = 0x10001
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2dee5(%rip), %rsi     # 0x516cf
callq 0x81c0
movq -0x8(%rbp), %rsi
movl $0x2, %edi
callq 0x4d340
cmpl $0x0, %eax
jne 0x23807
jmp 0x238c9
movq -0x8(%rbp), %rax
movl $0x8, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movzbl 0x1(%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x104, %rsi            # imm = 0x104
movq -0x10(%rbp), %rcx
leaq 0x2dc19(%rip), %rdx     # 0x5145b
callq 0x4d3a0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
leaq 0x3f4ec(%rip), %rsi     # 0x62d54
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x1, 0xe4(%rax)
movq -0x8(%rbp), %rax
movl $0x20020002, 0xdc(%rax) # imm = 0x20020002
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x88000000, 0x144(%rax) # imm = 0x88000000
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_DHIb
void __bea_callspec__ mov_DHIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[6]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
    (*pMyDisasm).Argument1.ArgPosition = HighPosition;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10001, 0x60(%rax)    # imm = 0x10001
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2ddd5(%rip), %rsi     # 0x516cf
callq 0x81c0
movq -0x8(%rbp), %rsi
movl $0x2, %edi
callq 0x4d340
cmpl $0x0, %eax
jne 0x23917
jmp 0x239d9
movq -0x8(%rbp), %rax
movl $0x8, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movzbl 0x1(%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x104, %rsi            # imm = 0x104
movq -0x10(%rbp), %rcx
leaq 0x2db09(%rip), %rdx     # 0x5145b
callq 0x4d3a0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
leaq 0x3f3e0(%rip), %rsi     # 0x62d58
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0x20020004, 0xdc(%rax) # imm = 0x20020004
movq -0x8(%rbp), %rax
movl $0x1, 0xe4(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x88000000, 0x144(%rax) # imm = 0x88000000
movq -0x8(%rbp), %rax
movl $0x8, 0x148(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x1f0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: retn_
void __bea_callspec__ retn_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
    (*pMyDisasm).Instruction.BranchType = RetType;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "retn ");
    #endif
    if (!Security(3, pMyDisasm)) return;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic,"%.4X",(Int64)*((UInt16*)(UIntPtr) (GV.EIP_+1)));
    #endif
    GV.ImmediatSize = 16;
    (*pMyDisasm).Instruction.Immediat = *((UInt16*)(UIntPtr) (GV.EIP_+1));
    GV.EIP_+=3;
    (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument1.ArgSize = 16;
    (*pMyDisasm).Argument1.AccessMode = READ;
    (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x10006, 0x60(%rax)    # imm = 0x10006
movq -0x8(%rbp), %rax
movl $0xd, 0x78(%rax)
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2bf96(%rip), %rsi     # 0x5177b
callq 0x81c0
movq -0x8(%rbp), %rsi
movl $0x3, %edi
callq 0x4d340
cmpl $0x0, %eax
jne 0x25802
jmp 0x258a6
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x9c, %rsi
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movzwl 0x1(%rax), %eax
movl %eax, %ecx
leaq 0x2bc9d(%rip), %rdx     # 0x514c6
callq 0x4d3a0
movq -0x8(%rbp), %rax
movl $0x10, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movzwl 0x1(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x3, %rcx
movq %rcx, 0x1f0(%rax)
movq -0x8(%rbp), %rax
movl $0x88000000, 0xdc(%rax) # imm = 0x88000000
movq -0x8(%rbp), %rax
movl $0x10, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xe8(%rax)
movq -0x8(%rbp), %rax
movl $0x20010, 0x98(%rax)    # imm = 0x20010
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: ret_
void __bea_callspec__ ret_(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
    (*pMyDisasm).Instruction.BranchType = RetType;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ret ");
    #endif
    GV.EIP_++;
    (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument2.ArgSize = 32;
    (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
    (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1e0(%rax), %eax
cmpl $0x2, %eax
jne 0x258d7
movq -0x8(%rbp), %rax
movb $0x1, 0x1e0(%rax)
movq -0x8(%rbp), %rax
movl $0x10006, 0x60(%rax)    # imm = 0x10006
movq -0x8(%rbp), %rax
movl $0xd, 0x78(%rax)
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2be82(%rip), %rsi     # 0x51782
callq 0x81c0
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
movq -0x8(%rbp), %rax
movl $0x40000000, 0x144(%rax) # imm = 0x40000000
movq -0x8(%rbp), %rax
movl $0x20, 0x148(%rax)
movq -0x8(%rbp), %rax
movl $0x10, 0x154(%rax)
movq -0x8(%rbp), %rax
movl $0x20010, 0x98(%rax)    # imm = 0x20010
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: les_GvM
void __bea_callspec__ les_GvM(PDISASM pMyDisasm)
{

    if (GV.Architecture == 64) {
        FailDecode(pMyDisasm);
    }
    else {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SEGMENT_REGISTER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "les ");
        #endif
        if (GV.OperandSize == 32) {
            GV.MemDecoration = Arg2fword;
            MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
            Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
            GV.EIP_+= GV.DECALAGE_EIP+2;
        }
        else {
            GV.MemDecoration = Arg2dword;
            MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
            Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
            GV.EIP_+= GV.DECALAGE_EIP+2;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x40, 0x25c(%rax)
jne 0x25987
movq -0x8(%rbp), %rdi
callq 0x30050
jmp 0x25a6d
movq -0x8(%rbp), %rax
movl $0x1000b, 0x60(%rax)    # imm = 0x1000B
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2bce5(%rip), %rsi     # 0x5168a
callq 0x81c0
movq -0x8(%rbp), %rax
cmpl $0x20, 0x20c(%rax)
jne 0x25a12
movq -0x8(%rbp), %rax
movl $0x6b, 0x210(%rax)
movq -0x8(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
movq -0x8(%rbp), %rsi
callq 0x4dd40
movq -0x8(%rbp), %rax
movl 0x244(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
jmp 0x25a6b
movq -0x8(%rbp), %rax
movl $0x67, 0x210(%rax)
movq -0x8(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
movq -0x8(%rbp), %rsi
callq 0x4dd40
movq -0x8(%rbp), %rax
movl 0x244(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
jmp 0x25a6d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: lds_GvM
void __bea_callspec__ lds_GvM(PDISASM pMyDisasm)
{
    /* if MOD == 11b, invalid instruction */
    /* or VEX Prefix - implemented in next release (AVX) */

    if (GV.Architecture == 64) {
        FailDecode(pMyDisasm);
    }
    else {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SEGMENT_REGISTER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lds ");
        #endif
        if (GV.OperandSize == 32) {
            GV.MemDecoration = Arg2fword;
            MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
            Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
            GV.EIP_+= GV.DECALAGE_EIP+2;
        }
        else {
            GV.MemDecoration = Arg2dword;
            MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
            Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
            GV.EIP_+= GV.DECALAGE_EIP+2;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x40, 0x25c(%rax)
jne 0x25aa7
movq -0x8(%rbp), %rdi
callq 0x30050
jmp 0x25b8d
movq -0x8(%rbp), %rax
movl $0x1000b, 0x60(%rax)    # imm = 0x1000B
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2bbb4(%rip), %rsi     # 0x51679
callq 0x81c0
movq -0x8(%rbp), %rax
cmpl $0x20, 0x20c(%rax)
jne 0x25b32
movq -0x8(%rbp), %rax
movl $0x6b, 0x210(%rax)
movq -0x8(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
movq -0x8(%rbp), %rsi
callq 0x4dd40
movq -0x8(%rbp), %rax
movl 0x244(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
jmp 0x25b8b
movq -0x8(%rbp), %rax
movl $0x67, 0x210(%rax)
movq -0x8(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movq -0x8(%rbp), %rsi
callq 0x4dbc0
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
movq -0x8(%rbp), %rsi
callq 0x4dd40
movq -0x8(%rbp), %rax
movl 0x244(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x1f0(%rax), %rcx
movq %rcx, 0x1f0(%rax)
jmp 0x25b8d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_EbIb
void __bea_callspec__ mov_EbIb(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    if (GV.REGOPCODE == 0) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
        #endif
        EbIb(pMyDisasm);
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movzbl 0x1(%rax), %ecx
sarl $0x3, %ecx
andl $0x7, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x240(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x240(%rax)
jne 0x25c06
movq -0x8(%rbp), %rax
movl $0x10001, 0x60(%rax)    # imm = 0x10001
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2bad9(%rip), %rsi     # 0x516cf
callq 0x81c0
movq -0x8(%rbp), %rdi
callq 0x4e3f0
jmp 0x25c0f
movq -0x8(%rbp), %rdi
callq 0x30050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_EvIv
void __bea_callspec__ mov_EvIv(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    if (GV.REGOPCODE == 0) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
        #endif
        EvIv(pMyDisasm);
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movzbl 0x1(%rax), %ecx
sarl $0x3, %ecx
andl $0x7, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x240(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x240(%rax)
jne 0x25c86
movq -0x8(%rbp), %rax
movl $0x10001, 0x60(%rax)    # imm = 0x10001
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x8, %rdi
leaq 0x2ba59(%rip), %rsi     # 0x516cf
callq 0x81c0
movq -0x8(%rbp), %rdi
callq 0x4e4f0
jmp 0x25c8f
movq -0x8(%rbp), %rdi
callq 0x30050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)