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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x1e5(%rdi)
jne 0xf608
movb $0x0, 0x1e5(%rbx)
movb $0x1, 0x1e8(%rbx)
cmpb $0x1, 0x1e6(%rbx)
jne 0xf61a
movw $0x100, 0x1e6(%rbx)     # imm = 0x100
movl $0x10006, 0x60(%rbx)    # imm = 0x10006
movl $0x1, 0x78(%rbx)
movl $0x206f6a, 0x68(%rbx)   # imm = 0x206F6A
movq 0x250(%rbx), %rax
testq %rax, %rax
je 0xf64e
movq 0x1f0(%rbx), %rcx
incq %rcx
cmpq %rax, %rcx
jae 0xf70b
movq 0x1f0(%rbx), %rax
movq 0x1f8(%rbx), %rcx
movsbq 0x1(%rax), %rax
movslq 0x264(%rbx), %rdx
movl $0x1, 0x258(%rbx)
testq %rcx, %rcx
jne 0xf67e
movq 0x200(%rbx), %rcx
addq %rdx, %rax
cmpl $0x10, 0x20c(%rbx)
leaq 0x2(%rcx,%rax), %rax
movzwl %ax, %r14d
cmovneq %rax, %r14
movq %r14, %rax
shrq $0x20, %rax
leaq 0x9c(%rbx), %rsi
testq %rax, %rax
leaq 0x1e3a7(%rip), %rax     # 0x2da54
leaq 0x1e3a8(%rip), %rdx     # 0x2da5c
cmovneq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movl $0x84000000, 0xdc(%rbx) # imm = 0x84000000
movl 0x20c(%rbx), %eax
movl %eax, 0xe0(%rbx)
movl $0x1, 0xe8(%rbx)
movq %r14, 0x88(%rbx)
addq $0x2, 0x1f0(%rbx)
movq 0x28ff7(%rip), %rax     # 0x386f0
movq %rax, 0x7c(%rbx)
movl 0x28ff5(%rip), %eax     # 0x386f8
movl %eax, 0x84(%rbx)
jmp 0xf715
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: jne_
void __bea_callspec__ jne_(PDISASM pMyDisasm)
{
    UInt64 MyAddress;
    signed long MyNumber;
    if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
        (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
        (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
        (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
        (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
    (*pMyDisasm).Instruction.BranchType = JNE;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jne ");
    #endif
    if (!Security(1, pMyDisasm)) return;
    MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
    CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
    if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
    if (MyAddress >= W64LIT (0x100000000)) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
        #endif
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
        #endif
    }
    (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
    (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
    (*pMyDisasm).Argument1.AccessMode = READ;
    (*pMyDisasm).Instruction.AddrValue = MyAddress;
    GV.EIP_+=2;
    FillFlags(pMyDisasm,49);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x1e5(%rdi)
jne 0xfc0f
movb $0x0, 0x1e5(%rbx)
movb $0x1, 0x1e8(%rbx)
cmpb $0x1, 0x1e6(%rbx)
jne 0xfc21
movw $0x100, 0x1e6(%rbx)     # imm = 0x100
movl $0x10006, 0x60(%rbx)    # imm = 0x10006
movl $0xfffffffd, 0x78(%rbx) # imm = 0xFFFFFFFD
movl $0x20656e6a, 0x68(%rbx) # imm = 0x20656E6A
movb $0x0, 0x6c(%rbx)
movq 0x250(%rbx), %rax
testq %rax, %rax
je 0xfc59
movq 0x1f0(%rbx), %rcx
incq %rcx
cmpq %rax, %rcx
jae 0xfd16
movq 0x1f0(%rbx), %rax
movq 0x1f8(%rbx), %rcx
movsbq 0x1(%rax), %rax
movslq 0x264(%rbx), %rdx
movl $0x1, 0x258(%rbx)
testq %rcx, %rcx
jne 0xfc89
movq 0x200(%rbx), %rcx
addq %rdx, %rax
cmpl $0x10, 0x20c(%rbx)
leaq 0x2(%rcx,%rax), %rax
movzwl %ax, %r14d
cmovneq %rax, %r14
movq %r14, %rax
shrq $0x20, %rax
leaq 0x9c(%rbx), %rsi
testq %rax, %rax
leaq 0x1dd9c(%rip), %rax     # 0x2da54
leaq 0x1dd9d(%rip), %rdx     # 0x2da5c
cmovneq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movl $0x84000000, 0xdc(%rbx) # imm = 0x84000000
movl 0x20c(%rbx), %eax
movl %eax, 0xe0(%rbx)
movl $0x1, 0xe8(%rbx)
movq %r14, 0x88(%rbx)
addq $0x2, 0x1f0(%rbx)
movq 0x286c8(%rip), %rax     # 0x383cc
movq %rax, 0x7c(%rbx)
movl 0x286c6(%rip), %eax     # 0x383d4
movl %eax, 0x84(%rbx)
jmp 0xfd20
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: js_
void __bea_callspec__ js_(PDISASM pMyDisasm)
{
    UInt64 MyAddress;
    signed long MyNumber;
    if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
        (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
        (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
        (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
        (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
    (*pMyDisasm).Instruction.BranchType = JS;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "js ");
    #endif
    if (!Security(1, pMyDisasm)) return;
    MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
    CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
    if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
    if (MyAddress >= W64LIT (0x100000000)) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
        #endif
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
        #endif
    }
    (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
    (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
    (*pMyDisasm).Argument1.AccessMode = READ;
    (*pMyDisasm).Instruction.AddrValue = MyAddress;
    GV.EIP_+=2;
    FillFlags(pMyDisasm,120);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x1e5(%rdi)
jne 0xffb6
movb $0x0, 0x1e5(%rbx)
movb $0x1, 0x1e8(%rbx)
cmpb $0x1, 0x1e6(%rbx)
jne 0xffc8
movw $0x100, 0x1e6(%rbx)     # imm = 0x100
movl $0x10006, 0x60(%rbx)    # imm = 0x10006
movl $0x5, 0x78(%rbx)
movl $0x20736a, 0x68(%rbx)   # imm = 0x20736A
movq 0x250(%rbx), %rax
testq %rax, %rax
je 0xfffc
movq 0x1f0(%rbx), %rcx
incq %rcx
cmpq %rax, %rcx
jae 0x100b9
movq 0x1f0(%rbx), %rax
movq 0x1f8(%rbx), %rcx
movsbq 0x1(%rax), %rax
movslq 0x264(%rbx), %rdx
movl $0x1, 0x258(%rbx)
testq %rcx, %rcx
jne 0x1002c
movq 0x200(%rbx), %rcx
addq %rdx, %rax
cmpl $0x10, 0x20c(%rbx)
leaq 0x2(%rcx,%rax), %rax
movzwl %ax, %r14d
cmovneq %rax, %r14
movq %r14, %rax
shrq $0x20, %rax
leaq 0x9c(%rbx), %rsi
testq %rax, %rax
leaq 0x1d9f9(%rip), %rax     # 0x2da54
leaq 0x1d9fa(%rip), %rdx     # 0x2da5c
cmovneq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movl $0x84000000, 0xdc(%rbx) # imm = 0x84000000
movl 0x20c(%rbx), %eax
movl %eax, 0xe0(%rbx)
movl $0x1, 0xe8(%rbx)
movq %r14, 0x88(%rbx)
addq $0x2, 0x1f0(%rbx)
movq 0x28679(%rip), %rax     # 0x38720
movq %rax, 0x7c(%rbx)
movl 0x28677(%rip), %eax     # 0x38728
movl %eax, 0x84(%rbx)
jmp 0x100c3
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: jns_
void __bea_callspec__ jns_(PDISASM pMyDisasm)
{
    UInt64 MyAddress;
    signed long MyNumber;
    if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
        (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
        (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
        (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
        (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
    (*pMyDisasm).Instruction.BranchType = JNS;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jns ");
    #endif
    if (!Security(1, pMyDisasm)) return;
    MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
    CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
    if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
    if (MyAddress >= W64LIT (0x100000000)) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
        #endif
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
        #endif
    }
    (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
    (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
    (*pMyDisasm).Argument1.AccessMode = READ;
    (*pMyDisasm).Instruction.AddrValue = MyAddress;
    GV.EIP_+=2;
    FillFlags(pMyDisasm,120);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x1e5(%rdi)
jne 0x100e9
movb $0x0, 0x1e5(%rbx)
movb $0x1, 0x1e8(%rbx)
cmpb $0x1, 0x1e6(%rbx)
jne 0x100fb
movw $0x100, 0x1e6(%rbx)     # imm = 0x100
movl $0x10006, 0x60(%rbx)    # imm = 0x10006
movl $0xfffffffb, 0x78(%rbx) # imm = 0xFFFFFFFB
movl $0x20736e6a, 0x68(%rbx) # imm = 0x20736E6A
movb $0x0, 0x6c(%rbx)
movq 0x250(%rbx), %rax
testq %rax, %rax
je 0x10133
movq 0x1f0(%rbx), %rcx
incq %rcx
cmpq %rax, %rcx
jae 0x101f0
movq 0x1f0(%rbx), %rax
movq 0x1f8(%rbx), %rcx
movsbq 0x1(%rax), %rax
movslq 0x264(%rbx), %rdx
movl $0x1, 0x258(%rbx)
testq %rcx, %rcx
jne 0x10163
movq 0x200(%rbx), %rcx
addq %rdx, %rax
cmpl $0x10, 0x20c(%rbx)
leaq 0x2(%rcx,%rax), %rax
movzwl %ax, %r14d
cmovneq %rax, %r14
movq %r14, %rax
shrq $0x20, %rax
leaq 0x9c(%rbx), %rsi
testq %rax, %rax
leaq 0x1d8c2(%rip), %rax     # 0x2da54
leaq 0x1d8c3(%rip), %rdx     # 0x2da5c
cmovneq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movl $0x84000000, 0xdc(%rbx) # imm = 0x84000000
movl 0x20c(%rbx), %eax
movl %eax, 0xe0(%rbx)
movl $0x1, 0xe8(%rbx)
movq %r14, 0x88(%rbx)
addq $0x2, 0x1f0(%rbx)
movq 0x28542(%rip), %rax     # 0x38720
movq %rax, 0x7c(%rbx)
movl 0x28540(%rip), %eax     # 0x38728
movl %eax, 0x84(%rbx)
jmp 0x101fa
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: jl_
void __bea_callspec__ jl_(PDISASM pMyDisasm)
{
    UInt64 MyAddress;
    signed long MyNumber;
    if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
        (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
        (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
        (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
        (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
    (*pMyDisasm).Instruction.BranchType = JL;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jl ");
    #endif
    if (!Security(1, pMyDisasm)) return;
    MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
    CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
    if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
    if (MyAddress >= W64LIT (0x100000000)) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
        #endif
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
        #endif
    }
    (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
    (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
    (*pMyDisasm).Argument1.AccessMode = READ;
    (*pMyDisasm).Instruction.AddrValue = MyAddress;
    GV.EIP_+=2;
    FillFlags(pMyDisasm,122);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x1e5(%rdi)
jne 0x1048a
movb $0x0, 0x1e5(%rbx)
movb $0x1, 0x1e8(%rbx)
cmpb $0x1, 0x1e6(%rbx)
jne 0x1049c
movw $0x100, 0x1e6(%rbx)     # imm = 0x100
movl $0x10006, 0x60(%rbx)    # imm = 0x10006
movl $0x7, 0x78(%rbx)
movl $0x206c6a, 0x68(%rbx)   # imm = 0x206C6A
movq 0x250(%rbx), %rax
testq %rax, %rax
je 0x104d0
movq 0x1f0(%rbx), %rcx
incq %rcx
cmpq %rax, %rcx
jae 0x1058d
movq 0x1f0(%rbx), %rax
movq 0x1f8(%rbx), %rcx
movsbq 0x1(%rax), %rax
movslq 0x264(%rbx), %rdx
movl $0x1, 0x258(%rbx)
testq %rcx, %rcx
jne 0x10500
movq 0x200(%rbx), %rcx
addq %rdx, %rax
cmpl $0x10, 0x20c(%rbx)
leaq 0x2(%rcx,%rax), %rax
movzwl %ax, %r14d
cmovneq %rax, %r14
movq %r14, %rax
shrq $0x20, %rax
leaq 0x9c(%rbx), %rsi
testq %rax, %rax
leaq 0x1d525(%rip), %rax     # 0x2da54
leaq 0x1d526(%rip), %rdx     # 0x2da5c
cmovneq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movl $0x84000000, 0xdc(%rbx) # imm = 0x84000000
movl 0x20c(%rbx), %eax
movl %eax, 0xe0(%rbx)
movl $0x1, 0xe8(%rbx)
movq %r14, 0x88(%rbx)
addq $0x2, 0x1f0(%rbx)
movq 0x281bd(%rip), %rax     # 0x38738
movq %rax, 0x7c(%rbx)
movl 0x281bb(%rip), %eax     # 0x38740
movl %eax, 0x84(%rbx)
jmp 0x10597
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: test_EbGb
void __bea_callspec__ test_EbGb(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
    #endif
    (*pMyDisasm).Argument1.AccessMode = READ;
    EbGb(pMyDisasm);
    FillFlags(pMyDisasm,104);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x74736574, 0x68(%rdi) # imm = 0x74736574
movw $0x20, 0x6c(%rdi)
movl $0x1, 0xe8(%rdi)
callq 0x2ad9b
movl 0x276e7(%rip), %eax     # 0x38668
movl %eax, 0x84(%rbx)
movq 0x276d2(%rip), %rax     # 0x38660
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: test_EvGv
void __bea_callspec__ test_EvGv(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
    #endif
    (*pMyDisasm).Argument1.AccessMode = READ;
    EvGv(pMyDisasm);
    FillFlags(pMyDisasm,104);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x74736574, 0x68(%rdi) # imm = 0x74736574
movw $0x20, 0x6c(%rdi)
movl $0x1, 0xe8(%rdi)
callq 0x2ae0b
movl 0x276a7(%rip), %eax     # 0x38668
movl %eax, 0x84(%rbx)
movq 0x27692(%rip), %rax     # 0x38660
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: xchg_EbGb
void __bea_callspec__ xchg_EbGb(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
    #endif
    EbGb(pMyDisasm);
    FillFlags(pMyDisasm,113);
    (*pMyDisasm).Argument2.AccessMode = WRITE;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0x10fe8
movb $0x1, 0x1dc(%rbx)
movl $0x10001, 0x60(%rbx)    # imm = 0x10001
movl $0x67686378, 0x68(%rbx) # imm = 0x67686378
movw $0x20, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ad9b
movl 0x276ca(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x276b5(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
movl $0x2, 0x150(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: xchg_EvGv
void __bea_callspec__ xchg_EvGv(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
    #endif
    EvGv(pMyDisasm);
    FillFlags(pMyDisasm,113);
    (*pMyDisasm).Argument2.AccessMode = WRITE;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0x1103b
movb $0x1, 0x1dc(%rbx)
movl $0x10001, 0x60(%rbx)    # imm = 0x10001
movl $0x67686378, 0x68(%rbx) # imm = 0x67686378
movw $0x20, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2ae0b
movl 0x27677(%rip), %eax     # 0x386d4
movl %eax, 0x84(%rbx)
movq 0x27662(%rip), %rax     # 0x386cc
movq %rax, 0x7c(%rbx)
movl $0x2, 0x150(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_EwSreg
void __bea_callspec__ mov_EwSreg(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    GV.MemDecoration = Arg1word;
    GV.OperandSize = 16;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    GV.SEG_ = 1;
    Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
    GV.SEG_ = 0;
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x20766f6d, 0x68(%rdi) # imm = 0x20766F6D
movb $0x0, 0x6c(%rdi)
movabsq $0x200000010, %rax      # imm = 0x200000010
movq %rax, 0x20c(%rdi)
addq $0x9c, %rdi
movq %rbx, %rsi
callq 0x2b196
movl $0x20, 0x20c(%rbx)
movl $0x1, 0x23c(%rbx)
leaq 0x104(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x23c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_SregEw
void __bea_callspec__ mov_SregEw(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    GV.MemDecoration = Arg2word;
    GV.OperandSize = 16;
    MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
    GV.OperandSize = 32;
    GV.SEG_ = 1;
    Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.SEG_ = 0;
    GV.EIP_ += GV.DECALAGE_EIP+2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x20766f6d, 0x68(%rdi) # imm = 0x20766F6D
movb $0x0, 0x6c(%rdi)
movabsq $0x6600000010, %rax     # imm = 0x6600000010
movq %rax, 0x20c(%rdi)
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x2b196
movl $0x20, 0x20c(%rbx)
movl $0x1, 0x23c(%rbx)
leaq 0x9c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2b24b
movl $0x0, 0x23c(%rbx)
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: pop_Ev
void __bea_callspec__ pop_Ev(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    if (GV.REGOPCODE == 0) {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
        #endif
        if (GV.Architecture == 64) {
            GV.OperandSize = 64;
            GV.MemDecoration = Arg1qword;
            MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
            GV.EIP_ += GV.DECALAGE_EIP+2;
            (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
            (*pMyDisasm).Argument2.ArgSize = 64;
            (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
            (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
        }
        else if (GV.OperandSize == 32) {
            GV.MemDecoration = Arg1dword;
            MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
            GV.EIP_ += GV.DECALAGE_EIP+2;
            (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
            (*pMyDisasm).Argument2.ArgSize = 32;
            (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
            (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
        }
        else {
            GV.MemDecoration = Arg1word;
            MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
            GV.EIP_ += GV.DECALAGE_EIP+2;
            (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
            (*pMyDisasm).Argument2.ArgSize = 16;
            (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
            (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
        }
    }
    else {
        FailDecode(pMyDisasm);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movq 0x1f0(%rdi), %rax
movzbl 0x1(%rax), %ecx
shrl $0x3, %ecx
leaq 0x68(%rdi), %rax
andl $0x7, %ecx
movl %ecx, 0x240(%rdi)
je 0x11279
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0x11346
movb $0x0, 0x4(%rax)
movl $0x20706f70, (%rax)     # imm = 0x20706F70
leaq 0x9c(%rbx), %rdi
cmpl $0x40, 0x25c(%rbx)
jne 0x112c8
movabsq $0x400000040, %rax      # imm = 0x400000040
movq %rax, 0x20c(%rbx)
movq %rbx, %rsi
callq 0x2b196
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movabsq $0x4040000000, %rax     # imm = 0x4040000000
jmp 0x1132b
cmpl $0x20, 0x20c(%rbx)
jne 0x112ff
movl $0x3, 0x210(%rbx)
movq %rbx, %rsi
callq 0x2b196
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movabsq $0x2040000000, %rax     # imm = 0x2040000000
jmp 0x1132b
movl $0x2, 0x210(%rbx)
movq %rbx, %rsi
callq 0x2b196
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
movabsq $0x1040000000, %rax     # imm = 0x1040000000
movq %rax, 0x144(%rbx)
movl $0x10, 0x154(%rbx)
movl $0x20020010, 0x98(%rbx) # imm = 0x20020010
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: movs_
void __bea_callspec__ movs_(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsb ");
    #endif
    (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
    (*pMyDisasm).Argument2.ArgSize = 8;
    (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6+REG7;
    GV.EIP_++;
    FillFlags(pMyDisasm, 68);
}

// Assembly:
cmpb $0x2, 0x1df(%rdi)
jne 0x12803
movb $0x1, 0x1df(%rdi)
cmpb $0x2, 0x1e0(%rdi)
jne 0x12813
movb $0x1, 0x1e0(%rdi)
movl $0x10007, 0x60(%rdi)    # imm = 0x10007
movl $0x73766f6d, 0x68(%rdi) # imm = 0x73766F6D
movl $0x206273, 0x6b(%rdi)   # imm = 0x206273
movabsq $0x840000000, %rax      # imm = 0x840000000
movq %rax, 0xdc(%rdi)
movl $0x80, 0xec(%rdi)
movq %rax, 0x144(%rdi)
movl $0x40, 0x154(%rdi)
movl $0x200c0, 0x98(%rdi)    # imm = 0x200C0
incq 0x1f0(%rdi)
movq 0x25c44(%rip), %rax     # 0x384b0
movq %rax, 0x7c(%rdi)
movl 0x25c42(%rip), %eax     # 0x384b8
movl %eax, 0x84(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: test_ALIb
void __bea_callspec__ test_ALIb(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
    #endif
    (*pMyDisasm).Argument1.AccessMode = READ;
    ALIb(pMyDisasm);
    FillFlags(pMyDisasm,104);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x74736574, 0x68(%rdi) # imm = 0x74736574
movw $0x20, 0x6c(%rdi)
movl $0x1, 0xe8(%rdi)
callq 0x2af06
movl 0x25b99(%rip), %eax     # 0x38668
movl %eax, 0x84(%rbx)
movq 0x25b84(%rip), %rax     # 0x38660
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: test_eAX_Iv
void __bea_callspec__ test_eAX_Iv(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
    #endif
    (*pMyDisasm).Argument1.AccessMode = READ;
    eAX_Iv(pMyDisasm);
    FillFlags(pMyDisasm,104);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10005, 0x60(%rdi)    # imm = 0x10005
movl $0x74736574, 0x68(%rdi) # imm = 0x74736574
movw $0x20, 0x6c(%rdi)
movl $0x1, 0xe8(%rdi)
callq 0x2afb0
movl 0x25b59(%rip), %eax     # 0x38668
movl %eax, 0x84(%rbx)
movq 0x25b44(%rip), %rax     # 0x38660
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: stos_
void __bea_callspec__ stos_(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "stosb ");
    #endif
    (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument2.ArgSize = 8;
    (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
    GV.EIP_++;
    FillFlags(pMyDisasm, 101);
}

// Assembly:
cmpb $0x2, 0x1df(%rdi)
jne 0x12b32
movb $0x1, 0x1df(%rdi)
cmpb $0x2, 0x1e0(%rdi)
jne 0x12b42
movb $0x1, 0x1e0(%rdi)
movl $0x10007, 0x60(%rdi)    # imm = 0x10007
movl $0x736f7473, 0x68(%rdi) # imm = 0x736F7473
movl $0x206273, 0x6b(%rdi)   # imm = 0x206273
movabsq $0x820020001, %rax      # imm = 0x820020001
movq %rax, 0x144(%rdi)
movabsq $0x840000000, %rax      # imm = 0x840000000
movq %rax, 0xdc(%rdi)
movl $0x80, 0xec(%rdi)
movl $0x20080, 0x98(%rdi)    # imm = 0x20080
incq 0x1f0(%rdi)
movq 0x25aa1(%rip), %rax     # 0x3863c
movq %rax, 0x7c(%rdi)
movl 0x25a9f(%rip), %eax     # 0x38644
movl %eax, 0x84(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: lodsb_
void __bea_callspec__ lodsb_(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lodsb ");
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
    (*pMyDisasm).Argument2.ArgSize = 8;
    (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6;
    GV.EIP_++;
    FillFlags(pMyDisasm, 59);
}

// Assembly:
cmpb $0x2, 0x1df(%rdi)
jne 0x12c84
movb $0x1, 0x1df(%rdi)
cmpb $0x2, 0x1e0(%rdi)
jne 0x12c94
movb $0x1, 0x1e0(%rdi)
movl $0x10007, 0x60(%rdi)    # imm = 0x10007
movl $0x73646f6c, 0x68(%rdi) # imm = 0x73646F6C
movl $0x206273, 0x6b(%rdi)   # imm = 0x206273
movabsq $0x820020001, %rax      # imm = 0x820020001
movq %rax, 0xdc(%rdi)
movabsq $0x840000000, %rax      # imm = 0x840000000
movq %rax, 0x144(%rdi)
movl $0x40, 0x154(%rdi)
movl $0x20040, 0x98(%rdi)    # imm = 0x20040
incq 0x1f0(%rdi)
movq 0x25757(%rip), %rax     # 0x38444
movq %rax, 0x7c(%rdi)
movl 0x25755(%rip), %eax     # 0x3844c
movl %eax, 0x84(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: scasb_
void __bea_callspec__ scasb_(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
    }
    if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
        (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "scasb ");
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument1.AccessMode = READ;
    (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
    (*pMyDisasm).Argument2.Memory.BaseRegister = REG7;
    (*pMyDisasm).Argument2.ArgSize = 8;
    (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
    GV.EIP_++;
    FillFlags(pMyDisasm, 94);
}

// Assembly:
cmpb $0x2, 0x1df(%rdi)
jne 0x12dd6
movb $0x1, 0x1df(%rdi)
cmpb $0x2, 0x1e0(%rdi)
jne 0x12de6
movb $0x1, 0x1e0(%rdi)
movl $0x10007, 0x60(%rdi)    # imm = 0x10007
movl $0x73616373, 0x68(%rdi) # imm = 0x73616373
movl $0x206273, 0x6b(%rdi)   # imm = 0x206273
movabsq $0x820020001, %rax      # imm = 0x820020001
movq %rax, 0xdc(%rdi)
movl $0x1, 0xe8(%rdi)
movabsq $0x840000000, %rax      # imm = 0x840000000
movq %rax, 0x144(%rdi)
movl $0x80, 0x154(%rdi)
movl $0x20080, 0x98(%rdi)    # imm = 0x20080
incq 0x1f0(%rdi)
movq 0x2579f(%rip), %rax     # 0x385e8
movq %rax, 0x7c(%rdi)
movl 0x2579d(%rip), %eax     # 0x385f0
movl %eax, 0x84(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_CLIb
void __bea_callspec__ mov_CLIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[1]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x20766f6d, 0x68(%rdi) # imm = 0x20766F6D
movb $0x0, 0x6c(%rdi)
movq 0x250(%rdi), %rax
testq %rax, %rax
je 0x12f78
movq 0x1f0(%rbx), %rcx
addq $0x2, %rcx
cmpq %rax, %rcx
jae 0x12fed
movl $0x8, 0x260(%rbx)
movq 0x1f0(%rbx), %rax
movzbl 0x1(%rax), %r14d
leaq 0x104(%rbx), %rsi
leaq 0x1aa77(%rip), %rdx     # 0x2da13
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movq %r14, 0x90(%rbx)
leaq 0x9c(%rbx), %rdi
leaq 0x25d28(%rip), %rsi     # 0x38ce4
callq 0x8150
movabsq $0x820020002, %rax      # imm = 0x820020002
movq %rax, 0xdc(%rbx)
movabsq $0x888000000, %rax      # imm = 0x888000000
movq %rax, 0x144(%rbx)
addq $0x2, 0x1f0(%rbx)
jmp 0x12ff7
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_DLIb
void __bea_callspec__ mov_DLIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[2]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x20766f6d, 0x68(%rdi) # imm = 0x20766F6D
movb $0x0, 0x6c(%rdi)
movq 0x250(%rdi), %rax
testq %rax, %rax
je 0x13034
movq 0x1f0(%rbx), %rcx
addq $0x2, %rcx
cmpq %rax, %rcx
jae 0x130a9
movl $0x8, 0x260(%rbx)
movq 0x1f0(%rbx), %rax
movzbl 0x1(%rax), %r14d
leaq 0x104(%rbx), %rsi
leaq 0x1a9bb(%rip), %rdx     # 0x2da13
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movq %r14, 0x90(%rbx)
leaq 0x9c(%rbx), %rdi
leaq 0x25c70(%rip), %rsi     # 0x38ce8
callq 0x8150
movabsq $0x820020004, %rax      # imm = 0x820020004
movq %rax, 0xdc(%rbx)
movabsq $0x888000000, %rax      # imm = 0x888000000
movq %rax, 0x144(%rbx)
addq $0x2, 0x1f0(%rbx)
jmp 0x130b3
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_BLIb
void __bea_callspec__ mov_BLIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[3]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG3;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x20766f6d, 0x68(%rdi) # imm = 0x20766F6D
movb $0x0, 0x6c(%rdi)
movq 0x250(%rdi), %rax
testq %rax, %rax
je 0x130f0
movq 0x1f0(%rbx), %rcx
addq $0x2, %rcx
cmpq %rax, %rcx
jae 0x13165
movl $0x8, 0x260(%rbx)
movq 0x1f0(%rbx), %rax
movzbl 0x1(%rax), %r14d
leaq 0x104(%rbx), %rsi
leaq 0x1a8ff(%rip), %rdx     # 0x2da13
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movq %r14, 0x90(%rbx)
leaq 0x9c(%rbx), %rdi
leaq 0x25bb8(%rip), %rsi     # 0x38cec
callq 0x8150
movabsq $0x820020008, %rax      # imm = 0x820020008
movq %rax, 0xdc(%rbx)
movabsq $0x888000000, %rax      # imm = 0x888000000
movq %rax, 0x144(%rbx)
addq $0x2, 0x1f0(%rbx)
jmp 0x1316f
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_AHIb
void __bea_callspec__ mov_AHIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[4]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
    (*pMyDisasm).Argument1.ArgPosition = HighPosition;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x20766f6d, 0x68(%rdi) # imm = 0x20766F6D
movb $0x0, 0x6c(%rdi)
movq 0x250(%rdi), %rax
testq %rax, %rax
je 0x131ac
movq 0x1f0(%rbx), %rcx
addq $0x2, %rcx
cmpq %rax, %rcx
jae 0x1322b
movl $0x8, 0x260(%rbx)
movq 0x1f0(%rbx), %rax
movzbl 0x1(%rax), %r14d
leaq 0x104(%rbx), %rsi
leaq 0x1a843(%rip), %rdx     # 0x2da13
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movq %r14, 0x90(%rbx)
leaq 0x9c(%rbx), %rdi
leaq 0x25b00(%rip), %rsi     # 0x38cf0
callq 0x8150
movabsq $0x820020001, %rax      # imm = 0x820020001
movq %rax, 0xdc(%rbx)
movl $0x1, 0xe4(%rbx)
movabsq $0x888000000, %rax      # imm = 0x888000000
movq %rax, 0x144(%rbx)
addq $0x2, 0x1f0(%rbx)
jmp 0x13235
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_CHIb
void __bea_callspec__ mov_CHIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[5]);
    #endif
    (*pMyDisasm).Argument1.ArgPosition = HighPosition;
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x20766f6d, 0x68(%rdi) # imm = 0x20766F6D
movb $0x0, 0x6c(%rdi)
movq 0x250(%rdi), %rax
testq %rax, %rax
je 0x13272
movq 0x1f0(%rbx), %rcx
addq $0x2, %rcx
cmpq %rax, %rcx
jae 0x132f1
movl $0x8, 0x260(%rbx)
movq 0x1f0(%rbx), %rax
movzbl 0x1(%rax), %r14d
leaq 0x104(%rbx), %rsi
leaq 0x1a77d(%rip), %rdx     # 0x2da13
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movq %r14, 0x90(%rbx)
leaq 0x9c(%rbx), %rdi
leaq 0x25a3e(%rip), %rsi     # 0x38cf4
callq 0x8150
movl $0x1, 0xe4(%rbx)
movabsq $0x820020002, %rax      # imm = 0x820020002
movq %rax, 0xdc(%rbx)
movabsq $0x888000000, %rax      # imm = 0x888000000
movq %rax, 0x144(%rbx)
addq $0x2, 0x1f0(%rbx)
jmp 0x132fb
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: mov_DHIb
void __bea_callspec__ mov_DHIb(PDISASM pMyDisasm)
{
    long MyNumber;
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
    #endif
    if (!Security(2, pMyDisasm)) return;
    GV.ImmediatSize = 8;
    MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
    #endif
    (*pMyDisasm).Instruction.Immediat = MyNumber;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[6]);
    #endif
    (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
    (*pMyDisasm).Argument1.ArgPosition = HighPosition;
    (*pMyDisasm).Argument1.ArgSize = 8;
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    GV.EIP_ += 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x20766f6d, 0x68(%rdi) # imm = 0x20766F6D
movb $0x0, 0x6c(%rdi)
movq 0x250(%rdi), %rax
testq %rax, %rax
je 0x13338
movq 0x1f0(%rbx), %rcx
addq $0x2, %rcx
cmpq %rax, %rcx
jae 0x133b7
movl $0x8, 0x260(%rbx)
movq 0x1f0(%rbx), %rax
movzbl 0x1(%rax), %r14d
leaq 0x104(%rbx), %rsi
leaq 0x1a6b7(%rip), %rdx     # 0x2da13
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2acdf
movq %r14, 0x90(%rbx)
leaq 0x9c(%rbx), %rdi
leaq 0x2597c(%rip), %rsi     # 0x38cf8
callq 0x8150
movabsq $0x820020004, %rax      # imm = 0x820020004
movq %rax, 0xdc(%rbx)
movl $0x1, 0xe4(%rbx)
movabsq $0x888000000, %rax      # imm = 0x888000000
movq %rax, 0x144(%rbx)
addq $0x2, 0x1f0(%rbx)
jmp 0x133c1
movl $0x1, 0x289(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: retn_
void __bea_callspec__ retn_(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
    (*pMyDisasm).Instruction.BranchType = RetType;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "retn ");
    #endif
    if (!Security(3, pMyDisasm)) return;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic,"%.4X",(Int64)*((UInt16*)(UIntPtr) (GV.EIP_+1)));
    #endif
    GV.ImmediatSize = 16;
    (*pMyDisasm).Instruction.Immediat = *((UInt16*)(UIntPtr) (GV.EIP_+1));
    GV.EIP_+=3;
    (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument1.ArgSize = 16;
    (*pMyDisasm).Argument1.AccessMode = READ;
    (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10006, 0x60(%rdi)    # imm = 0x10006
movl $0xd, 0x78(%rdi)
movl $0x6e746572, 0x68(%rdi) # imm = 0x6E746572
movw $0x20, 0x6c(%rdi)
movq 0x250(%rdi), %rax
testq %rax, %rax
je 0x1440a
movq 0x1f0(%rbx), %rcx
addq $0x3, %rcx
cmpq %rax, %rcx
jae 0x14479
leaq 0x9c(%rbx), %rsi
movq 0x1f0(%rbx), %rax
movzwl 0x1(%rax), %ecx
leaq 0x1964f(%rip), %rdx     # 0x2da72
movq %rbx, %rdi
callq 0x2acdf
movl $0x10, 0x260(%rbx)
movq 0x1f0(%rbx), %rax
movzwl 0x1(%rax), %ecx
movq %rcx, 0x90(%rbx)
addq $0x3, %rax
movq %rax, 0x1f0(%rbx)
movabsq $0x1088000000, %rax     # imm = 0x1088000000
movq %rax, 0xdc(%rbx)
movl $0x1, 0xe8(%rbx)
movl $0x20010, %eax          # imm = 0x20010
movl $0x98, %ecx
jmp 0x14483
movl $0x1, %eax
movl $0x289, %ecx            # imm = 0x289
movl %eax, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: les_GvM
void __bea_callspec__ les_GvM(PDISASM pMyDisasm)
{

    if (GV.Architecture == 64) {
        FailDecode(pMyDisasm);
    }
    else {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SEGMENT_REGISTER;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "les ");
        #endif
        if (GV.OperandSize == 32) {
            GV.MemDecoration = Arg2fword;
            MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
            Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
            GV.EIP_+= GV.DECALAGE_EIP+2;
        }
        else {
            GV.MemDecoration = Arg2dword;
            MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
            Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
            GV.EIP_+= GV.DECALAGE_EIP+2;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x40, 0x25c(%rdi)
jne 0x14505
movb $0x0, 0x6c(%rbx)
movl $0x203f3f3f, 0x68(%rbx) # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0x14567
movl $0x1000b, 0x60(%rbx)    # imm = 0x1000B
movl $0x2073656c, 0x68(%rbx) # imm = 0x2073656C
movb $0x0, 0x6c(%rbx)
leaq 0x104(%rbx), %rdi
leaq 0x9c(%rbx), %r14
cmpl $0x20, 0x20c(%rbx)
jne 0x1453a
movl $0x6b, 0x210(%rbx)
jmp 0x14544
movl $0x67, 0x210(%rbx)
movq %rbx, %rsi
callq 0x2b196
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b24b
movl 0x244(%rbx), %eax
addl $0x2, %eax
addq %rax, 0x1f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq