LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_prefixes.c
// Function: PrefSEGES
void __bea_callspec__ PrefSEGES(PDISASM pMyDisasm)
{
    if (!Security(0, pMyDisasm)) return;
    (*pMyDisasm).Prefix.ESPrefix = InUsePrefix;
    GV.EIP_++;
    (*pMyDisasm).Prefix.Number++;
    GV.NB_PREFIX++;
    (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
    (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
}

// Assembly:
movq 0x1f0(%rdi), %rax
movq 0x250(%rdi), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xc126
movl $0x1, 0x289(%rdi)
retq
movb $0x1, 0x1e4(%rdi)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rdi)
incl 0x1d4(%rdi)
incl 0x264(%rdi)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rdi)
movzbl 0x1(%rax), %eax
leaq 0x2cd48(%rip), %rcx     # 0x38ea0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: daa_
void __bea_callspec__ daa_(PDISASM pMyDisasm)
{

    if (GV.Architecture == 64) {
        FailDecode(pMyDisasm);
    }
    else {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "daa ");
        #endif
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
        (*pMyDisasm).Argument1.ArgSize = 8;
        FillFlags(pMyDisasm,28);
        GV.EIP_++;
    }

}

// Assembly:
cmpl $0x40, 0x25c(%rdi)
jne 0xc17a
movb $0x0, 0x6c(%rdi)
movl $0x203f3f3f, 0x68(%rdi) # imm = 0x203F3F3F
movl $0x1, 0x280(%rdi)
retq
movl $0x10002, 0x60(%rdi)    # imm = 0x10002
movl $0x20616164, 0x68(%rdi) # imm = 0x20616164
movb $0x0, 0x6c(%rdi)
movabsq $0x820020001, %rax      # imm = 0x820020001
movq %rax, 0xdc(%rdi)
movq 0x2c12c(%rip), %rax     # 0x382d0
movq %rax, 0x7c(%rdi)
movl 0x2c12a(%rip), %eax     # 0x382d8
movl %eax, 0x84(%rdi)
incq 0x1f0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sub_EbGb
void __bea_callspec__ sub_EbGb(PDISASM pMyDisasm)
{
    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, "sub ");
    #endif
    EbGb(pMyDisasm);
    FillFlags(pMyDisasm,103);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc1d0
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a6c7
movl 0x2c46c(%rip), %eax     # 0x3865c
movl %eax, 0x84(%rbx)
movq 0x2c457(%rip), %rax     # 0x38654
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sub_EvGv
void __bea_callspec__ sub_EvGv(PDISASM pMyDisasm)
{
    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, "sub ");
    #endif
    EvGv(pMyDisasm);
    FillFlags(pMyDisasm,103);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc217
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a737
movl 0x2c425(%rip), %eax     # 0x3865c
movl %eax, 0x84(%rbx)
movq 0x2c410(%rip), %rax     # 0x38654
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sub_GbEb
void __bea_callspec__ sub_GbEb(PDISASM pMyDisasm)
{
    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, "sub ");
    #endif
    GbEb(pMyDisasm);
    FillFlags(pMyDisasm,103);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc25e
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a78d
movl 0x2c3de(%rip), %eax     # 0x3865c
movl %eax, 0x84(%rbx)
movq 0x2c3c9(%rip), %rax     # 0x38654
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sub_eAX_Iv
void __bea_callspec__ sub_eAX_Iv(PDISASM pMyDisasm)
{
    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, "sub ");
    #endif
    eAX_Iv(pMyDisasm);
    FillFlags(pMyDisasm,103);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc333
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a8d3
movl 0x2c309(%rip), %eax     # 0x3865c
movl %eax, 0x84(%rbx)
movq 0x2c2f4(%rip), %rax     # 0x38654
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_prefixes.c
// Function: PrefSEGCS
void __bea_callspec__ PrefSEGCS(PDISASM pMyDisasm)
{
    if (!Security(0, pMyDisasm)) return;
    (*pMyDisasm).Prefix.CSPrefix = InUsePrefix;
    GV.EIP_++;
    (*pMyDisasm).Prefix.Number++;
    GV.NB_PREFIX++;
    (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
    (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
}

// Assembly:
movq 0x1f0(%rdi), %rax
movq 0x250(%rdi), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xc387
movl $0x1, 0x289(%rdi)
retq
movb $0x1, 0x1e5(%rdi)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rdi)
incl 0x1d4(%rdi)
incl 0x264(%rdi)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rdi)
movzbl 0x1(%rax), %eax
leaq 0x2cae7(%rip), %rcx     # 0x38ea0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: das_
void __bea_callspec__ das_(PDISASM pMyDisasm)
{

    if (GV.Architecture == 64) {
        FailDecode(pMyDisasm);
    }
    else {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "das ");
        #endif
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
        (*pMyDisasm).Argument1.ArgSize = 8;
        FillFlags(pMyDisasm,29);
        GV.EIP_++;
    }

}

// Assembly:
cmpl $0x40, 0x25c(%rdi)
jne 0xc3db
movb $0x0, 0x6c(%rdi)
movl $0x203f3f3f, 0x68(%rdi) # imm = 0x203F3F3F
movl $0x1, 0x280(%rdi)
retq
movl $0x10002, 0x60(%rdi)    # imm = 0x10002
movl $0x20736164, 0x68(%rdi) # imm = 0x20736164
movb $0x0, 0x6c(%rdi)
movabsq $0x820020001, %rax      # imm = 0x820020001
movq %rax, 0xdc(%rdi)
movq 0x2bed7(%rip), %rax     # 0x382dc
movq %rax, 0x7c(%rdi)
movl 0x2bed5(%rip), %eax     # 0x382e4
movl %eax, 0x84(%rdi)
incq 0x1f0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: xor_EbGb
void __bea_callspec__ xor_EbGb(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
    #endif
    EbGb(pMyDisasm);
    FillFlags(pMyDisasm,113);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc431
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a6c7
movl 0x2c283(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c26e(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: xor_EvGv
void __bea_callspec__ xor_EvGv(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
    #endif
    EvGv(pMyDisasm);
    FillFlags(pMyDisasm,113);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc478
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a737
movl 0x2c23c(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c227(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: xor_GbEb
void __bea_callspec__ xor_GbEb(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
    #endif
    GbEb(pMyDisasm);
    FillFlags(pMyDisasm,113);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc4bf
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a78d
movl 0x2c1f5(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c1e0(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: xor_GvEv
void __bea_callspec__ xor_GvEv(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm,113);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc506
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a7dc
movl 0x2c1ae(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c199(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: xor_ALIb
void __bea_callspec__ xor_ALIb(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
    #endif
    ALIb(pMyDisasm);
    FillFlags(pMyDisasm,113);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc54d
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a832
movl 0x2c167(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c152(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: xor_eAX_Iv
void __bea_callspec__ xor_eAX_Iv(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
    #endif
    eAX_Iv(pMyDisasm);
    FillFlags(pMyDisasm,113);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc594
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a8d3
movl 0x2c120(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c10b(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_prefixes.c
// Function: PrefSEGSS
void __bea_callspec__ PrefSEGSS(PDISASM pMyDisasm)
{
    if (!Security(0, pMyDisasm)) return;
    (*pMyDisasm).Prefix.SSPrefix = InUsePrefix;
    GV.EIP_++;
    (*pMyDisasm).Prefix.Number++;
    GV.NB_PREFIX++;
    (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
    (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
}

// Assembly:
movq 0x1f0(%rdi), %rax
movq 0x250(%rdi), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xc5e8
movl $0x1, 0x289(%rdi)
retq
movb $0x1, 0x1e2(%rdi)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rdi)
incl 0x1d4(%rdi)
incl 0x264(%rdi)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rdi)
movzbl 0x1(%rax), %eax
leaq 0x2c886(%rip), %rcx     # 0x38ea0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmp_EbGb
void __bea_callspec__ cmp_EbGb(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
    #endif
    EbGb(pMyDisasm);
    (*pMyDisasm).Argument1.AccessMode = READ;
    FillFlags(pMyDisasm,20);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10002, 0x60(%rdi)    # imm = 0x10002
movl $0x20706d63, 0x68(%rdi) # imm = 0x20706D63
movb $0x0, 0x6c(%rdi)
callq 0x2a6c7
movl $0x1, 0xe8(%rbx)
movq 0x2bbe0(%rip), %rax     # 0x38270
movq %rax, 0x7c(%rbx)
movl 0x2bbde(%rip), %eax     # 0x38278
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmp_EvGv
void __bea_callspec__ cmp_EvGv(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
    #endif
    EvGv(pMyDisasm);
    (*pMyDisasm).Argument1.AccessMode = READ;
    FillFlags(pMyDisasm,20);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10002, 0x60(%rdi)    # imm = 0x10002
movl $0x20706d63, 0x68(%rdi) # imm = 0x20706D63
movb $0x0, 0x6c(%rdi)
callq 0x2a737
movl $0x1, 0xe8(%rbx)
movq 0x2bba2(%rip), %rax     # 0x38270
movq %rax, 0x7c(%rbx)
movl 0x2bba0(%rip), %eax     # 0x38278
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmp_GbEb
void __bea_callspec__ cmp_GbEb(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
    #endif
    GbEb(pMyDisasm);
    (*pMyDisasm).Argument1.AccessMode = READ;
    FillFlags(pMyDisasm,20);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10002, 0x60(%rdi)    # imm = 0x10002
movl $0x20706d63, 0x68(%rdi) # imm = 0x20706D63
movb $0x0, 0x6c(%rdi)
callq 0x2a78d
movl $0x1, 0xe8(%rbx)
movq 0x2bb64(%rip), %rax     # 0x38270
movq %rax, 0x7c(%rbx)
movl 0x2bb62(%rip), %eax     # 0x38278
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmp_GvEv
void __bea_callspec__ cmp_GvEv(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
    #endif
    GvEv(pMyDisasm);
    (*pMyDisasm).Argument1.AccessMode = READ;
    FillFlags(pMyDisasm,20);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10002, 0x60(%rdi)    # imm = 0x10002
movl $0x20706d63, 0x68(%rdi) # imm = 0x20706D63
movb $0x0, 0x6c(%rdi)
callq 0x2a7dc
movl $0x1, 0xe8(%rbx)
movq 0x2bb26(%rip), %rax     # 0x38270
movq %rax, 0x7c(%rbx)
movl 0x2bb24(%rip), %eax     # 0x38278
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmp_ALIb
void __bea_callspec__ cmp_ALIb(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
    #endif
    ALIb(pMyDisasm);
    (*pMyDisasm).Argument1.AccessMode = READ;
    FillFlags(pMyDisasm,20);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10002, 0x60(%rdi)    # imm = 0x10002
movl $0x20706d63, 0x68(%rdi) # imm = 0x20706D63
movb $0x0, 0x6c(%rdi)
callq 0x2a832
movl $0x1, 0xe8(%rbx)
movq 0x2bae8(%rip), %rax     # 0x38270
movq %rax, 0x7c(%rbx)
movl 0x2bae6(%rip), %eax     # 0x38278
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: cmp_eAX_Iv
void __bea_callspec__ cmp_eAX_Iv(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
    #endif
    eAX_Iv(pMyDisasm);
    (*pMyDisasm).Argument1.AccessMode = READ;
    FillFlags(pMyDisasm,20);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10002, 0x60(%rdi)    # imm = 0x10002
movl $0x20706d63, 0x68(%rdi) # imm = 0x20706D63
movb $0x0, 0x6c(%rdi)
callq 0x2a8d3
movl $0x1, 0xe8(%rbx)
movq 0x2baaa(%rip), %rax     # 0x38270
movq %rax, 0x7c(%rbx)
movl 0x2baa8(%rip), %eax     # 0x38278
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_prefixes.c
// Function: PrefSEGDS
void __bea_callspec__ PrefSEGDS(PDISASM pMyDisasm)
{
    if (!Security(0, pMyDisasm)) return;
    (*pMyDisasm).Prefix.DSPrefix = InUsePrefix;
    GV.EIP_++;
    (*pMyDisasm).Prefix.Number++;
    GV.NB_PREFIX++;
    (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
    (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
}

// Assembly:
movq 0x1f0(%rdi), %rax
movq 0x250(%rdi), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xc7f9
movl $0x1, 0x289(%rdi)
retq
movb $0x1, 0x1e6(%rdi)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rdi)
incl 0x1d4(%rdi)
incl 0x264(%rdi)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rdi)
movzbl 0x1(%rax), %eax
leaq 0x2c675(%rip), %rcx     # 0x38ea0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: inc_eax
void __bea_callspec__ inc_eax(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        if (!Security(0, pMyDisasm)) return;
        GV.REX.W_ = 0;
        GV.REX.R_ = 0;
        GV.REX.X_ = 0;
        GV.REX.B_ = 0;
        GV.REX.state = InUsePrefix;
        GV.EIP_++;
        GV.NB_PREFIX++;
        (*pMyDisasm).Prefix.Number++;
        (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
        (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
        GV.OperandSize = 32;

    }
    else {
        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
        if (GV.OperandSize == 32) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
            (*pMyDisasm).Argument1.ArgSize = 32;
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
            (*pMyDisasm).Argument1.ArgSize = 16;
        }
        GV.EIP_++;
        FillFlags(pMyDisasm, 40);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x25c(%rdi)
jne 0xc8ad
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xc937
movl $0x1, 0x289(%rbx)
jmp 0xc983
cmpb $0x4, 0x1dc(%rbx)
jne 0xc8bd
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636e69, 0x68(%rbx) # imm = 0x20636E69
movb $0x0, 0x6c(%rbx)
xorl %ebp, %ebp
cmpl $0x20, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
sete %bpl
leaq 0x2c2f6(%rip), %rax     # 0x38be0
leaq 0x2c36f(%rip), %rsi     # 0x38c60
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8150
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2c535(%rip), %eax     # 0x38e40
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x2ba44(%rip), %eax     # 0x38368
movl %eax, 0x84(%rbx)
movq 0x2ba2f(%rip), %rax     # 0x38360
movq %rax, 0x7c(%rbx)
jmp 0xc983
movl $0x0, 0x284(%rbx)
movb $0x1, 0x288(%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rbx)
incl 0x264(%rbx)
incl 0x1d4(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x2c52d(%rip), %rcx     # 0x38ea0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
movl $0x20, 0x20c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: inc_ecx
void __bea_callspec__ inc_ecx(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        if (!Security(0, pMyDisasm)) return;
        GV.REX.W_ = 0;
        GV.REX.R_ = 0;
        GV.REX.X_ = 0;
        GV.REX.B_ = 1;
        GV.REX.state = InUsePrefix;
        GV.EIP_++;
        GV.NB_PREFIX++;
        (*pMyDisasm).Prefix.Number++;
        (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
        (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
        GV.OperandSize = 32;

    }
    else {
        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
        if (GV.OperandSize == 32) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[1]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+0];
            (*pMyDisasm).Argument1.ArgSize = 32;
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[1]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+0];
            (*pMyDisasm).Argument1.ArgSize = 16;
        }
        GV.EIP_++;
        FillFlags(pMyDisasm, 40);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x25c(%rdi)
jne 0xc9c2
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xca4c
movl $0x1, 0x289(%rbx)
jmp 0xca98
cmpb $0x4, 0x1dc(%rbx)
jne 0xc9d2
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636e69, 0x68(%rbx) # imm = 0x20636E69
movb $0x0, 0x6c(%rbx)
xorl %ebp, %ebp
cmpl $0x20, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
sete %bpl
leaq 0x2c1e9(%rip), %rax     # 0x38be8
leaq 0x2c262(%rip), %rsi     # 0x38c68
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8150
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2c424(%rip), %eax     # 0x38e44
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x2b92f(%rip), %eax     # 0x38368
movl %eax, 0x84(%rbx)
movq 0x2b91a(%rip), %rax     # 0x38360
movq %rax, 0x7c(%rbx)
jmp 0xca98
movl $0x1000000, 0x284(%rbx) # imm = 0x1000000
movb $0x1, 0x288(%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rbx)
incl 0x264(%rbx)
incl 0x1d4(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x2c418(%rip), %rcx     # 0x38ea0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
movl $0x20, 0x20c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: inc_edx
void __bea_callspec__ inc_edx(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        if (!Security(0, pMyDisasm)) return;
        GV.REX.W_ = 0;
        GV.REX.R_ = 0;
        GV.REX.X_ = 1;
        GV.REX.B_ = 0;
        GV.REX.state = InUsePrefix;
        GV.EIP_++;
        GV.NB_PREFIX++;
        (*pMyDisasm).Prefix.Number++;
        (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
        (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
        GV.OperandSize = 32;

    }
    else {
        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
        if (GV.OperandSize == 32) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[2]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+0];
            (*pMyDisasm).Argument1.ArgSize = 32;
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+0];
            (*pMyDisasm).Argument1.ArgSize = 16;
        }
        GV.EIP_++;
        FillFlags(pMyDisasm, 40);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x25c(%rdi)
jne 0xcad7
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xcb61
movl $0x1, 0x289(%rbx)
jmp 0xcbad
cmpb $0x4, 0x1dc(%rbx)
jne 0xcae7
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636e69, 0x68(%rbx) # imm = 0x20636E69
movb $0x0, 0x6c(%rbx)
xorl %ebp, %ebp
cmpl $0x20, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
sete %bpl
leaq 0x2c0dc(%rip), %rax     # 0x38bf0
leaq 0x2c155(%rip), %rsi     # 0x38c70
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8150
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2c313(%rip), %eax     # 0x38e48
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x2b81a(%rip), %eax     # 0x38368
movl %eax, 0x84(%rbx)
movq 0x2b805(%rip), %rax     # 0x38360
movq %rax, 0x7c(%rbx)
jmp 0xcbad
movl $0x10000, 0x284(%rbx)   # imm = 0x10000
movb $0x1, 0x288(%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rbx)
incl 0x264(%rbx)
incl 0x1d4(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x2c303(%rip), %rcx     # 0x38ea0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
movl $0x20, 0x20c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: inc_ebx
void __bea_callspec__ inc_ebx(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        if (!Security(0, pMyDisasm)) return;
        GV.REX.W_ = 0;
        GV.REX.R_ = 0;
        GV.REX.X_ = 1;
        GV.REX.B_ = 1;
        GV.REX.state = InUsePrefix;
        GV.EIP_++;
        GV.NB_PREFIX++;
        (*pMyDisasm).Prefix.Number++;
        (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
        (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
        GV.OperandSize = 32;

    }
    else {
        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
        if (GV.OperandSize == 32) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[3]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+0];
            (*pMyDisasm).Argument1.ArgSize = 32;
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[3]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+0];
            (*pMyDisasm).Argument1.ArgSize = 16;
        }
        GV.EIP_++;
        FillFlags(pMyDisasm, 40);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x25c(%rdi)
jne 0xcbec
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xcc76
movl $0x1, 0x289(%rbx)
jmp 0xccc2
cmpb $0x4, 0x1dc(%rbx)
jne 0xcbfc
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636e69, 0x68(%rbx) # imm = 0x20636E69
movb $0x0, 0x6c(%rbx)
xorl %ebp, %ebp
cmpl $0x20, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
sete %bpl
leaq 0x2bfcf(%rip), %rax     # 0x38bf8
leaq 0x2c048(%rip), %rsi     # 0x38c78
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8150
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2c202(%rip), %eax     # 0x38e4c
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x2b705(%rip), %eax     # 0x38368
movl %eax, 0x84(%rbx)
movq 0x2b6f0(%rip), %rax     # 0x38360
movq %rax, 0x7c(%rbx)
jmp 0xccc2
movl $0x1010000, 0x284(%rbx) # imm = 0x1010000
movb $0x1, 0x288(%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rbx)
incl 0x264(%rbx)
incl 0x1d4(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x2c1ee(%rip), %rcx     # 0x38ea0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
movl $0x20, 0x20c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: inc_esp
void __bea_callspec__ inc_esp(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        if (!Security(0, pMyDisasm)) return;
        GV.REX.W_ = 0;
        GV.REX.R_ = 1;
        GV.REX.X_ = 0;
        GV.REX.B_ = 0;
        GV.REX.state = InUsePrefix;
        GV.EIP_++;
        GV.NB_PREFIX++;
        (*pMyDisasm).Prefix.Number++;
        (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
        (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
        GV.OperandSize = 32;

    }
    else {
        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
        if (GV.OperandSize == 32) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[4]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+0];
            (*pMyDisasm).Argument1.ArgSize = 32;
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[4]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+0];
            (*pMyDisasm).Argument1.ArgSize = 16;
        }
        GV.EIP_++;
        FillFlags(pMyDisasm, 40);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x25c(%rdi)
jne 0xcd01
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xcd8b
movl $0x1, 0x289(%rbx)
jmp 0xcdd7
cmpb $0x4, 0x1dc(%rbx)
jne 0xcd11
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636e69, 0x68(%rbx) # imm = 0x20636E69
movb $0x0, 0x6c(%rbx)
xorl %ebp, %ebp
cmpl $0x20, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
sete %bpl
leaq 0x2bec2(%rip), %rax     # 0x38c00
leaq 0x2bf3b(%rip), %rsi     # 0x38c80
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8150
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2c0f1(%rip), %eax     # 0x38e50
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x2b5f0(%rip), %eax     # 0x38368
movl %eax, 0x84(%rbx)
movq 0x2b5db(%rip), %rax     # 0x38360
movq %rax, 0x7c(%rbx)
jmp 0xcdd7
movl $0x100, 0x284(%rbx)     # imm = 0x100
movb $0x1, 0x288(%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rbx)
incl 0x264(%rbx)
incl 0x1d4(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x2c0d9(%rip), %rcx     # 0x38ea0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
movl $0x20, 0x20c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: inc_ebp
void __bea_callspec__ inc_ebp(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        if (!Security(0, pMyDisasm)) return;
        GV.REX.W_ = 0;
        GV.REX.R_ = 1;
        GV.REX.X_ = 0;
        GV.REX.B_ = 1;
        GV.REX.state = InUsePrefix;
        GV.EIP_++;
        GV.NB_PREFIX++;
        (*pMyDisasm).Prefix.Number++;
        (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
        (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
        GV.OperandSize = 32;

    }
    else {
        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
        if (GV.OperandSize == 32) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[5]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+0];
            (*pMyDisasm).Argument1.ArgSize = 32;
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[5]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+0];
            (*pMyDisasm).Argument1.ArgSize = 16;
        }
        GV.EIP_++;
        FillFlags(pMyDisasm, 40);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x25c(%rdi)
jne 0xce16
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xcea0
movl $0x1, 0x289(%rbx)
jmp 0xceec
cmpb $0x4, 0x1dc(%rbx)
jne 0xce26
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636e69, 0x68(%rbx) # imm = 0x20636E69
movb $0x0, 0x6c(%rbx)
xorl %ebp, %ebp
cmpl $0x20, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
sete %bpl
leaq 0x2bdb5(%rip), %rax     # 0x38c08
leaq 0x2be2e(%rip), %rsi     # 0x38c88
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8150
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2bfe0(%rip), %eax     # 0x38e54
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x2b4db(%rip), %eax     # 0x38368
movl %eax, 0x84(%rbx)
movq 0x2b4c6(%rip), %rax     # 0x38360
movq %rax, 0x7c(%rbx)
jmp 0xceec
movl $0x1000100, 0x284(%rbx) # imm = 0x1000100
movb $0x1, 0x288(%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rbx)
incl 0x264(%rbx)
incl 0x1d4(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x2bfc4(%rip), %rcx     # 0x38ea0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
movl $0x20, 0x20c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: inc_edi
void __bea_callspec__ inc_edi(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        if (!Security(0, pMyDisasm)) return;
        GV.REX.W_ = 0;
        GV.REX.R_ = 1;
        GV.REX.X_ = 1;
        GV.REX.B_ = 1;
        GV.REX.state = InUsePrefix;
        GV.EIP_++;
        GV.NB_PREFIX++;
        (*pMyDisasm).Prefix.Number++;
        (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
        (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
        GV.OperandSize = 32;

    }
    else {
        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
        if (GV.OperandSize == 32) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[7]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+0];
            (*pMyDisasm).Argument1.ArgSize = 32;
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[7]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+0];
            (*pMyDisasm).Argument1.ArgSize = 16;
        }
        GV.EIP_++;
        FillFlags(pMyDisasm, 40);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x25c(%rdi)
jne 0xd040
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xd0ca
movl $0x1, 0x289(%rbx)
jmp 0xd116
cmpb $0x4, 0x1dc(%rbx)
jne 0xd050
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636e69, 0x68(%rbx) # imm = 0x20636E69
movb $0x0, 0x6c(%rbx)
xorl %ebp, %ebp
cmpl $0x20, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
sete %bpl
leaq 0x2bb9b(%rip), %rax     # 0x38c18
leaq 0x2bc14(%rip), %rsi     # 0x38c98
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8150
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2bdbe(%rip), %eax     # 0x38e5c
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x2b2b1(%rip), %eax     # 0x38368
movl %eax, 0x84(%rbx)
movq 0x2b29c(%rip), %rax     # 0x38360
movq %rax, 0x7c(%rbx)
jmp 0xd116
movb $0x0, 0x284(%rbx)
movq %rax, %rcx
incq %rcx
movl $0x1010101, 0x285(%rbx) # imm = 0x1010101
movq %rcx, 0x1f0(%rbx)
incl 0x264(%rbx)
incl 0x1d4(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x2bd9a(%rip), %rcx     # 0x38ea0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
movl $0x20, 0x20c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: dec_eax
void __bea_callspec__ dec_eax(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        if (!Security(0, pMyDisasm)) return;
        GV.REX.W_ = 1;
        GV.REX.R_ = 0;
        GV.REX.X_ = 0;
        GV.REX.B_ = 0;
        GV.REX.state = InUsePrefix;
        GV.EIP_++;
        GV.NB_PREFIX++;
        (*pMyDisasm).Prefix.Number++;
        GV.OperandSize = 64;
        (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
        (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
        GV.OperandSize = 32;

    }
    else {
        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
        if (GV.OperandSize == 32) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
            (*pMyDisasm).Argument1.ArgSize = 32;
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
            (*pMyDisasm).Argument1.ArgSize = 16;
        }
        GV.EIP_++;
        FillFlags(pMyDisasm, 30);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x25c(%rdi)
jne 0xd155
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xd1df
movl $0x1, 0x289(%rbx)
jmp 0xd235
cmpb $0x4, 0x1dc(%rbx)
jne 0xd165
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636564, 0x68(%rbx) # imm = 0x20636564
movb $0x0, 0x6c(%rbx)
xorl %ebp, %ebp
cmpl $0x20, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
sete %bpl
leaq 0x2ba4e(%rip), %rax     # 0x38be0
leaq 0x2bac7(%rip), %rsi     # 0x38c60
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8150
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2bc8d(%rip), %eax     # 0x38e40
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x2b124(%rip), %eax     # 0x382f0
movl %eax, 0x84(%rbx)
movq 0x2b10f(%rip), %rax     # 0x382e8
movq %rax, 0x7c(%rbx)
jmp 0xd235
movl $0x1, 0x284(%rbx)
movb $0x1, 0x288(%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rbx)
incl 0x264(%rbx)
incl 0x1d4(%rbx)
movl $0x40, 0x20c(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x2bc7b(%rip), %rcx     # 0x38ea0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
movl $0x20, 0x20c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: dec_ecx
void __bea_callspec__ dec_ecx(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        if (!Security(0, pMyDisasm)) return;
        GV.REX.W_ = 1;
        GV.REX.R_ = 0;
        GV.REX.X_ = 0;
        GV.REX.B_ = 1;
        GV.REX.state = InUsePrefix;
        GV.EIP_++;
        GV.NB_PREFIX++;
        (*pMyDisasm).Prefix.Number++;
        GV.OperandSize = 64;
        (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
        (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
        GV.OperandSize = 32;

    }
    else {
        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
        if (GV.OperandSize == 32) {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[1]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+0];
            (*pMyDisasm).Argument1.ArgSize = 32;
        }
        else {
            #ifndef BEA_LIGHT_DISASSEMBLY
               (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[1]);
            #endif
            (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+0];
            (*pMyDisasm).Argument1.ArgSize = 16;
        }
        GV.EIP_++;
        FillFlags(pMyDisasm, 30);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x25c(%rdi)
jne 0xd274
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xd2fe
movl $0x1, 0x289(%rbx)
jmp 0xd354
cmpb $0x4, 0x1dc(%rbx)
jne 0xd284
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636564, 0x68(%rbx) # imm = 0x20636564
movb $0x0, 0x6c(%rbx)
xorl %ebp, %ebp
cmpl $0x20, 0x20c(%rbx)
leaq 0x9c(%rbx), %rdi
sete %bpl
leaq 0x2b937(%rip), %rax     # 0x38be8
leaq 0x2b9b0(%rip), %rsi     # 0x38c68
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8150
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2bb72(%rip), %eax     # 0x38e44
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x2b005(%rip), %eax     # 0x382f0
movl %eax, 0x84(%rbx)
movq 0x2aff0(%rip), %rax     # 0x382e8
movq %rax, 0x7c(%rbx)
jmp 0xd354
movl $0x1000001, 0x284(%rbx) # imm = 0x1000001
movb $0x1, 0x288(%rbx)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rbx)
incl 0x264(%rbx)
incl 0x1d4(%rbx)
movl $0x40, 0x20c(%rbx)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rbx)
movzbl 0x1(%rax), %eax
leaq 0x2bb5c(%rip), %rcx     # 0x38ea0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
movl $0x20, 0x20c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq