LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: roundpd_
void __bea_callspec__ roundpd_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+ROUND_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "roundpd ");
        #endif
        GV.ImmediatSize = 8;
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
        GV.EIP_++;
        if (!Security(0, pMyDisasm)) return;
        GV.third_arg = 1;
        (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
        #endif
        (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
        (*pMyDisasm).Argument3.ArgSize = 8;

    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x2567a
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x80002b, 0x60(%rbx)   # imm = 0x80002B
movabsq $0x206470646e756f72, %rax # imm = 0x206470646E756F72
movq %rax, 0x68(%rbx)
movb $0x0, 0x70(%rbx)
movl $0x8, 0x260(%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 0x1f0(%rbx), %rax
movl $0x0, 0x230(%rbx)
leaq 0x1(%rax), %rcx
movq %rcx, 0x1f0(%rbx)
movq 0x250(%rbx), %rdx
decq %rdx
cmpq %rcx, %rdx
jae 0x25691
movl $0x1, %eax
movl $0x289, %ecx            # imm = 0x289
jmp 0x256d2
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, %eax
movl $0x280, %ecx            # imm = 0x280
jmp 0x256d2
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x835d(%rip), %rdx      # 0x2da13
movq %rbx, %rdi
callq 0x2acdf
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
movl $0x8, %eax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: pextrb_
void __bea_callspec__ pextrb_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pextrb ");
        #endif
        GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
        if (GV.MOD_== 0x3) {
            GV.MemDecoration = Arg1dword;
        }
        else {
            GV.MemDecoration = Arg1byte;
        }
        GV.ImmediatSize = 8;
        MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.SSE_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.SSE_ = 0;
        GV.EIP_ += GV.DECALAGE_EIP+3;
        if (!Security(0, pMyDisasm)) return;
        GV.third_arg = 1;
        (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
        #endif
        (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
        (*pMyDisasm).Argument3.ArgSize = 8;


    }
    else {
        FailDecode(pMyDisasm);
    }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x25e7c
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x800027, 0x60(%rbx)   # imm = 0x800027
movabsq $0x20627274786570, %rax # imm = 0x20627274786570
movq %rax, 0x68(%rbx)
movq 0x1f0(%rbx), %rax
movzbl 0x1(%rax), %eax
shrl $0x6, %eax
movl %eax, 0x218(%rbx)
xorl %ecx, %ecx
cmpl $0x3, %eax
sete %cl
leal 0x1(,%rcx,2), %eax
movl %eax, 0x210(%rbx)
movl $0x8, 0x260(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x230(%rbx)
movl 0x244(%rbx), %eax
addl $0x3, %eax
addq 0x1f0(%rbx), %rax
movq %rax, 0x1f0(%rbx)
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0x25e93
movl $0x1, %eax
movl $0x289, %ecx            # imm = 0x289
jmp 0x25ed6
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, %eax
movl $0x280, %ecx            # imm = 0x280
jmp 0x25ed6
movl $0x1, 0x278(%rbx)
movzbl -0x1(%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl -0x1(%rax), %ecx
leaq 0x7b59(%rip), %rdx      # 0x2da13
movq %rbx, %rdi
callq 0x2acdf
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
movl $0x8, %eax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: pextrw2_
void __bea_callspec__ pextrw2_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pextrw ");
        #endif
        GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
        if (GV.MOD_== 0x3) {
            GV.MemDecoration = Arg1dword;
        }
        else {
            GV.MemDecoration = Arg1word;
        }
        GV.ImmediatSize = 8;
        MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.SSE_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.SSE_ = 0;
        GV.EIP_ += GV.DECALAGE_EIP+3;
        if (!Security(0, pMyDisasm)) return;
        GV.third_arg = 1;
        (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
        #endif
        (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
        (*pMyDisasm).Argument3.ArgSize = 8;


    }
    else {
        FailDecode(pMyDisasm);
    }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x25fa7
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x800027, 0x60(%rbx)   # imm = 0x800027
movabsq $0x20777274786570, %rax # imm = 0x20777274786570
movq %rax, 0x68(%rbx)
movq 0x1f0(%rbx), %rax
movzbl 0x1(%rax), %eax
shrl $0x6, %eax
movl %eax, 0x218(%rbx)
xorl %ecx, %ecx
cmpl $0x3, %eax
sete %cl
orl $0x2, %ecx
movl %ecx, 0x210(%rbx)
movl $0x8, 0x260(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x230(%rbx)
movl 0x244(%rbx), %eax
addl $0x3, %eax
addq 0x1f0(%rbx), %rax
movq %rax, 0x1f0(%rbx)
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0x25fbe
movl $0x1, %eax
movl $0x289, %ecx            # imm = 0x289
jmp 0x26001
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, %eax
movl $0x280, %ecx            # imm = 0x280
jmp 0x26001
movl $0x1, 0x278(%rbx)
movzbl -0x1(%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl -0x1(%rax), %ecx
leaq 0x7a2e(%rip), %rdx      # 0x2da13
movq %rbx, %rdi
callq 0x2acdf
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
movl $0x8, %eax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: pextrd_
void __bea_callspec__ pextrd_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
        if (GV.REX.W_ == 0x1) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pextrq ");
            #endif
            GV.MemDecoration = Arg1qword;
            GV.OperandSize = 64;
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pextrd ");
            #endif
            GV.MemDecoration = Arg1dword;
        }
        GV.ImmediatSize = 8;
        MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.SSE_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.SSE_ = 0;
        GV.EIP_ += GV.DECALAGE_EIP+3;
        if (!Security(0, pMyDisasm)) return;
        GV.third_arg = 1;
        (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
        #endif
        (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
        (*pMyDisasm).Argument3.ArgSize = 8;


    }
    else {
        FailDecode(pMyDisasm);
    }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x26061
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x800027, 0x60(%rbx)   # imm = 0x800027
cmpb $0x1, 0x284(%rbx)
jne 0x2607b
movabsq $0x20717274786570, %rax # imm = 0x20717274786570
movq %rax, 0x68(%rbx)
movabsq $0x400000040, %rax      # imm = 0x400000040
movq %rax, 0x20c(%rbx)
jmp 0x26093
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, %eax
movl $0x280, %ecx            # imm = 0x280
jmp 0x26144
movabsq $0x20647274786570, %rax # imm = 0x20647274786570
movq %rax, 0x68(%rbx)
movl $0x3, 0x210(%rbx)
movl $0x8, 0x260(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x230(%rbx)
movl 0x244(%rbx), %eax
addl $0x3, %eax
addq 0x1f0(%rbx), %rax
movq %rax, 0x1f0(%rbx)
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0x26101
movl $0x1, %eax
movl $0x289, %ecx            # imm = 0x289
jmp 0x26144
movl $0x1, 0x278(%rbx)
movzbl -0x1(%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl -0x1(%rax), %ecx
leaq 0x78eb(%rip), %rdx      # 0x2da13
movq %rbx, %rdi
callq 0x2acdf
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
movl $0x8, %eax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: extractps_
void __bea_callspec__ extractps_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg1dword;
        (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "extractps ");
        #endif
        GV.ImmediatSize = 8;
        MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.SSE_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.SSE_ = 0;
        GV.EIP_+= GV.DECALAGE_EIP+2;
        GV.EIP_++;
        if (!Security(0, pMyDisasm)) return;
        GV.third_arg = 1;
        (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
        #endif
        (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
        (*pMyDisasm).Argument3.ArgSize = 8;


    }
    else {
        FailDecode(pMyDisasm);
    }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x26205
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x3, 0x210(%rbx)
movl $0x800027, 0x60(%rbx)   # imm = 0x800027
movabsq $0x7074636172747865, %rax # imm = 0x7074636172747865
movq %rax, 0x68(%rbx)
movl $0x207370, 0x6f(%rbx)   # imm = 0x207370
movl $0x8, 0x260(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x230(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq 0x1f0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x1f0(%rbx)
movq 0x250(%rbx), %rdx
decq %rdx
cmpq %rcx, %rdx
jae 0x2621c
movl $0x1, %eax
movl $0x289, %ecx            # imm = 0x289
jmp 0x2625d
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, %eax
movl $0x280, %ecx            # imm = 0x280
jmp 0x2625d
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x77d2(%rip), %rdx      # 0x2da13
movq %rbx, %rdi
callq 0x2acdf
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
movl $0x8, %eax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: pinsrb_
void __bea_callspec__ pinsrb_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2byte;
        (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pinsrb ");
        #endif
        GV.ImmediatSize = 8;
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
        GV.EIP_++;
        if (!Security(0, pMyDisasm)) return;
        GV.third_arg = 1;
        (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
        #endif
        (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
        (*pMyDisasm).Argument3.ArgSize = 8;


    }
    else {
        FailDecode(pMyDisasm);
    }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x26317
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x65, 0x210(%rbx)
movl $0x800027, 0x60(%rbx)   # imm = 0x800027
movabsq $0x206272736e6970, %rax # imm = 0x206272736E6970
movq %rax, 0x68(%rbx)
movl $0x8, 0x260(%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 0x1f0(%rbx), %rax
movl $0x0, 0x230(%rbx)
leaq 0x1(%rax), %rcx
movq %rcx, 0x1f0(%rbx)
movq 0x250(%rbx), %rdx
decq %rdx
cmpq %rcx, %rdx
jae 0x2632e
movl $0x1, %eax
movl $0x289, %ecx            # imm = 0x289
jmp 0x2636f
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, %eax
movl $0x280, %ecx            # imm = 0x280
jmp 0x2636f
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x76c0(%rip), %rdx      # 0x2da13
movq %rbx, %rdi
callq 0x2acdf
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
movl $0x8, %eax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: insertps_
void __bea_callspec__ insertps_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "insertps ");
        #endif
        GV.SSE_ = 1;
        GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
        if (GV.MOD_== 0x3) {
            GV.MemDecoration = Arg2qword;
        }
        else {
            GV.MemDecoration = Arg2dword;
        }

        GV.ImmediatSize = 8;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);


        Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.SSE_ = 0;
        GV.EIP_+= GV.DECALAGE_EIP+2;
        GV.EIP_++;
        if (!Security(0, pMyDisasm)) return;
        GV.third_arg = 1;
        (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
        #endif
        (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
        (*pMyDisasm).Argument3.ArgSize = 8;


    }
    else {
        FailDecode(pMyDisasm);
    }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x2644a
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x800027, 0x60(%rbx)   # imm = 0x800027
movabsq $0x7370747265736e69, %rax # imm = 0x7370747265736E69
movq %rax, 0x68(%rbx)
movw $0x20, 0x70(%rbx)
movl $0x1, 0x230(%rbx)
movq 0x1f0(%rbx), %rax
movzbl 0x1(%rax), %eax
shrl $0x6, %eax
movl %eax, 0x218(%rbx)
xorl %ecx, %ecx
cmpl $0x3, %eax
sete %cl
addl $0x67, %ecx
movl %ecx, 0x210(%rbx)
movl $0x8, 0x260(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x230(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq 0x1f0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x1f0(%rbx)
movq 0x250(%rbx), %rdx
decq %rdx
cmpq %rcx, %rdx
jae 0x26461
movl $0x1, %eax
movl $0x289, %ecx            # imm = 0x289
jmp 0x264a2
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, %eax
movl $0x280, %ecx            # imm = 0x280
jmp 0x264a2
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x758d(%rip), %rdx      # 0x2da13
movq %rbx, %rdi
callq 0x2acdf
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
movl $0x8, %eax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: pinsrd_
void __bea_callspec__ pinsrd_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
        if (GV.REX.W_ == 0x1) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pinsrq ");
            #endif
            GV.MemDecoration = Arg1qword;
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pinsrd ");
            #endif
            GV.MemDecoration = Arg1dword;
        }
        GV.ImmediatSize = 8;
        MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.SSE_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.SSE_ = 0;
        GV.EIP_ += GV.DECALAGE_EIP+3;
        if (!Security(0, pMyDisasm)) return;
        GV.third_arg = 1;
        (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
        #endif
        (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
        (*pMyDisasm).Argument3.ArgSize = 8;


    }
    else {
        FailDecode(pMyDisasm);
    }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x26571
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x800027, 0x60(%rbx)   # imm = 0x800027
xorl %eax, %eax
cmpb $0x1, 0x284(%rbx)
sete %al
movabsq $0x207172736e6970, %rcx # imm = 0x207172736E6970
movabsq $0x206472736e6970, %rdx # imm = 0x206472736E6970
cmoveq %rcx, %rdx
addl $0x3, %eax
movq %rdx, 0x68(%rbx)
movl %eax, 0x210(%rbx)
movl $0x8, 0x260(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b196
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x230(%rbx)
movl 0x244(%rbx), %eax
addl $0x3, %eax
addq 0x1f0(%rbx), %rax
movq %rax, 0x1f0(%rbx)
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0x26588
movl $0x1, %eax
movl $0x289, %ecx            # imm = 0x289
jmp 0x265cb
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, %eax
movl $0x280, %ecx            # imm = 0x280
jmp 0x265cb
movl $0x1, 0x278(%rbx)
movzbl -0x1(%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl -0x1(%rax), %ecx
leaq 0x7464(%rip), %rdx      # 0x2da13
movq %rbx, %rdi
callq 0x2acdf
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
movl $0x8, %eax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_AES.c
// Function: aeskeygen
void __bea_callspec__ aeskeygen(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if (GV.OperandSize == 16) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = AES_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "aeskeygenassist ");
        #endif
        GV.ImmediatSize = 8;
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
        GV.EIP_++;
        if (!Security(0, pMyDisasm)) return;
        GV.third_arg = 1;
        (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
        #endif
        (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
        (*pMyDisasm).Argument3.ArgSize = 8;


    }
    else {
        FailDecode(pMyDisasm);
    }

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x10, 0x20c(%rdi)
jne 0x26f99
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x40000000, 0x60(%rbx) # imm = 0x40000000
movups 0x783b(%rip), %xmm0     # 0x2e75a
movups %xmm0, 0x68(%rbx)
movb $0x0, 0x78(%rbx)
movl $0x8, 0x260(%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 0x1f0(%rbx), %rax
movl $0x0, 0x230(%rbx)
leaq 0x1(%rax), %rcx
movq %rcx, 0x1f0(%rbx)
movq 0x250(%rbx), %rdx
decq %rdx
cmpq %rcx, %rdx
jae 0x26fb0
movl $0x1, %eax
movl $0x289, %ecx            # imm = 0x289
jmp 0x26ff1
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, %eax
movl $0x280, %ecx            # imm = 0x280
jmp 0x26ff1
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x6a3e(%rip), %rdx      # 0x2da13
movq %rbx, %rdi
callq 0x2acdf
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
movl $0x8, %eax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/Routines_ModRM.c
// Function: Addr_SIB
void __bea_callspec__ Addr_SIB(ARGTYPE* pMyArgument, PDISASM pMyDisasm)
{
    if (!Security(2, pMyDisasm)) return;
    (*pMyArgument).ArgType = MEMORY_TYPE;
    if (GV.AddressSize >= 32) {
        GV.DECALAGE_EIP++;
        GV.BASE_  = ((UInt8) *((UInt8*) (UIntPtr) (GV.EIP_+2))) & 0x7;
        GV.SCALE_  = (((UInt8) *((UInt8*) (UIntPtr)(GV.EIP_+2))) & 0xc0) >> 6;
        GV.INDEX_  = (((UInt8) *((UInt8*) (UIntPtr)(GV.EIP_+2))) & 0x38) >> 3;
        (void) SIB[GV.SCALE_ ](pMyArgument, 0, pMyDisasm);
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((char*) (*pMyArgument).ArgMnemonic, Registers16Bits[6]);
        #endif
        (*pMyArgument).Memory.BaseRegister = REGS[6];
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x250(%rsi), %rax
testq %rax, %rax
je 0x2736d
movq 0x1f0(%rdx), %rcx
addq $0x2, %rcx
cmpq %rax, %rcx
jae 0x273e1
movl $0x40000000, 0x40(%rbx) # imm = 0x40000000
cmpl $0x20, 0x214(%rdx)
jl 0x273c7
incl 0x244(%rdx)
movq 0x1f0(%rdx), %rax
movzbl 0x2(%rax), %ecx
andl $0x7, %ecx
movl %ecx, 0x228(%rdx)
movzbl 0x2(%rax), %ecx
shrl $0x6, %ecx
movl %ecx, 0x224(%rdx)
movzbl 0x2(%rax), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x220(%rdx)
leaq 0x13be5(%rip), %rax     # 0x3afa0
movq (%rax,%rcx,8), %rax
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmpq *%rax
leaq 0x118c2(%rip), %rsi     # 0x38c90
movq %rbx, %rdi
callq 0x8150
movl 0x11a7c(%rip), %eax     # 0x38e58
movl %eax, 0x50(%rbx)
jmp 0x273eb
movl $0x1, 0x289(%rdx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: CopyFormattedNumber
size_t __bea_callspec__ CopyFormattedNumber(PDISASM pMyDisasm, char* pBuffer, const char* pFormat, Int64 MyNumber)
{
    size_t i = 0;
    if (!strcmp(pFormat,"%.2X")) MyNumber = MyNumber & 0xFF;
    if (!strcmp(pFormat,"%.4X")) MyNumber = MyNumber & 0xFFFF;
    if (!strcmp(pFormat,"%.8X")) MyNumber = MyNumber & 0xFFFFFFFF;
    if (GV.FORMATNUMBER == PrefixedNumeral) {
        (void) strcpy(pBuffer, "0x");
        (void) sprintf (pBuffer+2, pFormat, MyNumber);
        i += strlen(pBuffer);
    }
    else {
        (void) sprintf (pBuffer+i, pFormat, MyNumber);
        i += strlen(pBuffer);
        (void) strcpy(pBuffer+i, "h");
        i++;
    }
    return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x2d18(%rip), %rsi      # 0x2da13
movq %rdx, %rdi
callq 0x81e0
testl %eax, %eax
movzbl %r12b, %r13d
cmovneq %r12, %r13
leaq 0x2d5e(%rip), %rsi      # 0x2da72
movq %r14, %rdi
callq 0x81e0
testl %eax, %eax
movzwl %r13w, %r12d
cmovneq %r13, %r12
leaq 0x2d2f(%rip), %rsi      # 0x2da5c
movq %r14, %rdi
callq 0x81e0
testl %eax, %eax
movl %r12d, %edx
cmovneq %r12, %rdx
cmpl $0x10000, 0x248(%r15) # imm = 0x10000
jne 0x2ad73
movb $0x0, 0x2(%rbx)
movw $0x7830, (%rbx)         # imm = 0x7830
leaq 0x2(%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x8050
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8090
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x8050
movq %rbx, %rdi
callq 0x8090
movw $0x68, (%rbx,%rax)
incq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: EbGb
void __bea_callspec__ EbGb(PDISASM pMyDisasm)
{
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2b196
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x20, 0x20c(%rbx)
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/Routines_Disasm.c
// Function: EvGv
void __bea_callspec__ EvGv(PDISASM pMyDisasm)
{
    if (GV.OperandSize == 64) {
        GV.MemDecoration = Arg1qword;
    }
    else if (GV.OperandSize == 32) {
        GV.MemDecoration = Arg1dword;
    }
    else {
        GV.MemDecoration = Arg1word;
    }
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x20c(%rdi), %eax
xorl %ecx, %ecx
cmpl $0x20, %eax
sete %cl
orl $0x2, %ecx
cmpl $0x40, %eax
movl $0x4, %eax
cmovnel %ecx, %eax
movl %eax, 0x210(%rdi)
addq $0x9c, %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)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: GbEb
void __bea_callspec__ GbEb(PDISASM pMyDisasm)
{
    GV.MemDecoration = Arg2byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
    Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movabsq $0x6500000008, %rax     # imm = 0x6500000008
movq %rax, 0x20c(%rdi)
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x2b196
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x20, 0x20c(%rbx)
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/Routines_Disasm.c
// Function: GvEv
void __bea_callspec__ GvEv(PDISASM pMyDisasm)
{
    if (GV.OperandSize == 64) {
        GV.MemDecoration = Arg2qword;
    }
    else if (GV.OperandSize == 32) {
        GV.MemDecoration = Arg2dword;
    }
    else {
        GV.MemDecoration = Arg2word;
    }
    MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
    Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
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
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/Routines_Disasm.c
// Function: ALIb
void __bea_callspec__ ALIb(PDISASM pMyDisasm)
{
    long MyNumber;
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((Int8*)(IntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8Bits[0]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x250(%rdi), %rax
testq %rax, %rax
je 0x2af29
movq 0x1f0(%rbx), %rcx
addq $0x2, %rcx
cmpq %rax, %rcx
jae 0x2af9e
movl $0x8, 0x260(%rbx)
movq 0x1f0(%rbx), %rax
movsbq 0x1(%rax), %r14
leaq 0x104(%rbx), %rsi
leaq 0x2ac6(%rip), %rdx      # 0x2da13
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movq %r14, 0x90(%rbx)
leaq 0x9c(%rbx), %rdi
leaq 0xddb3(%rip), %rsi      # 0x38d20
callq 0x8150
movabsq $0x820020001, %rax      # imm = 0x820020001
movq %rax, 0xdc(%rbx)
movabsq $0x888000000, %rax      # imm = 0x888000000
movq %rax, 0x144(%rbx)
addq $0x2, 0x1f0(%rbx)
jmp 0x2afa8
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/Routines_ModRM.c
// Function: MOD_RM
void __bea_callspec__ MOD_RM(ARGTYPE* pMyArgument, PDISASM pMyDisasm)
{
    GV.DECALAGE_EIP = 0;
    if (!Security(1, pMyDisasm)) return;
    GV.MOD_ = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
    GV.RM_  = (*((UInt8*)(UIntPtr) (GV.EIP_+1))) & 0x7;
    if (GV.MOD_ == 0) {
        ModRM_0[GV.RM_](pMyArgument, pMyDisasm);
    }
    else if (GV.MOD_ == 1) {
        GV.DECALAGE_EIP++;
        ModRM_1[GV.RM_](pMyArgument, pMyDisasm);
    }
    else if (GV.MOD_ == 2) {
        if (GV.AddressSize >= 32) {
            GV.DECALAGE_EIP += 4;
        }
        else {
            GV.DECALAGE_EIP += 2;
        }
        ModRM_2[GV.RM_](pMyArgument, pMyDisasm);
    }
    else {
        ModRM_3[GV.RM_](pMyArgument, pMyDisasm);
    }

}

// Assembly:
movl $0x0, 0x244(%rsi)
movq 0x250(%rsi), %rax
testq %rax, %rax
je 0x2b1bb
movq 0x1f0(%rsi), %rcx
incq %rcx
cmpq %rax, %rcx
jae 0x2b1f5
movq 0x1f0(%rsi), %rax
movzbl 0x1(%rax), %ecx
shrl $0x6, %ecx
movl %ecx, 0x218(%rsi)
movzbl 0x1(%rax), %eax
andl $0x7, %eax
movl %eax, 0x21c(%rsi)
leaq 0x27a5(%rip), %rdx      # 0x2d988
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0xfcad(%rip), %rcx      # 0x3aea0
jmp 0x2b245
movl $0x1, 0x289(%rsi)
retq
xorl %ecx, %ecx
cmpl $0x20, 0x214(%rsi)
setge %cl
leal 0x2(,%rcx,2), %ecx
movl %ecx, 0x244(%rsi)
movzbl %al, %eax
leaq 0xfcfd(%rip), %rcx      # 0x3af20
jmp 0x2b245
movzbl %al, %eax
leaq 0xfd31(%rip), %rcx      # 0x3af60
jmp 0x2b245
movl $0x1, 0x244(%rsi)
movzbl %al, %eax
leaq 0xfc9b(%rip), %rcx      # 0x3aee0
movq (%rcx,%rax,8), %rax
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: GvEw
void __bea_callspec__ GvEw(PDISASM pMyDisasm)
{
    GV.MemDecoration = Arg2word;
    GV.OriginalOperandSize = GV.OperandSize;
    GV.OperandSize = 16;
    MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
    GV.OperandSize = GV.OriginalOperandSize;
    Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x20c(%rdi), %eax
movl %eax, 0x208(%rdi)
movabsq $0x6600000010, %rax     # imm = 0x6600000010
movq %rax, 0x20c(%rdi)
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x2b196
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%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/Routines_Disasm.c
// Function: GvEb
void __bea_callspec__ GvEb(PDISASM pMyDisasm)
{
    if (GV.OperandSize == 64) {
        GV.MemDecoration = Arg2byte;
        GV.OperandSize = 8;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.OperandSize = 64;
    }
    else if (GV.OperandSize == 32) {
        GV.MemDecoration = Arg2byte;
        GV.OperandSize = 8;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.OperandSize = 32;
    }
    else {
        GV.MemDecoration = Arg2byte;
        GV.OperandSize = 8;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.OperandSize = 16;
    }
    Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20c(%rdi), %ebp
movabsq $0x6500000008, %rax     # imm = 0x6500000008
movq %rax, 0x20c(%rdi)
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x2b196
xorl %eax, %eax
cmpl $0x20, %ebp
sete %al
shll $0x4, %eax
addl $0x10, %eax
cmpl $0x40, %ebp
cmovel %ebp, %eax
movl %eax, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: EbIb
void __bea_callspec__ EbIb(PDISASM pMyDisasm)
{
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.ImmediatSize = 8;
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_ += GV.DECALAGE_EIP+3;
    if (!Security(0, pMyDisasm)) return;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64)*((Int8*)(UIntPtr) (GV.EIP_-1)));
    #endif
    (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_-1));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movabsq $0x888000000, %rax      # imm = 0x888000000
movq %rax, 0x144(%rdi)
movl $0x8, 0x260(%rdi)
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2b196
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x3, %eax
addq 0x1f0(%rbx), %rax
movq %rax, 0x1f0(%rbx)
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0x2b6aa
movl $0x1, 0x289(%rbx)
jmp 0x2b6d7
leaq 0x104(%rbx), %rsi
movsbq -0x1(%rax), %rcx
leaq 0x2356(%rip), %rdx      # 0x2da13
movq %rbx, %rdi
callq 0x2acdf
movq 0x1f0(%rbx), %rax
movzbl -0x1(%rax), %eax
movq %rax, 0x90(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: test_GbEb
void __bea_callspec__ test_GbEb(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
    #endif
    (*pMyDisasm).Argument1.AccessMode = READ;
    GbEb(pMyDisasm);
    FillFlags(pMyDisasm,104);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x74736574, 0x68(%rdi) # imm = 0x74736574
movw $0x20, 0x6c(%rdi)
movl $0x1, 0xe8(%rdi)
callq 0x2ae61
movl 0xce1d(%rip), %eax      # 0x38668
movl %eax, 0x84(%rbx)
movq 0xce08(%rip), %rax      # 0x38660
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: test_GvEv
void __bea_callspec__ test_GvEv(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
    #endif
    (*pMyDisasm).Argument1.AccessMode = READ;
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm,104);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x74736574, 0x68(%rdi) # imm = 0x74736574
movw $0x20, 0x6c(%rdi)
movl $0x1, 0xe8(%rdi)
callq 0x2aeb0
movl 0xcddd(%rip), %eax      # 0x38668
movl %eax, 0x84(%rbx)
movq 0xcdc8(%rip), %rax      # 0x38660
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: Eb
void __bea_callspec__ Eb(PDISASM pMyDisasm)
{
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movabsq $0x100000008, %rax      # imm = 0x100000008
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2b196
movl $0x20, 0x20c(%rbx)
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/Routines_Disasm.c
// Function: Disasm
int __bea_callspec__ Disasm (PDISASM pMyDisasm) {

    if (InitVariables(pMyDisasm)) {
        (void) AnalyzeOpcode(pMyDisasm);
        if (!GV.OutOfBlock) {
            FixArgSizeForMemoryOperand(pMyDisasm);
            FixREXPrefixes(pMyDisasm);
            FillSegmentsRegisters(pMyDisasm);
            CompleteInstructionFields(pMyDisasm);
            #ifndef BEA_LIGHT_DISASSEMBLY
                if (GV.SYNTAX_ == ATSyntax) {
                    BuildCompleteInstructionATSyntax(pMyDisasm);
                }
                else {
                    BuildCompleteInstruction(pMyDisasm);
                }
            #endif
            if (GV.ERROR_OPCODE) {
                return -1;
            }
            else {
                return (int) (GV.EIP_-(*pMyDisasm).EIP);
            }
        }
        else {
            return 0;
        }
    }
    else {
        return -1;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2bb58
movq 0x1f0(%rbx), %rax
movzbl (%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl (%rax), %eax
leaq 0xd3cc(%rip), %rcx      # 0x38ea0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
xorl %eax, %eax
cmpl $0x0, 0x289(%rbx)
jne 0x2bb56
movq %rbx, %rdi
callq 0x2bcc3
movb 0x284(%rbx), %al
movb %al, 0x1e9(%rbx)
movl 0x285(%rbx), %eax
movl %eax, 0x1ea(%rbx)
movq %rbx, %rdi
callq 0x2bd93
movl 0x78(%rbx), %eax
addl $-0xb, %eax
cmpl $0x1, %eax
ja 0x2bb22
movl $0x1, 0xe8(%rbx)
cmpl $0x400, 0x24c(%rbx)     # imm = 0x400
jne 0x2bb38
movq %rbx, %rdi
callq 0x2c0d3
jmp 0x2bb40
movq %rbx, %rdi
callq 0x2c3e2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, 0x280(%rbx)
jne 0x2bb56
movl 0x1f0(%rbx), %eax
subl (%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/winton[P]redis_parse/redis_parse.c
// Function: createStringObject
static void *createStringObject(const redisReadTask *task, char *str, size_t len) {
	static char *record = NULL;
	static int score = -1;

	if (with_scores && record != NULL)
		score = atoi(str);
	else {
		record = malloc(len + 1);
		memcpy(record, str, len);
		record[len] = '\0';	
	}

	if (!with_scores || score != -1) {
		process_record(record, score);
		record = NULL;
		score = -1;
	}

	redisReply *r;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movb 0x7e90(%rip), %bpl      # 0xa280
cmpb $0x1, %bpl
jne 0x2410
cmpq $0x0, 0x9ac2(%rip)      # 0xbec0
je 0x2410
movq %r14, %rdi
callq 0x2230
movl %eax, 0x7e2a(%rip)      # 0xa238
jmp 0x2436
leaq 0x1(%rbx), %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, 0x9a9d(%rip)      # 0xbec0
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21d0
movb $0x0, (%r15,%rbx)
movl 0x7dfc(%rip), %esi      # 0xa238
cmpl $-0x1, %esi
sete %al
testb %al, %bpl
jne 0x2468
movq 0x9a72(%rip), %rdi      # 0xbec0
callq 0x329d
movq $0x0, 0x9a62(%rip) # 0xbec0
movl $0xffffffff, 0x7dd0(%rip) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/winton[P]redis_parse/redis_parse.c
// Function: column_to_index
int column_to_index(char *key) {
	int i, index = -1;

	for (i = 0; i < columns_count; ++i)
		if (strcmp(columns[i], key) == 0)
			index = i;
	
	return index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x7839(%rip), %r15d     # 0xa20c
testq %r15, %r15
je 0x2a09
movq %rdi, %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x7799(%rip), %r14      # 0xa180
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21c0
testl %eax, %eax
cmovel %r12d, %ebp
incq %r12
addq $0x14, %r14
cmpq %r12, %r15
jne 0x29ea
jmp 0x2a0e
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/winton[P]redis_parse/redis_parse.c
// Function: to_fields
char **to_fields(char *record) {
	char **fields = (char **)malloc(sizeof(char*) * columns_count);
	char *field;
	int i;

	for(i = 0; i < columns_count; ++i) {
		field = xstrtok(i == 0 ? record : NULL, "|");
		if (field == NULL)
			field = empty;
		fields[i] = field;
	}

	return fields;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x77e0(%rip), %r15d     # 0xa20c
leaq (,%r15,8), %rdi
callq 0x21f0
movq %rax, %r14
testq %r15, %r15
je 0x2a7f
xorl %r12d, %r12d
leaq 0x4647(%rip), %r15      # 0x7092
leaq 0x782f(%rip), %r13      # 0xa281
testq %r12, %r12
movl $0x0, %edi
cmoveq %rbx, %rdi
movq %r15, %rsi
callq 0x348c
testq %rax, %rax
cmoveq %r13, %rax
movq %rax, (%r14,%r12,8)
incq %r12
movl 0x7792(%rip), %eax      # 0xa20c
cmpq %rax, %r12
jb 0x2a52
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/winton[P]redis_parse/redis_parse.c
// Function: xstrtok
char *xstrtok(char *line, char *delims) {
	static char *saveline = NULL;
	char *p;
	int n;

	if(line != NULL)
		saveline = line;

	if (saveline == NULL || *saveline == '\0')
		return NULL;
	
	n = strcspn(saveline, delims);
	p = saveline;

	saveline += n;

	if (*saveline != '\0')
		*saveline++ = '\0';

	return p;
}

// Assembly:
testq %rdi, %rdi
je 0x3498
movq %rdi, 0x8a20(%rip)      # 0xbeb8
pushq %rbx
movq 0x8a18(%rip), %rbx      # 0xbeb8
testq %rbx, %rbx
je 0x34d6
cmpb $0x0, (%rbx)
je 0x34d6
movq %rbx, %rdi
callq 0x2160
movslq %eax, %rcx
leaq (%rbx,%rcx), %rax
movq %rax, 0x89f8(%rip)      # 0xbeb8
cmpb $0x0, (%rbx,%rcx)
je 0x34d8
leaq 0x1(%rax), %rcx
movq %rcx, 0x89e7(%rip)      # 0xbeb8
movb $0x0, (%rax)
jmp 0x34d8
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_06/strindex.c
// Function: main
int main(void)
{
  char s[] = "this is first string";
  char t[] = "this";

  printf("%d", strindex(s, t));

  return 0;
}

// Assembly:
pushq %rax
leaq 0xecc(%rip), %rax       # 0x2010
xorl %esi, %esi
movb $0x74, %dl
leaq 0xed6(%rip), %rcx       # 0x2025
cmpb $0x74, %dl
jne 0x116b
xorl %edx, %edx
movb (%rax,%rdx), %dil
cmpb (%rdx,%rcx), %dil
jne 0x116b
incq %rdx
cmpq $0x4, %rdx
jne 0x1156
jmp 0x117d
incl %esi
movb 0x1(%rax), %dl
incq %rax
cmpl $0x14, %esi
jne 0x114f
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0xea6(%rip), %rdi       # 0x202a
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_06/strindex.c
// Function: strindex
int strindex(char *s, char *t)
{
  char *first;
  char *second;
  int pos = 0;

  while (*s != '\0')
  {
    if (*s == *t)
    {
      first = s;
      second = t;

      while (*first++ == *second++)
      {
        if (*second == '\0')
          return pos;
      }
    }
    pos++;
    s++;
  }

  return -1;
}

// Assembly:
movb (%rdi), %r8b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %r8b, %r8b
je 0x11ce
movb (%rsi), %dl
xorl %ecx, %ecx
cmpb %dl, %r8b
jne 0x11c0
xorl %r8d, %r8d
movb (%rdi,%r8), %r9b
cmpb (%rsi,%r8), %r9b
jne 0x11c0
cmpb $0x0, 0x1(%rsi,%r8)
leaq 0x1(%r8), %r8
jne 0x11a8
jmp 0x11cf
incl %ecx
movb 0x1(%rdi), %r8b
incq %rdi
testb %r8b, %r8b
jne 0x11a0
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/src/boolean.c
// Function: SH_Boolean__init
SH_Boolean*
SH_Boolean__init(sh_bool_t value, int* err) {
	SH_Boolean* obj = (SH_Boolean*)malloc(sizeof(SH_Boolean));

	__cascade(err, (SH_Boolean*)0);

	if ((SH_Boolean*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_Boolean*)0;
	}

	obj->value = (value == SH_FALSE ? SH_FALSE : SH_TRUE);

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x1, %edi
callq 0x1040
testq %rbx, %rbx
je 0x113c
cmpl $0x0, (%rbx)
je 0x113c
xorl %eax, %eax
jmp 0x115f
testq %rax, %rax
je 0x1151
xorl %ecx, %ecx
negb %bpl
movl $0x0, %edx
sbbl %edx, %edx
movb %dl, (%rax)
jmp 0x1158
movl $0x80000001, %ecx       # imm = 0x80000001
xorl %eax, %eax
testq %rbx, %rbx
je 0x115f
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq