LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: jmp_short
void __bea_callspec__ jmp_short(PDISASM pMyDisasm)
{
    UInt64 MyAddress = 0;
    signed long MyNumber = 0;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
    (*pMyDisasm).Instruction.BranchType = JmpType;
    (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jmp ");
    #endif
    if (!Security(1, pMyDisasm)) return;
    MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
    CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
    if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
    if (MyAddress >= W64LIT (0x100000000)) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
        #endif
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
        #endif
    }
    (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
    (*pMyDisasm).Argument1.AccessMode = READ;
    (*pMyDisasm).Instruction.AddrValue = MyAddress;
    GV.EIP_+=2;
    FillFlags(pMyDisasm,49);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10006, 0x60(%rdi)    # imm = 0x10006
movl $0xb, 0x78(%rdi)
movl 0x20c(%rdi), %eax
movl %eax, 0xe0(%rdi)
movl $0x20706d6a, 0x68(%rdi) # imm = 0x20706D6A
movb $0x0, 0x6c(%rdi)
movq 0x250(%rdi), %rdx
movq 0x1f0(%rdi), %rcx
incq %rcx
decq %rdx
cmpq %rcx, %rdx
jae 0x173ce
movl $0x1, 0x289(%rbx)
jmp 0x17471
movsbq (%rcx), %rcx
movslq 0x264(%rbx), %rdx
movl $0x1, 0x258(%rbx)
movq 0x1f8(%rbx), %rdi
testq %rdi, %rdi
jne 0x173f6
movq 0x200(%rbx), %rdi
leaq 0x9c(%rbx), %rsi
addq %rdx, %rcx
leaq (%rdi,%rcx), %r14
addq $0x2, %r14
cmpl $0x10, %eax
jne 0x17413
movzwl %r14w, %r14d
jmp 0x17425
movq %r14, %rax
shrq $0x20, %rax
je 0x17425
leaq 0x13631(%rip), %rdx     # 0x2aa54
jmp 0x1742c
leaq 0x13630(%rip), %rdx     # 0x2aa5c
movq %rbx, %rdi
movq %r14, %rcx
callq 0x283ec
movl $0x84000000, 0xdc(%rbx) # imm = 0x84000000
movl $0x1, 0xe8(%rbx)
movq %r14, 0x88(%rbx)
addq $0x2, 0x1f0(%rbx)
movq 0x1ef8b(%rip), %rax     # 0x363ec
movq %rax, 0x7c(%rbx)
movl 0x1ef89(%rip), %eax     # 0x363f4
movl %eax, 0x84(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: in_ALDX
void __bea_callspec__ in_ALDX(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "in ");
    #endif
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers8Bits[0]);
    #endif
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[2]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
    (*pMyDisasm).Argument2.ArgSize = 16;
    GV.EIP_++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10008, 0x60(%rdi)    # imm = 0x10008
movl $0x206e69, 0x68(%rdi)   # imm = 0x206E69
addq $0x9c, %rdi
leaq 0x1f8a7(%rip), %rsi     # 0x36d40
callq 0x8170
leaq 0x104(%rbx), %rdi
leaq 0x1f7e4(%rip), %rsi     # 0x36c90
callq 0x8170
movl $0x20020000, %eax       # imm = 0x20020000
movl 0x1f9a4(%rip), %ecx     # 0x36e60
addl %eax, %ecx
movl %ecx, 0xdc(%rbx)
movl $0x8, 0xe0(%rbx)
addl 0x1f994(%rip), %eax     # 0x36e68
movl %eax, 0x144(%rbx)
movl $0x10, 0x148(%rbx)
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: in_eAX
void __bea_callspec__ in_eAX(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "in ");
    #endif
    if (GV.OperandSize >=32) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
        #endif
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[2]);
        #endif
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
        (*pMyDisasm).Argument1.ArgSize = 32;
        (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
        (*pMyDisasm).Argument2.ArgSize = 16;
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
        #endif
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[2]);
        #endif
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
        (*pMyDisasm).Argument1.ArgSize = 16;
        (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
        (*pMyDisasm).Argument2.ArgSize = 16;
    }
    GV.EIP_++;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x10008, 0x60(%rdi)    # imm = 0x10008
movl $0x206e69, 0x68(%rdi)   # imm = 0x206E69
addq $0x9c, %rdi
xorl %ebp, %ebp
cmpl $0x20, 0x20c(%rbx)
leaq 0x104(%rbx), %r14
setge %bpl
leaq 0x1f6dc(%rip), %rax     # 0x36c00
leaq 0x1f755(%rip), %rsi     # 0x36c80
cmovgeq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8170
leaq 0x1f74f(%rip), %rsi     # 0x36c90
movq %r14, %rdi
callq 0x8170
movl $0x20020000, %eax       # imm = 0x20020000
movl 0x1f914(%rip), %ecx     # 0x36e68
addl %eax, %ecx
addl 0x1f904(%rip), %eax     # 0x36e60
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
movl %ecx, 0x144(%rbx)
movl $0x10, 0x148(%rbx)
incq 0x1f0(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: out_DXAL
void __bea_callspec__ out_DXAL(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "out ");
    #endif
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2]);
    #endif
    (*pMyDisasm).Argument1.ArgSize = 16;
    (*pMyDisasm).Argument1.AccessMode = READ;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers8Bits[0]);
    #endif
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ ++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10008, 0x60(%rdi)    # imm = 0x10008
movl $0x2074756f, 0x68(%rdi) # imm = 0x2074756F
movb $0x0, 0x6c(%rdi)
addq $0x9c, %rdi
leaq 0x1f6e8(%rip), %rsi     # 0x36c90
callq 0x8170
movl $0x10, 0xe0(%rbx)
movl $0x1, 0xe8(%rbx)
leaq 0x104(%rbx), %rdi
leaq 0x1f771(%rip), %rsi     # 0x36d40
callq 0x8170
movl $0x8, 0x148(%rbx)
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: out_DXeAX
void __bea_callspec__ out_DXeAX(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "out ");
    #endif
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2]);
    #endif
    (*pMyDisasm).Argument1.ArgSize = 16;
    (*pMyDisasm).Argument1.AccessMode = READ;
    if (GV.OperandSize == 32) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[0]);
        #endif
        (*pMyDisasm).Argument2.ArgSize = 32;
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[0]);
        #endif
        (*pMyDisasm).Argument2.ArgSize = 16;
    }
    GV.EIP_ ++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10008, 0x60(%rdi)    # imm = 0x10008
movl $0x2074756f, 0x68(%rdi) # imm = 0x2074756F
movb $0x0, 0x6c(%rdi)
addq $0x9c, %rdi
leaq 0x1f683(%rip), %rsi     # 0x36c90
callq 0x8170
leaq 0x1f667(%rip), %rax     # 0x36c80
movl $0x10, 0xe0(%rbx)
movl $0x1, 0xe8(%rbx)
leaq 0x104(%rbx), %rdi
xorl %ebp, %ebp
cmpl $0x20, 0x20c(%rbx)
sete %bpl
leaq 0x1f5b8(%rip), %rsi     # 0x36c00
cmovneq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8170
movl %ebp, 0x148(%rbx)
incq 0x1f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_prefixes.c
// Function: PrefLock
void __bea_callspec__ PrefLock(PDISASM pMyDisasm)
{
    if (!Security(0, pMyDisasm)) return;
    (*pMyDisasm).Prefix.LockPrefix = InvalidPrefix;
    GV.EIP_++;
    (*pMyDisasm).Prefix.Number++;
    GV.NB_PREFIX++;
    (*pMyDisasm).Instruction.Opcode =  *((UInt8*) (UIntPtr)GV.EIP_);
    (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
    GV.OperandSize = 32;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1f0(%rdi), %rax
movq 0x250(%rdi), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0x1768f
pushq $0x1
popq %rax
movl $0x289, %ecx            # imm = 0x289
jmp 0x176cf
movb $0x4, 0x1dc(%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rbx)
incl 0x1d4(%rbx)
incl 0x264(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x1f7ff(%rip), %rcx     # 0x36ec0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
pushq $0x20
popq %rax
movl $0x20c, %ecx            # imm = 0x20C
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: int1_
void __bea_callspec__ int1_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "int1 ");
    #endif
    GV.EIP_++;
    FillFlags(pMyDisasm, 42);
}

// Assembly:
movl $0x10006, 0x60(%rdi)    # imm = 0x10006
movl $0x31746e69, 0x68(%rdi) # imm = 0x31746E69
movw $0x20, 0x6c(%rdi)
incq 0x1f0(%rdi)
movq 0x1eca2(%rip), %rax     # 0x36398
movq %rax, 0x7c(%rdi)
movl 0x1eca0(%rip), %eax     # 0x363a0
movl %eax, 0x84(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_prefixes.c
// Function: PrefREPNE
void __bea_callspec__ PrefREPNE(PDISASM pMyDisasm)
{
    if (!Security(0, pMyDisasm)) return;
    (*pMyDisasm).Prefix.RepnePrefix = SuperfluousPrefix;
    GV.EIP_++;
    (*pMyDisasm).Prefix.Number++;
    GV.NB_PREFIX++;
    GV.PrefRepne = 1;
    (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
    (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
    GV.PrefRepne = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1f0(%rdi), %rax
movq 0x250(%rdi), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0x1772d
movl $0x1, 0x289(%rbx)
jmp 0x17776
movb $0x2, 0x1df(%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rbx)
incl 0x1d4(%rbx)
incl 0x264(%rbx)
movl $0x1, 0x26c(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x1f757(%rip), %rcx     # 0x36ec0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
andl $0x0, 0x26c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_prefixes.c
// Function: PrefREPE
void __bea_callspec__ PrefREPE(PDISASM pMyDisasm)
{
    if (!Security(0, pMyDisasm)) return;
    (*pMyDisasm).Prefix.RepPrefix = SuperfluousPrefix;
    GV.EIP_++;
    (*pMyDisasm).Prefix.Number++;
    GV.NB_PREFIX++;
    GV.PrefRepe = 1;
    (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
    (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
    GV.PrefRepe = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1f0(%rdi), %rax
movq 0x250(%rdi), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0x1779e
movl $0x1, 0x289(%rbx)
jmp 0x177e7
movb $0x2, 0x1e0(%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rbx)
incl 0x1d4(%rbx)
incl 0x264(%rbx)
movl $0x1, 0x268(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x1f6e6(%rip), %rcx     # 0x36ec0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
andl $0x0, 0x268(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmc_
void __bea_callspec__ cmc_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmc ");
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 1;
    FillFlags(pMyDisasm, 18);
    GV.EIP_++;
}

// Assembly:
movl $0x1000a, 0x60(%rdi)    # imm = 0x1000A
movl $0x20636d63, 0x68(%rdi) # imm = 0x20636D63
movb $0x0, 0x6c(%rdi)
movabsq $0x120400001, %rax      # imm = 0x120400001
movq %rax, 0xdc(%rdi)
movq 0x1ea4b(%rip), %rax     # 0x36278
movq %rax, 0x7c(%rdi)
movl 0x1ea49(%rip), %eax     # 0x36280
movl %eax, 0x84(%rdi)
incq 0x1f0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: clc_
void __bea_callspec__ clc_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "clc ");
    #endif
    (*pMyDisasm).Argument1.ArgSize = 1;
    FillFlags(pMyDisasm, 14);
    GV.EIP_++;
}

// Assembly:
movl $0x1000a, 0x60(%rdi)    # imm = 0x1000A
movabsq $0x120400001, %rax      # imm = 0x120400001
movq %rax, 0xdc(%rdi)
movl $0x20636c63, 0x68(%rdi) # imm = 0x20636C63
movb $0x0, 0x6c(%rdi)
movq 0x1e404(%rip), %rax     # 0x36248
movq %rax, 0x7c(%rdi)
movl 0x1e402(%rip), %eax     # 0x36250
movl %eax, 0x84(%rdi)
incq 0x1f0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: stc_
void __bea_callspec__ stc_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "stc ");
    #endif
    GV.EIP_++;
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 1;
    FillFlags(pMyDisasm, 98);
}

// Assembly:
movl $0x1000a, 0x60(%rdi)    # imm = 0x1000A
movl $0x20637473, 0x68(%rdi) # imm = 0x20637473
movb $0x0, 0x6c(%rdi)
incq 0x1f0(%rdi)
movabsq $0x120400001, %rax      # imm = 0x120400001
movq %rax, 0xdc(%rdi)
movq 0x1e7ab(%rip), %rax     # 0x36638
movq %rax, 0x7c(%rdi)
movl 0x1e7a9(%rip), %eax     # 0x36640
movl %eax, 0x84(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cli_
void __bea_callspec__ cli_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cli ");
    #endif
    (*pMyDisasm).Argument1.ArgSize = 1;
    FillFlags(pMyDisasm, 16);
    GV.EIP_++;
}

// Assembly:
movl $0x1000a, 0x60(%rdi)    # imm = 0x1000A
movabsq $0x120400001, %rax      # imm = 0x120400001
movq %rax, 0xdc(%rdi)
movl $0x20696c63, 0x68(%rdi) # imm = 0x20696C63
movb $0x0, 0x6c(%rdi)
movq 0x1e398(%rip), %rax     # 0x36260
movq %rax, 0x7c(%rdi)
movl 0x1e396(%rip), %eax     # 0x36268
movl %eax, 0x84(%rdi)
incq 0x1f0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sti_
void __bea_callspec__ sti_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sti ");
    #endif
    GV.EIP_++;
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 1;
    FillFlags(pMyDisasm, 100);
}

// Assembly:
movl $0x1000a, 0x60(%rdi)    # imm = 0x1000A
movl $0x20697473, 0x68(%rdi) # imm = 0x20697473
movb $0x0, 0x6c(%rdi)
incq 0x1f0(%rdi)
movabsq $0x120400001, %rax      # imm = 0x120400001
movq %rax, 0xdc(%rdi)
movq 0x1e73f(%rip), %rax     # 0x36650
movq %rax, 0x7c(%rdi)
movl 0x1e73d(%rip), %eax     # 0x36658
movl %eax, 0x84(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cld_
void __bea_callspec__ cld_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cld ");
    #endif
    (*pMyDisasm).Argument1.ArgSize = 1;
    FillFlags(pMyDisasm, 15);
    GV.EIP_++;
}

// Assembly:
movl $0x1000a, 0x60(%rdi)    # imm = 0x1000A
movabsq $0x120400001, %rax      # imm = 0x120400001
movq %rax, 0xdc(%rdi)
movl $0x20646c63, 0x68(%rdi) # imm = 0x20646C63
movb $0x0, 0x6c(%rdi)
movq 0x1e308(%rip), %rax     # 0x36254
movq %rax, 0x7c(%rdi)
movl 0x1e306(%rip), %eax     # 0x3625c
movl %eax, 0x84(%rdi)
incq 0x1f0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: std_
void __bea_callspec__ std_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "std ");
    #endif
    GV.EIP_++;
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 1;
    FillFlags(pMyDisasm, 99);
}

// Assembly:
movl $0x1000a, 0x60(%rdi)    # imm = 0x1000A
movl $0x20647473, 0x68(%rdi) # imm = 0x20647473
movb $0x0, 0x6c(%rdi)
incq 0x1f0(%rdi)
movabsq $0x120400001, %rax      # imm = 0x120400001
movq %rax, 0xdc(%rdi)
movq 0x1e6af(%rip), %rax     # 0x36644
movq %rax, 0x7c(%rdi)
movl 0x1e6ad(%rip), %eax     # 0x3664c
movl %eax, 0x84(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_Grp4.c
// Function: G4_Eb
void __bea_callspec__ G4_Eb(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    if (GV.REGOPCODE == 0) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "inc ");
        #endif
        Eb(pMyDisasm);
        FillFlags(pMyDisasm, 40);
    }
    else if (GV.REGOPCODE == 1) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "dec ");
        #endif
        Eb(pMyDisasm);
        FillFlags(pMyDisasm, 30);
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1f0(%rdi), %rax
movzbl 0x1(%rax), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x240(%rdi)
cmpl $0x1, %eax
je 0x1800d
testl %eax, %eax
jne 0x18050
cmpb $0x4, 0x1dc(%rbx)
jne 0x17fde
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636e69, 0x68(%rbx) # imm = 0x20636E69
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x29049
movl 0x1e38a(%rip), %eax     # 0x36388
movl %eax, 0x84(%rbx)
movq 0x1e375(%rip), %rax     # 0x36380
jmp 0x1804a
cmpb $0x4, 0x1dc(%rbx)
jne 0x1801d
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636564, 0x68(%rbx) # imm = 0x20636564
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x29049
movl 0x1e2d3(%rip), %eax     # 0x36310
movl %eax, 0x84(%rbx)
movq 0x1e2be(%rip), %rax     # 0x36308
movq %rax, 0x7c(%rbx)
jmp 0x18065
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_A_M.c
// Function: lar_GvEw
void __bea_callspec__ lar_GvEw(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lar ");
    #endif
    GvEw(pMyDisasm);
    FillFlags(pMyDisasm, 53);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2000000, 0x60(%rdi)  # imm = 0x2000000
movl $0x2072616c, 0x68(%rdi) # imm = 0x2072616C
movb $0x0, 0x6c(%rdi)
callq 0x28bea
movl 0x1da54(%rip), %eax     # 0x36424
movl %eax, 0x84(%rbx)
movq 0x1da3f(%rip), %rax     # 0x3641c
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: lsl_GvEw
void __bea_callspec__ lsl_GvEw(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lsl ");
    #endif
    GvEw(pMyDisasm);
    FillFlags(pMyDisasm, 62);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2000000, 0x60(%rdi)  # imm = 0x2000000
movl $0x206c736c, 0x68(%rdi) # imm = 0x206C736C
movb $0x0, 0x6c(%rdi)
callq 0x28bea
movl 0x1da8c(%rip), %eax     # 0x36490
movl %eax, 0x84(%rbx)
movq 0x1da77(%rip), %rax     # 0x36488
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: syscall_
void __bea_callspec__ syscall_(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION+CONTROL_TRANSFER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "syscall ");
        #endif
        GV.EIP_++;
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG1+REG11;
        (*pMyDisasm).Argument1.ArgSize = 64;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
cmpl $0x40, 0x25c(%rdi)
jne 0x18a6a
movl $0x2000006, 0x60(%rdi)  # imm = 0x2000006
movabsq $0x206c6c6163737973, %rax # imm = 0x206C6C6163737973
movq %rax, 0x68(%rdi)
movb $0x0, 0x70(%rdi)
incq 0x1f0(%rdi)
movl $0x20020802, 0xdc(%rdi) # imm = 0x20020802
pushq $0x40
popq %rax
movl $0xe0, %ecx
jmp 0x18a7d
movb $0x0, 0x6c(%rdi)
movl $0x203f3f3f, 0x68(%rdi) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
movl %eax, (%rdi,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: clts_
void __bea_callspec__ clts_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "clts ");
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+CR_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 1;
    FillFlags(pMyDisasm, 17);
    GV.EIP_++;
}

// Assembly:
movl $0x2000000, 0x60(%rdi)  # imm = 0x2000000
movl $0x73746c63, 0x68(%rdi) # imm = 0x73746C63
movw $0x20, 0x6c(%rdi)
movabsq $0x120100001, %rax      # imm = 0x120100001
movq %rax, 0xdc(%rdi)
movq 0x1d7bf(%rip), %rax     # 0x3626c
movq %rax, 0x7c(%rdi)
movl 0x1d7bd(%rip), %eax     # 0x36274
movl %eax, 0x84(%rdi)
incq 0x1f0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sysret_
void __bea_callspec__ sysret_(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sysret ");
        #endif
        GV.EIP_++;
        (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG1+REG11;
        (*pMyDisasm).Argument2.ArgSize = 64;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
cmpl $0x40, 0x25c(%rdi)
jne 0x18afe
movl $0x2000000, 0x60(%rdi)  # imm = 0x2000000
movabsq $0x20746572737973, %rax # imm = 0x20746572737973
movq %rax, 0x68(%rdi)
incq 0x1f0(%rdi)
movl $0x20020802, 0x144(%rdi) # imm = 0x20020802
pushq $0x40
popq %rax
movl $0x148, %ecx            # imm = 0x148
jmp 0x18b11
movb $0x0, 0x6c(%rdi)
movl $0x203f3f3f, 0x68(%rdi) # imm = 0x203F3F3F
pushq $0x1
popq %rax
movl $0x280, %ecx            # imm = 0x280
movl %eax, (%rdi,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: nop_Ev
void __bea_callspec__ nop_Ev(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+MISCELLANEOUS_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "nop ");
    #endif
    if (GV.OperandSize == 64) {
        GV.MemDecoration = Arg2qword;
    }
    else if (GV.OperandSize == 32) {
        GV.MemDecoration = Arg2dword;
    }
    else {
        GV.MemDecoration = Arg2word;
    }
    MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
    GV.EIP_ += GV.DECALAGE_EIP+2;
    (*pMyDisasm).Argument2.AccessMode = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1000c, 0x60(%rdi)    # imm = 0x1000C
movl $0x20706f6e, 0x68(%rdi) # imm = 0x20706F6E
movb $0x0, 0x6c(%rdi)
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
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
andl $0x0, 0x150(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: hint_nop
void __bea_callspec__ hint_nop(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+MISCELLANEOUS_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "hint_nop ");
    #endif
    if (GV.OperandSize == 64) {
        GV.MemDecoration = Arg2qword;
    }
    else if (GV.OperandSize == 32) {
        GV.MemDecoration = Arg2dword;
    }
    else {
        GV.MemDecoration = Arg2word;
    }
    MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1000c, 0x60(%rdi)    # imm = 0x1000C
movabsq $0x706f6e5f746e6968, %rax # imm = 0x706F6E5F746E6968
movq %rax, 0x68(%rdi)
movw $0x20, 0x70(%rdi)
movl 0x20c(%rdi), %eax
xorl %ecx, %ecx
cmpl $0x20, %eax
sete %cl
orl $0x66, %ecx
cmpl $0x40, %eax
pushq $0x68
popq %rax
cmovnel %ecx, %eax
movl %eax, 0x210(%rdi)
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x28863
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_A_M.c
// Function: mov_RdCd
void __bea_callspec__ mov_RdCd(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    if (GV.MOD_== 3) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
        #endif
        GV.CR_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.CR_ = 0;
        FillFlags(pMyDisasm,67);
        GV.EIP_ += GV.DECALAGE_EIP+2;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2000000, 0x60(%rdi)  # imm = 0x2000000
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x28863
cmpl $0x3, 0x218(%rbx)
jne 0x1939d
movb $0x0, 0x6c(%rbx)
movl $0x20766f6d, 0x68(%rbx) # imm = 0x20766F6D
movl $0x1, 0x234(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
andl $0x0, 0x234(%rbx)
movq 0x1d149(%rip), %rax     # 0x364c4
movq %rax, 0x7c(%rbx)
movl 0x1d147(%rip), %eax     # 0x364cc
movl %eax, 0x84(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
jmp 0x193b2
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_A_M.c
// Function: mov_RdDd
void __bea_callspec__ mov_RdDd(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    if (GV.MOD_== 3) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
        #endif
        GV.DR_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.DR_ = 0;
        FillFlags(pMyDisasm,67);
        GV.EIP_ += GV.DECALAGE_EIP+2;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2000000, 0x60(%rdi)  # imm = 0x2000000
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x28863
cmpl $0x3, 0x218(%rbx)
jne 0x1942b
movb $0x0, 0x6c(%rbx)
movl $0x20766f6d, 0x68(%rbx) # imm = 0x20766F6D
movl $0x1, 0x238(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
andl $0x0, 0x238(%rbx)
movq 0x1d0bb(%rip), %rax     # 0x364c4
movq %rax, 0x7c(%rbx)
movl 0x1d0b9(%rip), %eax     # 0x364cc
movl %eax, 0x84(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
jmp 0x19440
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_A_M.c
// Function: mov_CdRd
void __bea_callspec__ mov_CdRd(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
    MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
    if (GV.MOD_== 3) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
        #endif
        GV.CR_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.CR_ = 0;
        FillFlags(pMyDisasm,67);
        GV.EIP_ += GV.DECALAGE_EIP+2;
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2000000, 0x60(%rdi)  # imm = 0x2000000
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x28863
cmpl $0x3, 0x218(%rbx)
jne 0x194b9
movb $0x0, 0x6c(%rbx)
movl $0x20766f6d, 0x68(%rbx) # imm = 0x20766F6D
movl $0x1, 0x234(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
andl $0x0, 0x234(%rbx)
movq 0x1d02d(%rip), %rax     # 0x364c4
movq %rax, 0x7c(%rbx)
movl 0x1d02b(%rip), %eax     # 0x364cc
movl %eax, 0x84(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
jmp 0x194ce
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: movntps_
void __bea_callspec__ movntps_(PDISASM pMyDisasm)
{
    GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
    if (GV.MOD_== 0x3) {
        FailDecode(pMyDisasm);
    }
    /* ========== 0x66 */
    else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
        GV.OperandSize = GV.OriginalOperandSize;
        (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
        GV.MemDecoration = Arg1dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CACHEABILITY_CONTROL;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movntpd ");
        #endif
        GV.SSE_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.SSE_ = 0;
        MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.EIP_ += GV.DECALAGE_EIP+2;

    }
    else {
        GV.MemDecoration = Arg1dqword;
        (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CACHEABILITY_CONTROL;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movntps ");
        #endif
        GV.SSE_ = 1;
        Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.SSE_ = 0;
        MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
        GV.EIP_ += GV.DECALAGE_EIP+2;

    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1f0(%rdi), %rax
movzbl 0x1(%rax), %eax
shrl $0x6, %eax
movl %eax, 0x218(%rdi)
cmpl $0x3, %eax
jne 0x19794
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0x1982f
cmpb $0x1, 0x1dd(%rbx)
jne 0x197cd
movl 0x208(%rbx), %eax
movl %eax, 0x20c(%rbx)
movb $0x8, 0x1dd(%rbx)
movl $0x8, 0x210(%rbx)
movl $0x100019, 0x60(%rbx)   # imm = 0x100019
movabsq $0x206470746e766f6d, %rax # imm = 0x206470746E766F6D
jmp 0x197e8
movl $0x8, 0x210(%rbx)
movl $0x100019, 0x60(%rbx)   # imm = 0x100019
movabsq $0x207370746e766f6d, %rax # imm = 0x207370746E766F6D
movq %rax, 0x68(%rbx)
movb $0x0, 0x70(%rbx)
movl $0x1, 0x230(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2890a
andl $0x0, 0x230(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x28863
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_prefixes.c
// Function: Esc_tableA4
void __bea_callspec__ Esc_tableA4(PDISASM pMyDisasm)
{
    if (!Security(0, pMyDisasm)) return;
    GV.EIP_++;
    (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_)+0x0F3800;
    (void) opcode_map3[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
}

// Assembly:
movq 0x1f0(%rdi), %rax
movq 0x250(%rdi), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0x19d0c
movl $0x1, 0x289(%rdi)
retq
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rdi)
movzbl 0x1(%rax), %ecx
orl $0xf3800, %ecx          # imm = 0xF3800
movl %ecx, 0x64(%rdi)
movzbl 0x1(%rax), %eax
leaq 0x1e18f(%rip), %rcx     # 0x37ec0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_prefixes.c
// Function: Esc_tableA5
void __bea_callspec__ Esc_tableA5(PDISASM pMyDisasm)
{
    if (!Security(0, pMyDisasm)) return;
    GV.EIP_++;
    (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_)+0x0F3A00;
    (void) opcode_map4[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
}

// Assembly:
movq 0x1f0(%rdi), %rax
movq 0x250(%rdi), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0x19d55
movl $0x1, 0x289(%rdi)
retq
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rdi)
movzbl 0x1(%rax), %ecx
orl $0xf3a00, %ecx          # imm = 0xF3A00
movl %ecx, 0x64(%rdi)
movzbl 0x1(%rax), %eax
leaq 0x1e946(%rip), %rcx     # 0x386c0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmovo_
void __bea_callspec__ cmovo_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovo ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm, 19);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movabsq $0x20656c6e766f6d63, %rax # imm = 0x20656C6E766F6D63
movq %rax, 0x68(%rdi)
movb $0x0, 0x70(%rdi)
callq 0x285bb
movl 0x1c1aa(%rip), %eax     # 0x3628c
movl %eax, 0x84(%rbx)
movq 0x1c195(%rip), %rax     # 0x36284
movq %rax, 0x7c(%rbx)
popq %rbx
retq