LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: pmaxud_
void __bea_callspec__ pmaxud_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_MINMAX;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaxud ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x22a90
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x800023, 0x60(%rbx)   # imm = 0x800023
movabsq $0x20647578616d70, %rax # imm = 0x20647578616D70
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x230(%rbx)
jmp 0x22aa5
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: pmulld_
void __bea_callspec__ pmulld_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmulld ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x22b01
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x800002, 0x60(%rbx)   # imm = 0x800002
movabsq $0x20646c6c756d70, %rax # imm = 0x20646C6C756D70
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x230(%rbx)
jmp 0x22b16
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: phminposuw_
void __bea_callspec__ phminposuw_(PDISASM pMyDisasm)
{
    /* ========== 0x66 */
    if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg2dqword;
        (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+HORIZONTAL_SEARCH;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phminposuw ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1dd(%rdi)
jne 0x22b79
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x800024, 0x60(%rbx)   # imm = 0x800024
movabsq $0x736f706e696d6870, %rax # imm = 0x736F706E696D6870
movq %rax, 0x68(%rbx)
movl $0x207775, 0x70(%rbx)   # imm = 0x207775
movl $0x1, 0x230(%rbx)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x230(%rbx)
jmp 0x22b8e
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_AES.c
// Function: aesimc
void __bea_callspec__ aesimc(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, "aesimc ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x10, 0x20c(%rdi)
jne 0x22bea
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x40000000, 0x60(%rbx) # imm = 0x40000000
movabsq $0x20636d69736561, %rax # imm = 0x20636D69736561
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x230(%rbx)
jmp 0x22bff
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_AES.c
// Function: aesenc
void __bea_callspec__ aesenc(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, "aesenc ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x10, 0x20c(%rdi)
jne 0x22c5b
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x40000000, 0x60(%rbx) # imm = 0x40000000
movabsq $0x20636e65736561, %rax # imm = 0x20636E65736561
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x230(%rbx)
jmp 0x22c70
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_AES.c
// Function: aesdec
void __bea_callspec__ aesdec(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, "aesdec ");
        #endif
        GV.SSE_ = 1;
        GxEx(pMyDisasm);
        GV.SSE_ = 0;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x10, 0x20c(%rdi)
jne 0x22d44
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x40000000, 0x60(%rbx) # imm = 0x40000000
movabsq $0x20636564736561, %rax # imm = 0x20636564736561
movq %rax, 0x68(%rbx)
movl $0x1, 0x230(%rbx)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x230(%rbx)
jmp 0x22d59
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: crc32_GvEb
void __bea_callspec__ crc32_GvEb(PDISASM pMyDisasm)
{
    /* ========= 0xf2 */
    if (GV.PrefRepne == 1) {
        (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
        (*pMyDisasm).Instruction.Category = SSE42_INSTRUCTION+ACCELERATOR_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "crc32 ");
        #endif
        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;
            MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        }

        if (GV.OperandSize == 16) {
            GV.OperandSize = 32;
            Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
            GV.OperandSize = 16;
        }
        else {
            Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
        }
        GV.EIP_ += GV.DECALAGE_EIP+2;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, 0x26c(%rdi)
jne 0x22e58
movb $0x8, 0x1df(%rbx)
movl $0x100002a, 0x60(%rbx)  # imm = 0x100002A
movl $0x33637263, 0x68(%rbx) # imm = 0x33637263
movl $0x203233, 0x6b(%rbx)   # imm = 0x203233
movl 0x20c(%rbx), %ebp
movl $0x65, 0x210(%rbx)
cmpl $0x20, %ebp
je 0x22e18
cmpl $0x40, %ebp
jne 0x22e74
movl $0x8, 0x20c(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x28863
movl %ebp, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
jmp 0x22e6d
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x28863
cmpl $0x10, 0x20c(%rbx)
jne 0x22e37
movl $0x20, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
movl $0x10, 0x20c(%rbx)
jmp 0x22e46
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: crc32_GvEv
void __bea_callspec__ crc32_GvEv(PDISASM pMyDisasm)
{
    /* ========= 0xf2 */
    if (GV.PrefRepne == 1) {
        (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
        (*pMyDisasm).Instruction.Category = SSE42_INSTRUCTION+ACCELERATOR_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "crc32 ");
        #endif

        if (GV.OperandSize == 64) {
            GV.MemDecoration = Arg2qword;
        }
        else if (GV.OperandSize == 32) {
            GV.MemDecoration = Arg2dword;
        }
        else {
            GV.MemDecoration = Arg2word;
        }
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);

        if (GV.OperandSize == 16) {
            GV.OperandSize = 32;
            Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
            GV.OperandSize = 16;
        }
        else {
            Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
        }
        GV.EIP_ += GV.DECALAGE_EIP+2;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, 0x26c(%rdi)
jne 0x22f37
movb $0x8, 0x1df(%rbx)
movl $0x100002a, 0x60(%rbx)  # imm = 0x100002A
movl $0x33637263, 0x68(%rbx) # imm = 0x33637263
movl $0x203233, 0x6b(%rbx)   # imm = 0x203233
movl 0x20c(%rbx), %eax
xorl %ecx, %ecx
cmpl $0x20, %eax
sete %cl
orl $0x66, %ecx
cmpl $0x40, %eax
pushq $0x68
popq %rax
cmovnel %ecx, %eax
movl %eax, 0x210(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x28863
cmpl $0x10, 0x20c(%rbx)
jne 0x22f4e
movl $0x20, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
movl $0x10, 0x20c(%rbx)
jmp 0x22f5d
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0x22f6d
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: roundps_
void __bea_callspec__ roundps_(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, "roundps ");
        #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 0x23004
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x80002b, 0x60(%rbx)   # imm = 0x80002B
movabsq $0x207370646e756f72, %rax # imm = 0x207370646E756F72
movq %rax, 0x68(%rbx)
movb $0x0, 0x70(%rbx)
movl $0x8, 0x260(%rbx)
movl $0x1, 0x230(%rbx)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x230(%rbx)
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x1f0(%rbx)
decq %rcx
cmpq %rdx, %rcx
jae 0x23019
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x23058
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
jmp 0x23058
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x79d5(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
pushq $0x8
popq %rax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x230f2
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)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x230(%rbx)
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x1f0(%rbx)
decq %rcx
cmpq %rdx, %rcx
jae 0x23107
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x23146
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
jmp 0x23146
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x78e7(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
pushq $0x8
popq %rax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_SSE.c
// Function: palignr_
void __bea_callspec__ palignr_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
    /* ========== 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, "palignr ");
        #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 {
        GV.MemDecoration = Arg2qword;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "palignr ");
        #endif
        GV.ImmediatSize = 8;
        GV.MMX_ = 1;
        GxEx(pMyDisasm);
        GV.MMX_ = 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;

    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x80018, 0x60(%rdi)    # imm = 0x80018
cmpb $0x1, 0x1dd(%rdi)
jne 0x23659
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movabsq $0x20726e67696c6170, %rax # imm = 0x20726E67696C6170
movq %rax, 0x68(%rbx)
movb $0x0, 0x70(%rbx)
movl $0x8, 0x260(%rbx)
movl $0x1, 0x230(%rbx)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x230(%rbx)
jmp 0x23698
movl $0x68, 0x210(%rbx)
movabsq $0x20726e67696c6170, %rax # imm = 0x20726E67696C6170
movq %rax, 0x68(%rbx)
movb $0x0, 0x70(%rbx)
movl $0x8, 0x260(%rbx)
movl $0x1, 0x22c(%rbx)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x22c(%rbx)
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
movq %rax, %rdx
incq %rdx
movq %rdx, 0x1f0(%rbx)
decq %rcx
cmpq %rdx, %rcx
jae 0x236c5
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x23704
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x7329(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
pushq $0x8
popq %rax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x237d4
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 0x28863
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
andl $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 0x237e9
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x2382a
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
jmp 0x2382a
movl $0x1, 0x278(%rbx)
movzbl -0x1(%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl -0x1(%rax), %ecx
leaq 0x7203(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
pushq $0x8
popq %rax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x238f6
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 0x28863
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
andl $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 0x2390b
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x2394c
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
jmp 0x2394c
movl $0x1, 0x278(%rbx)
movzbl -0x1(%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl -0x1(%rax), %ecx
leaq 0x70e1(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
pushq $0x8
popq %rax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2399a
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x800027, 0x60(%rbx)   # imm = 0x800027
cmpb $0x1, 0x284(%rbx)
jne 0x239b2
movl $0x40, 0x20c(%rbx)
pushq $0x4
popq %rax
movabsq $0x20717274786570, %rcx # imm = 0x20717274786570
jmp 0x239bf
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
jmp 0x23a73
pushq $0x3
popq %rax
movabsq $0x20647274786570, %rcx # imm = 0x20647274786570
movq %rcx, 0x68(%rbx)
movl %eax, 0x210(%rbx)
movl $0x8, 0x260(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x28863
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
andl $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 0x23a32
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x23a73
movl $0x1, 0x278(%rbx)
movzbl -0x1(%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl -0x1(%rax), %ecx
leaq 0x6fba(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
pushq $0x8
popq %rax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x23b2f
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 0x28863
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
andl $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 0x23b44
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x23b83
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
jmp 0x23b83
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x6eaa(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
pushq $0x8
popq %rax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x23c19
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)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x230(%rbx)
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x1f0(%rbx)
decq %rcx
cmpq %rdx, %rcx
jae 0x23c2e
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x23c6d
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
jmp 0x23c6d
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x6dc0(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
pushq $0x8
popq %rax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x23d43
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 0x28863
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
andl $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 0x23d58
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x23d97
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
jmp 0x23d97
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x6c96(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
pushq $0x8
popq %rax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x23e61
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 0x28863
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
andl $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 0x23e76
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x23eb7
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
jmp 0x23eb7
movl $0x1, 0x278(%rbx)
movzbl -0x1(%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl -0x1(%rax), %ecx
leaq 0x6b76(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
pushq $0x8
popq %rax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24713
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x6c, 0x210(%rbx)
movl $0x40000000, 0x60(%rbx) # imm = 0x40000000
movups 0x709d(%rip), %xmm0     # 0x2b75a
movups %xmm0, 0x68(%rbx)
movb $0x0, 0x78(%rbx)
movl $0x8, 0x260(%rbx)
movl $0x1, 0x230(%rbx)
movq %rbx, %rdi
callq 0x290ce
andl $0x0, 0x230(%rbx)
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x1f0(%rbx)
decq %rcx
cmpq %rdx, %rcx
jae 0x24728
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x24767
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
jmp 0x24767
movl $0x1, 0x278(%rbx)
movzbl (%rax), %ecx
movq %rcx, 0x90(%rbx)
leaq 0x16c(%rbx), %rsi
movzbl (%rax), %ecx
leaq 0x62c6(%rip), %rdx      # 0x2aa13
movq %rbx, %rdi
callq 0x283ec
movl $0x88000000, 0x1ac(%rbx) # imm = 0x88000000
pushq $0x8
popq %rax
movl $0x1b0, %ecx            # imm = 0x1B0
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24ad4
movq 0x1f0(%rdx), %rcx
addq $0x2, %rcx
cmpq %rax, %rcx
jae 0x24b48
movl $0x40000000, 0x40(%rbx) # imm = 0x40000000
cmpl $0x20, 0x214(%rdx)
jl 0x24b2e
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 0x1449e(%rip), %rax     # 0x38fc0
movq (%rax,%rcx,8), %rax
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmpq *%rax
leaq 0x1217b(%rip), %rsi     # 0x36cb0
movq %rbx, %rdi
callq 0x8170
movl 0x12335(%rip), %eax     # 0x36e78
movl %eax, 0x50(%rbx)
jmp 0x24b52
movl $0x1, 0x289(%rdx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x260b(%rip), %rsi      # 0x2aa13
movq %rdx, %rdi
callq 0x8210
testl %eax, %eax
movzbl %r12b, %r13d
cmovneq %r12, %r13
leaq 0x2651(%rip), %rsi      # 0x2aa72
movq %r14, %rdi
callq 0x8210
testl %eax, %eax
movzwl %r13w, %r12d
cmovneq %r13, %r12
leaq 0x2622(%rip), %rsi      # 0x2aa5c
movq %r14, %rdi
callq 0x8210
testl %eax, %eax
movl %r12d, %edx
cmovneq %r12, %rdx
cmpl $0x10000, 0x248(%r15) # imm = 0x10000
jne 0x28480
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_O2/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 0x28863
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x4
popq %rax
cmovnel %ecx, %eax
movl %eax, 0x210(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x28863
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x28863
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
movl $0x20, 0x20c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x68
popq %rax
cmovnel %ecx, %eax
movl %eax, 0x210(%rdi)
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x28863
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq