LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: pop_ds
void __bea_callspec__ pop_ds(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
    #endif
    if (GV.Architecture == 64) {
        FailDecode(pMyDisasm);
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[3]);
        #endif
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[3];
        (*pMyDisasm).Argument1.ArgSize = 16;
        (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
        (*pMyDisasm).Argument2.ArgSize = 16;
        (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
        (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
        GV.EIP_++;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x20706f70, 0x68(%rdi) # imm = 0x20706F70
movb $0x0, 0x6c(%rdi)
cmpl $0x40, 0x25c(%rdi)
jne 0xbcae
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xbd03
leaq 0x9c(%rbx), %rdi
leaq 0x2ac9c(%rip), %rsi     # 0x36958
callq 0x8170
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2b1a0(%rip), %eax     # 0x36e6c
movl %eax, 0xdc(%rbx)
pushq $0x10
popq %rax
movl %eax, 0xe0(%rbx)
movabsq $0x1040000000, %rcx     # imm = 0x1040000000
movq %rcx, 0x144(%rbx)
movl %eax, 0x154(%rbx)
movl $0x20020010, 0x98(%rbx) # imm = 0x20020010
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: and_EbGb
void __bea_callspec__ and_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, "and ");
    #endif
    EbGb(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbd19
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x284a8
movl 0x2a4b7(%rip), %eax     # 0x361f0
movl %eax, 0x84(%rbx)
movq 0x2a4a2(%rip), %rax     # 0x361e8
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: and_EvGv
void __bea_callspec__ and_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, "and ");
    #endif
    EvGv(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbd60
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x28518
movl 0x2a470(%rip), %eax     # 0x361f0
movl %eax, 0x84(%rbx)
movq 0x2a45b(%rip), %rax     # 0x361e8
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: and_GbEb
void __bea_callspec__ and_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, "and ");
    #endif
    GbEb(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbda7
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2856c
movl 0x2a429(%rip), %eax     # 0x361f0
movl %eax, 0x84(%rbx)
movq 0x2a414(%rip), %rax     # 0x361e8
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: and_GvEv
void __bea_callspec__ and_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, "and ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbdee
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x285bb
movl 0x2a3e2(%rip), %eax     # 0x361f0
movl %eax, 0x84(%rbx)
movq 0x2a3cd(%rip), %rax     # 0x361e8
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: and_ALIb
void __bea_callspec__ and_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, "and ");
    #endif
    ALIb(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbe35
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2860f
movl 0x2a39b(%rip), %eax     # 0x361f0
movl %eax, 0x84(%rbx)
movq 0x2a386(%rip), %rax     # 0x361e8
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: and_eAX_Iv
void __bea_callspec__ and_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, "and ");
    #endif
    eAX_Iv(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbe7c
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x286b0
movl 0x2a354(%rip), %eax     # 0x361f0
movl %eax, 0x84(%rbx)
movq 0x2a33f(%rip), %rax     # 0x361e8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbed0
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 0x2afbe(%rip), %rcx     # 0x36ec0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O2/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 0xbf24
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 0x2a3a2(%rip), %rax     # 0x362f0
movq %rax, 0x7c(%rdi)
movl 0x2a3a0(%rip), %eax     # 0x362f8
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: 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 0xbf7a
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x284a8
movl 0x2a6e2(%rip), %eax     # 0x3667c
movl %eax, 0x84(%rbx)
movq 0x2a6cd(%rip), %rax     # 0x36674
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: 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 0xbfc1
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x28518
movl 0x2a69b(%rip), %eax     # 0x3667c
movl %eax, 0x84(%rbx)
movq 0x2a686(%rip), %rax     # 0x36674
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: 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 0xc008
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2856c
movl 0x2a654(%rip), %eax     # 0x3667c
movl %eax, 0x84(%rbx)
movq 0x2a63f(%rip), %rax     # 0x36674
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: sub_GvEv
void __bea_callspec__ sub_GvEv(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
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm,103);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc04f
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x285bb
movl 0x2a60d(%rip), %eax     # 0x3667c
movl %eax, 0x84(%rbx)
movq 0x2a5f8(%rip), %rax     # 0x36674
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: 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 0xc0dd
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x286b0
movl 0x2a57f(%rip), %eax     # 0x3667c
movl %eax, 0x84(%rbx)
movq 0x2a56a(%rip), %rax     # 0x36674
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc131
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 0x2ad5d(%rip), %rcx     # 0x36ec0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O2/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 0xc185
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 0x2a14d(%rip), %rax     # 0x362fc
movq %rax, 0x7c(%rdi)
movl 0x2a14b(%rip), %eax     # 0x36304
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: 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 0xc1db
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x284a8
movl 0x2a4f9(%rip), %eax     # 0x366f4
movl %eax, 0x84(%rbx)
movq 0x2a4e4(%rip), %rax     # 0x366ec
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: 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 0xc222
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x28518
movl 0x2a4b2(%rip), %eax     # 0x366f4
movl %eax, 0x84(%rbx)
movq 0x2a49d(%rip), %rax     # 0x366ec
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: 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 0xc269
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2856c
movl 0x2a46b(%rip), %eax     # 0x366f4
movl %eax, 0x84(%rbx)
movq 0x2a456(%rip), %rax     # 0x366ec
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: 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 0xc2b0
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x285bb
movl 0x2a424(%rip), %eax     # 0x366f4
movl %eax, 0x84(%rbx)
movq 0x2a40f(%rip), %rax     # 0x366ec
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: 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 0xc2f7
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2860f
movl 0x2a3dd(%rip), %eax     # 0x366f4
movl %eax, 0x84(%rbx)
movq 0x2a3c8(%rip), %rax     # 0x366ec
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: 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 0xc33e
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x286b0
movl 0x2a396(%rip), %eax     # 0x366f4
movl %eax, 0x84(%rbx)
movq 0x2a381(%rip), %rax     # 0x366ec
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc392
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 0x2aafc(%rip), %rcx     # 0x36ec0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O2/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 0x284a8
movl $0x1, 0xe8(%rbx)
movq 0x29e56(%rip), %rax     # 0x36290
movq %rax, 0x7c(%rbx)
movl 0x29e54(%rip), %eax     # 0x36298
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x28518
movl $0x1, 0xe8(%rbx)
movq 0x29e18(%rip), %rax     # 0x36290
movq %rax, 0x7c(%rbx)
movl 0x29e16(%rip), %eax     # 0x36298
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2856c
movl $0x1, 0xe8(%rbx)
movq 0x29dda(%rip), %rax     # 0x36290
movq %rax, 0x7c(%rbx)
movl 0x29dd8(%rip), %eax     # 0x36298
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x285bb
movl $0x1, 0xe8(%rbx)
movq 0x29d9c(%rip), %rax     # 0x36290
movq %rax, 0x7c(%rbx)
movl 0x29d9a(%rip), %eax     # 0x36298
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2860f
movl $0x1, 0xe8(%rbx)
movq 0x29d5e(%rip), %rax     # 0x36290
movq %rax, 0x7c(%rbx)
movl 0x29d5c(%rip), %eax     # 0x36298
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x286b0
movl $0x1, 0xe8(%rbx)
movq 0x29d20(%rip), %rax     # 0x36290
movq %rax, 0x7c(%rbx)
movl 0x29d1e(%rip), %eax     # 0x36298
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc5a3
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 0x2a8eb(%rip), %rcx     # 0x36ec0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O2/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 0xc657
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xc6e1
movl $0x1, 0x289(%rbx)
jmp 0xc72a
cmpb $0x4, 0x1dc(%rbx)
jne 0xc667
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 0x2a56c(%rip), %rax     # 0x36c00
leaq 0x2a5e5(%rip), %rsi     # 0x36c80
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8170
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2a7ab(%rip), %eax     # 0x36e60
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x29cba(%rip), %eax     # 0x36388
movl %eax, 0x84(%rbx)
movq 0x29ca5(%rip), %rax     # 0x36380
movq %rax, 0x7c(%rbx)
jmp 0xc72a
andl $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 0x2a7a6(%rip), %rcx     # 0x36ec0
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_O2/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 0xc769
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xc7f3
movl $0x1, 0x289(%rbx)
jmp 0xc83f
cmpb $0x4, 0x1dc(%rbx)
jne 0xc779
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 0x2a462(%rip), %rax     # 0x36c08
leaq 0x2a4db(%rip), %rsi     # 0x36c88
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8170
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2a69d(%rip), %eax     # 0x36e64
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x29ba8(%rip), %eax     # 0x36388
movl %eax, 0x84(%rbx)
movq 0x29b93(%rip), %rax     # 0x36380
movq %rax, 0x7c(%rbx)
jmp 0xc83f
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 0x2a691(%rip), %rcx     # 0x36ec0
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_O2/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 0xc87e
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xc908
movl $0x1, 0x289(%rbx)
jmp 0xc954
cmpb $0x4, 0x1dc(%rbx)
jne 0xc88e
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 0x2a355(%rip), %rax     # 0x36c10
leaq 0x2a3ce(%rip), %rsi     # 0x36c90
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8170
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2a58c(%rip), %eax     # 0x36e68
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x29a93(%rip), %eax     # 0x36388
movl %eax, 0x84(%rbx)
movq 0x29a7e(%rip), %rax     # 0x36380
movq %rax, 0x7c(%rbx)
jmp 0xc954
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 0x2a57c(%rip), %rcx     # 0x36ec0
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_O2/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 0xc993
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xca1d
movl $0x1, 0x289(%rbx)
jmp 0xca69
cmpb $0x4, 0x1dc(%rbx)
jne 0xc9a3
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 0x2a248(%rip), %rax     # 0x36c18
leaq 0x2a2c1(%rip), %rsi     # 0x36c98
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8170
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2a47b(%rip), %eax     # 0x36e6c
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x2997e(%rip), %eax     # 0x36388
movl %eax, 0x84(%rbx)
movq 0x29969(%rip), %rax     # 0x36380
movq %rax, 0x7c(%rbx)
jmp 0xca69
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 0x2a467(%rip), %rcx     # 0x36ec0
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_O2/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 0xcaa8
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xcb32
movl $0x1, 0x289(%rbx)
jmp 0xcb7e
cmpb $0x4, 0x1dc(%rbx)
jne 0xcab8
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 0x2a13b(%rip), %rax     # 0x36c20
leaq 0x2a1b4(%rip), %rsi     # 0x36ca0
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8170
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2a36a(%rip), %eax     # 0x36e70
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x29869(%rip), %eax     # 0x36388
movl %eax, 0x84(%rbx)
movq 0x29854(%rip), %rax     # 0x36380
movq %rax, 0x7c(%rbx)
jmp 0xcb7e
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 0x2a352(%rip), %rcx     # 0x36ec0
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_O2/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 0xcbbd
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xcc47
movl $0x1, 0x289(%rbx)
jmp 0xcc93
cmpb $0x4, 0x1dc(%rbx)
jne 0xcbcd
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 0x2a02e(%rip), %rax     # 0x36c28
leaq 0x2a0a7(%rip), %rsi     # 0x36ca8
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8170
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2a259(%rip), %eax     # 0x36e74
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x29754(%rip), %eax     # 0x36388
movl %eax, 0x84(%rbx)
movq 0x2973f(%rip), %rax     # 0x36380
movq %rax, 0x7c(%rbx)
jmp 0xcc93
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 0x2a23d(%rip), %rcx     # 0x36ec0
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_O2/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 0xcde7
movq 0x1f0(%rbx), %rax
movq 0x250(%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xce71
movl $0x1, 0x289(%rbx)
jmp 0xcebd
cmpb $0x4, 0x1dc(%rbx)
jne 0xcdf7
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 0x29e14(%rip), %rax     # 0x36c38
leaq 0x29e8d(%rip), %rsi     # 0x36cb8
cmoveq %rax, %rsi
shll $0x4, %ebp
addl $0x10, %ebp
callq 0x8170
movl $0x20020000, %eax       # imm = 0x20020000
addl 0x2a037(%rip), %eax     # 0x36e7c
movl %eax, 0xdc(%rbx)
movl %ebp, 0xe0(%rbx)
incq 0x1f0(%rbx)
movl 0x2952a(%rip), %eax     # 0x36388
movl %eax, 0x84(%rbx)
movq 0x29515(%rip), %rax     # 0x36380
movq %rax, 0x7c(%rbx)
jmp 0xcebd
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 0x2a013(%rip), %rcx     # 0x36ec0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
movl $0x20, 0x20c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq