LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/binary.cpp
// Function: BinInfo::dumpFunc()
void BinInfo::dumpFunc()
{
    fprintf(stderr, "%-18s\t%-16s\t%-16s\t%-16s\t\n", "[Function Name]", "[Virtual Addr]", "[Map Start]", "[Map End]");
    char buf[128];
    for (FunctionIter iter = funcInfo.begin(); iter != funcInfo.end(); iter++) {
        fprintf(stderr, "%s\n", iter->toString(buf, sizeof(buf)));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0x2cc59(%rip), %rbp     # 0x35fd0
movq (%rbp), %rdi
leaq 0x20eb3(%rip), %rsi     # 0x2a235
leaq 0x20ec6(%rip), %rdx     # 0x2a24f
leaq 0x20ecf(%rip), %rcx     # 0x2a25f
leaq 0x20ed7(%rip), %r8      # 0x2a26e
leaq 0x20edc(%rip), %r9      # 0x2a27a
xorl %eax, %eax
callq 0x8220
movq 0x38(%rbx), %r14
movq %rsp, %r15
leaq 0x20d66(%rip), %r12     # 0x2a119
cmpq 0x40(%rbx), %r14
je 0x93e6
movq (%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
movl $0x80, %edx
callq 0x9920
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x8220
addq $0x268, %r14            # imm = 0x268
jmp 0x93b3
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/binary.cpp
// Function: BinInfo::disasm()
void BinInfo::disasm()
{
    long pcount = 0;
    long bcount = 0;
    for (FunctionIter iter = funcInfo.begin(); iter != funcInfo.end(); iter++) {
        iter->disasm();
        //iter->dumpBiref();
        iter->reduction();
        iter->findCandidatePair();
        //iter->dumpBiref();
        pcount += iter->getCandidatePairs().size();
        bcount += iter->mergeBB();
#if 0
        const vector<BasicBlock *> vBB = iter->getBasicBlocks();
        for (BasicBlock::ConstBBPtrIter iter = vBB.begin(); iter != vBB.end(); iter++) {
            (*iter)->dump();
        }
#endif
    }
    printf("Count of Pairs: %ld\n", pcount);
    printf("Count of Equal Pairs: %ld\n", bcount);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x38(%rdi), %r12
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpq 0x40(%r15), %r12
je 0x9443
movq %r12, %rdi
callq 0x998e
movq %r12, %rdi
callq 0x9d34
movq %r12, %rdi
callq 0x9c86
addq 0x60(%r12), %r14
movq %r12, %rdi
callq 0x9b62
addq %rax, %rbx
addq $0x268, %r12            # imm = 0x268
jmp 0x940c
leaq 0x20e3a(%rip), %rdi     # 0x2a284
movq %r14, %rsi
xorl %eax, %eax
callq 0x8030
leaq 0x20e3e(%rip), %rdi     # 0x2a299
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8030
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/function.cpp
// Function: Function::Function(Function const&)
Function::Function (const Function &func)
{
    this->mapStart = func.mapStart;
    this->mapEnd = func.mapEnd;
    this->virStart = func.virStart;
    this->funcName = strdup(func.funcName);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
andl $0x0, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
leaq 0x40(%rdi), %rax
movq %rax, 0x50(%rdi)
movq %rax, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x18(%rsi), %rdi
callq 0x82d0
movq %rax, 0x18(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/function.cpp
// Function: Function::disasm()
void Function::disasm()
{
    //printf("\tStart Function::disasm %s\n", funcName);
    queue<BasicBlock *> que;
    BasicBlock *bb = findBasicBlock(mapStart);
    que.push(bb);
    bb->setDisasmPending(true);
    while (!que.empty()) {
        bb = que.front();
        bb->disasm();
        const vector<BasicBlock *> &succ = bb->getSuccessors();
        for (BasicBlock::ConstBBPtrIter iter = succ.begin(); iter != succ.end(); iter++) {
            if ((*iter)->isDisasmed() || (*iter)->isDisasmPending())
                continue;
            que.push(*iter);
            (*iter)->setDisasmPending(true);
        }
        que.pop();
        bb->setDisasmPending(false);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9df6
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x9a5e
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xa0f8
movq 0x8(%rsp), %rax
movb $0x1, 0x59(%rax)
leaq 0x10(%rsp), %rbx
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
je 0x9a31
movq (%rax), %rdi
movq %rdi, 0x8(%rsp)
callq 0x84ea
movq 0x8(%rsp), %r15
movq 0x18(%r15), %r14
cmpq 0x20(%r15), %r14
je 0x9a1e
movq (%r14), %rax
cmpb $0x0, 0x58(%rax)
jne 0x9a18
cmpb $0x0, 0x59(%rax)
jne 0x9a18
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa0f8
movq (%r14), %rax
movb $0x1, 0x59(%rax)
addq $0x8, %r14
jmp 0x99f1
movq %rbx, %rdi
callq 0xa32c
movq 0x8(%rsp), %rax
movb $0x0, 0x59(%rax)
jmp 0x99cf
leaq 0x10(%rsp), %rdi
callq 0x9ef2
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x9a49
jmp 0x9a49
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9ef2
movq %rbx, %rdi
callq 0x82a0
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/function.cpp
// Function: Function::findBasicBlock(unsigned long long)
BasicBlock *Function::findBasicBlock(ADDR addr)
{
    BasicBlock *pos = hashTableBB[hash(addr)];
    while (pos) {
        if (pos->getFirstInstAddr() == getVirAddr(addr))
            break;
        pos = pos->getHashNext();
    }

    if (!pos) {
        pos = new BasicBlock(addr, getVirAddr(addr), this);
        basicBlocks.push_back(pos);
        BasicBlock *bb = hashTableBB[hash(addr)];
        pos->setHashNext(bb);
        hashTableBB[hash(addr)] = pos;
    }
    return pos;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %r14d, %eax
andl $0x3f, %eax
leaq (%rdi,%rax,8), %r12
addq $0x68, %r12
movq %r12, %rcx
movq (%rcx), %r15
testq %r15, %r15
je 0x9aa7
movq (%r15), %rax
movq 0x8(%rax), %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x98e4
leaq 0x48(%r15), %rcx
cmpq %rax, %r13
jne 0x9a82
jmp 0x9af4
pushq $0x60
popq %rdi
callq 0x8190
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x98e4
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x843c
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
addq $0x20, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x892c
movq (%r12), %rax
movq (%r14), %r15
movq %rax, 0x48(%r15)
movq %r15, (%r12)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r15, %rdi
callq 0x81a0
movq %rbx, %rdi
callq 0x82a0
nop
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/function.cpp
// Function: Function::mergeBB()
long Function::mergeBB()
{
    long count = 0;
    for (set<BasicBlock *>::iterator iter = pairBBs.begin(); iter!=pairBBs.end(); iter++) {
        BasicBlock* bbptr = *iter;
        
        assert(bbptr->getSuccessors().size() == 2);
        TaintBlock *left = new TaintBlock(bbptr->getSuccessors().front());
        TaintBlock *right = new TaintBlock(bbptr->getSuccessors().back());
        if (*left == *right) {
            bbptr->dump();
            left->dump();
            bbptr->getSuccessors().front()->dump();
            right->dump();
            bbptr->getSuccessors().back()->dump();
            count++;
        }
        free(left);
        free(right);
    }
    return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %r15
addq $0x40, %rbx
xorl %r14d, %r14d
cmpq %rbx, %r15
je 0x9c36
movq 0x20(%r15), %r13
movq 0x20(%r13), %rax
subq 0x18(%r13), %rax
cmpq $0x10, %rax
jne 0x9c48
movl $0xe0, %edi
callq 0x8190
movq %rax, %r12
movq 0x18(%r13), %rax
movq (%rax), %rsi
movq %r12, %rdi
callq 0xaae8
movl $0xe0, %edi
callq 0x8190
movq %rax, %rbp
movq 0x20(%r13), %rax
movq -0x8(%rax), %rsi
movq %rbp, %rdi
callq 0xaae8
movq %r12, %rdi
movq %rbp, %rsi
callq 0xaa94
testb %al, %al
je 0x9c16
movq %r13, %rdi
callq 0x8864
movq %r12, %rdi
callq 0xaec0
movq 0x18(%r13), %rax
movq (%rax), %rdi
callq 0x8864
movq %rbp, %rdi
callq 0xaec0
movq 0x20(%r13), %rax
movq -0x8(%rax), %rdi
callq 0x8864
incq %r14
movq %r12, %rdi
callq 0x81d0
movq %rbp, %rdi
callq 0x81d0
movq %r15, %rdi
callq 0x81c0
movq %rax, %r15
jmp 0x9b7b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x206f8(%rip), %rdi     # 0x2a347
leaq 0x20714(%rip), %rsi     # 0x2a36a
leaq 0x2071e(%rip), %rcx     # 0x2a37b
pushq $0x7f
popq %rdx
callq 0x8100
movq %rax, %rbx
jmp 0x9c70
movq %rax, %rbx
movq %rbp, %r12
movl $0xe0, %esi
movq %r12, %rdi
callq 0x81a0
movq %rbx, %rdi
callq 0x82a0
nop
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/function.cpp
// Function: Function::findCandidatePair()
void Function::findCandidatePair()
{
   // for (BasicBlock::ConstRevBBPtrIter iter = leafBBs.rbegin(); iter!=leafBBs.rend(); iter++) {
    for (BasicBlock::BBPtrIter iter = basicBlocks.begin(); iter!=basicBlocks.end(); iter++) {
        BasicBlock* bbptr = *iter;
        if (!bbptr->isLeaf())
            continue;
        if (bbptr->isVisited())
            continue;
        const vector<BasicBlock *> preds = bbptr->getPredecessors();
        if (preds.size() != 1)
            continue;
        BasicBlock *pred = preds.front();
        if (pred->getSuccessors().size() != 2)
            continue;
        pairBBs.insert(pred);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %r13
leaq 0x38(%rdi), %r14
leaq 0x8(%rsp), %r15
movq %rsp, %r12
cmpq 0x28(%rbx), %r13
je 0x9d10
movq (%r13), %rsi
movq 0x8(%rsi), %rax
cmpl $0xd, -0x215(%rax)
jne 0x9d0a
cmpb $0x0, 0x5a(%rsi)
jne 0x9d0a
addq $0x30, %rsi
movq %r15, %rdi
callq 0x9e12
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x9d02
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rax), %rcx
subq 0x18(%rax), %rcx
cmpq $0x10, %rcx
jne 0x9d02
movq %r14, %rdi
movq %r12, %rsi
callq 0xa3a8
movq %r15, %rdi
callq 0x89d6
addq $0x8, %r13
jmp 0x9ca6
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x89d6
movq %rbx, %rdi
callq 0x82a0
nop
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/function.cpp
// Function: Function::reduction()
void Function::reduction()
{
    bool change = false;
    do {
        change = false;
        for (BasicBlock::BBPtrIter iter = basicBlocks.begin(); iter!=basicBlocks.end(); iter++) {
            BasicBlock* bbptr = *iter;
            if (bbptr->isRemoved()) {
                basicBlocks.erase(iter);
                break;
            }
            const vector<BasicBlock *> succs = bbptr->getSuccessors();
            if (succs.size() != 1)
                continue;
            BasicBlock *succ = succs.front();
            if (succ->getPredecessors().size() != 1)
                continue;
            
            bbptr->merge(succ);
            succ->setRemoved(true);
            change = true;
        }
    } while (change);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq 0x8(%rsp), %rax
movq (%rax), %r12
xorl %r14d, %r14d
cmpq 0x28(%rbx), %r12
je 0x9dcc
movq (%r12), %r13
cmpb $0x1, 0x5b(%r13)
je 0x9dbf
leaq 0x18(%r13), %rsi
movq %r15, %rdi
callq 0x9e12
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x9db1
movq (%rax), %rbp
movq 0x38(%rbp), %rax
subq 0x30(%rbp), %rax
cmpq $0x8, %rax
jne 0x9db1
movq %r13, %rdi
movq %rbp, %rsi
callq 0x88aa
movb $0x1, 0x5b(%rbp)
movb $0x1, %r14b
movq %r15, %rdi
callq 0x89d6
addq $0x8, %r12
jmp 0x9d5e
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x9e60
testb $0x1, %r14b
jne 0x9d53
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x89d6
movq %rbx, %rdi
callq 0x82a0
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/main.cpp
// Function: main
int main(int argc, char* argv [])
{
    // 1.judge illegal
    if(argc<=1){
        fprintf(stderr, "Usage: ./rop FileList\n");
        abort();
    }
    // 2.read file List and find Ret Code
    vector<BinInfo> vBin;
    puts("[1] BinInfo parse");
    for(int i=1; i<argc; i++){
        BinInfo bin(argv[i]);
        //bin.findRetCodeInElf();
        vBin.push_back(bin);
    }

#if 0
    puts("");
    puts("[2] Dump Function Information");
    for (vector<BinInfo>::iterator iter = vBin.begin(); iter != vBin.end(); iter++) {
        iter->dumpFunc();
    }
#endif
    puts("");
    puts("[2] Disasm Function");
    for (vector<BinInfo>::iterator iter = vBin.begin(); iter != vBin.end(); iter++) {
        iter->disasm();
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpl $0x1, %edi
jle 0xa5b6
movq %rsi, %rbx
movl %edi, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x1fea5(%rip), %rdi     # 0x2a3db
callq 0x8250
movl %ebp, %r12d
pushq $0x1
popq %r13
leaq 0x20(%rsp), %r15
cmpq %r13, %r12
je 0xa570
movq (%rbx,%r13,8), %rsi
movq %r15, %rdi
callq 0x9050
movq %r14, %rdi
movq %r15, %rsi
callq 0xa5fc
movq %r15, %rdi
callq 0xa628
incq %r13
jmp 0xa547
pushq $0xa
popq %rdi
callq 0x8200
leaq 0x1fe6e(%rip), %rdi     # 0x2a3ed
callq 0x8250
movq (%rsp), %rbx
cmpq 0x8(%rsp), %rbx
je 0xa59d
movq %rbx, %rdi
callq 0x93f8
addq $0x58, %rbx
jmp 0xa588
movq %rsp, %rdi
callq 0xa63e
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2ba13(%rip), %rax     # 0x35fd0
movq (%rax), %rcx
leaq 0x1fdfd(%rip), %rdi     # 0x2a3c4
pushq $0x16
popq %rsi
pushq $0x1
popq %rdx
callq 0x82e0
callq 0x80f0
jmp 0xa5d9
movq %rax, %rbx
jmp 0xa5eb
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xa628
movq %rsp, %rdi
callq 0xa63e
movq %rbx, %rdi
callq 0x82a0
nop
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: add_EbGb
void __bea_callspec__ add_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, "add ");
    #endif
    EbGb(pMyDisasm);
    FillFlags(pMyDisasm,5);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb248
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x284a8
movl 0x2af7c(%rip), %eax     # 0x361e4
movl %eax, 0x84(%rbx)
movq 0x2af67(%rip), %rax     # 0x361dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: add_EvGv
void __bea_callspec__ add_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, "add ");
    #endif
    EvGv(pMyDisasm);
    FillFlags(pMyDisasm,5);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb28f
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x28518
movl 0x2af35(%rip), %eax     # 0x361e4
movl %eax, 0x84(%rbx)
movq 0x2af20(%rip), %rax     # 0x361dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: add_GbEb
void __bea_callspec__ add_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, "add ");
    #endif
    GbEb(pMyDisasm);
    FillFlags(pMyDisasm,5);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb2d6
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2856c
movl 0x2aeee(%rip), %eax     # 0x361e4
movl %eax, 0x84(%rbx)
movq 0x2aed9(%rip), %rax     # 0x361dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: add_GvEv
void __bea_callspec__ add_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, "add ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm,5);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb31d
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x285bb
movl 0x2aea7(%rip), %eax     # 0x361e4
movl %eax, 0x84(%rbx)
movq 0x2ae92(%rip), %rax     # 0x361dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: add_ALIb
void __bea_callspec__ add_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, "add ");
    #endif
    ALIb(pMyDisasm);
    FillFlags(pMyDisasm,5);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb364
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2860f
movl 0x2ae60(%rip), %eax     # 0x361e4
movl %eax, 0x84(%rbx)
movq 0x2ae4b(%rip), %rax     # 0x361dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: add_eAX_Iv
void __bea_callspec__ add_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, "add ");
    #endif
    eAX_Iv(pMyDisasm);
    FillFlags(pMyDisasm,5);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xb3ab
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x286b0
movl 0x2ae19(%rip), %eax     # 0x361e4
movl %eax, 0x84(%rbx)
movq 0x2ae04(%rip), %rax     # 0x361dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: push_es
void __bea_callspec__ push_es(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[0]);
        #endif
        (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[0];
        (*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 0xb419
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xb46e
leaq 0x9c(%rbx), %rdi
leaq 0x2b519(%rip), %rsi     # 0x36940
callq 0x8170
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2ba29(%rip), %eax     # 0x36e60
movl %eax, 0x144(%rbx)
pushq $0x10
popq %rax
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_O2/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 0xb4a9
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xb4fe
leaq 0x9c(%rbx), %rdi
leaq 0x2b489(%rip), %rsi     # 0x36940
callq 0x8170
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2b999(%rip), %eax     # 0x36e60
movl %eax, 0xdc(%rbx)
pushq $0x10
popq %rax
movl %eax, 0xe0(%rbx)
movabsq $0x1040000000, %rcx     # imm = 0x1040000000
movq %rcx, 0x144(%rbx)
movl %eax, 0x154(%rbx)
movl $0x20020010, 0x98(%rbx) # imm = 0x20020010
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_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 0xb514
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x284a8
movl 0x2aff0(%rip), %eax     # 0x36520
movl %eax, 0x84(%rbx)
movq 0x2afdb(%rip), %rax     # 0x36518
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb557
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x28518
movl 0x2afad(%rip), %eax     # 0x36520
movl %eax, 0x84(%rbx)
movq 0x2af98(%rip), %rax     # 0x36518
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb59a
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2856c
movl 0x2af6a(%rip), %eax     # 0x36520
movl %eax, 0x84(%rbx)
movq 0x2af55(%rip), %rax     # 0x36518
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb5dd
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x285bb
movl 0x2af27(%rip), %eax     # 0x36520
movl %eax, 0x84(%rbx)
movq 0x2af12(%rip), %rax     # 0x36518
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb620
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2860f
movl 0x2aee4(%rip), %eax     # 0x36520
movl %eax, 0x84(%rbx)
movq 0x2aecf(%rip), %rax     # 0x36518
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb663
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x286b0
movl 0x2aea1(%rip), %eax     # 0x36520
movl %eax, 0x84(%rbx)
movq 0x2ae8c(%rip), %rax     # 0x36518
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb6cd
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xb722
leaq 0x9c(%rbx), %rdi
leaq 0x2b26d(%rip), %rsi     # 0x36948
callq 0x8170
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2b779(%rip), %eax     # 0x36e64
movl %eax, 0x144(%rbx)
pushq $0x10
popq %rax
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_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_prefixes.c
// Function: Esc_2byte
void __bea_callspec__ Esc_2byte(PDISASM pMyDisasm)
{
    if (!Security(0, pMyDisasm)) return;
    GV.EIP_++;
    (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_)+0x0F00;
    (void) opcode_map2[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
}

// Assembly:
movq 0x1f0(%rdi), %rax
movq 0x250(%rdi), %rcx
decq %rcx
cmpq %rax, %rcx
jae 0xb745
movl $0x1, 0x289(%rdi)
retq
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1f0(%rdi)
movzbl 0x1(%rax), %ecx
orl $0xf00, %ecx            # imm = 0xF00
movl %ecx, 0x64(%rdi)
movzbl 0x1(%rax), %eax
leaq 0x2bf56(%rip), %rcx     # 0x376c0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O2/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 0xb781
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x284a8
movl 0x2aa37(%rip), %eax     # 0x361d8
movl %eax, 0x84(%rbx)
movq 0x2aa22(%rip), %rax     # 0x361d0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: 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 0xb7c8
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x28518
movl 0x2a9f0(%rip), %eax     # 0x361d8
movl %eax, 0x84(%rbx)
movq 0x2a9db(%rip), %rax     # 0x361d0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: 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 0xb80f
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2856c
movl 0x2a9a9(%rip), %eax     # 0x361d8
movl %eax, 0x84(%rbx)
movq 0x2a994(%rip), %rax     # 0x361d0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: 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 0xb856
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x285bb
movl 0x2a962(%rip), %eax     # 0x361d8
movl %eax, 0x84(%rbx)
movq 0x2a94d(%rip), %rax     # 0x361d0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: 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 0xb89d
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2860f
movl 0x2a91b(%rip), %eax     # 0x361d8
movl %eax, 0x84(%rbx)
movq 0x2a906(%rip), %rax     # 0x361d0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: 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 0xb8e4
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x286b0
movl 0x2a8d4(%rip), %eax     # 0x361d8
movl %eax, 0x84(%rbx)
movq 0x2a8bf(%rip), %rax     # 0x361d0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb952
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xb9a7
leaq 0x9c(%rbx), %rdi
leaq 0x2aff0(%rip), %rsi     # 0x36950
callq 0x8170
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2b4f8(%rip), %eax     # 0x36e68
movl %eax, 0x144(%rbx)
pushq $0x10
popq %rax
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_O2/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 0xb9e2
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xba37
leaq 0x9c(%rbx), %rdi
leaq 0x2af60(%rip), %rsi     # 0x36950
callq 0x8170
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2b468(%rip), %eax     # 0x36e68
movl %eax, 0xdc(%rbx)
pushq $0x10
popq %rax
movl %eax, 0xe0(%rbx)
movabsq $0x1040000000, %rcx     # imm = 0x1040000000
movq %rcx, 0x144(%rbx)
movl %eax, 0x154(%rbx)
movl $0x20020010, 0x98(%rbx) # imm = 0x20020010
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_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 0xba4d
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x284a8
movl 0x2ab97(%rip), %eax     # 0x36604
movl %eax, 0x84(%rbx)
movq 0x2ab82(%rip), %rax     # 0x365fc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xba94
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x28518
movl 0x2ab50(%rip), %eax     # 0x36604
movl %eax, 0x84(%rbx)
movq 0x2ab3b(%rip), %rax     # 0x365fc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbadb
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2856c
movl 0x2ab09(%rip), %eax     # 0x36604
movl %eax, 0x84(%rbx)
movq 0x2aaf4(%rip), %rax     # 0x365fc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbb22
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x285bb
movl 0x2aac2(%rip), %eax     # 0x36604
movl %eax, 0x84(%rbx)
movq 0x2aaad(%rip), %rax     # 0x365fc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbb69
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2860f
movl 0x2aa7b(%rip), %eax     # 0x36604
movl %eax, 0x84(%rbx)
movq 0x2aa66(%rip), %rax     # 0x365fc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbbb0
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x286b0
movl 0x2aa34(%rip), %eax     # 0x36604
movl %eax, 0x84(%rbx)
movq 0x2aa1f(%rip), %rax     # 0x365fc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbc1e
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xbc73
leaq 0x9c(%rbx), %rdi
leaq 0x2ad2c(%rip), %rsi     # 0x36958
callq 0x8170
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2b230(%rip), %eax     # 0x36e6c
movl %eax, 0x144(%rbx)
pushq $0x10
popq %rax
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