LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: DecisionNode::~DecisionNode()
DecisionNode::~DecisionNode(void)

{				// We own sub nodes
  vector<DecisionNode *>::iterator iter;
  for(iter=children.begin();iter!=children.end();++iter)
    delete *iter;
  vector<pair<DisjointPattern *,Constructor *> >::iterator piter;
  for(piter=list.begin();piter!=list.end();++piter)
    delete (*piter).first;	// Delete the patterns
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd83d0
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0xdd5d0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0xd9e30
movq %rax, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd6810
testb $0x1, %al
jne 0x14af82
jmp 0x14afc1
leaq 0x48(%rsp), %rdi
callq 0xdca20
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x14afb3
movq 0x10(%rsp), %rdi
callq 0xce050
movq 0x10(%rsp), %rdi
movl $0x48, %esi
callq 0xd8620
jmp 0x14afb5
leaq 0x48(%rsp), %rdi
callq 0xd5120
jmp 0x14af5a
leaq 0x30(%rsp), %rdi
callq 0xdaf90
movq 0x18(%rsp), %rdi
callq 0xd24f0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rdi
callq 0xdb220
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xdb430
testb $0x1, %al
jne 0x14b008
jmp 0x14b039
leaq 0x30(%rsp), %rdi
callq 0xce2e0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x14b02b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x14b02d
leaq 0x30(%rsp), %rdi
callq 0xd7e10
jmp 0x14afe4
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0xdcdb0
movq 0x18(%rsp), %rdi
callq 0xdfb60
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: DecisionNode::getMaximumLength(bool)
int4 DecisionNode::getMaximumLength(bool context)

{				// Get maximum length of instruction pattern in bytes
  int4 max = 0;
  int4 val,i;

  for(i=0;i<list.size();++i) {
    val = list[i].first->getLength(context);
    if (val > max)
      max = val;
  }
  return max;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0xd5590
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x14b0f0
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0xd9cd0
movq (%rax), %rdi
movb 0x1f(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xd7730
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jle 0x14b0e1
movl 0x14(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0x14b0e3
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x14b08c
movl 0x18(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: DecisionNode::getNumFixed(int, int, bool)
int4 DecisionNode::getNumFixed(int4 low,int4 size,bool context)

{				// Get number of patterns that specify this field
  int4 count = 0;
  uintm mask;
				// Bits which must be specified in the mask
  uintm m = (size==8*sizeof(uintm)) ? 0 : (((uintm)1)<<size);
  m = m-1;

  for(int4 i=0;i<list.size();++i) {
    mask = list[i].first->getMask(low,size,context);
    if ((mask&m)==m)
      count += 1;
  }
  return count;
}

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
movslq 0x38(%rsp), %rax
cmpq $0x20, %rax
jne 0x14b13e
xorl %eax, %eax
movl %eax, 0x14(%rsp)
jmp 0x14b14d
movl 0x38(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xd5590
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x14b1dd
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xd9cd0
movq (%rax), %rdi
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movb 0x37(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xe1bf0
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
andl 0x28(%rsp), %eax
cmpl 0x28(%rsp), %eax
jne 0x14b1ce
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x14b1d0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x14b168
movl 0x30(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: DecisionNode::consistentValues(std::vector<unsigned int, std::allocator<unsigned int>>&, DisjointPattern*)
void DecisionNode::consistentValues(vector<uint4> &bins,DisjointPattern *pat)

{				// Produce all possible values of -pat- by
				// iterating through all possible values of the
				// "don't care" bits within the value of -pat-
				// that intersects with this node (startbit,bitsize,context)
  uintm m = (bitsize==8*sizeof(uintm)) ? 0 : (((uintm)1)<<bitsize);
  m = m-1;
  uintm commonMask = m & pat->getMask(startbit,bitsize,contextdecision);
  uintm commonValue = commonMask & pat->getValue(startbit,bitsize,contextdecision);
  uintm dontCareMask = m^commonMask;

  for(uintm i=0;i<=dontCareMask;++i) { // Iterate over values that contain all don't care bits
    if ((i&dontCareMask)!=i) continue; // If all 1 bits in the value are don't cares
    bins.push_back( commonValue | i ); // add 1 bits into full value and store
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0x3c(%rax), %rax
cmpq $0x20, %rax
jne 0x14b85f
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x14b872
movq 0x10(%rsp), %rax
movl 0x3c(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x2c(%rsp)
movl 0x2c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, 0x2c(%rsp)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movl 0x38(%rax), %esi
movl 0x3c(%rax), %edx
movb 0x34(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xe1bf0
movl 0x4(%rsp), %ecx
movl %eax, %edx
movq 0x10(%rsp), %rax
andl %edx, %ecx
movl %ecx, 0x28(%rsp)
movl 0x28(%rsp), %ecx
movl %ecx, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x38(%rax), %esi
movl 0x3c(%rax), %edx
movb 0x34(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xda0f0
movl %eax, %ecx
movl 0x8(%rsp), %eax
andl %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x2c(%rsp), %eax
xorl 0x28(%rsp), %eax
movl %eax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
ja 0x14b93d
movl 0x1c(%rsp), %eax
andl 0x20(%rsp), %eax
cmpl 0x1c(%rsp), %eax
je 0x14b915
jmp 0x14b930
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %eax
orl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0xd0e90
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x14b8fb
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: calc_maskword(int, int, int&, int&, unsigned int&)
static void calc_maskword(int4 sbit,int4 ebit,int4 &num,int4 &shift,uintm &mask)

{
  num = sbit/(8*sizeof(uintm));
  if ( num != ebit/(8*sizeof(uintm)))
    throw SleighError("Context field not contained within one machine int");
  sbit -= num*8*sizeof(uintm);
  ebit -= num*8*sizeof(uintm);

  shift = 8*sizeof(uintm)-ebit-1;
  mask = (~((uintm)0))>>(sbit+shift);
  mask <<= shift;
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movl %esi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movslq 0x64(%rsp), %rax
shrq $0x5, %rax
movl %eax, %ecx
movq 0x58(%rsp), %rax
movl %ecx, (%rax)
movq 0x58(%rsp), %rax
movslq (%rax), %rax
movslq 0x60(%rsp), %rcx
shrq $0x5, %rcx
cmpq %rcx, %rax
je 0x14c3eb
movb $0x1, 0x13(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x3d325(%rip), %rsi     # 0x18968a
leaq 0x28(%rsp), %rdi
callq 0xe00a0
jmp 0x14c371
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd06e0
jmp 0x14c381
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
movq 0x7bad7(%rip), %rsi     # 0x1c7e68
movq 0x7b688(%rip), %rdx     # 0x1c7a20
callq 0xe01f0
jmp 0x14c47d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x14c3ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd4550
leaq 0x27(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x13(%rsp)
jne 0x14c3dd
jmp 0x14c3e6
movq (%rsp), %rdi
callq 0xd5400
jmp 0x14c473
movq 0x58(%rsp), %rax
movl (%rax), %eax
shll $0x3, %eax
movslq %eax, %rcx
shlq $0x2, %rcx
movslq 0x64(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x64(%rsp)
movq 0x58(%rsp), %rax
movl (%rax), %eax
shll $0x3, %eax
movslq %eax, %rcx
shlq $0x2, %rcx
movslq 0x60(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x60(%rsp)
movslq 0x60(%rsp), %rcx
movl $0x20, %eax
subq %rcx, %rax
subq $0x1, %rax
movl %eax, %ecx
movq 0x50(%rsp), %rax
movl %ecx, (%rax)
movl 0x64(%rsp), %ecx
movq 0x50(%rsp), %rax
addl (%rax), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shrl %cl, %eax
movl %eax, %ecx
movq 0x48(%rsp), %rax
movl %ecx, (%rax)
movq 0x50(%rsp), %rax
movl (%rax), %ecx
movq 0x48(%rsp), %rax
movl (%rax), %edx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, (%rax)
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextOp::validate() const
void ContextOp::validate(void) const

{ // Throw an exception if the PatternExpression is not valid
  vector<const PatternValue *> values;

  patexp->listValues(values);	// Get all the expression tokens
  for(int4 i=0;i<values.size();++i) {
    const OperandValue *val = dynamic_cast<const OperandValue *>(values[i]);
    if (val == (const OperandValue *)0) continue;
    // Certain operands cannot be used in context expressions
    // because these are evaluated BEFORE the operand offset
    // has been recovered. If the offset is not relative to
    // the base constructor, then we throw an error
    if (!val->isConstructorRelative())
      throw SleighError(val->getName()+": cannot be used in context expression");
  }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x88(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0xe17a0
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rsi
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x14c537
movl $0x0, 0x78(%rsp)
movslq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xe2120
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jae 0x14c6c3
movslq 0x78(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0xcfee0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x14c5c0
movq 0x28(%rsp), %rdi
movq 0x7b9f5(%rip), %rsi     # 0x1c7f88
movq 0x7b6d6(%rip), %rdx     # 0x1c7c70
xorl %eax, %eax
movl %eax, %ecx
callq 0xd99a0
movq %rax, 0x20(%rsp)
jmp 0x14c5c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x14c6d8
xorl %eax, %eax
movq %rax, 0x20(%rsp)
jmp 0x14c5c9
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0x14c5e0
jmp 0x14c6b3
movq 0x70(%rsp), %rdi
callq 0xd2e20
movb %al, 0x1f(%rsp)
jmp 0x14c5f0
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x14c6b1
jmp 0x14c5fe
movb $0x1, 0x4f(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
callq 0xde340
movq %rax, 0x10(%rsp)
jmp 0x14c623
movq 0x10(%rsp), %rsi
leaq 0x3cffb(%rip), %rdx     # 0x18962a
leaq 0x50(%rsp), %rdi
callq 0xdb370
jmp 0x14c63b
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xd06e0
jmp 0x14c64c
movq 0x8(%rsp), %rdi
movb $0x0, 0x4f(%rsp)
movq 0x7b80b(%rip), %rsi     # 0x1c7e68
movq 0x7b3bc(%rip), %rdx     # 0x1c7a20
callq 0xe01f0
jmp 0x14c6f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x14c69c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x4f(%rsp)
jne 0x14c6a5
jmp 0x14c6af
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x14c6d8
jmp 0x14c6b3
movl 0x78(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x78(%rsp)
jmp 0x14c53f
leaq 0x88(%rsp), %rdi
callq 0xd3b20
addq $0xa8, %rsp
retq
leaq 0x88(%rsp), %rdi
callq 0xd3b20
movq 0x80(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextOp::saveXml(std::ostream&) const
void ContextOp::saveXml(ostream &s) const

{
  s << "<context_op";
  s << " i=\"" << dec << num << "\"";
  s << " shift=\"" << shift << "\"";
  s << " mask=\"0x" << hex << mask << "\" >\n";
  patexp->saveXml(s);
  s << "</context_op>\n";
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x3cf2e(%rip), %rsi     # 0x189651
callq 0xd8300
movq 0x8(%rsp), %rdi
leaq 0x3cf29(%rip), %rsi     # 0x18965d
callq 0xd8300
movq %rax, %rdi
movq 0x7b655(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movq (%rsp), %rax
movl 0x10(%rax), %esi
callq 0xe03e0
movq %rax, %rdi
leaq 0x3cd2b(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x8(%rsp), %rdi
leaq 0x3c0a1(%rip), %rsi     # 0x188813
callq 0xd8300
movq %rax, %rdi
movq (%rsp), %rax
movl 0x18(%rax), %esi
callq 0xe03e0
movq %rax, %rdi
leaq 0x3ccfc(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x8(%rsp), %rdi
leaq 0x3cec1(%rip), %rsi     # 0x189662
callq 0xd8300
movq %rax, %rdi
movq 0x7b818(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rdi
movq (%rsp), %rax
movl 0x14(%rax), %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x3ce9e(%rip), %rsi     # 0x18966c
callq 0xd8300
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x8(%rsp), %rdi
leaq 0x3ce7f(%rip), %rsi     # 0x189671
callq 0xd8300
addq $0x18, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextOp::clone() const
ContextChange *ContextOp::clone(void) const

{
  ContextOp *res = new ContextOp();
  (res->patexp = patexp)->layClaim();
  res->mask = mask;
  res->num = num;
  res->shift = shift;
  return res;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x20, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0xdc080
jmp 0x14cd4f
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rax
movq %rdi, 0x8(%rax)
callq 0xd99b0
movq 0x8(%rsp), %rax
movl 0x14(%rax), %edx
movq 0x28(%rsp), %rcx
movl %edx, 0x14(%rcx)
movl 0x10(%rax), %edx
movq 0x28(%rsp), %rcx
movl %edx, 0x10(%rcx)
movl 0x18(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x20, %esi
callq 0xd8620
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextCommit::ContextCommit(TripleSymbol*, int, int, bool)
ContextCommit::ContextCommit(TripleSymbol *s,int4 sbit,int4 ebit,bool fl)

{
  sym = s;
  flow = fl;

  int4 shift;
  calc_maskword(sbit,ebit,num,shift,mask);
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xda790
movq (%rsp), %r8
movq 0x7ad28(%rip), %rax     # 0x1c7b30
addq $0x10, %rax
movq %rax, (%r8)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%r8)
movb 0x1f(%rsp), %al
andb $0x1, %al
movb %al, 0x18(%r8)
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
movq %r8, %rdx
addq $0x10, %rdx
addq $0x14, %r8
leaq 0x18(%rsp), %rcx
callq 0x14c2f0
jmp 0x14ce41
addq $0x38, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
callq 0xda6f0
movq 0x10(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextCommit::clone() const
ContextChange *ContextCommit::clone(void) const

{
  ContextCommit *res = new ContextCommit();
  res->sym = sym;
  res->flow = flow;
  res->mask = mask;
  res->num = num;
  return res;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x20, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0xdd530
jmp 0x14d84f
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rdx
movq 0x28(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movb 0x18(%rax), %dl
movq 0x28(%rsp), %rcx
andb $0x1, %dl
movb %dl, 0x18(%rcx)
movl 0x14(%rax), %edx
movq 0x28(%rsp), %rcx
movl %edx, 0x14(%rcx)
movl 0x10(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x20, %esi
callq 0xd8620
movq 0x20(%rsp), %rdi
callq 0xe0be0
// File: jstaursky[P]hutch/src/Sleigh/loadimage.cc
// Function: LoadImage::load(int, Address const&)
uint1 *LoadImage::load(int4 size,const Address &addr)

{
  uint1 *buf = new uint1[ size ];
  if (buf == (uint1 *)0)
    throw LowlevelError("Out of memory");
  loadFill(buf,size,addr);
  return buf;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movslq 0x6c(%rsp), %rdi
callq 0xce140
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x15db19
movb $0x1, 0x23(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x2bdfe(%rip), %rsi     # 0x189894
leaq 0x38(%rsp), %rdi
callq 0xe00a0
jmp 0x15daa2
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd1ae0
jmp 0x15dab3
movq 0x8(%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0x6a3cc(%rip), %rsi     # 0x1c7e90
movq 0x6a105(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x15db46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x15dafa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4550
leaq 0x37(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x23(%rsp)
jne 0x15db0d
jmp 0x15db17
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x15db3c
movq 0x18(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x6c(%rsp), %edx
movq 0x60(%rsp), %rcx
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x58(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/loadimage.cc
// Function: RawLoadImage::RawLoadImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
RawLoadImage::RawLoadImage(const string &f) : LoadImage(f)

{
  vma = 0;
  thefile = (ifstream *)0;
  spaceid = (AddrSpace *)0;
  filesize = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0xe2b70
movq (%rsp), %rax
movq 0x6a214(%rip), %rcx     # 0x1c7d90
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x38(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/loadimage.cc
// Function: RawLoadImage::open()
void RawLoadImage::open(void)

{
  if (thefile != (ifstream *)0) throw LowlevelError("loadimage is already open");
  thefile = new ifstream(filename.c_str());
  if (!(*thefile)) {
    string errmsg = "Unable to open raw image file: "+filename;
    throw LowlevelError(errmsg);
  }
  thefile->seekg(0,ios::end);
  filesize = thefile->tellg();
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rax)
je 0x15dd38
movb $0x1, 0x6b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x20(%rsp)
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xe0c80
movq 0x28(%rsp), %rdx
leaq 0x2bbfc(%rip), %rsi     # 0x1898a2
leaq 0x80(%rsp), %rdi
callq 0xe00a0
jmp 0x15dcb5
movq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xd1ae0
jmp 0x15dcc9
movq 0x20(%rsp), %rdi
movb $0x0, 0x6b(%rsp)
movq 0x6a1b6(%rip), %rsi     # 0x1c7e90
movq 0x69eef(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x15de9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x15dd16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xd4550
leaq 0x7f(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x6b(%rsp)
jne 0x15dd29
jmp 0x15dd33
movq 0x20(%rsp), %rdi
callq 0xd5400
jmp 0x15de93
movl $0x208, %edi            # imm = 0x208
callq 0xd8380
movq 0x30(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0xd1d80
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0xe17f0
jmp 0x15dd6e
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0xd2470
testb $0x1, %al
jne 0x15dd95
jmp 0x15de46
movq 0x30(%rsp), %rdx
addq $0x8, %rdx
leaq 0x2bb17(%rip), %rsi     # 0x1898bc
leaq 0x48(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd7370
movl $0x20, %edi
callq 0xd2b40
movq (%rsp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0xd1ae0
jmp 0x15ddd3
movq 0x8(%rsp), %rdi
movq 0x6a0b1(%rip), %rsi     # 0x1c7e90
movq 0x69dea(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x15de9d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
movl $0x208, %esi            # imm = 0x208
callq 0xd8620
jmp 0x15de93
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0xd5400
jmp 0x15de3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd4550
jmp 0x15de93
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xdbeb0
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0xe0440
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd3e70
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x38(%rax)
addq $0xa8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: BreakTableCallBack::registerPcodeCallback(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BreakCallBack*)
void BreakTableCallBack::registerPcodeCallback(const string &name,BreakCallBack *func)

{
  func->setEmulate(emulate);
  vector<string> userops;
  trans->getUserOpNames(userops);
  for(int4 i=0;i<userops.size();++i) {
    if (userops[i] == name) {
      pcodecallback[(uintb)i] = func;
      return;
    }
  }
  throw LowlevelError("Bad userop name: "+name);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x90(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0xceb60
leaq 0x78(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xe0e60
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rsi
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
jmp 0x15e425
movl $0x0, 0x68(%rsp)
movslq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xe1670
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x15e4ec
movslq 0x68(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0xe1770
movq %rax, %rdi
movq 0x98(%rsp), %rsi
callq 0xd3cf0
testb $0x1, %al
jne 0x15e477
jmp 0x15e4da
movq 0x28(%rsp), %rdi
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x48, %rdi
movslq 0x68(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0xe0a20
movq %rax, 0x18(%rsp)
jmp 0x15e4a8
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x78(%rsp), %rdi
callq 0xd5480
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x15e588
jmp 0x15e4dc
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x15e42d
movb $0x1, 0x3f(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
movq 0x98(%rsp), %rdx
leaq 0x2b56f(%rip), %rsi     # 0x189a7e
leaq 0x40(%rsp), %rdi
callq 0xd7370
jmp 0x15e51b
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd1ae0
jmp 0x15e52c
movq 0x8(%rsp), %rdi
movb $0x0, 0x3f(%rsp)
movq 0x69953(%rip), %rsi     # 0x1c7e90
movq 0x6968c(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x15e59c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x15e573
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x3f(%rsp)
jne 0x15e57c
jmp 0x15e586
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x15e588
leaq 0x78(%rsp), %rdi
callq 0xd5480
movq 0x70(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: BreakTableCallBack::setEmulate(Emulate*)
void BreakTableCallBack::setEmulate(Emulate *emu)

{ // Make sure all callbbacks are aware of new emulator
  emulate = emu;
  map<Address,BreakCallBack *>::iterator iter1;

  for(iter1=addresscallback.begin();iter1!=addresscallback.end();++iter1)
    (*iter1).second->setEmulate(emu);

  map<uintb,BreakCallBack *>::iterator iter2;


  for(iter2=pcodecallback.begin();iter2!=pcodecallback.end();++iter2)
    (*iter2).second->setEmulate(emu);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rax)
leaq 0x30(%rsp), %rdi
callq 0xd5050
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0xd4770
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0xd0a50
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd8180
testb $0x1, %al
jne 0x15e66d
jmp 0x15e691
leaq 0x30(%rsp), %rdi
callq 0xd5d60
movq 0x10(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0xceb60
leaq 0x30(%rsp), %rdi
callq 0xd30c0
jmp 0x15e646
leaq 0x18(%rsp), %rdi
callq 0xe0b10
movq (%rsp), %rdi
addq $0x48, %rdi
callq 0xd81e0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
addq $0x48, %rdi
callq 0xd9850
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xd9d00
testb $0x1, %al
jne 0x15e6de
jmp 0x15e702
leaq 0x18(%rsp), %rdi
callq 0xd51b0
movq 0x8(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0xceb60
leaq 0x18(%rsp), %rdi
callq 0xd0e70
jmp 0x15e6b7
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: BreakTableCallBack::doPcodeOpBreak(PcodeOpRaw*)
bool BreakTableCallBack::doPcodeOpBreak(PcodeOpRaw *curop)

{
  uintb val = curop->getInput(0)->offset;
  map<uintb,BreakCallBack *>::const_iterator iter;

  iter = pcodecallback.find(val);
  if (iter == pcodecallback.end()) return false;
  return (*iter).second->pcodeCallback(curop);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0xd9f00
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd0ec0
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
leaq 0x38(%rsp), %rsi
callq 0xdbcb0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd1a40
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0x48, %rdi
callq 0xd9850
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd1a40
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd23e0
testb $0x1, %al
jne 0x15e7af
jmp 0x15e7b6
movb $0x0, 0x57(%rsp)
jmp 0x15e7d5
leaq 0x30(%rsp), %rdi
callq 0xd8760
movq 0x8(%rax), %rdi
movq 0x40(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: BreakTableCallBack::doAddressBreak(Address const&)
bool BreakTableCallBack::doAddressBreak(const Address &addr)

{
  map<Address,BreakCallBack *>::const_iterator iter;
  
  iter = addresscallback.find(addr);
  if (iter == addresscallback.end()) return false;
  return (*iter).second->addressCallback(addr);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0xdc770
movq (%rsp), %rdi
addq $0x18, %rdi
movq 0x30(%rsp), %rsi
callq 0xd2f20
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xe17b0
movq (%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x18, %rdi
callq 0xd0a50
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe17b0
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xddbf0
testb $0x1, %al
jne 0x15e867
jmp 0x15e86e
movb $0x0, 0x47(%rsp)
jmp 0x15e88d
leaq 0x28(%rsp), %rdi
callq 0xd2570
movq 0x10(%rax), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: PcodeEmitCache::createVarnode(VarnodeData const*)
VarnodeData *PcodeEmitCache::createVarnode(const VarnodeData *var)

{
  VarnodeData *res = new VarnodeData();
  *res = *var;
  varcache.push_back(res);
  return res;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x18, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0xd36e0
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq (%rdx), %rsi
movq %rsi, (%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%rcx)
movq 0x10(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0xde110
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: PcodeEmitCache::dump(Address const&, OpCode, VarnodeData*, VarnodeData*, int)
void PcodeEmitCache::dump(const Address &addr,OpCode opc,VarnodeData *outvar,VarnodeData *vars,int4 isize)

{
  PcodeOpRaw *op = new PcodeOpRaw();
  op->setSeqNum(addr,uniq);
  opcache.push_back(op);
  op->setBehavior( inst[opc] );
  uniq += 1;
  if (outvar != (VarnodeData *)0) {
    VarnodeData *outvn = createVarnode(outvar);
    op->setOutput(outvn);
  }
  for(int4 i=0;i<isize;++i) {
    VarnodeData *invn = createVarnode(vars+i);
    op->addInput(invn);
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movl %r9d, 0x4c(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x40, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0xdb090
jmp 0x15e9e9
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq 0x68(%rsp), %rsi
movl 0x20(%rax), %edx
callq 0xdfa50
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x40(%rsp), %rsi
callq 0xe1a90
movq 0x8(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x18(%rax), %rdi
movl 0x64(%rsp), %eax
movl %eax, %esi
callq 0xcf710
movq (%rsp), %rdi
movq (%rax), %rsi
callq 0xd4d90
movq 0x8(%rsp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
cmpq $0x0, 0x58(%rsp)
je 0x15eaa0
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xda530
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xd6fd0
jmp 0x15eaa0
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x40, %esi
callq 0xd8620
jmp 0x15eaf3
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x15eaee
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
movslq 0x24(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0xda530
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd7320
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x15eaa8
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulateMemory::executeUnary()
void EmulateMemory::executeUnary(void)

{
  uintb in1 = memstate->getValue(currentOp->getInput(0));
  uintb out = currentBehave->evaluateUnary(currentOp->getOutput()->size,
					   currentOp->getInput(0)->size,in1);
  memstate->setValue(currentOp->getOutput(),out);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0xd9f00
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xcec10
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x20(%rax), %rdi
callq 0xdff40
movq %rax, %rcx
movq 0x20(%rsp), %rax
movl 0x10(%rcx), %ecx
movl %ecx, 0x1c(%rsp)
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0xd9f00
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x10(%rax), %edx
movq 0x38(%rsp), %rcx
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x20(%rax), %rdi
callq 0xdff40
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rdx
callq 0xd39e0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulateMemory::executeBinary()
void EmulateMemory::executeBinary(void)

{
  uintb in1 = memstate->getValue(currentOp->getInput(0));
  uintb in2 = memstate->getValue(currentOp->getInput(1));
  uintb out = currentBehave->evaluateBinary(currentOp->getOutput()->size,
					    currentOp->getInput(0)->size,in1,in2);
  memstate->setValue(currentOp->getOutput(),out);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0xd9f00
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xcec10
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x20(%rax), %rdi
movl $0x1, %esi
callq 0xd9f00
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xcec10
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x40(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x20(%rax), %rdi
callq 0xdff40
movq %rax, %rcx
movq 0x28(%rsp), %rax
movl 0x10(%rcx), %ecx
movl %ecx, 0x24(%rsp)
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0xd9f00
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x10(%rax), %edx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x20(%rax), %rdi
callq 0xdff40
movq 0x30(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
callq 0xd39e0
addq $0x58, %rsp
retq
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulateMemory::executeLoad()
void EmulateMemory::executeLoad(void)

{
  uintb off = memstate->getValue(currentOp->getInput(1));
  AddrSpace *spc = Address::getSpaceFromConst(currentOp->getInput(0)->getAddr());

  off = AddrSpace::addressToByte(off,spc->getWordSize());
  uintb res = memstate->getValue(spc,off,currentOp->getOutput()->size);
  memstate->setValue(currentOp->getOutput(),res);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, (%rsp)
movq 0x20(%rax), %rdi
movl $0x1, %esi
callq 0xd9f00
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xcec10
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x58(%rsp)
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0xd9f00
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0xd9250
leaq 0x40(%rsp), %rdi
callq 0xd29e0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0xde1c0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0xe2550
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x58(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x58(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x20(%rax), %rdi
callq 0xdff40
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movl 0x10(%rax), %ecx
callq 0xd1b50
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x20(%rax), %rdi
callq 0xdff40
movq 0x30(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
callq 0xd39e0
addq $0x68, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulateMemory::executeStore()
void EmulateMemory::executeStore(void)

{
  uintb val = memstate->getValue(currentOp->getInput(2)); // Value being stored
  uintb off = memstate->getValue(currentOp->getInput(1)); // Offset to store at
  AddrSpace *spc = Address::getSpaceFromConst(currentOp->getInput(0)->getAddr()); // Space to store in

  off = AddrSpace::addressToByte(off,spc->getWordSize());
  memstate->setValue(spc,off,currentOp->getInput(2)->size,val);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, (%rsp)
movq 0x20(%rax), %rdi
movl $0x2, %esi
callq 0xd9f00
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xcec10
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x58(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x20(%rax), %rdi
movl $0x1, %esi
callq 0xd9f00
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xcec10
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0xd9f00
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0xd9250
leaq 0x38(%rsp), %rdi
callq 0xd29e0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0xde1c0
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0xe2550
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movq 0x20(%rax), %rdi
movl $0x2, %esi
callq 0xd9f00
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl 0x10(%rax), %ecx
movq 0x58(%rsp), %r8
callq 0xe1810
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::EmulatePcodeCache(Translate*, MemoryState*, BreakTable*)
EmulatePcodeCache::EmulatePcodeCache(Translate *t,MemoryState *s,BreakTable *b)
  : EmulateMemory(s)
{
  trans = t;
  OpBehavior::registerInstructions(inst,t);
  breaktable = b;
  breaktable->setEmulate(this);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x40(%rsp), %rsi
callq 0xd4c00
movq 0x20(%rsp), %rdi
movq 0x68198(%rip), %rax     # 0x1c7a50
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x30, %rdi
movq %rdi, 0x8(%rsp)
callq 0xd8e30
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x10(%rsp)
callq 0xd6d70
movq 0x20(%rsp), %rdi
addq $0x60, %rdi
movq %rdi, 0x18(%rsp)
callq 0xdaca0
movq 0x20(%rsp), %rdi
subq $-0x80, %rdi
callq 0xe1dc0
jmp 0x15f903
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rdi)
addq $0x60, %rdi
movq 0x48(%rsp), %rsi
callq 0xe3090
jmp 0x15f921
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rax
movq %rax, 0x78(%rsi)
movq 0x78(%rsi), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x15f93e
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xe1df0
movq 0x10(%rsp), %rdi
callq 0xdcb20
movq 0x8(%rsp), %rdi
callq 0xe2460
movq 0x20(%rsp), %rdi
callq 0xdc030
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::clearCache()
void EmulatePcodeCache::clearCache(void)

{
  for(int4 i=0;i<opcache.size();++i)
    delete opcache[i];
  for(int4 i=0;i<varcache.size();++i)
    delete varcache[i];
  opcache.clear();
  varcache.clear();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x30, %rdi
callq 0xd8690
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x15fa19
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xd75a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x15fa0a
movq 0x10(%rsp), %rdi
callq 0xe1f20
movq 0x10(%rsp), %rdi
movl $0x40, %esi
callq 0xd8620
jmp 0x15fa0c
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x15f9ab
movl $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x48, %rdi
callq 0xd77b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x15fa83
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movslq 0x28(%rsp), %rsi
callq 0xd59b0
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x15fa74
movq (%rsp), %rdi
movl $0x18, %esi
callq 0xd8620
jmp 0x15fa76
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x15fa21
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
callq 0xcf2f0
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
callq 0xd8d70
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::~EmulatePcodeCache()
EmulatePcodeCache::~EmulatePcodeCache(void)

{
  clearCache();
  for(int4 i=0;i<inst.size();++i) {
    OpBehavior *t_op = inst[i];
    if (t_op != (OpBehavior *)0)
      delete t_op;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x67f86(%rip), %rax     # 0x1c7a50
addq $0x10, %rax
movq %rax, (%rdi)
callq 0xd1280
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x60, %rdi
callq 0xe30c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x15fb52
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xd90a0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x15fb43
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x15fb41
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x15fb43
jmp 0x15fb45
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x15fade
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
callq 0xe1df0
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
callq 0xdcb20
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
callq 0xe2460
movq 0x18(%rsp), %rdi
callq 0xdc030
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::createInstruction(Address const&)
void EmulatePcodeCache::createInstruction(const Address &addr)

{
  clearCache();
  PcodeEmitCache emit(opcache,varcache,inst,0);
  instruction_length = trans->oneInstruction(emit,addr);
  current_op = 0;
  instruction_start = true;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd1280
movq (%rsp), %rcx
movq %rcx, %rsi
addq $0x30, %rsi
movq %rcx, %rdx
addq $0x48, %rdx
addq $0x60, %rcx
xorl %eax, %eax
movl %eax, %r8d
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xdfa60
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
movq 0x28(%rax), %rdi
movq 0x48(%rsp), %rdx
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
movl %eax, 0x10(%rsp)
jmp 0x15fc27
movq (%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, 0x98(%rax)
movl $0x0, 0x94(%rax)
movb $0x1, 0x90(%rax)
leaq 0x20(%rsp), %rdi
callq 0xd1440
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd1440
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::establishOp()
void EmulatePcodeCache::establishOp(void)

{
  if (current_op < opcache.size()) {
    currentOp = opcache[current_op];
    currentBehave = currentOp->getBehavior();
    return;
  }
  currentOp = (PcodeOpRaw *)0;
  currentBehave = (OpBehavior *)0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movslq 0x94(%rdi), %rax
movq %rax, 0x8(%rsp)
addq $0x30, %rdi
callq 0xd8690
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x15fcef
movq (%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movslq 0x94(%rax), %rsi
callq 0xd75a0
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rdi
callq 0xd2f80
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x15fd03
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, 0x10(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::fallthruOp()
void EmulatePcodeCache::fallthruOp(void)

{
  instruction_start = false;
  current_op += 1;
  if (current_op >= opcache.size()) {
    current_address = current_address + instruction_length;
    createInstruction(current_address);
  }
  establishOp();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movb $0x0, 0x90(%rdi)
movl 0x94(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x94(%rdi)
movslq 0x94(%rdi), %rax
movq %rax, 0x8(%rsp)
addq $0x30, %rdi
callq 0xd8690
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x15fda0
movq (%rsp), %rax
movq %rax, %rsi
addq $0x80, %rsi
movl 0x98(%rax), %edx
leaq 0x10(%rsp), %rdi
callq 0xd8150
movq (%rsp), %rdi
addq $0x80, %rdi
leaq 0x10(%rsp), %rsi
callq 0xdafc0
movq (%rsp), %rdi
movq %rdi, %rsi
addq $0x80, %rsi
callq 0xd73a0
movq (%rsp), %rdi
callq 0xd8bf0
addq $0x28, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::executeBranch()
void EmulatePcodeCache::executeBranch(void)

{
  const Address &destaddr( currentOp->getInput(0)->getAddr() );
  if (destaddr.isConstant()) {
    uintm id = destaddr.getOffset();
    id = id + (uintm)current_op;
    current_op = id;
    if (current_op == opcache.size())
      fallthruOp();
    else if ((current_op < 0)||(current_op >= opcache.size()))
      throw LowlevelError("Bad intra-instruction branch");
  }
  else
    setExecuteAddress(destaddr);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0xd9f00
movq %rax, %rsi
leaq 0x68(%rsp), %rdi
callq 0xd9250
leaq 0x68(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0xd55a0
testb $0x1, %al
jne 0x15fe01
jmp 0x15ff49
movq 0x78(%rsp), %rdi
callq 0xe03b0
movq 0x20(%rsp), %rdi
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addl 0x94(%rdi), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x94(%rdi)
movslq 0x94(%rdi), %rax
movq %rax, 0x18(%rsp)
addq $0x30, %rdi
callq 0xd8690
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x15fe5e
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
jmp 0x15ff47
movq 0x20(%rsp), %rax
cmpl $0x0, 0x94(%rax)
jl 0x15fe97
movq 0x20(%rsp), %rdi
movslq 0x94(%rdi), %rax
movq %rax, 0x10(%rsp)
addq $0x30, %rdi
callq 0xd8690
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jb 0x15ff45
movb $0x1, 0x2b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x29cd2(%rip), %rsi     # 0x189b97
leaq 0x40(%rsp), %rdi
callq 0xe00a0
jmp 0x15fed1
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd1ae0
jmp 0x15fee1
movq (%rsp), %rdi
movb $0x0, 0x2b(%rsp)
movq 0x67f9f(%rip), %rsi     # 0x1c7e90
movq 0x67cd8(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x15ff6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x15ff27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd4550
leaq 0x3f(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x2b(%rsp)
jne 0x15ff3a
jmp 0x15ff43
movq (%rsp), %rdi
callq 0xd5400
jmp 0x15ff64
jmp 0x15ff47
jmp 0x15ff5c
movq 0x20(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq (%rdi), %rax
callq *0x90(%rax)
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nop
// File: jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::executeInstruction()
void EmulatePcodeCache::executeInstruction(void)

{
  if (instruction_start) {
    if (breaktable->doAddressBreak(current_address))
      return;
  }
  do {
    executeCurrentOp();
  } while(!instruction_start);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x90(%rax)
je 0x1600fc
movq 0x8(%rsp), %rsi
movq 0x78(%rsi), %rdi
addq $0x80, %rsi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x1600f8
jmp 0x1600fa
jmp 0x160119
jmp 0x1600fc
jmp 0x1600fe
movq 0x8(%rsp), %rdi
callq 0xce930
movq 0x8(%rsp), %rax
movb 0x90(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1600fe
addq $0x18, %rsp
retq
nop