LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x2a7dc
movl 0x1d903(%rip), %eax     # 0x3826c
movl %eax, 0x84(%rbx)
movq 0x1d8ee(%rip), %rax     # 0x38264
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a9d2
cmpb $0x1, 0x1dd(%rbx)
jne 0x1a9e9
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 0x1aa04
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0x1aa50
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 0x2aa8c
movl $0x0, 0x230(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ab6d
movb $0x8, 0x1e0(%rbx)
movl $0x67, 0x210(%rbx)
movl $0x80002, 0x60(%rbx)    # imm = 0x80002
movabsq $0x2073737472717372, %rax # imm = 0x2073737472717372
jmp 0x1ab88
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 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ac09
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 0x1ac28
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 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1acad
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 0x1accc
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 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ad3c
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movabsq $0x2064706e646e61, %rax # imm = 0x2064706E646E61
jmp 0x1ad46
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 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1add9
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 0x1adf1
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 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ae7c
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 0x1ae9b
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 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: cvtdq2ps_
void __bea_callspec__ cvtdq2ps_(PDISASM pMyDisasm)
{
    /* ========== 0xf3 */
    if (GV.PrefRepe == 1) {
        (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvttps2dq ");
        #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 = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtps2dq ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtdq2ps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, 0x268(%rdi)
jne 0x1b230
movb $0x8, 0x1e0(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x100014, 0x60(%rbx)   # imm = 0x100014
movabsq $0x6432737074747663, %rax # imm = 0x6432737074747663
movq %rax, 0x68(%rbx)
movl $0x207164, 0x6f(%rbx)   # imm = 0x207164
jmp 0x1b28e
cmpb $0x1, 0x1dd(%rbx)
jne 0x1b269
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x100014, 0x60(%rbx)   # imm = 0x100014
movabsq $0x7164327370747663, %rax # imm = 0x7164327370747663
jmp 0x1b284
movl $0x6c, 0x210(%rbx)
movl $0x100014, 0x60(%rbx)   # imm = 0x100014
movabsq $0x7370327164747663, %rax # imm = 0x7370327164747663
movq %rax, 0x68(%rbx)
movw $0x20, 0x70(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_MMX.c
// Function: punpcklbw_
void __bea_callspec__ punpcklbw_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {            
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpcklbw ");
        #endif
        (*pMyDisasm).Argument1.AccessMode = READ;
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2qword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpcklbw ");
        #endif
        (*pMyDisasm).Argument1.AccessMode = READ;
        GV.MMX_ = 1;
        GxEx(pMyDisasm);
        GV.MMX_ = 0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x40014, 0x60(%rdi)    # imm = 0x40014
cmpb $0x1, 0x1dd(%rdi)
jne 0x1b72d
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x230, %r14d           # imm = 0x230
movl $0x6c, %eax
jmp 0x1b738
movl $0x22c, %r14d           # imm = 0x22C
movl $0x68, %eax
movl %eax, 0x210(%rbx)
movabsq $0x626c6b63706e7570, %rax # imm = 0x626C6B63706E7570
movq %rax, 0x68(%rbx)
movl $0x207762, 0x6f(%rbx)   # imm = 0x207762
movl $0x1, %eax
movl %eax, 0xe8(%rbx)
movl %eax, (%rbx,%r14)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_MMX.c
// Function: punpckldq_
void __bea_callspec__ punpckldq_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {            
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckldq ");
        #endif
        (*pMyDisasm).Argument1.AccessMode = READ;
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2qword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckldq ");
        #endif
        (*pMyDisasm).Argument1.AccessMode = READ;
        GV.MMX_ = 1;
        GxEx(pMyDisasm);
        GV.MMX_ = 0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x40014, 0x60(%rdi)    # imm = 0x40014
cmpb $0x1, 0x1dd(%rdi)
jne 0x1b881
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x230, %r14d           # imm = 0x230
movl $0x6c, %eax
jmp 0x1b88c
movl $0x22c, %r14d           # imm = 0x22C
movl $0x68, %eax
movl %eax, 0x210(%rbx)
movabsq $0x646c6b63706e7570, %rax # imm = 0x646C6B63706E7570
movq %rax, 0x68(%rbx)
movl $0x207164, 0x6f(%rbx)   # imm = 0x207164
movl $0x1, %eax
movl %eax, 0xe8(%rbx)
movl %eax, (%rbx,%r14)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_MMX.c
// Function: packsswb_
void __bea_callspec__ packsswb_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {            
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "packsswb ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2qword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "packsswb ");
        #endif
        GV.MMX_ = 1;
        GxEx(pMyDisasm);
        GV.MMX_ = 0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x40014, 0x60(%rdi)    # imm = 0x40014
cmpb $0x1, 0x1dd(%rdi)
jne 0x1b92b
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x230, %r14d           # imm = 0x230
movl $0x6c, %eax
jmp 0x1b936
movl $0x22c, %r14d           # imm = 0x22C
movl $0x68, %eax
movl %eax, 0x210(%rbx)
movabsq $0x627773736b636170, %rax # imm = 0x627773736B636170
movq %rax, 0x68(%rbx)
movw $0x20, 0x70(%rbx)
movl $0x1, (%rbx,%r14)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_MMX.c
// Function: packuswb_
void __bea_callspec__ packuswb_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {            
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "packuswb ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2qword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "packuswb ");
        #endif
        GV.MMX_ = 1;
        GxEx(pMyDisasm);
        GV.MMX_ = 0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x40014, 0x60(%rdi)    # imm = 0x40014
cmpb $0x1, 0x1dd(%rdi)
jne 0x1bbc2
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x230, %r14d           # imm = 0x230
movl $0x6c, %eax
jmp 0x1bbcd
movl $0x22c, %r14d           # imm = 0x22C
movl $0x68, %eax
movl %eax, 0x210(%rbx)
movabsq $0x627773756b636170, %rax # imm = 0x627773756B636170
movq %rax, 0x68(%rbx)
movw $0x20, 0x70(%rbx)
movl $0x1, (%rbx,%r14)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_MMX.c
// Function: punpckhwd_
void __bea_callspec__ punpckhwd_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {            
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhwd ");
        #endif
        (*pMyDisasm).Argument1.AccessMode = READ;
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2qword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhwd ");
        #endif
        (*pMyDisasm).Argument1.AccessMode = READ;
        GV.MMX_ = 1;
        GxEx(pMyDisasm);
        GV.MMX_ = 0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x40014, 0x60(%rdi)    # imm = 0x40014
cmpb $0x1, 0x1dd(%rdi)
jne 0x1bd0e
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x230, %r14d           # imm = 0x230
movl $0x6c, %eax
jmp 0x1bd19
movl $0x22c, %r14d           # imm = 0x22C
movl $0x68, %eax
movl %eax, 0x210(%rbx)
movabsq $0x77686b63706e7570, %rax # imm = 0x77686B63706E7570
movq %rax, 0x68(%rbx)
movl $0x206477, 0x6f(%rbx)   # imm = 0x206477
movl $0x1, %eax
movl %eax, 0xe8(%rbx)
movl %eax, (%rbx,%r14)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_MMX.c
// Function: punpckhdq_
void __bea_callspec__ punpckhdq_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {            
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhdq ");
        #endif
        (*pMyDisasm).Argument1.AccessMode = READ;
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2qword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhdq ");
        #endif
        (*pMyDisasm).Argument1.AccessMode = READ;
        GV.MMX_ = 1;
        GxEx(pMyDisasm);
        GV.MMX_ = 0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x40014, 0x60(%rdi)    # imm = 0x40014
cmpb $0x1, 0x1dd(%rdi)
jne 0x1bdb8
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x230, %r14d           # imm = 0x230
movl $0x6c, %eax
jmp 0x1bdc3
movl $0x22c, %r14d           # imm = 0x22C
movl $0x68, %eax
movl %eax, 0x210(%rbx)
movabsq $0x64686b63706e7570, %rax # imm = 0x64686B63706E7570
movq %rax, 0x68(%rbx)
movl $0x207164, 0x6f(%rbx)   # imm = 0x207164
movl $0x1, %eax
movl %eax, 0xe8(%rbx)
movl %eax, (%rbx,%r14)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: punpcklqdq_
void __bea_callspec__ punpcklqdq_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SIMD128bits;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpcklqdq ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        FailDecode(pMyDisasm);
    }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x1bf57
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x100017, 0x60(%rbx)   # imm = 0x100017
movabsq $0x716c6b63706e7570, %rax # imm = 0x716C6B63706E7570
movq %rax, 0x68(%rbx)
movl $0x207164, 0x70(%rbx)   # imm = 0x207164
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
jmp 0x1bf6c
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: punpckhqdq_
void __bea_callspec__ punpckhqdq_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SIMD128bits;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhqdq ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        FailDecode(pMyDisasm);
    }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x1bff8
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x100017, 0x60(%rbx)   # imm = 0x100017
movabsq $0x71686b63706e7570, %rax # imm = 0x71686B63706E7570
movq %rax, 0x68(%rbx)
movl $0x207164, 0x70(%rbx)   # imm = 0x207164
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
jmp 0x1c00d
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_MMX.c
// Function: movq_PQ
void __bea_callspec__ movq_PQ(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+DATA_TRANSFER;
    /* ========= 0xf3 */
    if (GV.PrefRepe == 1) {
        (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movdqu ");
        #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 = Arg2dqword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movdqa ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2qword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movq ");
        #endif
        GV.MMX_ = 1;
        GxEx(pMyDisasm);
        GV.MMX_ = 0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x40001, 0x60(%rdi)    # imm = 0x40001
cmpl $0x1, 0x268(%rdi)
jne 0x1c102
movb $0x8, 0x1e0(%rbx)
movl $0x6c, 0x210(%rbx)
movabsq $0x20757164766f6d, %rax # imm = 0x20757164766F6D
jmp 0x1c132
cmpb $0x1, 0x1dd(%rbx)
jne 0x1c13e
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movabsq $0x20617164766f6d, %rax # imm = 0x20617164766F6D
movq %rax, 0x68(%rbx)
movl $0x230, %r14d           # imm = 0x230
jmp 0x1c15b
movl $0x68, 0x210(%rbx)
movl $0x71766f6d, 0x68(%rbx) # imm = 0x71766F6D
movw $0x20, 0x6c(%rbx)
movl $0x22c, %r14d           # imm = 0x22C
movl $0x1, (%rbx,%r14)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: vmread_
void __bea_callspec__ vmread_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = VM_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "vmread ");
    #endif
    if (GV.Architecture == 64) {
        GV.OperandSize = 64;
    }
    EvGv(pMyDisasm);
    if (GV.Architecture == 64) {
        GV.OperandSize = 32;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x4000000, 0x60(%rdi)  # imm = 0x4000000
movabsq $0x20646165726d76, %rax # imm = 0x20646165726D76
movq %rax, 0x68(%rdi)
cmpl $0x40, 0x25c(%rdi)
jne 0x1ce2e
movl $0x40, 0x20c(%rbx)
movq %rbx, %rdi
callq 0x2a737
cmpl $0x40, 0x25c(%rbx)
jne 0x1ce49
movl $0x20, 0x20c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: vmwrite_
void __bea_callspec__ vmwrite_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = VM_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "vmwrite ");
    #endif
    if (GV.Architecture == 64) {
        GV.OperandSize = 64;
    }
    GvEv(pMyDisasm);
    if (GV.Architecture == 64) {
        GV.OperandSize = 32;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x4000000, 0x60(%rdi)  # imm = 0x4000000
movabsq $0x2065746972776d76, %rax # imm = 0x2065746972776D76
movq %rax, 0x68(%rdi)
movb $0x0, 0x70(%rdi)
cmpl $0x40, 0x25c(%rdi)
jne 0x1ce7b
movl $0x40, 0x20c(%rbx)
movq %rbx, %rdi
callq 0x2a7dc
cmpl $0x40, 0x25c(%rbx)
jne 0x1ce96
movl $0x20, 0x20c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: haddpd_VW
void __bea_callspec__ haddpd_VW(PDISASM pMyDisasm)
{

    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+SIMD_FP_HORIZONTAL;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "haddpd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+SIMD_FP_HORIZONTAL;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "haddps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x1cec4
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movabsq $0x20647064646168, %rax # imm = 0x20647064646168
jmp 0x1cece
movabsq $0x20737064646168, %rax # imm = 0x20737064646168
movl $0x6c, 0x210(%rbx)
movl $0x20001d, 0x60(%rbx)   # imm = 0x20001D
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: hsubpd_VW
void __bea_callspec__ hsubpd_VW(PDISASM pMyDisasm)
{

    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+SIMD_FP_HORIZONTAL;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "hsubpd ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+SIMD_FP_HORIZONTAL;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "hsubps ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x1cf53
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movabsq $0x20647062757368, %rax # imm = 0x20647062757368
jmp 0x1cf5d
movabsq $0x20737062757368, %rax # imm = 0x20737062757368
movl $0x6c, 0x210(%rbx)
movl $0x20001d, 0x60(%rbx)   # imm = 0x20001D
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_MMX.c
// Function: movq_QP
void __bea_callspec__ movq_QP(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+DATA_TRANSFER;
    /* ========= 0xf3 */
    if (GV.PrefRepe == 1) {
        (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
        GV.MemDecoration = Arg1dqword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movdqu ");
        #endif
        GV.SSE_ = 1;
        ExGx(pMyDisasm);
        GV.SSE_ = 0;
    }
    /* ========== 0x66 */
    else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {            
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg1dqword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movdqa ");
        #endif
        GV.SSE_ = 1;
        ExGx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        GV.MemDecoration = Arg1qword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movq ");
        #endif
        GV.MMX_ = 1;
        ExGx(pMyDisasm);
        GV.MMX_ = 0;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x40001, 0x60(%rdi)    # imm = 0x40001
cmpl $0x1, 0x268(%rdi)
jne 0x1d156
movb $0x8, 0x1e0(%rbx)
movl $0x8, 0x210(%rbx)
movabsq $0x20757164766f6d, %rax # imm = 0x20757164766F6D
jmp 0x1d186
cmpb $0x1, 0x1dd(%rbx)
jne 0x1d192
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x8, 0x210(%rbx)
movabsq $0x20617164766f6d, %rax # imm = 0x20617164766F6D
movq %rax, 0x68(%rbx)
movl $0x230, %r14d           # imm = 0x230
jmp 0x1d1af
movl $0x4, 0x210(%rbx)
movl $0x71766f6d, 0x68(%rbx) # imm = 0x71766F6D
movw $0x20, 0x6c(%rbx)
movl $0x22c, %r14d           # imm = 0x22C
movl $0x1, (%rbx,%r14)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2aa8c
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2ab36
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movl $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: seto_
void __bea_callspec__ seto_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "seto ");
    #endif
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_+= GV.DECALAGE_EIP+2;
    FillFlags(pMyDisasm,95);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x6f746573, 0x68(%rdi) # imm = 0x6F746573
movw $0x20, 0x6c(%rdi)
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2aa8c
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movq 0x1993c(%rip), %rax     # 0x385f4
movq %rax, 0x7c(%rbx)
movl 0x1993a(%rip), %eax     # 0x385fc
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: setb_
void __bea_callspec__ setb_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setb ");
    #endif
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_+= GV.DECALAGE_EIP+2;
    FillFlags(pMyDisasm,95);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x62746573, 0x68(%rdi) # imm = 0x62746573
movw $0x20, 0x6c(%rdi)
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2aa8c
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movq 0x19865(%rip), %rax     # 0x385f4
movq %rax, 0x7c(%rbx)
movl 0x19863(%rip), %eax     # 0x385fc
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: setne_
void __bea_callspec__ setne_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setne ");
    #endif
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_+= GV.DECALAGE_EIP+2;
    FillFlags(pMyDisasm,95);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x6e746573, 0x68(%rdi) # imm = 0x6E746573
movl $0x20656e, 0x6b(%rdi)   # imm = 0x20656E
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2aa8c
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movq 0x19722(%rip), %rax     # 0x385f4
movq %rax, 0x7c(%rbx)
movl 0x19720(%rip), %eax     # 0x385fc
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: setbe_
void __bea_callspec__ setbe_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setbe ");
    #endif
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_+= GV.DECALAGE_EIP+2;
    FillFlags(pMyDisasm,95);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x62746573, 0x68(%rdi) # imm = 0x62746573
movl $0x206562, 0x6b(%rdi)   # imm = 0x206562
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2aa8c
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movq 0x196b6(%rip), %rax     # 0x385f4
movq %rax, 0x7c(%rbx)
movl 0x196b4(%rip), %eax     # 0x385fc
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: setnbe_
void __bea_callspec__ setnbe_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setnbe ");
    #endif
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_+= GV.DECALAGE_EIP+2;
    FillFlags(pMyDisasm,95);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movabsq $0x2065626e746573, %rax # imm = 0x2065626E746573
movq %rax, 0x68(%rdi)
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2aa8c
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movq 0x1964a(%rip), %rax     # 0x385f4
movq %rax, 0x7c(%rbx)
movl 0x19648(%rip), %eax     # 0x385fc
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sets_
void __bea_callspec__ sets_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sets ");
    #endif
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_+= GV.DECALAGE_EIP+2;
    FillFlags(pMyDisasm,95);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x73746573, 0x68(%rdi) # imm = 0x73746573
movw $0x20, 0x6c(%rdi)
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2aa8c
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movq 0x195df(%rip), %rax     # 0x385f4
movq %rax, 0x7c(%rbx)
movl 0x195dd(%rip), %eax     # 0x385fc
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: setns_
void __bea_callspec__ setns_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setns ");
    #endif
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_+= GV.DECALAGE_EIP+2;
    FillFlags(pMyDisasm,95);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x6e746573, 0x68(%rdi) # imm = 0x6E746573
movl $0x20736e, 0x6b(%rdi)   # imm = 0x20736E
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2aa8c
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movq 0x19573(%rip), %rax     # 0x385f4
movq %rax, 0x7c(%rbx)
movl 0x19571(%rip), %eax     # 0x385fc
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: setp_
void __bea_callspec__ setp_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setp ");
    #endif
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_+= GV.DECALAGE_EIP+2;
    FillFlags(pMyDisasm,95);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x70746573, 0x68(%rdi) # imm = 0x70746573
movw $0x20, 0x6c(%rdi)
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2aa8c
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movq 0x19508(%rip), %rax     # 0x385f4
movq %rax, 0x7c(%rbx)
movl 0x19506(%rip), %eax     # 0x385fc
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: setge_
void __bea_callspec__ setge_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setnl ");
    #endif
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_+= GV.DECALAGE_EIP+2;
    FillFlags(pMyDisasm,95);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x6e746573, 0x68(%rdi) # imm = 0x6E746573
movl $0x206c6e, 0x6b(%rdi)   # imm = 0x206C6E
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2aa8c
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movq 0x193c5(%rip), %rax     # 0x385f4
movq %rax, 0x7c(%rbx)
movl 0x193c3(%rip), %eax     # 0x385fc
movl %eax, 0x84(%rbx)
popq %rbx
retq