LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: DecisionProperties::conflictingPattern(Constructor*, Constructor*)
void DecisionProperties::conflictingPattern(Constructor *a,Constructor *b)

{ // Note that -a- and -b- have (potentially) conflicting patterns
  if ((!a->isError())&&(!b->isError())) {
    a->setError(true);
    b->setError(true);
    ostringstream s;
    s << "Constructor patterns cannot be distinguished: \n   ";
    a->printInfo(s);
    s << "\n   ";
    b->printInfo(s);
    s << endl;
    conflicterrors.push_back(s.str());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
cmpb $0x0, 0x94(%rsi)
jne 0x74fb1
movq %rdx, %r14
cmpb $0x0, 0x94(%rdx)
jne 0x74fb1
movq %rsi, %r15
movq %rdi, %rbx
movb $0x1, %al
movb %al, 0x94(%rsi)
movb %al, 0x94(%r14)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x504a0
leaq 0x1373f(%rip), %rsi     # 0x88685
movq %r12, %rdi
callq 0x4f5b0
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x51c70
leaq 0x13751(%rip), %rsi     # 0x886b3
leaq 0x20(%rsp), %rdi
callq 0x4f5b0
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x51c70
leaq 0x20(%rsp), %rdi
callq 0x4e140
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x50fb0
addq $0x18, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4dc80
movq %rsp, %rdi
callq 0x4e020
leaq 0x20(%rsp), %rdi
callq 0x4d7c0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4e020
jmp 0x74fd2
jmp 0x74fcf
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4d7c0
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %r13
pushq $0x48
popq %r15
cmpq 0x20(%rbx), %r13
je 0x75044
movq (%r13), %r12
testq %r12, %r12
je 0x75033
movq %r12, %rdi
callq 0x4d040
movq %r12, %rdi
movq %r15, %rsi
callq 0x4f670
addq $0x8, %r13
jmp 0x7501c
movq (%rbx), %r15
cmpq 0x8(%rbx), %r15
je 0x75061
movq (%r15), %rdi
testq %rdi, %rdi
je 0x7505b
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %r15
jmp 0x75047
movq %r14, %rdi
callq 0x51890
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x50040
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movzbl %sil, %ebp
xorl %r12d, %r12d
xorl %r14d, %r14d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r12, %rcx
jbe 0x750c0
movq (%rax,%r15), %rdi
movl %ebp, %esi
callq 0x4f2e0
cmpl %r14d, %eax
cmovgl %eax, %r14d
incq %r12
addq $0x10, %r15
jmp 0x75092
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %eax
movl %edx, %ecx
movl %esi, (%rsp)
pushq $-0x1
popq %r13
shll %cl, %r13d
xorl %ebp, %ebp
movl %edx, 0x4(%rsp)
cmpl $0x20, %edx
cmovel %ebp, %r13d
movq %rdi, %r14
movzbl %al, %r15d
xorl %ebx, %ebx
xorl %r12d, %r12d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rbx, %rcx
jbe 0x7513b
movq (%rax,%rbp), %rdi
movl (%rsp), %esi
movl 0x4(%rsp), %edx
movl %r15d, %ecx
callq 0x51cc0
orl %r13d, %eax
xorl %ecx, %ecx
cmpl $-0x1, %eax
sete %cl
addl %ecx, %r12d
incq %rbx
addq $0x10, %rbp
jmp 0x750fe
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: DecisionNode::getScore(int, int, bool)
double DecisionNode::getScore(int4 low,int4 size,bool context)

{
  int4 numBins = 1 << size;		// size is between 1 and 8
  int4 i;
  uintm val,mask;
  uintm m = ((uintm)1)<<size;
  m = m-1;

  int4 total = 0;
  vector<int4> count(numBins,0);

  for(i=0;i<list.size();++i) {
    mask = list[i].first->getMask(low,size,context);
    if ((mask&m)!=m) continue;	// Skip if field not fully specified
    val = list[i].first->getValue(low,size,context);
    total += 1;
    count[val] += 1;
  }
  if (total <= 0) return -1.0;
  double sc = 0.0;
  for(i=0;i<numBins;++i) {
    if (count[i] <= 0) continue;
    if (count[i] >= list.size()) return -1.0;
    double p = ((double)count[i])/total;
    sc -= p * log(p);
  }
  return ( sc / log(2.0) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r12d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x1
popq %rax
movl %ebp, %ecx
shll %cl, %eax
movq %rax, 0x18(%rsp)
movslq %eax, %r15
leaq 0x2c(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movq %r15, %rsi
callq 0x51d90
negl %r15d
movq %r15, (%rsp)
xorl %r13d, %r13d
movzbl %r12b, %r12d
xorl %r15d, %r15d
movl $0x0, 0x10(%rsp)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r15, %rcx
jbe 0x75200
movq (%rax,%r13), %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x51cc0
orl (%rsp), %eax
cmpl $-0x1, %eax
jne 0x751f7
movq (%rbx), %rax
movq (%rax,%r13), %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x4fc20
incl 0x10(%rsp)
movl %eax, %eax
movq 0x30(%rsp), %rcx
incl (%rcx,%rax,4)
incq %r15
addq $0x10, %r13
jmp 0x751a9
movsd 0x12e18(%rip), %xmm0    # 0x88020
movl 0x10(%rsp), %eax
testl %eax, %eax
jle 0x75286
cvtsi2sd %eax, %xmm1
movsd %xmm1, 0x20(%rsp)
xorl %r14d, %r14d
movq 0x18(%rsp), %r15
testl %r15d, %r15d
cmovlel %r14d, %r15d
xorpd %xmm1, %xmm1
cmpq %r14, %r15
je 0x7528d
movq 0x30(%rsp), %rax
movslq (%rax,%r14,4), %rax
testq %rax, %rax
jle 0x75281
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
sarq $0x4, %rcx
cmpq %rax, %rcx
jbe 0x75286
cvtsi2sd %eax, %xmm0
divsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, (%rsp)
callq 0x4ee10
movsd (%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
subsd %xmm0, %xmm1
movsd 0x12d9f(%rip), %xmm0    # 0x88020
incq %r14
jmp 0x7522d
movsd %xmm0, (%rsp)
jmp 0x7529a
divsd 0x12d93(%rip), %xmm1    # 0x88028
movsd %xmm1, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4fab0
movsd (%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4fab0
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl 0x38(%rdi), %esi
movl 0x3c(%rdi), %ecx
pushq $-0x1
popq %rax
movl %eax, %r12d
shll %cl, %r12d
cmpl $0x20, %ecx
notl %r12d
cmovel %eax, %r12d
movzbl 0x34(%rdi), %eax
movq %rdx, %rdi
movl %ecx, %edx
movl %eax, %ecx
callq 0x51cc0
movl %eax, %ebp
andl %r12d, %ebp
movl 0x38(%r15), %esi
movl 0x3c(%r15), %edx
movzbl 0x34(%r15), %ecx
movq %r14, %rdi
callq 0x4fc20
movl %eax, %r14d
andl %ebp, %r14d
xorl %r12d, %ebp
xorl %r12d, %r12d
movl %ebp, %r13d
notl %r13d
leaq 0x4(%rsp), %r15
cmpl %ebp, %r12d
ja 0x754dc
testl %r13d, %r12d
jne 0x754d7
movl %r12d, %eax
orl %r14d, %eax
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4ebd0
incl %r12d
jmp 0x754b8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: DecisionNode::resolve(ParserWalker&) const
Constructor *DecisionNode::resolve(ParserWalker &walker) const

{
  if (bitsize == 0) {		// The node is terminal
    vector<pair<DisjointPattern *,Constructor *> >::const_iterator iter;
    for(iter=list.begin();iter!=list.end();++iter)
      if ((*iter).first->isMatch(walker))
	return (*iter).second;
    ostringstream s;
    s << walker.getAddr().getShortcut();
    walker.getAddr().printRaw(s);
    s << ": Unable to resolve constructor";
    throw BadDataError(s.str());
  }
  uintm val;
  if (contextdecision)
    val = walker.getContextBits(startbit,bitsize);
  else
    val = walker.getInstructionBits(startbit,bitsize);
  return children[val]->resolve(walker);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %rbx
movq %rdi, %r14
movl 0x3c(%r14), %edx
testl %edx, %edx
je 0x757fc
movl 0x38(%r14), %esi
cmpb $0x1, 0x34(%r14)
jne 0x757e8
movq %rbx, %rdi
callq 0x4dce0
jmp 0x757f0
movq %rbx, %rdi
callq 0x4eea0
movl %eax, %eax
movq 0x18(%r14), %rcx
movq (%rcx,%rax,8), %r14
jmp 0x757cb
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x7582d
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
testb %al, %al
jne 0x7581b
addq $0x10, %r15
jmp 0x757ff
movq 0x8(%r15), %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x504a0
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x75846
movq (%rbx), %rax
movq 0x50(%rax), %rax
movsbl 0x30(%rax), %esi
movq %r14, %rdi
callq 0x4fc10
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x75862
movq (%rbx), %rdi
addq $0x50, %rdi
leaq 0x20(%rsp), %rsi
callq 0x4f5a0
leaq 0x12e66(%rip), %rsi     # 0x886dd
leaq 0x20(%rsp), %rdi
callq 0x4f5b0
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x50fb0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x392a0(%rip), %rsi     # 0xaeb50
movq 0x39381(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
movq %rsp, %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x758d4
jmp 0x758e1
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
jmp 0x758e1
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x4d7c0
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rax
movl %edi, %ecx
sarl $0x5, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
movslq %esi, %rdx
shrq $0x5, %rdx
cmpq %rcx, %rdx
jne 0x75980
movl %edi, %ecx
andl $-0x20, %ecx
andl $0x1f, %edi
subl %esi, %ecx
leal 0x1f(%rcx), %edx
addl %edi, %ecx
addl $0x1f, %ecx
pushq $-0x1
popq %rsi
shrl %cl, %esi
movl %edx, (%rax)
movl %esi, (%r8)
movb (%rax), %cl
shll %cl, %esi
movl %esi, (%r8)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x12e28(%rip), %rsi     # 0x887ba
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x394ce(%rip), %rsi     # 0xaee88
movq 0x39277(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x759e0
jmp 0x759e8
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsp, %rsi
andq $0x0, 0x10(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
xorl %r12d, %r12d
movq 0x3952a(%rip), %rbx     # 0xaef88
movq 0x39263(%rip), %r14     # 0xaecc8
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x75aa9
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x75aa4
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x4fa60
testq %rax, %rax
je 0x75aa4
movq %rax, %r15
movq %rax, %rdi
callq 0x4e240
testb %al, %al
je 0x75abe
incq %r12
jmp 0x75a65
movq %rsp, %rdi
callq 0x4d930
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
movq %r15, %rdi
callq 0x50e50
leaq 0x12c82(%rip), %rdx     # 0x8875a
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x50160
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x3938a(%rip), %rsi     # 0xaee88
movq 0x39133(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
jmp 0x75b30
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x75b26
jmp 0x75b33
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
jmp 0x75b33
movq %rax, %r14
movq %rsp, %rdi
callq 0x4d930
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x12c2b(%rip), %rsi     # 0x88781
movq %rbx, %rdi
callq 0x4f5b0
leaq 0x12c28(%rip), %rsi     # 0x8878d
movq %rbx, %rdi
callq 0x4f5b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x51690
leaq 0x12a27(%rip), %r15     # 0x885bc
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f5b0
leaq 0x11c44(%rip), %rsi     # 0x877eb
movq %rbx, %rdi
callq 0x4f5b0
movl 0x18(%r14), %esi
movq %rax, %rdi
callq 0x51690
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f5b0
leaq 0x12bc5(%rip), %rsi     # 0x88792
movq %rbx, %rdi
callq 0x4f5b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movl 0x14(%r14), %esi
movq %rax, %rdi
callq 0x4e990
leaq 0x12b9f(%rip), %rsi     # 0x8879c
movq %rax, %rdi
callq 0x4f5b0
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
leaq 0x12b88(%rip), %rsi     # 0x887a1
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4f5b0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextOp::restoreXml(Element const*, SleighBase*)
void ContextOp::restoreXml(const Element *el,SleighBase *trans)

{
  {
    istringstream s(el->getAttributeValue("i"));
    s.unsetf(ios::dec | ios::hex | ios::oct);
    s >> num;
  }
  {
    istringstream s(el->getAttributeValue("shift"));
    s.unsetf(ios::dec | ios::hex | ios::oct);
    s >> shift;
  }
  {
    istringstream s(el->getAttributeValue("mask"));
    s.unsetf(ios::dec | ios::hex | ios::oct);
    s >> mask;
  }
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  patexp = (PatternValue *)PatternExpression::restoreExpression(*iter,trans);
  patexp->layClaim();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x12b6e(%rip), %rsi     # 0x887b0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x50230
leaq 0x30(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rax, %rsi
callq 0x51500
leaq 0x10(%rsp), %rdi
callq 0x4e020
leaq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x48(%rsp,%rax)
leaq 0x10(%rbx), %rsi
callq 0x4e750
leaq 0x30(%rsp), %rdi
callq 0x4e070
leaq 0x11b80(%rip), %rsi     # 0x87823
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x50230
leaq 0x30(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rax, %rsi
callq 0x51500
leaq 0x10(%rsp), %rdi
callq 0x4e020
leaq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x48(%rsp,%rax)
leaq 0x18(%rbx), %rsi
callq 0x4e750
leaq 0x30(%rsp), %rdi
callq 0x4e070
leaq 0x118e7(%rip), %rsi     # 0x875eb
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x50230
leaq 0x30(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rax, %rsi
callq 0x51500
leaq 0x10(%rsp), %rdi
callq 0x4e020
leaq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x48(%rsp,%rax)
leaq 0x14(%rbx), %rsi
callq 0x51830
leaq 0x30(%rsp), %rdi
callq 0x4e070
movq 0x78(%r15), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x4f580
movq %rax, 0x8(%rbx)
incl 0x8(%rax)
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x75d89
jmp 0x75d98
jmp 0x75d89
jmp 0x75d98
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4e070
jmp 0x75dae
movq %rax, %rbx
jmp 0x75dae
jmp 0x75da1
jmp 0x75da1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x4f5d0
movq 0x38ee7(%rip), %rcx     # 0xaecb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
incl 0x8(%rcx)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movl 0x18(%rbx), %ecx
movl %ecx, 0x18(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
movl %edx, %eax
movq 0x38dba(%rip), %rdx     # 0xaebb0
addq $0x10, %rdx
movq %rdx, (%rdi)
movq %rsi, 0x8(%rdi)
movb %r8b, 0x18(%rdi)
leaq 0x10(%rdi), %rdx
leaq 0x14(%rdi), %r8
leaq 0x4(%rsp), %r9
movl %eax, %edi
movl %ecx, %esi
movq %r9, %rcx
callq 0x75933
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextCommit::saveXml(std::ostream&) const
void ContextCommit::saveXml(ostream &s) const

{
  s << "<commit";
  a_v_u(s,"id",sym->getId());
  a_v_i(s,"num",num);
  a_v_u(s,"mask",mask);
  a_v_b(s,"flow",flow);
  s << "/>\n";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1295c(%rip), %rsi     # 0x887b2
movq %rbx, %rdi
callq 0x4f5b0
leaq 0x10e8b(%rip), %rsi     # 0x86cf0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movq 0x8(%r14), %rax
movl 0x28(%rax), %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f410
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x1016b(%rip), %rsi     # 0x86004
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movslq 0x10(%r14), %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x50e20
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x11721(%rip), %rsi     # 0x875eb
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movl 0x14(%r14), %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f410
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x123a3(%rip), %rsi     # 0x8829e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movzbl 0x18(%r14), %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4da10
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x118c8(%rip), %rsi     # 0x877f5
movq %rbx, %rdi
callq 0x4f5b0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x75f49
jmp 0x75f58
jmp 0x75f49
jmp 0x75f58
jmp 0x75f49
jmp 0x75f58
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4e020
jmp 0x75f5b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextCommit::restoreXml(Element const*, SleighBase*)
void ContextCommit::restoreXml(const Element *el,SleighBase *trans)

{
  uintm id;
  {
    istringstream s(el->getAttributeValue("id"));
    s.unsetf(ios::dec | ios::hex | ios::oct);
    s >> id;
    sym = (TripleSymbol *)trans->findSymbol(id);
  }
  {
    istringstream s(el->getAttributeValue("num"));
    s.unsetf(ios::dec | ios::hex | ios::oct);
    s >> num;
  }
  {
    istringstream s(el->getAttributeValue("mask"));
    s.unsetf(ios::dec | ios::hex | ios::oct);
    s >> mask;
  }
  if (el->getNumAttributes()==4)
    flow = xml_readbool(el->getAttributeValue("flow"));
  else
    flow = true;		// Default is to flow.  flow=true
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10d70(%rip), %rsi     # 0x86cf0
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x515e0
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x50230
leaq 0x30(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rax, %rsi
callq 0x51500
leaq 0x10(%rsp), %rdi
callq 0x4e020
leaq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x48(%rsp,%rax)
leaq 0xc(%rsp), %rsi
callq 0x51830
movl 0xc(%rsp), %eax
movq 0x198(%r15), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x8(%rbx)
leaq 0x30(%rsp), %rdi
callq 0x4e070
leaq 0x1000f(%rip), %rsi     # 0x86004
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x515e0
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x50230
leaq 0x30(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rax, %rsi
callq 0x51500
leaq 0x10(%rsp), %rdi
callq 0x4e020
leaq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x48(%rsp,%rax)
leaq 0x10(%rbx), %rsi
callq 0x4e750
leaq 0x30(%rsp), %rdi
callq 0x4e070
leaq 0x11595(%rip), %rsi     # 0x875eb
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x515e0
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x50230
leaq 0x30(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rax, %rsi
callq 0x51500
leaq 0x10(%rsp), %rdi
callq 0x4e020
leaq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x48(%rsp,%rax)
leaq 0x14(%rbx), %rsi
callq 0x51830
leaq 0x30(%rsp), %rdi
callq 0x4e070
movq 0x48(%r14), %rax
subq 0x40(%r14), %rax
movabsq $0x1fffffffe0, %rcx     # imm = 0x1FFFFFFFE0
andq %rax, %rcx
cmpq $0x80, %rcx
jne 0x76108
leaq 0x121c9(%rip), %rsi     # 0x8829e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x515e0
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x50230
movq %rax, %rdi
callq 0x4fb70
movb %al, 0x18(%rbx)
leaq 0x30(%rsp), %rdi
callq 0x4e020
jmp 0x7610c
movb $0x1, 0x18(%rbx)
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x7614d
jmp 0x7613c
jmp 0x7612d
jmp 0x7613c
jmp 0x7612d
jmp 0x7613c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4e070
jmp 0x76152
movq %rax, %rbx
jmp 0x76152
jmp 0x76145
jmp 0x76145
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x4f5d0
movq 0x38a43(%rip), %rcx     # 0xaebb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movb 0x18(%rbx), %cl
movb %cl, 0x18(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x30(%rdi)
jne 0x78e1c
movq %rdi, %rbx
movl $0x208, %edi            # imm = 0x208
callq 0x4f5d0
movq %rax, %r15
movq 0x8(%rbx), %rsi
pushq $0x8
popq %rdx
movq %rax, %rdi
callq 0x51bb0
movq %r15, 0x30(%rbx)
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
jne 0x78e67
pushq $0x2
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x504b0
movq 0x30(%rbx), %rdi
callq 0x516d0
movq %rax, 0x38(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0xfa7e(%rip), %rsi      # 0x888ac
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x3604a(%rip), %rsi     # 0xaeea0
movq 0x35ddb(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
jmp 0x78eae
addq $0x8, %rbx
leaq 0xfa54(%rip), %rsi      # 0x888c6
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4f1c0
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x4ddf0
movq 0x36001(%rip), %rsi     # 0xaeea0
movq 0x35d92(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
jmp 0x78ebe
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
leaq 0x8(%rsp), %rdi
callq 0x4e020
jmp 0x78efb
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x78ee1
jmp 0x78efb
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
jmp 0x78efb
movq %rax, %r14
movl $0x208, %esi            # imm = 0x208
movq %r15, %rdi
callq 0x4f670
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/loadimage.cc
// Function: RawLoadImage::loadFill(unsigned char*, int, Address const&)
void RawLoadImage::loadFill(uint1 *ptr,int4 size,const Address &addr)

{
  uintb curaddr = addr.getOffset();
  uintb offset = 0;
  uintb readsize;

  curaddr -= vma;		// Get relative offset of first byte
  while(size>0) {
    if (curaddr >= filesize) {
      if (offset == 0)		// Initial address not within file
	break;
      memset(ptr+offset,0,size); // Fill out the rest of the buffer with 0
      return;
    }
    readsize = size;
    if (curaddr + readsize > filesize) // Adjust to biggest possible read
      readsize = filesize - curaddr;
    thefile->seekg(curaddr);
    thefile->read((char *)(ptr+offset),readsize);
    offset += readsize;
    size -= readsize;
    curaddr += readsize;
  }
  if (size > 0) {
    ostringstream errmsg;
    errmsg << "Unable to load " << dec << size << " bytes at " << addr.getShortcut();
    addr.printRaw(errmsg);
    throw DataUnavailError(errmsg.str());
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %r12
subq 0x28(%rdi), %r12
xorl %ebx, %ebx
testl %ebp, %ebp
jle 0x78fa4
movq 0x38(%r15), %rax
movq %rax, %r13
movl %ebp, %edx
subq %r12, %r13
jbe 0x78fb6
leaq (%r12,%rdx), %rcx
cmpq %rax, %rcx
cmovbeq %rdx, %r13
movq 0x30(%r15), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x500e0
movq 0x30(%r15), %rdi
leaq (%r14,%rbx), %rsi
movq %r13, %rdx
callq 0x50050
addq %r13, %rbx
subl %r13d, %ebp
addq %r13, %r12
jmp 0x78f5e
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %rbx, %rbx
je 0x78fd9
addq %rbx, %r14
movq %r14, %rdi
xorl %esi, %esi
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4e470
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x504a0
leaq 0xf901(%rip), %rsi      # 0x888ee
movq %r14, %rdi
callq 0x4f5b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movl %ebp, %esi
callq 0x51690
leaq 0xf8e3(%rip), %rsi      # 0x888fe
movq %rax, %rdi
callq 0x4f5b0
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movsbl 0x30(%rcx), %esi
movq %rax, %rdi
callq 0x4fc10
leaq 0x30(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x4f5a0
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x50fb0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x35e67(%rip), %rsi     # 0xaeee0
movq 0x35bb8(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x7909f
jmp 0x790ac
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
jmp 0x790ac
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x4d7c0
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rdx)
movq %rsp, %rsi
andq $0x0, 0x10(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
pushq $-0x1
popq %r12
xorl %r13d, %r13d
incq %r12
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x791cb
addq %r13, %rdi
movq %r14, %rsi
callq 0x4e5d0
addq $0x20, %r13
testb %al, %al
je 0x79172
addq $0x48, %r15
leaq 0x18(%rsp), %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x51820
movq %rbx, (%rax)
movq %rsp, %rdi
callq 0x4ea80
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0xf7f1(%rip), %rsi      # 0x889ce
leaq 0x18(%rsp), %rdi
movq %r14, %rdx
callq 0x4f1c0
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x35c9d(%rip), %rsi     # 0xaeea0
movq 0x35a2e(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
jmp 0x79214
movq %rax, %r14
jmp 0x79238
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x79230
jmp 0x79238
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %rsp, %rdi
callq 0x4ea80
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rdi)
movq 0x30(%rdi), %rax
leaq 0x20(%rdi), %r15
cmpq %r15, %rax
je 0x79290
movq 0x30(%rax), %rcx
movq %rbx, 0x8(%rcx)
movq %rax, %rdi
callq 0x4ea10
jmp 0x79279
movq 0x60(%r14), %rax
addq $0x50, %r14
cmpq %r14, %rax
je 0x792af
movq 0x28(%rax), %rcx
movq %rbx, 0x8(%rcx)
movq %rax, %rdi
callq 0x4ea10
jmp 0x79298
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
addq $0x48, %rdi
callq 0x51d70
addq $0x50, %r14
cmpq %r14, %rax
je 0x792f2
movq 0x28(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
jmp 0x792f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0x51a80
addq $0x20, %r14
cmpq %r14, %rax
je 0x7932f
movq 0x30(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x4f5d0
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x50d90
movq (%r15), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r15
movl %edx, 0xc(%rsp)
movq %rsi, %r13
movq %rdi, %r14
pushq $0x40
popq %rdi
callq 0x4f5d0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movl 0x20(%r14), %ecx
movups (%r13), %xmm0
movups %xmm0, 0x8(%rax)
movq %rcx, 0x18(%rax)
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x51c20
movq (%r12), %rax
movq 0x18(%r14), %rcx
movl 0xc(%rsp), %edx
movq (%rcx), %rcx
movq (%rcx,%rdx,8), %rcx
movq %rcx, (%rax)
incl 0x20(%r14)
testq %r15, %r15
je 0x79434
movq %r14, %rdi
movq %r15, %rsi
callq 0x4fda0
movq 0x10(%rsp), %rcx
movq %rax, 0x20(%rcx)
xorl %r15d, %r15d
testl %ebp, %ebp
cmovgl %ebp, %r15d
subq $0x1, %r15
jb 0x79461
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4fda0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x4f1a0
addq $0x18, %rbx
jmp 0x7943d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rax
movq (%rax), %rsi
callq 0x4d2e0
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %rdx
movq 0x28(%rcx), %rcx
movl 0x10(%rdx), %esi
movq (%rcx), %rcx
movl 0x10(%rcx), %edx
movq (%rdi), %r8
movq %rax, %rcx
callq *0x10(%r8)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %rsi
movq %rax, %rdx
popq %rbx
jmp 0x4e530
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rax
movq (%rax), %rsi
callq 0x4d2e0
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4d2e0
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %rdx
movq 0x28(%rcx), %rcx
movl 0x10(%rdx), %esi
movq (%rcx), %rcx
movl 0x10(%rcx), %edx
movq (%rdi), %r9
movq %r14, %rcx
movq %rax, %r8
callq *0x18(%r9)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4e530
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4d2e0
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %r8
movq 0x28(%rcx), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rsi
movl 0x5c(%rsi), %edx
imulq %rax, %rdx
movl 0x10(%r8), %ecx
callq 0x4de20
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %rsi
movq %rax, %rdx
popq %rbx
jmp 0x4e530
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x4d2e0
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4d2e0
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rcx
movq 0x28(%rcx), %rcx
movq (%rcx), %rdx
movq 0x10(%rcx), %rcx
movq 0x8(%rdx), %rsi
movl 0x5c(%rsi), %edx
imulq %rax, %rdx
movl 0x10(%rcx), %ecx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51bc0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdi, %rbx
movb $0x1, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movq 0x34f87(%rip), %rax     # 0xaeae8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x30(%rdi), %r14
leaq 0x60(%rdi), %r12
andq $0x0, 0x80(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
andq $0x0, 0x70(%rdi)
movq %rsi, 0x28(%rdi)
movq %r12, %rdi
callq 0x520e0
movq %r15, 0x78(%rbx)
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
addq $0x48, %rbx
movq %r12, %rdi
callq 0x50a00
movq %rbx, %rdi
callq 0x505b0
movq %r14, %rdi
callq 0x4e3a0
movq %r15, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
pushq $0x40
popq %r14
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x79c28
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x79c18
leaq 0x28(%r15), %rdi
callq 0x505b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f670
incq %r12
jmp 0x79bf2
xorl %r15d, %r15d
pushq $0x18
popq %r14
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jbe 0x79c57
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x4f670
incq %r15
jmp 0x79c2f
movq 0x30(%rbx), %rdx
cmpq %rdx, 0x38(%rbx)
je 0x79c65
movq %rdx, 0x38(%rbx)
cmpq %rax, %rcx
je 0x79c6e
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x34e5f(%rip), %rax     # 0xaeae8
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x4dc10
leaq 0x60(%rbx), %r14
xorl %r15d, %r15d
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x79cc4
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x79cbf
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
jmp 0x79c9c
movq %r14, %rdi
callq 0x50a00
leaq 0x48(%rbx), %rdi
callq 0x505b0
addq $0x30, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4e3a0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4dc10
leaq 0x30(%r14), %rsi
leaq 0x48(%r14), %rdx
leaq 0x60(%r14), %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %r8d, %r8d
callq 0x51420
movq 0x28(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x60(%rax)
movl %eax, 0x98(%r14)
andl $0x0, 0x94(%r14)
movb $0x1, 0x90(%r14)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq 0x94(%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x38(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x79d84
movq (%rcx,%rax,8), %rax
movq (%rax), %rcx
jmp 0x79d88
xorl %eax, %eax
xorl %ecx, %ecx
movq %rax, 0x20(%rdi)
movq %rcx, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb $0x0, 0x90(%rdi)
movslq 0x94(%rdi), %rax
incq %rax
movl %eax, 0x94(%rdi)
movq 0x38(%rdi), %rcx
subq 0x30(%rdi), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
ja 0x79e01
leaq 0x80(%rbx), %r14
movl 0x98(%rbx), %edx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f560
movq (%r15), %rax
movq %rax, 0x80(%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x88(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f1d0
movq %rbx, %rdi
callq 0x4f7a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop