LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/src/basic_block.cpp
// Function: BasicBlock::toString(char*, int) const
char *BasicBlock::toString(char *buf, int size) const
{
    snprintf(buf, size, "\t\t\t0x%llx(0x%llx) %ld instructions", (ADDR)this, getFirstInstAddr(), insts.size());

    if (!successors.empty()) {
        snprintf(buf+strlen(buf), size-strlen(buf), "\n\t\t\tsucc{");
        for (ConstBBPtrIter iter = successors.begin(); iter != successors.end(); iter++) {
            snprintf(buf+strlen(buf), size-strlen(buf), "0x%llx(0x%llx), ", (ADDR)(*iter), (*iter)->getFirstInstAddr());
        }
        snprintf(buf+strlen(buf)-2, size-strlen(buf)+2, "}");
    }

    if (!predecessors.empty()) {
        snprintf(buf+strlen(buf), size-strlen(buf), "\n\t\t\tpred{");
        for (ConstBBPtrIter iter = predecessors.begin(); iter != predecessors.end(); iter++) {
            snprintf(buf+strlen(buf), size-strlen(buf), "0x%llx(0x%llx), ", (ADDR)(*iter), (*iter)->getFirstInstAddr());
        }
        snprintf(buf+strlen(buf)-2, size-strlen(buf)+2, "}");
    }
    return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movslq %edx, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x8(%rax), %r8
subq %rax, %rcx
movabsq $-0x5e16bcf632f6fbb, %r9 # imm = 0xFA1E94309CD09045
imulq %rcx, %r9
leaq 0x24797(%rip), %rdx     # 0x2d0c4
movq %rsi, %rdi
movq %r14, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x8230
movq 0x18(%r15), %rax
cmpq 0x20(%r15), %rax
je 0x89d5
movq %rbx, %rdi
callq 0x8090
leaq (%rbx,%rax), %rdi
movq %r14, %rsi
subq %rax, %rsi
leaq 0x24783(%rip), %rdx     # 0x2d0e7
xorl %eax, %eax
callq 0x8230
movq 0x18(%r15), %r13
cmpq 0x20(%r15), %r13
je 0x89ad
leaq 0x24775(%rip), %r12     # 0x2d0f1
movq %rbx, %rdi
callq 0x8090
leaq (%rbx,%rax), %rdi
movq %r14, %rsi
subq %rax, %rsi
movq (%r13), %rcx
movq (%rcx), %rax
movq 0x8(%rax), %r8
movq %r12, %rdx
xorl %eax, %eax
callq 0x8230
addq $0x8, %r13
cmpq 0x20(%r15), %r13
jne 0x897c
movq %rbx, %rdi
callq 0x8090
leaq (%rbx,%rax), %rdi
addq $-0x2, %rdi
movq %r14, %rsi
subq %rax, %rsi
addq $0x2, %rsi
leaq 0x24734(%rip), %rdx     # 0x2d102
xorl %eax, %eax
callq 0x8230
movq 0x30(%r15), %rax
cmpq 0x38(%r15), %rax
je 0x8a6d
movq %rbx, %rdi
callq 0x8090
leaq (%rbx,%rax), %rdi
movq %r14, %rsi
subq %rax, %rsi
leaq 0x24708(%rip), %rdx     # 0x2d104
xorl %eax, %eax
callq 0x8230
movq 0x30(%r15), %r13
cmpq 0x38(%r15), %r13
je 0x8a45
leaq 0x246dd(%rip), %r12     # 0x2d0f1
movq %rbx, %rdi
callq 0x8090
leaq (%rbx,%rax), %rdi
movq %r14, %rsi
subq %rax, %rsi
movq (%r13), %rcx
movq (%rcx), %rax
movq 0x8(%rax), %r8
movq %r12, %rdx
xorl %eax, %eax
callq 0x8230
addq $0x8, %r13
cmpq 0x38(%r15), %r13
jne 0x8a14
movq %rbx, %rdi
callq 0x8090
leaq (%rbx,%rax), %rdi
addq $-0x2, %rdi
subq %rax, %r14
addq $0x2, %r14
leaq 0x2469f(%rip), %rdx     # 0x2d102
movq %r14, %rsi
xorl %eax, %eax
callq 0x8230
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/src/basic_block.cpp
// Function: BasicBlock::dump() const
void BasicBlock::dump() const
{
    dumpBiref();
    for (ConstDisasmIter iter = insts.begin(); iter != insts.end(); iter++) {
    printf("\t\t\t0x%.8lx\t%s\n", iter->VirtualAddr, (char *)&iter->CompleteInstr);
    }
    puts("");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x88f8
movq %r14, %rdi
callq 0x8220
movq (%rbx), %r15
cmpq 0x8(%rbx), %r15
je 0x8afa
leaq 0x24633(%rip), %r14     # 0x2d10e
movq 0x8(%r15), %rsi
leaq 0x14(%r15), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x8030
addq $0x28d, %r15            # imm = 0x28D
cmpq 0x8(%rbx), %r15
jne 0x8adb
movl $0xa, %edi
callq 0x81d0
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
movups %xmm0, 0x20(%rdi)
xorl %eax, %eax
movq %rax, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movl $0x0, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rcx, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x18(%rsi), %rdi
callq 0x82a0
movq %rax, 0x18(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0xa1cc
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x9c3a
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x9b10
movq %rax, (%rcx)
movq 0x40(%rsp), %rcx
addq $0x8, %rcx
movq %rcx, 0x40(%rsp)
jmp 0x9b29
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa342
movq 0x8(%rsp), %rax
movq 0x40(%rsp), %rcx
movb $0x1, 0x59(%rax)
movq 0x20(%rsp), %rax
cmpq %rax, %rcx
je 0x9c0c
leaq 0x10(%rsp), %rbx
movq (%rax), %rdi
movq %rdi, 0x8(%rsp)
callq 0x86ac
movq 0x8(%rsp), %r15
movq 0x18(%r15), %r14
movq 0x20(%r15), %rax
cmpq %rax, %r14
je 0x9ba8
movq (%r14), %rcx
cmpb $0x0, 0x58(%rcx)
jne 0x9ba2
cmpb $0x0, 0x59(%rcx)
jne 0x9ba2
movq 0x40(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rax
je 0x9b8c
movq %rcx, (%rax)
addq $0x8, 0x40(%rsp)
jmp 0x9b97
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa342
movq (%r14), %rax
movb $0x1, 0x59(%rax)
movq 0x20(%r15), %rax
addq $0x8, %r14
jmp 0x9b5a
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x9bc1
addq $0x8, %rax
jmp 0x9bf3
movq 0x28(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x8170
movq 0x38(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rcx
movb $0x0, 0x59(%rcx)
cmpq %rax, 0x40(%rsp)
jne 0x9b40
leaq 0x10(%rsp), %rdi
callq 0xa174
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x9c24
jmp 0x9c24
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa174
movq %rbx, %rdi
callq 0x8270
nop
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rdi, %rbx
movl %r15d, %r12d
andl $0x3f, %r12d
movl %r12d, %eax
movq 0x68(%rdi,%rax,8), %r14
movq 0x8(%rdi), %r13
testq %r14, %r14
je 0x9c99
movq %r15, %rax
subq (%rbx), %rax
setb %cl
addq 0x10(%rbx), %rax
testb $0x1, %cl
movq $-0x1, %rcx
cmovneq %rcx, %rax
cmpq %r15, %r13
cmovbq %rcx, %rax
movq (%r14), %rcx
cmpq %rax, 0x8(%rcx)
je 0x9d0a
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0x9c87
movl $0x60, %edi
callq 0x8160
movq %rax, %r14
movq $-0x1, %rdx
cmpq %r15, %r13
jb 0x9cc1
movq %r15, %rax
subq (%rbx), %rax
jb 0x9cc1
addq 0x10(%rbx), %rax
movq %rax, %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x85ec
movq %r14, 0x8(%rsp)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x9ce8
movq %r14, (%rsi)
addq $0x8, 0x28(%rbx)
jmp 0x9cfc
leaq 0x20(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x8cb6
movq (%r14), %r14
movq 0x68(%rbx,%r12,8), %rax
movq %rax, 0x48(%r14)
movq %r14, 0x68(%rbx,%r12,8)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x60, %esi
movq %r14, %rdi
callq 0x8170
movq %rbx, %rdi
callq 0x8270
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x9e4e
movq 0x20(%r15), %r13
movq 0x20(%r13), %rax
subq 0x18(%r13), %rax
cmpq $0x10, %rax
jne 0x9e60
movl $0xe0, %edi
callq 0x8160
movq %rax, %r12
movq 0x18(%r13), %rax
movq (%rax), %rsi
movq %r12, %rdi
callq 0xadb2
movl $0xe0, %edi
callq 0x8160
movq %rax, %rbp
movq 0x20(%r13), %rax
movq -0x8(%rax), %rsi
movq %rbp, %rdi
callq 0xadb2
movq %r12, %rdi
movq %rbp, %rsi
callq 0xad10
testb %al, %al
je 0x9e2a
movq %r13, %rdi
callq 0x8aa4
movq %r12, %rdi
callq 0xb1dc
movq 0x18(%r13), %rax
movq (%rax), %rdi
callq 0x8aa4
movq %rbp, %rdi
callq 0xb1dc
movq 0x20(%r13), %rax
movq -0x8(%rax), %rdi
callq 0x8aa4
incq %r14
movq %r12, %rdi
callq 0x81c0
movq %rbp, %rdi
callq 0x81c0
movq %r15, %rdi
callq 0x81b0
movq %rax, %r15
cmpq %rbx, %rax
jne 0x9d98
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x234e0(%rip), %rdi     # 0x2d347
leaq 0x234fc(%rip), %rsi     # 0x2d36a
leaq 0x23506(%rip), %rcx     # 0x2d37b
movl $0x7f, %edx
callq 0x80e0
movq %rax, %rbx
jmp 0x9e8a
movq %rax, %rbx
movq %rbp, %r12
movl $0xe0, %esi
movq %r12, %rdi
callq 0x8170
movq %rbx, %rdi
callq 0x8270
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xa73e
movq %rsi, %rbx
movl %edi, %ebp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x22d3f(%rip), %rdi     # 0x2d3db
callq 0x8220
leaq 0x58(%rsp), %r15
leaq 0x30(%rsp), %r13
movl %ebp, %ebp
movl $0x1, %r14d
leaq 0x20(%rsp), %r12
movq (%rbx,%r14,8), %rsi
movq %r12, %rdi
callq 0x9178
movq %rsp, %rdi
movq %r12, %rsi
callq 0xa768
movq %r15, %rdi
callq 0x95c0
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0xa6ee
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8170
incq %r14
cmpq %r14, %rbp
jne 0xa6b8
movl $0xa, %edi
callq 0x81d0
leaq 0x22ce6(%rip), %rdi     # 0x2d3ed
callq 0x8220
movq (%rsp), %rbx
cmpq 0x8(%rsp), %rbx
je 0xa725
movq %rbx, %rdi
callq 0x94ce
addq $0x58, %rbx
jmp 0xa710
movq %rsp, %rdi
callq 0xa7ba
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8444
jmp 0xa745
movq %rax, %rbx
jmp 0xa757
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xa792
movq %rsp, %rdi
callq 0xa7ba
movq %rbx, %rdi
callq 0x8270
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xb490
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a6c7
movl 0x2cd14(%rip), %eax     # 0x381c4
movl %eax, 0x84(%rbx)
movq 0x2ccff(%rip), %rax     # 0x381bc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb4d7
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a737
movl 0x2cccd(%rip), %eax     # 0x381c4
movl %eax, 0x84(%rbx)
movq 0x2ccb8(%rip), %rax     # 0x381bc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb51e
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a78d
movl 0x2cc86(%rip), %eax     # 0x381c4
movl %eax, 0x84(%rbx)
movq 0x2cc71(%rip), %rax     # 0x381bc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb565
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a7dc
movl 0x2cc3f(%rip), %eax     # 0x381c4
movl %eax, 0x84(%rbx)
movq 0x2cc2a(%rip), %rax     # 0x381bc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb5ac
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a832
movl 0x2cbf8(%rip), %eax     # 0x381c4
movl %eax, 0x84(%rbx)
movq 0x2cbe3(%rip), %rax     # 0x381bc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb5f3
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20646461, 0x68(%rbx) # imm = 0x20646461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a8d3
movl 0x2cbb1(%rip), %eax     # 0x381c4
movl %eax, 0x84(%rbx)
movq 0x2cb9c(%rip), %rax     # 0x381bc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb760
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2a6c7
movl 0x2cd84(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2cd6f(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb7a3
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2a737
movl 0x2cd41(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2cd2c(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb7e6
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2a78d
movl 0x2ccfe(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2cce9(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb829
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2a7dc
movl 0x2ccbb(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2cca6(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb86c
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2a832
movl 0x2cc78(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2cc63(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb8af
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20726f, 0x68(%rbx)   # imm = 0x20726F
movq %rbx, %rdi
callq 0x2a8d3
movl 0x2cc35(%rip), %eax     # 0x38500
movl %eax, 0x84(%rbx)
movq 0x2cc20(%rip), %rax     # 0x384f8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xb919
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xb970
leaq 0x9c(%rbx), %rdi
leaq 0x2d001(%rip), %rsi     # 0x38928
callq 0x8150
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2d50d(%rip), %eax     # 0x38e44
movl %eax, 0x144(%rbx)
movl $0x10, %eax
movl %eax, 0x148(%rbx)
movabsq $0x1040000000, %rcx     # imm = 0x1040000000
movq %rcx, 0xdc(%rbx)
movl %eax, 0xec(%rbx)
movl $0x20020010, 0x98(%rbx) # imm = 0x20020010
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb993
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 0x2dce8(%rip), %rcx     # 0x396a0
jmpq *(%rcx,%rax,8)
// File: /workspace/github_c_makefile_star2_O3/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 0xb9cf
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a6c7
movl 0x2c7c9(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c7b4(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xba16
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a737
movl 0x2c782(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c76d(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xba5d
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a78d
movl 0x2c73b(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c726(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbaa4
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a7dc
movl 0x2c6f4(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c6df(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbaeb
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a832
movl 0x2c6ad(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c698(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbb32
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20636461, 0x68(%rbx) # imm = 0x20636461
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a8d3
movl 0x2c666(%rip), %eax     # 0x381b8
movl %eax, 0x84(%rbx)
movq 0x2c651(%rip), %rax     # 0x381b0
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbba0
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xbbf7
leaq 0x9c(%rbx), %rdi
leaq 0x2cd82(%rip), %rsi     # 0x38930
callq 0x8150
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2d28a(%rip), %eax     # 0x38e48
movl %eax, 0x144(%rbx)
movl $0x10, %eax
movl %eax, 0x148(%rbx)
movabsq $0x1040000000, %rcx     # imm = 0x1040000000
movq %rcx, 0xdc(%rbx)
movl %eax, 0xec(%rbx)
movl $0x20020010, 0x98(%rbx) # imm = 0x20020010
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbc9f
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a6c7
movl 0x2c925(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c910(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbce6
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a737
movl 0x2c8de(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c8c9(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbd2d
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a78d
movl 0x2c897(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c882(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbd74
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a7dc
movl 0x2c850(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c83b(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbdbb
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a832
movl 0x2c809(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c7f4(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbe02
movb $0x1, 0x1dc(%rbx)
movl $0x10002, 0x60(%rbx)    # imm = 0x10002
movl $0x20626273, 0x68(%rbx) # imm = 0x20626273
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a8d3
movl 0x2c7c2(%rip), %eax     # 0x385e4
movl %eax, 0x84(%rbx)
movq 0x2c7ad(%rip), %rax     # 0x385dc
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: 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 0xbe70
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xbec7
leaq 0x9c(%rbx), %rdi
leaq 0x2caba(%rip), %rsi     # 0x38938
callq 0x8150
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2cfbe(%rip), %eax     # 0x38e4c
movl %eax, 0x144(%rbx)
movl $0x10, %eax
movl %eax, 0x148(%rbx)
movabsq $0x1040000000, %rcx     # imm = 0x1040000000
movq %rcx, 0xdc(%rbx)
movl %eax, 0xec(%rbx)
movl $0x20020010, 0x98(%rbx) # imm = 0x20020010
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_N_Z.c
// Function: pop_ds
void __bea_callspec__ pop_ds(PDISASM pMyDisasm)
{
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
    #endif
    if (GV.Architecture == 64) {
        FailDecode(pMyDisasm);
    }
    else {
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[3]);
        #endif
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[3];
        (*pMyDisasm).Argument1.ArgSize = 16;
        (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
        (*pMyDisasm).Argument2.ArgSize = 16;
        (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
        (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
        GV.EIP_++;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x10001, 0x60(%rdi)    # imm = 0x10001
movl $0x20706f70, 0x68(%rdi) # imm = 0x20706F70
movb $0x0, 0x6c(%rdi)
cmpl $0x40, 0x25c(%rdi)
jne 0xbf02
leaq 0x68(%rbx), %rax
movb $0x0, 0x4(%rax)
movl $0x203f3f3f, (%rax)     # imm = 0x203F3F3F
movl $0x1, 0x280(%rbx)
jmp 0xbf59
leaq 0x9c(%rbx), %rdi
leaq 0x2ca28(%rip), %rsi     # 0x38938
callq 0x8150
movl $0x21000000, %eax       # imm = 0x21000000
addl 0x2cf2c(%rip), %eax     # 0x38e4c
movl %eax, 0xdc(%rbx)
movl $0x10, %eax
movl %eax, 0xe0(%rbx)
movabsq $0x1040000000, %rcx     # imm = 0x1040000000
movq %rcx, 0x144(%rbx)
movl %eax, 0x154(%rbx)
movl $0x20020010, 0x98(%rbx) # imm = 0x20020010
incq 0x1f0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: and_EbGb
void __bea_callspec__ and_EbGb(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
    #endif
    EbGb(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbf6f
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a6c7
movl 0x2c241(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c22c(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: and_EvGv
void __bea_callspec__ and_EvGv(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
    #endif
    EvGv(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbfb6
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a737
movl 0x2c1fa(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c1e5(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: and_GbEb
void __bea_callspec__ and_GbEb(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
    #endif
    GbEb(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xbffd
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a78d
movl 0x2c1b3(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c19e(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: and_GvEv
void __bea_callspec__ and_GvEv(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
    #endif
    GvEv(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc044
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a7dc
movl 0x2c16c(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c157(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: and_ALIb
void __bea_callspec__ and_ALIb(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
    #endif
    ALIb(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc08b
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a832
movl 0x2c125(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c110(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/disasm/instr_set/opcodes_A_M.c
// Function: and_eAX_Iv
void __bea_callspec__ and_eAX_Iv(PDISASM pMyDisasm)
{
    if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
        (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
    }
    (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
    #endif
    eAX_Iv(pMyDisasm);
    FillFlags(pMyDisasm,6);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x4, 0x1dc(%rdi)
jne 0xc0d2
movb $0x1, 0x1dc(%rbx)
movl $0x10003, 0x60(%rbx)    # imm = 0x10003
movl $0x20646e61, 0x68(%rbx) # imm = 0x20646E61
movb $0x0, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x2a8d3
movl 0x2c0de(%rip), %eax     # 0x381d0
movl %eax, 0x84(%rbx)
movq 0x2c0c9(%rip), %rax     # 0x381c8
movq %rax, 0x7c(%rbx)
popq %rbx
retq