LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: SleighBuilder::SleighBuilder(ParserWalker*, DisassemblyCache*, PcodeCacher*, AddrSpace*, AddrSpace*, unsigned int)
SleighBuilder::SleighBuilder (ParserWalker* w, DisassemblyCache* dcache,
                              PcodeCacher* pc, AddrSpace* cspc, AddrSpace* uspc,
                              uint4 umask) :
PcodeBuilder (0)
{
    walker = w;
    discache = dcache;
    cache = pc;
    const_space = cspc;
    uniq_space = uspc;
    uniquemask = umask;
    uniqueoffset = (walker->getAddr ().getOffset () & uniquemask) << 4;
}

// Assembly:
subq $0x58, %rsp
movl 0x60(%rsp), %eax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0xd1f30
movq 0x8(%rsp), %rax
movq 0xacbed(%rip), %rcx     # 0x1c7d60
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x20(%rax)
movl 0x60(%rsp), %ecx
movq %rcx, 0x28(%rax)
movq 0x10(%rax), %rdi
callq 0xcee30
movq %rax, 0x10(%rsp)
jmp 0x11b1bf
movq 0x10(%rsp), %rdi
callq 0xe03b0
movq %rax, (%rsp)
jmp 0x11b1cf
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
andq 0x28(%rax), %rcx
shlq $0x4, %rcx
movq %rcx, 0x30(%rax)
addq $0x58, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xd62a0
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: SleighBuilder::appendBuild(OpTpl*, int)
void SleighBuilder::appendBuild (OpTpl* bld, int4 secnum)
// Append pcode for a particular build statement
{
    // Recover operand index from build statement
    int4 index = bld->getIn (0)->getOffset ().getReal ();
    // Check if operand is a subtable
    SubtableSymbol* sym = (SubtableSymbol*)walker->getConstructor ()
                              ->getOperand (index)
                              ->getDefiningSymbol ();
    if ((sym == (SubtableSymbol*)0) ||
        (sym->getType () != SleighSymbol::subtable_symbol))
        return;

    walker->pushOperand (index);
    Constructor* ct = walker->getConstructor ();
    if (secnum >= 0) {
        ConstructTpl* construct = ct->getNamedTempl (secnum);
        if (construct == (ConstructTpl*)0)
            buildEmpty (ct, secnum);
        else
            build (construct, secnum);
    } else {
        ConstructTpl* construct = ct->getTempl ();
        build (construct, -1);
    }
    walker->popOperand ();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0xd3b80
movq %rax, %rdi
callq 0xdbaf0
movq %rax, %rdi
callq 0xdd890
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl %ecx, 0x30(%rsp)
movq 0x10(%rax), %rdi
callq 0xd81d0
movq %rax, %rdi
movl 0x30(%rsp), %esi
callq 0xd3060
movq %rax, %rdi
callq 0xdf550
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x11b28e
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0xb, %eax
je 0x11b293
jmp 0x11b335
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x30(%rsp), %esi
callq 0xcf7d0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xd81d0
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x34(%rsp)
jl 0x11b304
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0xe0d30
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x11b2ef
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0xde230
jmp 0x11b302
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0xd0740
jmp 0x11b327
movq 0x20(%rsp), %rdi
callq 0xd87a0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xd0740
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xceb70
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: DisassemblyCache::getParserContext(Address const&)
ParserContext* DisassemblyCache::getParserContext (const Address& addr)

{ // Return a (possibly cached) ParserContext that is associated with -addr-

    // If n different calls to this interface are made with n different
    // Addresses, if
    //    n <= minimumreuse   AND
    //    all the addresses are within the windowsize (=mask+1)
    // then the cacher guarantees that you get all different ParserContext
    // objects
    int4 hashindex = ((int4)addr.getOffset ()) & mask;
    ParserContext* res = hashtable[hashindex];
    if (res->getAddr () == addr)
        return res;
    res = list[nextfree];
    // Advance the circular index
    nextfree += 1;
    if (nextfree >= minimumreuse)
        nextfree = 0;
    res->setAddr (addr);
    // Need to start over with parsing
    res->setParserState (ParserContext::uninitialized);
    // Stick it into the hashtable
    hashtable[hashindex] = res;
    return res;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
andl 0x14(%rax), %ecx
movl %ecx, 0x1c(%rsp)
movq 0x28(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xd2a50
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0xdc0d0
testb $0x1, %al
jne 0x11b650
jmp 0x11b65c
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x11b6cb
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rax
movslq 0x20(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movq %rax, 0x10(%rsp)
movl 0x20(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x20(%rcx)
movl 0x20(%rcx), %eax
cmpl 0x10(%rcx), %eax
jl 0x11b68f
movq 0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdaaa0
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0xd58a0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
movq 0x28(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: DisassemblyCache::free()
void DisassemblyCache::free (void)

{
    for (int4 i = 0; i < minimumreuse; ++i)
        delete list[i];
    delete[] list;
    delete[] hashtable;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x11be4e
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x11be3f
movq 0x18(%rsp), %rdi
callq 0xdb350
movq 0x18(%rsp), %rdi
movl $0xa8, %esi
callq 0xd8620
jmp 0x11be41
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x11bdfb
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x11be6c
movq 0x10(%rsp), %rdi
callq 0xdb380
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x11be8a
movq 0x8(%rsp), %rdi
callq 0xdb380
addq $0x38, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: Sleigh::Sleigh(LoadImage*, ContextDatabase*)
Sleigh::Sleigh (LoadImage* ld, ContextDatabase* c_db) : SleighBase ()

{
    loader = ld;
    context_db = c_db;
    cache = new ContextCache (c_db);
    discache = (DisassemblyCache*)0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd77c0
movq 0x10(%rsp), %rdi
movq 0xabc7a(%rip), %rax     # 0x1c7b88
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x200, %rdi            # imm = 0x200
movq %rdi, 0x18(%rsp)
callq 0xdc150
jmp 0x11bf28
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, 0x1e0(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x1e8(%rax)
movl $0x30, %edi
callq 0xd8380
movq %rax, 0x8(%rsp)
jmp 0x11bf56
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xd66f0
jmp 0x11bf67
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x1f0(%rax)
movq $0x0, 0x1f8(%rax)
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x11bfcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x11bfc5
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x30, %esi
callq 0xd8620
movq 0x18(%rsp), %rdi
callq 0xdfb70
movq 0x10(%rsp), %rdi
callq 0xde270
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: Sleigh::reset(LoadImage*, ContextDatabase*)
void Sleigh::reset (LoadImage* ld, ContextDatabase* c_db)

{ // Completely clear everything except the base and reconstruct
    // with a new loader and context
    clearForDelete ();
    pcode_cache.clear ();
    loader = ld;
    context_db = c_db;
    cache = new ContextCache (c_db);
    discache = (DisassemblyCache*)0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xdee10
movq (%rsp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0xce380
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x1e0(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x1e8(%rax)
movl $0x30, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0xd66f0
jmp 0x11c15e
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x1f0(%rax)
movq $0x0, 0x1f8(%rax)
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x30, %esi
callq 0xd8620
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: Sleigh::obtainContext(Address const&, int) const
ParserContext* Sleigh::obtainContext (const Address& addr, int4 state) const
// Obtain a ParserContext for the instruction at the given -addr-. This may be
// cached.
{
    // Make sure parsing has proceeded to at least the given -state.
    ParserContext* pos = discache->getParserContext (addr);
    int4 curstate = pos->getParserState ();
    if (curstate >= state)
        return pos;
    if (curstate == ParserContext::uninitialized) {
        resolve (*pos);
        if (state == ParserContext::disassembly)
            return pos;
    }
    // If we reach here,  state must be ParserContext::pcode
    resolveHandles (*pos);
    return pos;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x1f8(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0xd3bf0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xdbfb0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jl 0x11c4b5
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x11c4f7
cmpl $0x0, 0xc(%rsp)
jne 0x11c4df
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xdc090
cmpl $0x1, 0x1c(%rsp)
jne 0x11c4dd
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x11c4f7
jmp 0x11c4df
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xd3880
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: Sleigh::getInstructionBytes(Address const&, unsigned char*) const
void Sleigh::getInstructionBytes (const Address& baseaddr, uint1* buf) const

{
    ParserContext* pos = obtainContext (baseaddr, ParserContext::disassembly);
    ParserWalker walker(pos);
    walker.baseState();

    auto len = pos->getLength();

    uintm tmp;
    int4 bytestart = 0;
    do {
        tmp = walker.getInstructionBytes(bytestart,sizeof(uint1));
        memcpy(&buf[bytestart], (uint1*)&tmp, sizeof(uint1));
    } while (bytestart += 1, bytestart != len);

    return;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movl $0x1, %edx
callq 0xd40b0
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xd7160
leaq 0x18(%rsp), %rdi
callq 0xe07e0
movq 0xb8(%rsp), %rdi
callq 0xd1b00
movl %eax, 0x14(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x18(%rsp), %rdi
movl $0x1, %edx
callq 0xd6420
movl %eax, 0x10(%rsp)
movq 0xc0(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb 0x10(%rsp), %dl
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jne 0x11cb56
addq $0xd8, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: Sleigh::printAssembly(AssemblyEmit&, Address const&) const
int4 Sleigh::printAssembly (AssemblyEmit& emit, const Address& baseaddr) const

{
    int4 sz;

    ParserContext* pos = obtainContext (baseaddr, ParserContext::disassembly);
    ParserWalker walker (pos);
    walker.baseState ();

    Constructor* ct = walker.getConstructor ();
    ostringstream mons;
    ct->printMnemonic (mons, walker);
    ostringstream body;
    ct->printBody (body, walker);
    emit.dump (baseaddr, mons.str (), body.str ());
    sz = pos->getLength ();
    return sz;
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
movq %rdx, 0x420(%rsp)
movq 0x430(%rsp), %rdi
movq 0x420(%rsp), %rsi
movl $0x1, %edx
callq 0xd40b0
movq %rax, 0x410(%rsp)
movq 0x410(%rsp), %rsi
leaq 0x370(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xd7160
movq 0x20(%rsp), %rdi
callq 0xe07e0
movq 0x20(%rsp), %rdi
callq 0xd81d0
movq %rax, 0x368(%rsp)
leaq 0x1f0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xdbe90
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x368(%rsp), %rdi
callq 0xd32e0
jmp 0x11cc42
leaq 0x68(%rsp), %rdi
callq 0xdbe90
jmp 0x11cc4e
movq 0x368(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x370(%rsp), %rdx
callq 0xdad80
jmp 0x11cc6a
movq 0x428(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x420(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x1f0(%rsp), %rsi
callq 0xd8840
jmp 0x11cc98
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd8840
jmp 0x11cca9
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq *%rax
jmp 0x11ccc8
leaq 0x28(%rsp), %rdi
callq 0xd4550
leaq 0x48(%rsp), %rdi
callq 0xd4550
movq 0x410(%rsp), %rdi
callq 0xd1b00
movl %eax, 0x4(%rsp)
jmp 0x11ccef
movl 0x4(%rsp), %eax
movl %eax, 0x41c(%rsp)
movl 0x41c(%rsp), %eax
movl %eax, (%rsp)
leaq 0x68(%rsp), %rdi
callq 0xd0160
leaq 0x1f0(%rsp), %rdi
callq 0xd0160
movl (%rsp), %eax
addq $0x438, %rsp            # imm = 0x438
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e8(%rsp)
movl %eax, 0x1e4(%rsp)
jmp 0x11cd9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e8(%rsp)
movl %eax, 0x1e4(%rsp)
jmp 0x11cd90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e8(%rsp)
movl %eax, 0x1e4(%rsp)
jmp 0x11cd86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e8(%rsp)
movl %eax, 0x1e4(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd4550
leaq 0x48(%rsp), %rdi
callq 0xd4550
leaq 0x68(%rsp), %rdi
callq 0xd0160
leaq 0x1f0(%rsp), %rdi
callq 0xd0160
movq 0x1e8(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/include/sleigh.hh
// Function: PcodeCacher::allocateVarnodes(unsigned int)
VarnodeData *allocateVarnodes(uint4 size) {
    VarnodeData *newptr = curpool + size;
    if (newptr <= endpool) {
      VarnodeData *res = curpool;
      curpool = newptr;
      return res;
    }
    return expandPool(size);
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
movl 0x24(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rcx), %rax
ja 0x11db39
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x11db4c
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0xda190
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/include/sleigh.hh
// Function: PcodeCacher::allocateInstruction()
PcodeData *allocateInstruction(void)
    {
        issued.push_back(PcodeData());
        PcodeData *res = &issued.back();
        res->outvar = (VarnodeData *)0;
        res->invar = (VarnodeData *)0;
        return res;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x18, %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd36e0
leaq 0x20(%rsp), %rdi
callq 0xd8030
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd1700
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0xdca90
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/include/context.hh
// Function: ParserContext::allocateOperand(int, ParserWalkerChange&)
inline void ParserContext::allocateOperand(int4 i,ParserWalkerChange &walker) {
  ConstructState *opstate = &state[alloc++];
  opstate->parent = walker.point;
  opstate->ct = (Constructor *)0;
  walker.point->resolve[i] = opstate;
  walker.breadcrumb[walker.depth++] += 1;
  walker.point = opstate;
  walker.breadcrumb[walker.depth] = 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, %rdi
addq $0x80, %rdi
movl 0xa0(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0xa0(%rcx)
movslq %eax, %rsi
callq 0xdda70
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
addq $0x40, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xd3290
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rdx
movl 0x18(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x18(%rdx)
movslq %ecx, %rcx
movl 0x1c(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x1c(%rax,%rcx,4)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rcx
movslq 0x18(%rcx), %rcx
movl $0x0, 0x1c(%rax,%rcx,4)
addq $0x28, %rsp
retq
// File: jstaursky[P]hutch/src/Sleigh/include/sleigh.hh
// Function: PcodeData::store(VarnodeData*, VarnodeData*)
void store (VarnodeData* outv, VarnodeData* inv)
    {
        if (outv != nullptr) {
            this->outvar = new VarnodeData;
            *this->outvar = *outv;
        }
        invar = new VarnodeData[isize];
        for (auto i = 0; i != isize; ++i)
            this->invar[i] = inv[i];
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x11ee08
movl $0x18, %edi
callq 0xd8380
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rax), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movslq 0x18(%rax), %rax
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xce140
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x18(%rcx), %eax
je 0x11ee99
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x11ee44
addq $0x28, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/sleighbase.cc
// Function: SleighBase::SleighBase()
SleighBase::SleighBase(void)

{
  root = (SubtableSymbol *)0;
  maxdelayslotbytes = 0;
  unique_allocatemask = 0;
  numSections = 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xdc6e0
movq 0x18(%rsp), %rdi
movq 0xa6da4(%rip), %rax     # 0x1c7aa8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x148, %rdi            # imm = 0x148
movq %rdi, 0x8(%rsp)
callq 0xe0e60
movq 0x18(%rsp), %rdi
addq $0x160, %rdi            # imm = 0x160
movq %rdi, 0x10(%rsp)
callq 0xde650
movq 0x18(%rsp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0xdd580
jmp 0x120d45
movq 0x18(%rsp), %rax
movq $0x0, 0x190(%rax)
movl $0x0, 0x1d0(%rax)
movl $0x0, 0x1d4(%rax)
movl $0x0, 0x1d8(%rax)
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xe20c0
movq 0x8(%rsp), %rdi
callq 0xd5480
movq 0x18(%rsp), %rdi
callq 0xd3250
movq 0x28(%rsp), %rdi
callq 0xe0be0
nop
// File: jstaursky[P]hutch/src/Sleigh/sleighbase.cc
// Function: SleighBase::reregisterContext()
void SleighBase::reregisterContext(void)

{
  SymbolScope *glb = symtab.getGlobalScope();
  SymbolTree::const_iterator iter;
  SleighSymbol *sym;
  for(iter=glb->begin();iter!=glb->end();++iter) {
    sym = *iter;
    if (sym->getType() == SleighSymbol::context_symbol) {
      ContextSymbol *csym = (ContextSymbol *)sym;
      ContextField *field = (ContextField *)csym->getPatternValue();
      int4 startbit = field->getStartBit();
      int4 endbit = field->getEndBit();
      registerContext(csym->getName(),startbit,endbit);
    }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x198, %rdi            # imm = 0x198
callq 0xd7210
movq %rax, 0x48(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd3950
movq 0x48(%rsp), %rdi
callq 0xd71f0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0xd9490
movq %rax, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd8da0
testb $0x1, %al
jne 0x12142e
jmp 0x1214b7
leaq 0x40(%rsp), %rdi
callq 0xe1aa0
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0xf, %eax
jne 0x1214a6
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd3490
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd5620
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xd1f90
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1214a8
leaq 0x40(%rsp), %rdi
callq 0xdcc00
jmp 0x121407
addq $0x58, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleighbase.cc
// Function: SleighBase::getRegister(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const VarnodeData &SleighBase::getRegister(const string &nm) const

{
  VarnodeSymbol *sym = (VarnodeSymbol *)findSymbol(nm);
  if (sym == (VarnodeSymbol *)0)
    throw SleighError("Unknown register name: "+nm);
  if (sym->getType() != SleighSymbol::varnode_symbol)
    throw SleighError("Symbol is not a register: "+nm);
  return sym->getFixedVarnode();
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xcf950
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0x121646
movb $0x1, 0x43(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdx
leaq 0x66fed(%rip), %rsi     # 0x1885b4
leaq 0x50(%rsp), %rdi
callq 0xd7370
jmp 0x1215d3
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xd06e0
jmp 0x1215e4
movq 0x10(%rsp), %rdi
movb $0x0, 0x43(%rsp)
movq 0xa6873(%rip), %rsi     # 0x1c7e68
movq 0xa6424(%rip), %rdx     # 0x1c7a20
callq 0xe01f0
jmp 0x12170f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x12162e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x43(%rsp)
jne 0x121637
jmp 0x121641
movq 0x10(%rsp), %rdi
callq 0xd5400
jmp 0x121705
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x6, %eax
je 0x1216f3
movb $0x1, 0x1f(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rdx
leaq 0x66f52(%rip), %rsi     # 0x1885cc
leaq 0x20(%rsp), %rdi
callq 0xd7370
jmp 0x121686
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd06e0
jmp 0x121697
movq 0x8(%rsp), %rdi
movb $0x0, 0x1f(%rsp)
movq 0xa67c0(%rip), %rsi     # 0x1c7e68
movq 0xa6371(%rip), %rdx     # 0x1c7a20
callq 0xe01f0
jmp 0x12170f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1216de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x1f(%rsp)
jne 0x1216e7
jmp 0x1216f1
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x121705
movq 0x70(%rsp), %rdi
callq 0xd0730
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xe0be0
nop
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenPattern::buildSingle(int, int, unsigned int)
PatternBlock *TokenPattern::buildSingle(int4 startbit,int4 endbit,uintm byteval)

{				// Create a mask/value pattern within a single word
				// The field is given by the bitrange [startbit,endbit]
				// bit 0 is the MOST sig bit of the word
				// use the least sig bits of byteval to fill in
				// the field's value
  uintm mask;
  int4 offset = 0;
  int4 size = endbit-startbit+1;
  while(startbit >= 8) {
    offset += 1;
    startbit -= 8;
    endbit -= 8;
  }    
  mask = (~((uintm)0)) << (sizeof(uintm)*8-size);
  byteval = (byteval << (sizeof(uintm)*8-size))& mask;
  mask >>= startbit;
  byteval >>= startbit;
  return new PatternBlock(offset,mask,byteval);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x30(%rsp), %eax
subl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
cmpl $0x8, 0x34(%rsp)
jl 0x126b01
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x34(%rsp), %eax
subl $0x8, %eax
movl %eax, 0x34(%rsp)
movl 0x30(%rsp), %eax
subl $0x8, %eax
movl %eax, 0x30(%rsp)
jmp 0x126ad7
movb 0x20(%rsp), %cl
negb %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
movb 0x20(%rsp), %cl
negb %cl
shll %cl, %eax
movl 0x28(%rsp), %ecx
andl %ecx, %eax
movl %eax, 0x2c(%rsp)
movb 0x34(%rsp), %cl
movl 0x28(%rsp), %eax
shrl %cl, %eax
movl %eax, 0x28(%rsp)
movb 0x34(%rsp), %cl
movl 0x2c(%rsp), %eax
shrl %cl, %eax
movl %eax, 0x2c(%rsp)
movl $0x38, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x2c(%rsp), %ecx
callq 0xce540
jmp 0x126b6c
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x38, %esi
callq 0xd8620
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenPattern::buildBigBlock(int, int, int, long)
PatternBlock *TokenPattern::buildBigBlock(int4 size,int4 bitstart,int4 bitend,intb value)

{				// Build pattern block given a bigendian contiguous
				// range of bits and a value for those bits
  int4 tmpstart,startbit,endbit;
  PatternBlock *tmpblock,*block;

  startbit = 8*size - 1 - bitend;
  endbit = 8*size - 1 - bitstart;
  
  block = (PatternBlock *)0;
  while(endbit >= startbit) {
    tmpstart = endbit - (endbit & 7);
    if (tmpstart < startbit)
      tmpstart = startbit;
    tmpblock = buildSingle(tmpstart,endbit,(uintm)value);
    if (block == (PatternBlock *)0)
      block = tmpblock;
    else {
      PatternBlock *newblock = block->intersect(tmpblock);
      delete block;
      delete tmpblock;
      block = newblock;
    }
    value >>= (endbit-tmpstart+1);
    endbit = tmpstart - 1;
  }
  return block;
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movl %esi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq %rcx, 0x40(%rsp)
movl 0x54(%rsp), %eax
shll $0x3, %eax
subl $0x1, %eax
subl 0x4c(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x54(%rsp), %eax
shll $0x3, %eax
subl $0x1, %eax
subl 0x50(%rsp), %eax
movl %eax, 0x34(%rsp)
movq $0x0, 0x20(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x38(%rsp), %eax
jl 0x126cda
movl 0x34(%rsp), %eax
movl 0x34(%rsp), %ecx
andl $0x7, %ecx
subl %ecx, %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x38(%rsp), %eax
jge 0x126c13
movl 0x38(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %edi
movl 0x34(%rsp), %esi
movq 0x40(%rsp), %rax
movl %eax, %edx
callq 0xe1db0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x126c40
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x126cb0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdb440
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x126c7d
movq 0x10(%rsp), %rdi
callq 0xd2d60
movq 0x10(%rsp), %rdi
movl $0x38, %esi
callq 0xd8620
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x126ca6
movq 0x8(%rsp), %rdi
callq 0xd2d60
movq 0x8(%rsp), %rdi
movl $0x38, %esi
callq 0xd8620
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x34(%rsp), %ecx
subl 0x3c(%rsp), %ecx
addl $0x1, %ecx
movq 0x40(%rsp), %rax
movl %ecx, %ecx
sarq %cl, %rax
movq %rax, 0x40(%rsp)
movl 0x3c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x126be2
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenPattern::TokenPattern(bool)
TokenPattern::TokenPattern(bool tf)

{				// TRUE or FALSE pattern
  leftellipsis = false;
  rightellipsis = false;
  pattern = new InstructionPattern(tf);
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
movq %rdi, (%rsp)
callq 0xd7230
movq 0x8(%rsp), %rax
movb $0x0, 0x20(%rax)
movb $0x0, 0x21(%rax)
movl $0x10, %edi
callq 0xd8380
movq %rax, 0x10(%rsp)
jmp 0x127067
movq 0x10(%rsp), %rdi
movzbl 0x2f(%rsp), %esi
andl $0x1, %esi
callq 0xdbad0
jmp 0x12707b
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1270ba
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x10, %esi
callq 0xd8620
movq (%rsp), %rdi
callq 0xd88f0
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenPattern::TokenPattern(Token*)
TokenPattern::TokenPattern(Token *tok)

{
  leftellipsis = false;
  rightellipsis = false;
  pattern = new InstructionPattern(true);
  toklist.push_back(tok);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
movq %rdi, (%rsp)
callq 0xd7230
movq 0x8(%rsp), %rax
movb $0x0, 0x20(%rax)
movb $0x0, 0x21(%rax)
movl $0x10, %edi
callq 0xd8380
movq %rax, 0x10(%rsp)
jmp 0x127113
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xdbad0
jmp 0x127124
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x28(%rsp), %rsi
callq 0xdd590
jmp 0x127141
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x127173
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x10, %esi
callq 0xd8620
movq (%rsp), %rdi
callq 0xd88f0
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenPattern::TokenPattern(Token*, long, int, int)
TokenPattern::TokenPattern(Token *tok,intb value,int4 bitstart,int4 bitend)

{				// A basic instruction pattern

  toklist.push_back(tok);
  leftellipsis = false;
  rightellipsis = false;
  PatternBlock *block;

  if (tok->isBigEndian())
    block = buildBigBlock(tok->getSize(),bitstart,bitend,value);
  else
    block = buildLittleBlock(tok->getSize(),bitstart,bitend,value);
  pattern = new InstructionPattern(block);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movl %r8d, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x8, %rdi
movq %rdi, 0x38(%rsp)
callq 0xd7230
movq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xdd590
jmp 0x1271d5
movq 0x30(%rsp), %rax
movb $0x0, 0x20(%rax)
movb $0x0, 0x21(%rax)
movq 0x68(%rsp), %rdi
callq 0xdfd00
movb %al, 0x2f(%rsp)
jmp 0x1271f2
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x1271fc
jmp 0x127248
movq 0x68(%rsp), %rdi
callq 0xd9c90
movl %eax, 0x28(%rsp)
jmp 0x12720c
movl 0x28(%rsp), %edi
movl 0x5c(%rsp), %esi
movl 0x58(%rsp), %edx
movq 0x60(%rsp), %rcx
callq 0xdd470
movq %rax, 0x20(%rsp)
jmp 0x127229
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x12727f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1272d0
movq 0x68(%rsp), %rdi
callq 0xd9c90
movl %eax, 0x1c(%rsp)
jmp 0x127258
movl 0x1c(%rsp), %edi
movl 0x5c(%rsp), %esi
movl 0x58(%rsp), %edx
movq 0x60(%rsp), %rcx
callq 0xcf080
movq %rax, 0x10(%rsp)
jmp 0x127275
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x10, %edi
callq 0xd8380
movq %rax, 0x8(%rsp)
jmp 0x127290
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xd6d10
jmp 0x1272a1
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
addq $0x78, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movl $0x10, %esi
callq 0xd8620
movq 0x38(%rsp), %rdi
callq 0xd88f0
movq 0x50(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenPattern::TokenPattern(long, int, int)
TokenPattern::TokenPattern(intb value,int4 startbit,int4 endbit)

{				// A basic context pattern
  leftellipsis = false;
  rightellipsis = false;
  PatternBlock *block;
  int4 size = (endbit/8) + 1;

  block = buildBigBlock(size,size*8-1-endbit,size*8-1-startbit,value);
  pattern = new ContextPattern(block);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0xd7230
movq 0x10(%rsp), %rax
movb $0x0, 0x20(%rax)
movb $0x0, 0x21(%rax)
movl 0x40(%rsp), %eax
movl %eax, %ecx
addl $0x7, %ecx
testl %eax, %eax
cmovsl %ecx, %eax
sarl $0x3, %eax
incl %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %edi
movl %edi, %eax
leal -0x1(,%rax,8), %edx
movl 0x40(%rsp), %eax
movl %edx, %esi
subl %eax, %esi
movl 0x44(%rsp), %eax
subl %eax, %edx
movq 0x48(%rsp), %rcx
callq 0xdd470
movq %rax, 0x18(%rsp)
jmp 0x12736e
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x10, %edi
callq 0xd8380
movq %rax, (%rsp)
jmp 0x127388
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xde600
jmp 0x127398
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1273d5
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x10, %esi
callq 0xd8620
movq 0x8(%rsp), %rdi
callq 0xd88f0
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenPattern::TokenPattern(TokenPattern const&)
TokenPattern::TokenPattern(const TokenPattern &tokpat)

{
  pattern = tokpat.pattern->simplifyClone();
  toklist = tokpat.toklist;
  leftellipsis = tokpat.leftellipsis;
  rightellipsis = tokpat.rightellipsis;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0xd7230
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0x12742d
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rdi)
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0xdb420
jmp 0x12744d
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movb 0x20(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq 0x28(%rsp), %rcx
movb 0x21(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x21(%rax)
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xd88f0
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenPattern::operator=(TokenPattern const&)
const TokenPattern &TokenPattern::operator=(const TokenPattern &tokpat)

{
  delete pattern;

  pattern = tokpat.pattern->simplifyClone();
  toklist = tokpat.toklist;
  leftellipsis = tokpat.leftellipsis;
  rightellipsis = tokpat.rightellipsis;
  return *this;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1274d1
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0xdb420
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movb 0x20(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq 0x18(%rsp), %rcx
movb 0x21(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x21(%rax)
addq $0x28, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenPattern::doAnd(TokenPattern const&) const
TokenPattern TokenPattern::doAnd(const TokenPattern &tokpat) const

{				// Return -this- AND tokpat
  TokenPattern res((Pattern *)0);
  int4 sa = res.resolveTokens(*this,tokpat);

  res.pattern = pattern->doAnd(tokpat.pattern,sa);
  return res;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x3f(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xd13e0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xdf600
movl %eax, 0x28(%rsp)
jmp 0x127572
movq 0x20(%rsp), %rax
movl 0x28(%rsp), %ecx
movl %ecx, 0x38(%rsp)
movq (%rax), %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rsi
movl 0x38(%rsp), %edx
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movq %rax, 0x8(%rsp)
jmp 0x12759e
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x1275dd
jmp 0x1275d3
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xd2580
jmp 0x1275e7
movq 0x18(%rsp), %rdi
callq 0xd2580
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenPattern::doOr(TokenPattern const&) const
TokenPattern TokenPattern::doOr(const TokenPattern &tokpat) const

{				// Return -this- OR tokpat
  TokenPattern res((Pattern *)0);
  int4 sa = res.resolveTokens(*this,tokpat);

  res.pattern = pattern->doOr(tokpat.pattern,sa);
  return res;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x3f(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xd13e0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xdf600
movl %eax, 0x28(%rsp)
jmp 0x127652
movq 0x20(%rsp), %rax
movl 0x28(%rsp), %ecx
movl %ecx, 0x38(%rsp)
movq (%rax), %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rsi
movl 0x38(%rsp), %edx
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq %rax, 0x8(%rsp)
jmp 0x12767e
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x1276bd
jmp 0x1276b3
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xd2580
jmp 0x1276c7
movq 0x18(%rsp), %rdi
callq 0xd2580
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenPattern::getMinimumLength() const
int4 TokenPattern::getMinimumLength(void) const

{				// Add up length of concatenated tokens
  int4 length = 0;
  for(int4 i=0;i<toklist.size();++i)
    length += toklist[i]->getSize();
  return length;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xd41b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x128208
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movslq 0x18(%rsp), %rsi
callq 0xdc980
movq (%rax), %rdi
callq 0xd9c90
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1281b3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenField::TokenField(Token*, bool, int, int)
TokenField::TokenField(Token *tk,bool s,int4 bstart,int4 bend)

{
  tok = tk;
  bigendian = tok->isBigEndian();
  signbit = s;
  bitstart = bstart;
  bitend = bend;
  if (tk->isBigEndian()) {
    byteend = (tk->getSize()*8 - bitstart - 1)/8;
    bytestart = (tk->getSize()*8 - bitend - 1)/8;
  }
  else {
    bytestart = bitstart/8;
    byteend = bitend/8;
  }
  shift = bitstart % 8;
}

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movl %ecx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe2390
movq 0x10(%rsp), %rax
movq 0x9f4c6(%rip), %rcx     # 0x1c7fa0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0xdfd00
movb %al, 0x1b(%rsp)
jmp 0x128af9
movq 0x10(%rsp), %rax
movb 0x1b(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x18(%rax)
movb 0x37(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x19(%rax)
movl 0x30(%rsp), %ecx
movl %ecx, 0x1c(%rax)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x20(%rax)
movq 0x38(%rsp), %rdi
callq 0xdfd00
movb %al, 0xf(%rsp)
jmp 0x128b30
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x128b3d
jmp 0x128bc0
movq 0x38(%rsp), %rdi
callq 0xd9c90
movl %eax, 0x8(%rsp)
jmp 0x128b4d
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %edx
shll $0x3, %edx
movl 0x1c(%rax), %ecx
subl %ecx, %edx
movl %edx, %ecx
decl %ecx
addl $0x6, %edx
testl %ecx, %ecx
cmovsl %edx, %ecx
sarl $0x3, %ecx
movl %ecx, 0x28(%rax)
movq 0x38(%rsp), %rdi
callq 0xd9c90
movl %eax, 0x4(%rsp)
jmp 0x128b80
movq 0x10(%rsp), %rcx
movl 0x4(%rsp), %eax
shll $0x3, %eax
subl 0x20(%rcx), %eax
subl $0x1, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x24(%rax)
jmp 0x128bef
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xdd8e0
jmp 0x128c0c
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x24(%rax)
movl 0x20(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movq 0x10(%rsp), %rax
movl %edx, 0x2c(%rax)
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: TokenField::getValue(ParserWalker&) const
intb TokenField::getValue(ParserWalker &walker) const

{				// Construct value given specific instruction stream
  intb res = getInstructionBytes(walker,bytestart,byteend,bigendian);
  
  res >>= shift;
  if (signbit)
    sign_extend(res,bitend-bitstart);
  else
    zero_extend(res,bitend-bitstart);
  return res;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rax), %esi
movl 0x28(%rax), %edx
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x128cb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movl 0x2c(%rax), %ecx
movq 0x10(%rsp), %rdx
movl %ecx, %ecx
sarq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x10(%rsp)
testb $0x1, 0x19(%rax)
je 0x128c8f
movq 0x8(%rsp), %rax
movl 0x20(%rax), %esi
subl 0x1c(%rax), %esi
leaq 0x10(%rsp), %rdi
callq 0xd74e0
jmp 0x128ca4
movq 0x8(%rsp), %rax
movl 0x20(%rax), %esi
subl 0x1c(%rax), %esi
leaq 0x10(%rsp), %rdi
callq 0xdfa80
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slghpatexpress.cc
// Function: getInstructionBytes(ParserWalker&, int, int, bool)
static intb getInstructionBytes(ParserWalker &walker,int4 bytestart,int4 byteend,bool bigendian)

{				// Build a intb from the instruction bytes
  intb res = 0;
  uintm tmp;
  int4 size,tmpsize;

  size = byteend-bytestart+1;
  tmpsize = size;
  while(tmpsize >= sizeof(uintm)) {
    tmp = walker.getInstructionBytes(bytestart,sizeof(uintm));
    res <<= 8*sizeof(uintm);
    res |= tmp;
    bytestart += sizeof(uintm);
    tmpsize -= sizeof(uintm);
  }
  if (tmpsize > 0) {
    tmp = walker.getInstructionBytes(bytestart,tmpsize);
    res <<= 8*tmpsize;
    res |= tmp;
  }
  if (!bigendian)
    byte_swap(res,size);
  return res;
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq $0x0, 0x18(%rsp)
movl 0x28(%rsp), %eax
subl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rax
cmpq $0x4, %rax
jb 0x128d43
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl $0x4, %edx
callq 0xd6420
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
shlq $0x20, %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
orq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movslq 0x2c(%rsp), %rax
addq $0x4, %rax
movl %eax, 0x2c(%rsp)
movslq 0xc(%rsp), %rax
subq $0x4, %rax
movl %eax, 0xc(%rsp)
jmp 0x128ce9
cmpl $0x0, 0xc(%rsp)
jle 0x128d84
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0xd6420
movl %eax, 0x14(%rsp)
movl 0xc(%rsp), %ecx
shll $0x3, %ecx
movq 0x18(%rsp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
orq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x128d99
movl 0x10(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0xdc050
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)