LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: pop_es
void __bea_callspec__ pop_es(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[0]);
        #endif
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[0];
        (*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 0xb76f
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xb7c6
leaq 0x9c(%rbx), %rdi
leaq 0x2d1a3(%rip), %rsi     # 0x38920
callq 0x8150
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2d6b3(%rip), %eax     # 0x38e40
movl %eax, 0xdc(%rbx)
movl $0x10, %eax
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_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: or_EbGb
void __bea_callspec__ or_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, "or ");
    #endif
    EbGb(pMyDisasm);
    FillFlags(pMyDisasm,74);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb7dc
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2ad9b
movl 0x2cd08(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2ccf3(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: or_EvGv
void __bea_callspec__ or_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, "or ");
    #endif
    EvGv(pMyDisasm);
    FillFlags(pMyDisasm,74);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb81f
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2ae0b
movl 0x2ccc5(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2ccb0(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: or_GbEb
void __bea_callspec__ or_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, "or ");
    #endif
    GbEb(pMyDisasm);
    FillFlags(pMyDisasm,74);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb862
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2ae61
movl 0x2cc82(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2cc6d(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: or_GvEv
void __bea_callspec__ or_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, "or ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm,74);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb8a5
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2aeb0
movl 0x2cc3f(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2cc2a(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: or_ALIb
void __bea_callspec__ or_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, "or ");
    #endif
    ALIb(pMyDisasm);
    FillFlags(pMyDisasm,74);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb8e8
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2af06
movl 0x2cbfc(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2cbe7(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: or_eAX_Iv
void __bea_callspec__ or_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, "or ");
    #endif
    eAX_Iv(pMyDisasm);
    FillFlags(pMyDisasm,74);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb92b
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2afb0
movl 0x2cbb9(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2cba4(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: push_cs
void __bea_callspec__ push_cs(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
    #endif
    if (GV.Architecture == 64) {
        FailDecode(pMyDisasm);
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[1]);
        #endif
        (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[1];
        (*pMyDisasm).Argument2.ArgSize = 16;
        (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
        (*pMyDisasm).Argument1.ArgSize = 16;
        (*pMyDisasm).Argument1.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 $0x68737570, 0x68(%rdi) # imm = 0x68737570
movw $0x20, 0x6c(%rdi)
cmpl $0x40, 0x25c(%rdi)
jne 0xb995
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xb9ec
leaq 0x9c(%rbx), %rdi
leaq 0x2cf85(%rip), %rsi     # 0x38928
callq 0x8150
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2d491(%rip), %eax     # 0x38e44
movl %eax, 0x144(%rbx)
movl $0x10, %eax
movl %eax, 0x148(%rbx)
movabsq $0x1040000000, %rcx     # imm = 0x1040000000
movq %rcx, 0xdc(%rbx)
movl %eax, 0xec(%rbx)
movl $0x20020010, 0x98(%rbx) # imm = 0x20020010
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/Routines_Disasm.c
// Function: PrefSEGFS
int __bea_callspec__ Security(int len, PDISASM pMyDisasm)
{
    if ((GV.EndOfBlock != 0) && (GV.EIP_+(UInt64)len >= GV.EndOfBlock)) {
        GV.OutOfBlock = 1;
        return 0;
    }
    return 1;
}

// Assembly:
movq 0x250(%rdi), %rax
testq %rax, %rax
je 0xecc5
cmpq %rax, 0x1f0(%rdi)
jae 0xed09
movb $0x1, 0x1e1(%rdi)
movq 0x1f0(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x1f0(%rdi)
incl 0x1d4(%rdi)
incl 0x264(%rdi)
movl $0x1, 0x274(%rdi)
movzbl 0x1(%rax), %ecx
movl %ecx, 0x64(%rdi)
movzbl 0x1(%rax), %eax
leaq 0x2a19a(%rip), %rcx     # 0x38ea0
jmpq *(%rcx,%rax,8)
movl $0x1, 0x289(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: adc_EbGb
void __bea_callspec__ adc_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, "adc ");
    #endif
    EbGb(pMyDisasm);
    FillFlags(pMyDisasm,4);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xba4f
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ad9b
movl 0x2c749(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c734(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: adc_EvGv
void __bea_callspec__ adc_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, "adc ");
    #endif
    EvGv(pMyDisasm);
    FillFlags(pMyDisasm,4);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xba96
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ae0b
movl 0x2c702(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c6ed(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: adc_GbEb
void __bea_callspec__ adc_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, "adc ");
    #endif
    GbEb(pMyDisasm);
    FillFlags(pMyDisasm,4);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbadd
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ae61
movl 0x2c6bb(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c6a6(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: adc_GvEv
void __bea_callspec__ adc_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, "adc ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm,4);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbb24
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2aeb0
movl 0x2c674(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c65f(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: adc_ALIb
void __bea_callspec__ adc_ALIb(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, "adc ");
    #endif
    ALIb(pMyDisasm);
    FillFlags(pMyDisasm,4);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbb6b
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2af06
movl 0x2c62d(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c618(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: adc_eAX_Iv
void __bea_callspec__ adc_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, "adc ");
    #endif
    eAX_Iv(pMyDisasm);
    FillFlags(pMyDisasm,4);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbbb2
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2afb0
movl 0x2c5e6(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c5d1(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: push_ss
void __bea_callspec__ push_ss(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
    #endif
    if (GV.Architecture == 64) {
        FailDecode(pMyDisasm);
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[2]);
        #endif
        (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[2];
        (*pMyDisasm).Argument2.ArgSize = 16;
        (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
        (*pMyDisasm).Argument1.ArgSize = 16;
        (*pMyDisasm).Argument1.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 $0x68737570, 0x68(%rdi) # imm = 0x68737570
movw $0x20, 0x6c(%rdi)
cmpl $0x40, 0x25c(%rdi)
jne 0xbc20
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xbc77
leaq 0x9c(%rbx), %rdi
leaq 0x2cd02(%rip), %rsi     # 0x38930
callq 0x8150
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2d20a(%rip), %eax     # 0x38e48
movl %eax, 0x144(%rbx)
movl $0x10, %eax
movl %eax, 0x148(%rbx)
movabsq $0x1040000000, %rcx     # imm = 0x1040000000
movq %rcx, 0xdc(%rbx)
movl %eax, 0xec(%rbx)
movl $0x20020010, 0x98(%rbx) # imm = 0x20020010
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: pop_ss
void __bea_callspec__ pop_ss(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[2]);
        #endif
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[2];
        (*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 0xbcb2
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xbd09
leaq 0x9c(%rbx), %rdi
leaq 0x2cc70(%rip), %rsi     # 0x38930
callq 0x8150
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2d178(%rip), %eax     # 0x38e48
movl %eax, 0xdc(%rbx)
movl $0x10, %eax
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_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sbb_EbGb
void __bea_callspec__ sbb_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, "sbb ");
    #endif
    EbGb(pMyDisasm);
    FillFlags(pMyDisasm,93);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbd1f
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ad9b
movl 0x2c8a5(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c890(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sbb_EvGv
void __bea_callspec__ sbb_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, "sbb ");
    #endif
    EvGv(pMyDisasm);
    FillFlags(pMyDisasm,93);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbd66
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ae0b
movl 0x2c85e(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c849(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sbb_GbEb
void __bea_callspec__ sbb_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, "sbb ");
    #endif
    GbEb(pMyDisasm);
    FillFlags(pMyDisasm,93);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbdad
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ae61
movl 0x2c817(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c802(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sbb_GvEv
void __bea_callspec__ sbb_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, "sbb ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm,93);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbdf4
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2aeb0
movl 0x2c7d0(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c7bb(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sbb_ALIb
void __bea_callspec__ sbb_ALIb(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, "sbb ");
    #endif
    ALIb(pMyDisasm);
    FillFlags(pMyDisasm,93);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbe3b
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2af06
movl 0x2c789(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c774(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: sbb_eAX_Iv
void __bea_callspec__ sbb_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, "sbb ");
    #endif
    eAX_Iv(pMyDisasm);
    FillFlags(pMyDisasm,93);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbe82
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2afb0
movl 0x2c742(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c72d(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: push_ds
void __bea_callspec__ push_ds(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
    #endif
    if (GV.Architecture == 64) {
        FailDecode(pMyDisasm);
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[3]);
        #endif
        (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[3];
        (*pMyDisasm).Argument2.ArgSize = 16;
        (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
        (*pMyDisasm).Argument1.ArgSize = 16;
        (*pMyDisasm).Argument1.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 $0x68737570, 0x68(%rdi) # imm = 0x68737570
movw $0x20, 0x6c(%rdi)
cmpl $0x40, 0x25c(%rdi)
jne 0xbef0
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xbf47
leaq 0x9c(%rbx), %rdi
leaq 0x2ca3a(%rip), %rsi     # 0x38938
callq 0x8150
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2cf3e(%rip), %eax     # 0x38e4c
movl %eax, 0x144(%rbx)
movl $0x10, %eax
movl %eax, 0x148(%rbx)
movabsq $0x1040000000, %rcx     # imm = 0x1040000000
movq %rcx, 0xdc(%rbx)
movl %eax, 0xec(%rbx)
movl $0x20020010, 0x98(%rbx) # imm = 0x20020010
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbf82
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xbfd9
leaq 0x9c(%rbx), %rdi
leaq 0x2c9a8(%rip), %rsi     # 0x38938
callq 0x8150
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2ceac(%rip), %eax     # 0x38e4c
movl %eax, 0xdc(%rbx)
movl $0x10, %eax
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_O1/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 0xbfef
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ad9b
movl 0x2c1c1(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c1ac(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc036
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ae0b
movl 0x2c17a(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c165(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc07d
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ae61
movl 0x2c133(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c11e(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc0c4
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2aeb0
movl 0x2c0ec(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c0d7(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc10b
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2af06
movl 0x2c0a5(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c090(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc152
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2afb0
movl 0x2c05e(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c049(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc1fe
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 0x2c0a8(%rip), %rax     # 0x382d0
movq %rax, 0x7c(%rdi)
movl 0x2c0a6(%rip), %eax     # 0x382d8
movl %eax, 0x84(%rdi)
incq 0x1f0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc254
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ad9b
movl 0x2c3e8(%rip), %eax     # 0x3865c
movl %eax, 0x84(%rbx)
movq 0x2c3d3(%rip), %rax     # 0x38654
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xc29b
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ae0b
movl 0x2c3a1(%rip), %eax     # 0x3865c
movl %eax, 0x84(%rbx)
movq 0x2c38c(%rip), %rax     # 0x38654
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xc2e2
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ae61
movl 0x2c35a(%rip), %eax     # 0x3865c
movl %eax, 0x84(%rbx)
movq 0x2c345(%rip), %rax     # 0x38654
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xc329
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2aeb0
movl 0x2c313(%rip), %eax     # 0x3865c
movl %eax, 0x84(%rbx)
movq 0x2c2fe(%rip), %rax     # 0x38654
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xc3b7
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20627573, 0x68(%rbx) # imm = 0x20627573
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2afb0
movl 0x2c285(%rip), %eax     # 0x3865c
movl %eax, 0x84(%rbx)
movq 0x2c270(%rip), %rax     # 0x38654
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc463
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 0x2be4f(%rip), %rax     # 0x382dc
movq %rax, 0x7c(%rdi)
movl 0x2be4d(%rip), %eax     # 0x382e4
movl %eax, 0x84(%rdi)
incq 0x1f0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc4b9
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ad9b
movl 0x2c1fb(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c1e6(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xc500
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ae0b
movl 0x2c1b4(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c19f(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xc547
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ae61
movl 0x2c16d(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c158(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xc58e
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2aeb0
movl 0x2c126(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c111(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xc5d5
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2af06
movl 0x2c0df(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c0ca(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xc61c
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f78, 0x68(%rbx) # imm = 0x20726F78
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2afb0
movl 0x2c098(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x2c083(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2ad9b
movl $0x1, 0xe8(%rbx)
movq 0x2bb54(%rip), %rax     # 0x38270
movq %rax, 0x7c(%rbx)
movl 0x2bb52(%rip), %eax     # 0x38278
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2ae0b
movl $0x1, 0xe8(%rbx)
movq 0x2bb16(%rip), %rax     # 0x38270
movq %rax, 0x7c(%rbx)
movl 0x2bb14(%rip), %eax     # 0x38278
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2ae61
movl $0x1, 0xe8(%rbx)
movq 0x2bad8(%rip), %rax     # 0x38270
movq %rax, 0x7c(%rbx)
movl 0x2bad6(%rip), %eax     # 0x38278
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2aeb0
movl $0x1, 0xe8(%rbx)
movq 0x2ba9a(%rip), %rax     # 0x38270
movq %rax, 0x7c(%rbx)
movl 0x2ba98(%rip), %eax     # 0x38278
movl %eax, 0x84(%rbx)
popq %rbx
retq