LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: movlps_MV
void __bea_callspec__ movlps_MV(PDISASM pMyDisasm)
{

    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg1qword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movlpd ");
        #endif
        GV.SSE_ = 1;
        ExGx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg1qword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movlps ");
        #endif
        GV.SSE_ = 1;
        ExGx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x19a43
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movabsq $0x2064706c766f6d, %rax # imm = 0x2064706C766F6D
movl $0x100001, %ecx         # imm = 0x100001
jmp 0x19a52
movabsq $0x2073706c766f6d, %rax # imm = 0x2073706C766F6D
movl $0x80001, %ecx          # imm = 0x80001
movl $0x4, 0x210(%rbx)
movl %ecx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: unpcklps_
void __bea_callspec__ unpcklps_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SHUFFLE_UNPACK;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "unpcklpd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SHUFFLE_UNPACK;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "unpcklps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x19ae4
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x100015, 0x60(%rbx)   # imm = 0x100015
movabsq $0x64706c6b63706e75, %rax # imm = 0x64706C6B63706E75
jmp 0x19aff
movl $0x6c, 0x210(%rbx)
movl $0x100015, 0x60(%rbx)   # imm = 0x100015
movabsq $0x73706c6b63706e75, %rax # imm = 0x73706C6B63706E75
movq %rax, 0x68(%rbx)
movw $0x20, 0x70(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: unpckhps_
void __bea_callspec__ unpckhps_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if (GV.OperandSize == 16) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SHUFFLE_UNPACK;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "unpckhpd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SHUFFLE_UNPACK;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "unpckhps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x10, 0x20c(%rdi)
jne 0x19b8a
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x100015, 0x60(%rbx)   # imm = 0x100015
movabsq $0x6470686b63706e75, %rax # imm = 0x6470686B63706E75
jmp 0x19ba5
movl $0x6c, 0x210(%rbx)
movl $0x100015, 0x60(%rbx)   # imm = 0x100015
movabsq $0x7370686b63706e75, %rax # imm = 0x7370686B63706E75
movq %rax, 0x68(%rbx)
movw $0x20, 0x70(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: movhps_VM
void __bea_callspec__ movhps_VM(PDISASM pMyDisasm)
{

    /* ========= 0xf3 */
    if (GV.PrefRepe == 1) {
        (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
        GV.MemDecoration = Arg2qword;
        (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movshdup ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    /* ========== 0x66 */
    else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2qword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movhpd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2qword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+DATA_TRANSFER;
        GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
        if (GV.MOD_== 0x3) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movlhps ");
            #endif
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movhps ");
            #endif
        }
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, 0x268(%rdi)
jne 0x19c31
movb $0x8, 0x1e0(%rbx)
movl $0x68, 0x210(%rbx)
movl $0x200001, 0x60(%rbx)   # imm = 0x200001
movabsq $0x7075646873766f6d, %rax # imm = 0x7075646873766F6D
movq %rax, 0x68(%rbx)
movw $0x20, 0x70(%rbx)
jmp 0x19cbc
cmpb $0x1, 0x1dd(%rbx)
jne 0x19c6e
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x68, 0x210(%rbx)
movl $0x100001, 0x60(%rbx)   # imm = 0x100001
movabsq $0x20647068766f6d, %rax # imm = 0x20647068766F6D
movq %rax, 0x68(%rbx)
jmp 0x19cbc
movl $0x68, 0x210(%rbx)
movl $0x80001, 0x60(%rbx)    # imm = 0x80001
movq 0x1f0(%rbx), %rax
movzbl 0x1(%rax), %ecx
shrl $0x6, %ecx
movl %ecx, 0x218(%rbx)
leaq 0x68(%rbx), %rax
cmpl $0x3, %ecx
jne 0x19caf
movabsq $0x207370686c766f6d, %rcx # imm = 0x207370686C766F6D
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
jmp 0x19cbc
movabsq $0x20737068766f6d, %rcx # imm = 0x20737068766F6D
movq %rcx, (%rax)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: movhps_MV
void __bea_callspec__ movhps_MV(PDISASM pMyDisasm)
{

    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg1qword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movhpd ");
        #endif
        GV.SSE_ = 1;
        ExGx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg1qword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movhps ");
        #endif
        GV.SSE_ = 1;
        ExGx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x19d31
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movabsq $0x20647068766f6d, %rax # imm = 0x20647068766F6D
movl $0x100001, %ecx         # imm = 0x100001
jmp 0x19d40
movabsq $0x20737068766f6d, %rax # imm = 0x20737068766F6D
movl $0x80001, %ecx          # imm = 0x80001
movl $0x4, 0x210(%rbx)
movl %ecx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: hint_nop
void __bea_callspec__ hint_nop(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+MISCELLANEOUS_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "hint_nop ");
    #endif
    if (GV.OperandSize == 64) {
        GV.MemDecoration = Arg2qword;
    }
    else if (GV.OperandSize == 32) {
        GV.MemDecoration = Arg2dword;
    }
    else {
        GV.MemDecoration = Arg2word;
    }
    MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1000c, 0x60(%rdi)    # imm = 0x1000C
movabsq $0x706f6e5f746e6968, %rax # imm = 0x706F6E5F746E6968
movq %rax, 0x68(%rdi)
movw $0x20, 0x70(%rdi)
movl 0x20c(%rdi), %eax
xorl %ecx, %ecx
cmpl $0x20, %eax
sete %cl
orl $0x66, %ecx
cmpl $0x40, %eax
movl $0x68, %eax
cmovnel %ecx, %eax
movl %eax, 0x210(%rdi)
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x2b196
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_RdCd
void __bea_callspec__ mov_RdCd(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    if (GV.MOD_== 3) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
        #endif
        GV.CR_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.CR_ = 0;
        FillFlags(pMyDisasm,67);
        GV.EIP_ += GV.DECALAGE_EIP+2;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2000000, 0x60(%rdi)  # imm = 0x2000000
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2b196
cmpl $0x3, 0x218(%rbx)
jne 0x19fdd
movb $0x0, 0x6c(%rbx)
movl $0x20766f6d, 0x68(%rbx) # imm = 0x20766F6D
movl $0x1, 0x234(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x234(%rbx)
movq 0x1e4e9(%rip), %rax     # 0x384a4
movq %rax, 0x7c(%rbx)
movl 0x1e4e7(%rip), %eax     # 0x384ac
movl %eax, 0x84(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
jmp 0x19ff2
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_RdDd
void __bea_callspec__ mov_RdDd(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    if (GV.MOD_== 3) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
        #endif
        GV.DR_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.DR_ = 0;
        FillFlags(pMyDisasm,67);
        GV.EIP_ += GV.DECALAGE_EIP+2;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2000000, 0x60(%rdi)  # imm = 0x2000000
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2b196
cmpl $0x3, 0x218(%rbx)
jne 0x1a06e
movb $0x0, 0x6c(%rbx)
movl $0x20766f6d, 0x68(%rbx) # imm = 0x20766F6D
movl $0x1, 0x238(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x238(%rbx)
movq 0x1e458(%rip), %rax     # 0x384a4
movq %rax, 0x7c(%rbx)
movl 0x1e456(%rip), %eax     # 0x384ac
movl %eax, 0x84(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
jmp 0x1a083
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_CdRd
void __bea_callspec__ mov_CdRd(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
    MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
    if (GV.MOD_== 3) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
        #endif
        GV.CR_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.CR_ = 0;
        FillFlags(pMyDisasm,67);
        GV.EIP_ += GV.DECALAGE_EIP+2;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2000000, 0x60(%rdi)  # imm = 0x2000000
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x2b196
cmpl $0x3, 0x218(%rbx)
jne 0x1a0ff
movb $0x0, 0x6c(%rbx)
movl $0x20766f6d, 0x68(%rbx) # imm = 0x20766F6D
movl $0x1, 0x234(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x234(%rbx)
movq 0x1e3c7(%rip), %rax     # 0x384a4
movq %rax, 0x7c(%rbx)
movl 0x1e3c5(%rip), %eax     # 0x384ac
movl %eax, 0x84(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
jmp 0x1a114
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: movaps_VW
void __bea_callspec__ movaps_VW(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movapd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movaps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x1a1d3
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movabsq $0x20647061766f6d, %rax # imm = 0x20647061766F6D
jmp 0x1a1dd
movabsq $0x20737061766f6d, %rax # imm = 0x20737061766F6D
movl $0x6c, 0x210(%rbx)
movl $0x100001, 0x60(%rbx)   # imm = 0x100001
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: movaps_WV
void __bea_callspec__ movaps_WV(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg1dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movapd ");
        #endif
        GV.SSE_ = 1;
        ExGx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movaps ");
        #endif
        GV.SSE_ = 1;
        ExGx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x1a267
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movabsq $0x20647061766f6d, %rax # imm = 0x20647061766F6D
movl $0x8, %ecx
jmp 0x1a276
movabsq $0x20737061766f6d, %rax # imm = 0x20737061766F6D
movl $0x6c, %ecx
movl %ecx, 0x210(%rbx)
movl $0x100001, 0x60(%rbx)   # imm = 0x100001
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: movntps_
void __bea_callspec__ movntps_(PDISASM pMyDisasm)
{
    GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
    if (GV.MOD_== 0x3) {
        FailDecode(pMyDisasm);
    }
    /* ========== 0x66 */
    else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg1dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CACHEABILITY_CONTROL;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movntpd ");
        #endif
        GV.SSE_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.SSE_ = 0;
        MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.EIP_ += GV.DECALAGE_EIP+2;

    }
    else {
        GV.MemDecoration = Arg1dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CACHEABILITY_CONTROL;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movntps ");
        #endif
        GV.SSE_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.SSE_ = 0;
        MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.EIP_ += GV.DECALAGE_EIP+2;

    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1f0(%rdi), %rax
movzbl 0x1(%rax), %eax
shrl $0x6, %eax
movl %eax, 0x218(%rdi)
cmpl $0x3, %eax
jne 0x1a44d
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0x1a4eb
cmpb $0x1, 0x1dd(%rbx)
jne 0x1a486
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x8, 0x210(%rbx)
movl $0x100019, 0x60(%rbx)   # imm = 0x100019
movabsq $0x206470746e766f6d, %rax # imm = 0x206470746E766F6D
jmp 0x1a4a1
movl $0x8, 0x210(%rbx)
movl $0x100019, 0x60(%rbx)   # imm = 0x100019
movabsq $0x207370746e766f6d, %rax # imm = 0x207370746E766F6D
movq %rax, 0x68(%rbx)
movb $0x0, 0x70(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x230(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: ucomiss_VW
void __bea_callspec__ ucomiss_VW(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if (GV.OperandSize == 16) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+COMPARISON_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ucomisd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+COMPARISON_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ucomiss ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x10, 0x20c(%rdi)
jne 0x1a7ea
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x67, 0x210(%rbx)
movl $0x10000d, 0x60(%rbx)   # imm = 0x10000D
movabsq $0x206473696d6f6375, %rax # imm = 0x206473696D6F6375
jmp 0x1a805
movl $0x6c, 0x210(%rbx)
movl $0x8000d, 0x60(%rbx)    # imm = 0x8000D
movabsq $0x207373696d6f6375, %rax # imm = 0x207373696D6F6375
movq %rax, 0x68(%rbx)
movb $0x0, 0x70(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: comiss_VW
void __bea_callspec__ comiss_VW(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2qword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+COMPARISON_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "comisd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+COMPARISON_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "comiss ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x1a887
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movabsq $0x206473696d6f63, %rax # imm = 0x206473696D6F63
movl $0x10000d, %ecx         # imm = 0x10000D
movl $0x68, %edx
jmp 0x1a89b
movabsq $0x207373696d6f63, %rax # imm = 0x207373696D6F63
movl $0x8000d, %ecx          # imm = 0x8000D
movl $0x6c, %edx
movl %edx, 0x210(%rbx)
movl %ecx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovo_
void __bea_callspec__ cmovo_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovo ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x766f6d63, 0x68(%rdi) # imm = 0x766F6D63
movl $0x206f76, 0x6b(%rdi)   # imm = 0x206F76
callq 0x2aeb0
movl 0x1d7a4(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d78f(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovno_
void __bea_callspec__ cmovno_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovno ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movabsq $0x206f6e766f6d63, %rax # imm = 0x206F6E766F6D63
movq %rax, 0x68(%rdi)
callq 0x2aeb0
movl 0x1d76d(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d758(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovb_
void __bea_callspec__ cmovb_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovb ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x766f6d63, 0x68(%rdi) # imm = 0x766F6D63
movl $0x206276, 0x6b(%rdi)   # imm = 0x206276
callq 0x2aeb0
movl 0x1d736(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d721(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovnb_
void __bea_callspec__ cmovnb_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovnb ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movabsq $0x20626e766f6d63, %rax # imm = 0x20626E766F6D63
movq %rax, 0x68(%rdi)
callq 0x2aeb0
movl 0x1d6ff(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d6ea(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmove_
void __bea_callspec__ cmove_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmove ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x766f6d63, 0x68(%rdi) # imm = 0x766F6D63
movl $0x206576, 0x6b(%rdi)   # imm = 0x206576
callq 0x2aeb0
movl 0x1d6c8(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d6b3(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovne_
void __bea_callspec__ cmovne_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovne ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movabsq $0x20656e766f6d63, %rax # imm = 0x20656E766F6D63
movq %rax, 0x68(%rdi)
callq 0x2aeb0
movl 0x1d691(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d67c(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovbe_
void __bea_callspec__ cmovbe_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovbe ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movabsq $0x206562766f6d63, %rax # imm = 0x206562766F6D63
movq %rax, 0x68(%rdi)
callq 0x2aeb0
movl 0x1d65a(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d645(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovnbe_
void __bea_callspec__ cmovnbe_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovnbe ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movabsq $0x2065626e766f6d63, %rax # imm = 0x2065626E766F6D63
movq %rax, 0x68(%rdi)
movb $0x0, 0x70(%rdi)
callq 0x2aeb0
movl 0x1d61f(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d60a(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovs_
void __bea_callspec__ cmovs_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovs ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x766f6d63, 0x68(%rdi) # imm = 0x766F6D63
movl $0x207376, 0x6b(%rdi)   # imm = 0x207376
callq 0x2aeb0
movl 0x1d5e8(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d5d3(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovns_
void __bea_callspec__ cmovns_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovns ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movabsq $0x20736e766f6d63, %rax # imm = 0x20736E766F6D63
movq %rax, 0x68(%rdi)
callq 0x2aeb0
movl 0x1d5b1(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d59c(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovp_
void __bea_callspec__ cmovp_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovp ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x766f6d63, 0x68(%rdi) # imm = 0x766F6D63
movl $0x207076, 0x6b(%rdi)   # imm = 0x207076
callq 0x2aeb0
movl 0x1d57a(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d565(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovnp_
void __bea_callspec__ cmovnp_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovnp ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movabsq $0x20706e766f6d63, %rax # imm = 0x20706E766F6D63
movq %rax, 0x68(%rdi)
callq 0x2aeb0
movl 0x1d543(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d52e(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovl_
void __bea_callspec__ cmovl_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovl ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x766f6d63, 0x68(%rdi) # imm = 0x766F6D63
movl $0x206c76, 0x6b(%rdi)   # imm = 0x206C76
callq 0x2aeb0
movl 0x1d50c(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d4f7(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovnl_
void __bea_callspec__ cmovnl_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovnl ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movabsq $0x206c6e766f6d63, %rax # imm = 0x206C6E766F6D63
movq %rax, 0x68(%rdi)
callq 0x2aeb0
movl 0x1d4d5(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d4c0(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovle_
void __bea_callspec__ cmovle_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovle ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movabsq $0x20656c766f6d63, %rax # imm = 0x20656C766F6D63
movq %rax, 0x68(%rdi)
callq 0x2aeb0
movl 0x1d49e(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d489(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovnle_
void __bea_callspec__ cmovnle_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovnle ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movabsq $0x20656c6e766f6d63, %rax # imm = 0x20656C6E766F6D63
movq %rax, 0x68(%rdi)
movb $0x0, 0x70(%rdi)
callq 0x2aeb0
movl 0x1d463(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d44e(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: movmskps_
void __bea_callspec__ movmskps_(PDISASM pMyDisasm)
{
    GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
    if (GV.MOD_!= 0x3) {
        FailDecode(pMyDisasm);
    }
    /* ========== 0x66 */
    else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movmskpd ");
        #endif
        GV.SSE_ = 1;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.SSE_ = 0;
        Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.EIP_ += GV.DECALAGE_EIP+2;

    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+DATA_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movmskps ");
        #endif
        GV.SSE_ = 1;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.SSE_ = 0;
        Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.EIP_ += GV.DECALAGE_EIP+2;

    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1f0(%rdi), %rax
movzbl 0x1(%rax), %eax
shrl $0x6, %eax
movl %eax, 0x218(%rdi)
cmpl $0x3, %eax
jne 0x1ae72
cmpb $0x1, 0x1dd(%rbx)
jne 0x1ae89
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x100001, 0x60(%rbx)   # imm = 0x100001
movabsq $0x64706b736d766f6d, %rax # imm = 0x64706B736D766F6D
jmp 0x1aea4
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0x1aef0
movl $0x6c, 0x210(%rbx)
movl $0x80001, 0x60(%rbx)    # imm = 0x80001
movabsq $0x73706b736d766f6d, %rax # imm = 0x73706B736D766F6D
movq %rax, 0x68(%rbx)
movw $0x20, 0x70(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
movl $0x0, 0x230(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: rsqrtps_
void __bea_callspec__ rsqrtps_(PDISASM pMyDisasm)
{
    /* ========== 0xf3 */
    if (GV.PrefRepe == 1) {
        (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
        GV.MemDecoration = Arg2dword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rsqrtss ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rsqrtps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, 0x268(%rdi)
jne 0x1b00d
movb $0x8, 0x1e0(%rbx)
movl $0x67, 0x210(%rbx)
movl $0x80002, 0x60(%rbx)    # imm = 0x80002
movabsq $0x2073737472717372, %rax # imm = 0x2073737472717372
jmp 0x1b028
movl $0x6c, 0x210(%rbx)
movl $0x80002, 0x60(%rbx)    # imm = 0x80002
movabsq $0x2073707472717372, %rax # imm = 0x2073707472717372
movq %rax, 0x68(%rbx)
movb $0x0, 0x70(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: rcpps_
void __bea_callspec__ rcpps_(PDISASM pMyDisasm)
{
    /* ========== 0xf3 */
    if (GV.PrefRepe == 1) {
        (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
        GV.MemDecoration = Arg2dword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcpss ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcpps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, 0x268(%rdi)
jne 0x1b0a9
movb $0x8, 0x1e0(%rbx)
movl $0x67, 0x210(%rbx)
movl $0x80002, 0x60(%rbx)    # imm = 0x80002
movl $0x73706372, 0x68(%rbx) # imm = 0x73706372
movl $0x207373, 0x6b(%rbx)   # imm = 0x207373
jmp 0x1b0c8
movl $0x6c, 0x210(%rbx)
movl $0x80002, 0x60(%rbx)    # imm = 0x80002
movl $0x70706372, 0x68(%rbx) # imm = 0x70706372
movl $0x207370, 0x6b(%rbx)   # imm = 0x207370
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: andps_VW
void __bea_callspec__ andps_VW(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "andpd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "andps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x1b14d
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x80003, 0x60(%rbx)    # imm = 0x80003
movl $0x70646e61, 0x68(%rbx) # imm = 0x70646E61
movl $0x206470, 0x6b(%rbx)   # imm = 0x206470
jmp 0x1b16c
movl $0x6c, 0x210(%rbx)
movl $0x80003, 0x60(%rbx)    # imm = 0x80003
movl $0x70646e61, 0x68(%rbx) # imm = 0x70646E61
movl $0x207370, 0x6b(%rbx)   # imm = 0x207370
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: andnps_VW
void __bea_callspec__ andnps_VW(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "andnpd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "andnps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x1b1dc
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movabsq $0x2064706e646e61, %rax # imm = 0x2064706E646E61
jmp 0x1b1e6
movabsq $0x2073706e646e61, %rax # imm = 0x2073706E646E61
movl $0x6c, 0x210(%rbx)
movl $0x80003, 0x60(%rbx)    # imm = 0x80003
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: orps_VW
void __bea_callspec__ orps_VW(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+LOGICAL_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "orpd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "orps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x1b279
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x100003, 0x60(%rbx)   # imm = 0x100003
movl $0x6470726f, 0x68(%rbx) # imm = 0x6470726F
jmp 0x1b291
movl $0x6c, 0x210(%rbx)
movl $0x80003, 0x60(%rbx)    # imm = 0x80003
movl $0x7370726f, 0x68(%rbx) # imm = 0x7370726F
movw $0x20, 0x6c(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: xorps_VW
void __bea_callspec__ xorps_VW(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+LOGICAL_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xorpd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xorps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x1b31c
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x100003, 0x60(%rbx)   # imm = 0x100003
movl $0x70726f78, 0x68(%rbx) # imm = 0x70726F78
movl $0x206470, 0x6b(%rbx)   # imm = 0x206470
jmp 0x1b33b
movl $0x6c, 0x210(%rbx)
movl $0x80003, 0x60(%rbx)    # imm = 0x80003
movl $0x70726f78, 0x68(%rbx) # imm = 0x70726F78
movl $0x207370, 0x6b(%rbx)   # imm = 0x207370
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq