LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: VarnodeListSymbol::print(std::ostream&, ParserWalker&) const
void VarnodeListSymbol::print(ostream &s,ParserWalker &walker) const

{
  uint4 ind = (uint4)patval->getValue(walker);
  if (ind >= varnode_table.size())
    throw SleighError("Value out of range for varnode table");
  s << varnode_table[ind]->getName();
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rax), %rdi
movq 0x70(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x20(%rsp), %rdi
movl %eax, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movq %rax, 0x28(%rsp)
addq $0x38, %rdi
callq 0xcf930
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jb 0x142bf6
movb $0x1, 0x33(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x10(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xe0c80
movq 0x18(%rsp), %rdx
leaq 0x46675(%rip), %rsi     # 0x1891e5
leaq 0x48(%rsp), %rdi
callq 0xe00a0
jmp 0x142b7c
movq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd06e0
jmp 0x142b8d
movq 0x10(%rsp), %rdi
movb $0x0, 0x33(%rsp)
movq 0x852ca(%rip), %rsi     # 0x1c7e68
movq 0x84e7b(%rip), %rdx     # 0x1c7a20
callq 0xe01f0
jmp 0x142c3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x142bd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd4550
leaq 0x47(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x33(%rsp)
jne 0x142bea
jmp 0x142bf4
movq 0x10(%rsp), %rdi
callq 0xd5400
jmp 0x142c31
movq 0x20(%rsp), %rdi
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
movl 0x6c(%rsp), %eax
movl %eax, %esi
callq 0xd99e0
movq (%rax), %rdi
callq 0xd1f90
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xd7350
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xe0be0
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: VarnodeListSymbol::saveXml(std::ostream&) const
void VarnodeListSymbol::saveXml(ostream &s) const

{
  s << "<varlist_sym";
  SleighSymbol::saveXmlHeader(s);
  s << ">\n";
  patval->saveXml(s);
  for(int4 i=0;i<varnode_table.size();++i) {
    if (varnode_table[i] == (VarnodeSymbol *)0)
      s << "<null/>\n";
    else
      s << "<var id=\"0x" << hex << varnode_table[i]->getId() << "\"/>\n";
  }
  s << "</varlist_sym>\n";
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x465a6(%rip), %rsi     # 0x18920a
callq 0xd8300
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdd790
movq 0x28(%rsp), %rdi
leaq 0x469ea(%rip), %rsi     # 0x18966e
callq 0xd8300
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x38, %rdi
callq 0xcf930
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x142d67
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
movslq 0x24(%rsp), %rsi
callq 0xd99e0
cmpq $0x0, (%rax)
jne 0x142cfa
movq 0x28(%rsp), %rdi
leaq 0x45699(%rip), %rsi     # 0x18838c
callq 0xd8300
jmp 0x142d55
movq 0x28(%rsp), %rdi
leaq 0x46511(%rip), %rsi     # 0x189217
callq 0xd8300
movq %rax, %rdi
movq 0x852b3(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
movslq 0x24(%rsp), %rsi
callq 0xd99e0
movq (%rax), %rdi
callq 0xdbac0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x45acc(%rip), %rsi     # 0x18881c
callq 0xd8300
jmp 0x142d57
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x142ca5
movq 0x28(%rsp), %rdi
leaq 0x464b0(%rip), %rsi     # 0x189223
callq 0xd8300
addq $0x38, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: OperandSymbol::OperandSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, Constructor*)
OperandSymbol::OperandSymbol(const string &nm,int4 index,Constructor *ct)
  : SpecificSymbol(nm)
{
  flags = 0;
  hand = index;
  localexp = new OperandValue(index,ct);
  localexp->layClaim();
  defexp = (PatternExpression *)0;
  triple = (TripleSymbol *)0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0xdf5b0
movq 0x8(%rsp), %rax
movq 0x84931(%rip), %rcx     # 0x1c7a28
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x58(%rax)
movl 0x34(%rsp), %ecx
movl %ecx, 0x3c(%rax)
movl $0x18, %edi
callq 0xd8380
movq %rax, 0x10(%rsp)
jmp 0x14311d
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x28(%rsp), %rdx
callq 0xd2190
jmp 0x143132
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq 0x40(%rax), %rdi
callq 0xd99b0
jmp 0x14314b
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq $0x0, 0x48(%rax)
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x143192
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x18, %esi
callq 0xd8620
movq 0x8(%rsp), %rdi
callq 0xdf230
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: OperandSymbol::defineOperand(PatternExpression*)
void OperandSymbol::defineOperand(PatternExpression *pe)

{
  if ((defexp != (PatternExpression *)0)||(triple!=(TripleSymbol *)0))
    throw SleighError("Redefining operand");
  defexp = pe;
  defexp->layClaim();
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x50(%rax)
jne 0x1431df
movq 0x18(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x143291
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 0x4603b(%rip), %rsi     # 0x189249
leaq 0x38(%rsp), %rdi
callq 0xe00a0
jmp 0x14321a
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd06e0
jmp 0x14322b
movq 0x8(%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0x84c2c(%rip), %rsi     # 0x1c7e68
movq 0x847dd(%rip), %rdx     # 0x1c7a20
callq 0xe01f0
jmp 0x1432b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x143272
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 0x143285
jmp 0x14328f
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x1432ad
movq 0x18(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, 0x50(%rax)
movq 0x50(%rax), %rdi
callq 0xd99b0
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: OperandSymbol::getVarnode() const
VarnodeTpl *OperandSymbol::getVarnode(void) const

{
  VarnodeTpl *res;
  if (defexp != (PatternExpression *)0)
    res = new VarnodeTpl(hand,true); // Definite constant handle
  else {
    SpecificSymbol *specsym = dynamic_cast<SpecificSymbol *>(triple);
    if (specsym != (SpecificSymbol *)0)
      res = specsym->getVarnode();
    else if ((triple != (TripleSymbol *)0)&&
	     ((triple->getType() == valuemap_symbol)||(triple->getType() == name_symbol)))
      res = new VarnodeTpl(hand,true); // Zero-size symbols
    else
      res = new VarnodeTpl(hand,false); // Possible dynamic handle
  }
  return res;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x50(%rax)
je 0x1434d4
movl $0x68, %edi
callq 0xd8380
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movl 0x3c(%rax), %esi
movl $0x1, %edx
callq 0xcee70
jmp 0x1434a3
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x143615
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x68, %esi
callq 0xd8620
jmp 0x14361f
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x14350b
movq 0x18(%rsp), %rdi
movq 0x849ec(%rip), %rsi     # 0x1c7ee0
movq 0x8482d(%rip), %rdx     # 0x1c7d28
xorl %eax, %eax
movl %eax, %ecx
callq 0xd99a0
movq %rax, 0x10(%rsp)
jmp 0x143514
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x143514
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x14353b
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq %rax, 0x48(%rsp)
jmp 0x143613
movq 0x28(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x1435c3
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x4, %eax
je 0x14356f
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x5, %eax
jne 0x1435c3
movl $0x68, %edi
callq 0xd8380
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movl 0x3c(%rax), %esi
movl $0x1, %edx
callq 0xcee70
jmp 0x143598
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x143611
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x68, %esi
callq 0xd8620
jmp 0x14361f
movl $0x68, %edi
callq 0xd8380
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, (%rsp)
movl 0x3c(%rax), %esi
xorl %edx, %edx
callq 0xcee70
jmp 0x1435e8
movq (%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x143611
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x68, %esi
callq 0xd8620
jmp 0x14361f
jmp 0x143613
jmp 0x143615
movq 0x48(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: OperandSymbol::print(std::ostream&, ParserWalker&) const
void OperandSymbol::print(ostream &s,ParserWalker &walker) const

{
  walker.pushOperand(getIndex());
  if (triple != (TripleSymbol *)0) {
    if (triple->getType() == SleighSymbol::subtable_symbol)
      walker.getConstructor()->print(s,walker);
    else
      triple->print(s,walker);
  }
  else {
    intb val = defexp->getValue(walker);
    if (val >= 0)
      s << "0x" << hex << val;
    else
      s << "-0x" << hex << -val;
  }
  walker.popOperand();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xd91d0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0xcf7d0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x143744
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0xb, %eax
jne 0x143726
movq 0x20(%rsp), %rdi
callq 0xd81d0
movq %rax, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xce090
jmp 0x14373f
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x1437c7
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jl 0x143794
movq 0x28(%rsp), %rdi
leaq 0x457e3(%rip), %rsi     # 0x188f54
callq 0xd8300
movq %rax, %rdi
movq 0x84848(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0xe1550
jmp 0x1437c5
movq 0x28(%rsp), %rdi
leaq 0x45857(%rip), %rsi     # 0x188ff7
callq 0xd8300
movq %rax, %rdi
movq 0x84819(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
subq 0x18(%rsp), %rsi
callq 0xe1550
jmp 0x1437c7
movq 0x20(%rsp), %rdi
callq 0xceb70
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: Constructor::print(std::ostream&, ParserWalker&) const
void Constructor::print(ostream &s,ParserWalker &walker) const

{
  vector<string>::const_iterator piter;

  for(piter=printpiece.begin();piter!=printpiece.end();++piter) {
    if ((*piter)[0] == '\n') {
      int4 index = (*piter)[1]-'A';
      operands[index]->print(s,walker);
    }
    else
      s << *piter;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd6f70
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0xcf990
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0xd5000
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd5c30
testb $0x1, %al
jne 0x14384f
jmp 0x1438e6
leaq 0x28(%rsp), %rdi
callq 0xce840
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd9290
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1438b6
leaq 0x28(%rsp), %rdi
callq 0xce840
movq %rax, %rdi
movl $0x1, %esi
callq 0xd9290
movq 0x8(%rsp), %rdi
movsbl (%rax), %eax
subl $0x41, %eax
movl %eax, 0x14(%rsp)
addq $0x18, %rdi
movslq 0x14(%rsp), %rsi
callq 0xcfaf0
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x1438d5
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0xce840
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xd7350
jmp 0x1438d7
leaq 0x28(%rsp), %rdi
callq 0xd6a80
jmp 0x143824
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: OperandSymbol::saveXml(std::ostream&) const
void OperandSymbol::saveXml(ostream &s) const

{
  s << "<operand_sym";
  SleighSymbol::saveXmlHeader(s);
  if (triple != (TripleSymbol *)0)
    s << " subsym=\"0x" << hex << triple->getId() << "\"";
  s << " off=\"" << dec << reloffset << "\"";
  s << " base=\"" << offsetbase << "\"";
  s << " minlen=\"" << minimumlength << "\"";
  if (isCodeAddress())
    s << " code=\"true\"";
  s << " index=\"" << dec << hand << "\">\n";
  localexp->saveXml(s);
  if (defexp != (PatternExpression *)0)
    defexp->saveXml(s);
  s << "</operand_sym>\n";
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x45908(%rip), %rsi     # 0x18925c
callq 0xd8300
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdd790
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x1439c5
movq 0x18(%rsp), %rdi
leaq 0x458e9(%rip), %rsi     # 0x189269
callq 0xd8300
movq %rax, %rdi
movq 0x84639(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x48(%rax), %rdi
callq 0xdbac0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x45acc(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x18(%rsp), %rdi
leaq 0x458a4(%rip), %rsi     # 0x189275
callq 0xd8300
movq %rax, %rdi
movq 0x843b8(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x30(%rax), %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x45a8d(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x18(%rsp), %rdi
leaq 0x4586c(%rip), %rsi     # 0x18927c
callq 0xd8300
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x34(%rax), %esi
callq 0xe03e0
movq %rax, %rdi
leaq 0x45a5d(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x18(%rsp), %rdi
leaq 0x45844(%rip), %rsi     # 0x189284
callq 0xd8300
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x38(%rax), %esi
callq 0xe03e0
movq %rax, %rdi
leaq 0x45a2d(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x10(%rsp), %rdi
callq 0xd3c40
testb $0x1, %al
jne 0x143a74
jmp 0x143a85
movq 0x18(%rsp), %rdi
leaq 0x4580e(%rip), %rsi     # 0x18928e
callq 0xd8300
movq 0x18(%rsp), %rdi
leaq 0x44e5a(%rip), %rsi     # 0x1888eb
callq 0xd8300
movq %rax, %rdi
movq 0x842f8(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x3c(%rax), %esi
callq 0xe03e0
movq %rax, %rdi
leaq 0x4535d(%rip), %rsi     # 0x188e1c
callq 0xd8300
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x143af8
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x18(%rsp), %rdi
leaq 0x45797(%rip), %rsi     # 0x18929b
callq 0xd8300
addq $0x28, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: StartSymbol::getVarnode() const
VarnodeTpl *StartSymbol::getVarnode(void) const

{ // Returns current instruction offset as a constant
  ConstTpl spc(const_space);
  ConstTpl off(ConstTpl::j_start);
  ConstTpl sz_zero;
  return new VarnodeTpl(spc,off,sz_zero);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq 0x30(%rax), %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd69a0
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x2, %esi
callq 0xd7df0
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd4400
movl $0x68, %edi
callq 0xd8380
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0xdf370
jmp 0x144646
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: StartSymbol::getFixedHandle(FixedHandle&, ParserWalker&) const
void StartSymbol::getFixedHandle(FixedHandle &hand,ParserWalker &walker) const

{
  hand.space = walker.getCurSpace();
  hand.offset_space = (AddrSpace *)0;
  hand.offset_offset = walker.getAddr().getOffset(); // Get starting address of instruction
  hand.size = hand.space->getAddrSize();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%rsp), %rdi
callq 0xdadc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rdi
callq 0xcee30
movq %rax, %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xd7510
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: FlowDestSymbol::getFixedHandle(FixedHandle&, ParserWalker&) const
void FlowDestSymbol::getFixedHandle(FixedHandle &hand,ParserWalker &walker) const

{
  Address refAddr = walker.getDestAddr();
  hand.space = const_space;
  hand.offset_space = (AddrSpace *)0;
  hand.offset_offset = refAddr.getOffset();
  hand.size = refAddr.getAddrSize();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xd9090
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0xd6c50
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
leaq 0x10(%rsp), %rdi
callq 0xdcb60
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: Constructor::Constructor()
Constructor::Constructor(void)

{
  pattern = (TokenPattern *)0;
  parent = (SubtableSymbol *)0;
  pateq = (PatternEquation *)0;
  templ = (ConstructTpl *)0;
  firstwhitespace = -1;
  flowthruindex = -1;
  inerror = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0xdc5e0
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0xe0e60
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0xd6900
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
callq 0xd6240
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x60(%rax)
movl $0xffffffff, 0x88(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x8c(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x94(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: Constructor::Constructor(SubtableSymbol*)
Constructor::Constructor(SubtableSymbol *p)

{
  pattern = (TokenPattern *)0;
  parent = p;
  pateq = (PatternEquation *)0;
  templ = (ConstructTpl *)0;
  firstwhitespace = -1;
  inerror = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
callq 0xdc5e0
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0xe0e60
movq (%rsp), %rdi
addq $0x48, %rdi
callq 0xd6900
movq (%rsp), %rdi
addq $0x68, %rdi
callq 0xd6240
movq (%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x60(%rax)
movl $0xffffffff, 0x88(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x94(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: Constructor::~Constructor()
Constructor::~Constructor(void)

{
  if (pattern != (TokenPattern *)0)
    delete pattern;
  if (pateq != (PatternEquation *)0)
    PatternEquation::release(pateq);
  if (templ != (ConstructTpl *)0)
    delete templ;
  for(int4 i=0;i<namedtempl.size();++i) {
    ConstructTpl *ntpl = namedtempl[i];
    if (ntpl != (ConstructTpl *)0)
      delete ntpl;
  }
  vector<ContextChange *>::iterator iter;
  for(iter=context.begin();iter!=context.end();++iter)
    delete *iter;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, (%rax)
je 0x145387
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x145385
movq 0x28(%rsp), %rdi
callq 0xd2580
movq 0x28(%rsp), %rdi
movl $0x28, %esi
callq 0xd8620
jmp 0x145387
movq 0x30(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1453a5
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xd5660
jmp 0x1453a3
jmp 0x1453a5
movq 0x30(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x1453e0
movq 0x30(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x1453de
movq 0x20(%rsp), %rdi
callq 0xde070
movq 0x20(%rsp), %rdi
movl $0x28, %esi
callq 0xd8620
jmp 0x1453e0
movl $0x0, 0x5c(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x5c(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x68, %rdi
callq 0xd33b0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x14546d
movq 0x30(%rsp), %rdi
addq $0x68, %rdi
movslq 0x5c(%rsp), %rsi
callq 0xd9460
movq (%rax), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x14545b
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x145459
movq 0x10(%rsp), %rdi
callq 0xde070
movq 0x10(%rsp), %rdi
movl $0x28, %esi
callq 0xd8620
jmp 0x14545b
jmp 0x14545d
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x1453e8
leaq 0x48(%rsp), %rdi
callq 0xd0540
movq 0x30(%rsp), %rdi
addq $0x48, %rdi
callq 0xd6d20
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x30(%rsp), %rdi
addq $0x48, %rdi
callq 0xda5b0
movq %rax, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd79f0
testb $0x1, %al
jne 0x1454bc
jmp 0x1454ed
leaq 0x48(%rsp), %rdi
callq 0xdc2f0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1454df
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1454e1
leaq 0x48(%rsp), %rdi
callq 0xd90e0
jmp 0x145494
movq 0x30(%rsp), %rdi
addq $0x68, %rdi
callq 0xda060
movq 0x30(%rsp), %rdi
addq $0x48, %rdi
callq 0xe2340
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
callq 0xd5480
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0xcf440
addq $0x68, %rsp
retq
movq %rax, %rdi
callq 0xe7140
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: Constructor::addOperand(OperandSymbol*)
void Constructor::addOperand(OperandSymbol *sym)

{
  string operstring = "\n ";	// Indicater character for operand
  operstring[1] = ('A'+operands.size()); // Encode index of operand
  operands.push_back(sym);
  printpiece.push_back(operstring); // Placeholder for operand's string
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xe0c80
movq 0x18(%rsp), %rdx
leaq 0x42f95(%rip), %rsi     # 0x188538
leaq 0x38(%rsp), %rdi
callq 0xe00a0
jmp 0x1455af
leaq 0x37(%rsp), %rdi
callq 0xd8ec0
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0xd98e0
addb $0x41, %al
movb %al, 0x7(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0xe2f50
movq %rax, 0x8(%rsp)
jmp 0x1455e3
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movb 0x7(%rsp), %cl
movb %cl, (%rax)
addq $0x18, %rdi
leaq 0x58(%rsp), %rsi
callq 0xdd2e0
jmp 0x145603
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
leaq 0x38(%rsp), %rsi
callq 0xd3180
jmp 0x145618
leaq 0x38(%rsp), %rdi
callq 0xd4550
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0xd8ec0
jmp 0x145659
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4550
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: Constructor::setNamedSection(ConstructTpl*, int)
void Constructor::setNamedSection(ConstructTpl *tpl,int4 id)

{				// Add a named section to the constructor
  while(namedtempl.size() <= id)
    namedtempl.push_back((ConstructTpl *)0);
  namedtempl[id] = tpl;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x68, %rdi
callq 0xd33b0
movslq 0x24(%rsp), %rcx
cmpq %rcx, %rax
ja 0x145982
movq 0x10(%rsp), %rdi
addq $0x68, %rdi
movq $0x0, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0xe2c60
jmp 0x14594c
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x68, %rdi
movslq 0x24(%rsp), %rsi
callq 0xd9460
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: Constructor::printMnemonic(std::ostream&, ParserWalker&) const
void Constructor::printMnemonic(ostream &s,ParserWalker &walker) const

{
  if (flowthruindex != -1) {
    SubtableSymbol *sym = dynamic_cast<SubtableSymbol *>(operands[flowthruindex]->getDefiningSymbol());
    if (sym != (SubtableSymbol *)0) {
      walker.pushOperand(flowthruindex);
      walker.getConstructor()->printMnemonic(s,walker);
      walker.popOperand();
      return;
    }
  }
  int4 endind = (firstwhitespace==-1) ? printpiece.size() : firstwhitespace;
  for(int4 i=0;i<endind;++i) {
    if (printpiece[i][0] == '\n') {
      int4 index = printpiece[i][1]-'A';
      operands[index]->print(s,walker);
    }
    else
      s << printpiece[i];
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpl $-0x1, 0x8c(%rax)
je 0x145af5
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x8c(%rax), %rsi
callq 0xcfaf0
movq (%rax), %rdi
callq 0xdf550
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x145a98
movq 0x18(%rsp), %rdi
movq 0x8245f(%rip), %rsi     # 0x1c7ee0
movq 0x82460(%rip), %rdx     # 0x1c7ee8
xorl %eax, %eax
movl %eax, %ecx
callq 0xd99a0
movq %rax, 0x10(%rsp)
jmp 0x145aa1
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x145aa1
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x145af3
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rdi
movl 0x8c(%rax), %esi
callq 0xcf7d0
movq 0x40(%rsp), %rdi
callq 0xd81d0
movq %rax, %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xd32e0
movq 0x40(%rsp), %rdi
callq 0xceb70
jmp 0x145bfb
jmp 0x145af5
movq 0x20(%rsp), %rax
cmpl $-0x1, 0x88(%rax)
jne 0x145b18
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
callq 0xe1670
movq %rax, 0x8(%rsp)
jmp 0x145b29
movq 0x20(%rsp), %rax
movslq 0x88(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl %eax, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x145bfb
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movslq 0x30(%rsp), %rsi
callq 0xda3d0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd9290
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x145bc1
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movslq 0x30(%rsp), %rsi
callq 0xda3d0
movq %rax, %rdi
movl $0x1, %esi
callq 0xd9290
movq 0x20(%rsp), %rdi
movsbl (%rax), %eax
subl $0x41, %eax
movl %eax, 0x2c(%rsp)
addq $0x18, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xcfaf0
movq (%rax), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x145be9
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
addq $0x30, %rdi
movslq 0x30(%rsp), %rsi
callq 0xda3d0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xd7350
jmp 0x145beb
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x145b3a
addq $0x58, %rsp
retq
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: Constructor::printBody(std::ostream&, ParserWalker&) const
void Constructor::printBody(ostream &s,ParserWalker &walker) const

{
  if (flowthruindex != -1) {
    SubtableSymbol *sym = dynamic_cast<SubtableSymbol *>(operands[flowthruindex]->getDefiningSymbol());
    if (sym != (SubtableSymbol *)0) {
      walker.pushOperand(flowthruindex);
      walker.getConstructor()->printBody(s,walker);
      walker.popOperand();
      return;
    }
  }
  if (firstwhitespace == -1) return; // Nothing to print after firstwhitespace
  for(int4 i=firstwhitespace+1;i<printpiece.size();++i) {
    if (printpiece[i][0]=='\n') {
      int4 index = printpiece[i][1]-'A';
      operands[index]->print(s,walker);
    }
    else
      s << printpiece[i];
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $-0x1, 0x8c(%rax)
je 0x145cd5
movq 0x28(%rsp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x8c(%rax), %rsi
callq 0xcfaf0
movq (%rax), %rdi
callq 0xdf550
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x145c78
movq 0x20(%rsp), %rdi
movq 0x8227f(%rip), %rsi     # 0x1c7ee0
movq 0x82280(%rip), %rdx     # 0x1c7ee8
xorl %eax, %eax
movl %eax, %ecx
callq 0xd99a0
movq %rax, 0x18(%rsp)
jmp 0x145c81
xorl %eax, %eax
movq %rax, 0x18(%rsp)
jmp 0x145c81
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x145cd3
movq 0x28(%rsp), %rax
movq 0x40(%rsp), %rdi
movl 0x8c(%rax), %esi
callq 0xcf7d0
movq 0x40(%rsp), %rdi
callq 0xd81d0
movq %rax, %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xdad80
movq 0x40(%rsp), %rdi
callq 0xceb70
jmp 0x145dd8
jmp 0x145cd5
movq 0x28(%rsp), %rax
cmpl $-0x1, 0x88(%rax)
jne 0x145ce8
jmp 0x145dd8
movq 0x28(%rsp), %rax
movl 0x88(%rax), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x34(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x30, %rdi
callq 0xe1670
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x145dd8
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
movslq 0x34(%rsp), %rsi
callq 0xda3d0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd9290
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x145d9c
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
movslq 0x34(%rsp), %rsi
callq 0xda3d0
movq %rax, %rdi
movl $0x1, %esi
callq 0xd9290
movq 0x28(%rsp), %rdi
movsbl (%rax), %eax
subl $0x41, %eax
movl %eax, 0x30(%rsp)
addq $0x18, %rdi
movslq 0x30(%rsp), %rsi
callq 0xcfaf0
movq (%rax), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x145dc6
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x30, %rdi
movslq 0x34(%rsp), %rsi
callq 0xda3d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xd7350
jmp 0x145dc8
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x145cfa
addq $0x58, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: Constructor::markSubtableOperands(std::vector<int, std::allocator<int>>&) const
void Constructor::markSubtableOperands(vector<int4> &check) const

{ // Adjust -check- so it has one entry for every operand, a 0 if it is a subtable, a 2 if it is not
  check.resize(operands.size());
  for(int4 i=0;i<operands.size();++i) {
    TripleSymbol *sym = operands[i]->getDefiningSymbol();
    if ((sym != (TripleSymbol *)0)&&(sym->getType() == SleighSymbol::subtable_symbol))
      check[i] = 0;
    else
      check[i] = 2;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x18, %rdi
callq 0xd98e0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xd50c0
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, (%rsp)
addq $0x18, %rdi
callq 0xd98e0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x145f19
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movslq 0x24(%rsp), %rsi
callq 0xcfaf0
movq (%rax), %rdi
callq 0xdf550
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x145ef2
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0xb, %eax
jne 0x145ef2
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xd2680
movl $0x0, (%rax)
jmp 0x145f07
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xd2680
movl $0x2, (%rax)
jmp 0x145f09
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x145e80
addq $0x38, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: Constructor::collectLocalExports(std::vector<unsigned long, std::allocator<unsigned long>>&) const
void Constructor::collectLocalExports(vector<uintb> &results) const

{
  if (templ == (ConstructTpl *)0) return;
  HandleTpl *handle = templ->getResult();
  if (handle == (HandleTpl *)0) return;
  if (handle->getSpace().isConstSpace()) return;	// Even if the value is dynamic, the pointed to value won't get used
  if (handle->getPtrSpace().getType() != ConstTpl::real) {
    if (handle->getTempSpace().isUniqueSpace())
      results.push_back(handle->getTempOffset().getReal());
    return;
  }
  if (handle->getSpace().isUniqueSpace()) {
    results.push_back(handle->getPtrOffset().getReal());
    return;
  }
  if (handle->getSpace().getType() == ConstTpl::handle) {
    int4 handleIndex = handle->getSpace().getHandleIndex();
    OperandSymbol *opSym = getOperand(handleIndex);
    opSym->collectLocalValues(results);
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x60(%rax)
jne 0x145f44
jmp 0x14607f
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0xcf9d0
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x145f64
jmp 0x14607f
movq 0x40(%rsp), %rdi
callq 0xe19b0
movq %rax, %rdi
callq 0xd0a60
testb $0x1, %al
jne 0x145f7c
jmp 0x145f81
jmp 0x14607f
movq 0x40(%rsp), %rdi
callq 0xce590
movq %rax, %rdi
callq 0xde5d0
cmpl $0x0, %eax
je 0x145fe5
movq 0x40(%rsp), %rdi
callq 0xdcd10
movq %rax, %rdi
callq 0xd5e30
testb $0x1, %al
jne 0x145fb0
jmp 0x145fe0
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0xd09b0
movq %rax, %rdi
callq 0xdd890
movq 0x10(%rsp), %rdi
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0xd6640
jmp 0x14607f
movq 0x40(%rsp), %rdi
callq 0xe19b0
movq %rax, %rdi
callq 0xd5e30
testb $0x1, %al
jne 0x145ffd
jmp 0x14602f
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0xd4cc0
movq %rax, %rdi
callq 0xdd890
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0xd6640
jmp 0x14607f
movq 0x40(%rsp), %rdi
callq 0xe19b0
movq %rax, %rdi
callq 0xde5d0
cmpl $0x1, %eax
jne 0x14607f
movq 0x40(%rsp), %rdi
callq 0xe19b0
movq %rax, %rdi
callq 0xd1b90
movq 0x18(%rsp), %rdi
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %esi
callq 0xd3060
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq (%rdi), %rax
callq *0x58(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: Constructor::isRecursive() const
bool Constructor::isRecursive(void) const

{ // Does this constructor cause recursion with its table
  for(int4 i=0;i<operands.size();++i) {
    TripleSymbol *sym = operands[i]->getDefiningSymbol();
    if (sym == parent) return true;
  }
  return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
callq 0xd98e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x146116
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movslq 0x24(%rsp), %rsi
callq 0xcfaf0
movq (%rax), %rdi
callq 0xdf550
movq 0x10(%rsp), %rcx
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rcx), %rax
jne 0x146107
movb $0x1, 0x37(%rsp)
jmp 0x14611b
jmp 0x146109
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1460ab
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SubtableSymbol::SubtableSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
SubtableSymbol::SubtableSymbol(const string &nm) : TripleSymbol(nm)

{
  beingbuilt = false;
  pattern = (TokenPattern *)0;
  decisiontree = (DecisionNode *)0;
  errors = 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 0xdbf90
movq (%rsp), %rdi
movq 0x7ea2c(%rip), %rax     # 0x1c7c98
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x40, %rdi
callq 0xd1340
movq (%rsp), %rax
movb $0x0, 0x38(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x58(%rax)
movb $0x0, 0x39(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SubtableSymbol::~SubtableSymbol()
SubtableSymbol::~SubtableSymbol(void)

{
  if (pattern != (TokenPattern *)0)
    delete pattern;
  if (decisiontree != (DecisionNode *)0)
    delete decisiontree;
  vector<Constructor *>::iterator iter;
  for(iter=construct.begin();iter!=construct.end();++iter)
    delete *iter;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x7e9de(%rip), %rcx     # 0x1c7c98
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x30(%rax)
je 0x1492f7
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1492f5
movq 0x18(%rsp), %rdi
callq 0xd2580
movq 0x18(%rsp), %rdi
movl $0x28, %esi
callq 0xd8620
jmp 0x1492f7
movq 0x20(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x149332
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x149330
movq 0x10(%rsp), %rdi
callq 0xce050
movq 0x10(%rsp), %rdi
movl $0x48, %esi
callq 0xd8620
jmp 0x149332
leaq 0x38(%rsp), %rdi
callq 0xd17b0
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
callq 0xdfc20
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
callq 0xda680
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xdf7d0
testb $0x1, %al
jne 0x149381
jmp 0x1493c0
leaq 0x38(%rsp), %rdi
callq 0xd70f0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1493b2
movq 0x8(%rsp), %rdi
callq 0xe2650
movq 0x8(%rsp), %rdi
movl $0x98, %esi
callq 0xd8620
jmp 0x1493b4
leaq 0x38(%rsp), %rdi
callq 0xdacc0
jmp 0x149359
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
callq 0xcfbd0
movq 0x20(%rsp), %rdi
callq 0xe1840
addq $0x48, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SubtableSymbol::saveXml(std::ostream&) const
void SubtableSymbol::saveXml(ostream &s) const

{
  if (decisiontree == (DecisionNode *)0) return; // Not fully formed
  s << "<subtable_sym";
  SleighSymbol::saveXmlHeader(s);
  s << " numct=\"" << dec << construct.size() << "\">\n";
  for(int4 i=0;i<construct.size();++i)
    construct[i]->saveXml(s);
  decisiontree->saveXml(s);
  s << "</subtable_sym>\n";
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x58(%rax)
jne 0x1494b4
jmp 0x1495a1
movq 0x28(%rsp), %rdi
leaq 0x3ffee(%rip), %rsi     # 0x1894ae
callq 0xd8300
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdd790
movq 0x28(%rsp), %rdi
leaq 0x3ffdc(%rip), %rsi     # 0x1894bc
callq 0xd8300
movq %rax, %rdi
movq 0x7e8a9(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq 0x18(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x40, %rdi
callq 0xd2520
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xd0050
movq %rax, %rdi
leaq 0x3f8fe(%rip), %rsi     # 0x188e1c
callq 0xd8300
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x40, %rdi
callq 0xd2520
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x14957d
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
movslq 0x24(%rsp), %rsi
callq 0xd5ce0
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xda5e0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x14952b
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xd9720
movq 0x28(%rsp), %rdi
leaq 0x3ff29(%rip), %rsi     # 0x1894c5
callq 0xd8300
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SubtableSymbol::buildDecisionTree(DecisionProperties&)
void SubtableSymbol::buildDecisionTree(DecisionProperties &props)

{				// Associate pattern disjoints to constructors
  if (pattern == (TokenPattern *)0) return; // Pattern not fully formed
  Pattern *pat;
  decisiontree = new DecisionNode((DecisionNode *)0);
  for(int4 i=0;i<construct.size();++i) {
    pat = construct[i]->getPattern()->getPattern();
    if (pat->numDisjoint() == 0)
      decisiontree->addConstructorPair((const DisjointPattern *)pat,construct[i]);
    else
      for(int4 j=0;j<pat->numDisjoint();++j)
	decisiontree->addConstructorPair(pat->getDisjoint(j),construct[i]);
  }
  decisiontree->split(props);	// Create the decision strategy
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x30(%rax)
jne 0x14a5b4
jmp 0x14a74a
movl $0x48, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x38(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xda360
jmp 0x14a5d4
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, 0x58(%rax)
movl $0x0, 0x50(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0x40, %rdi
callq 0xd2520
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jae 0x14a737
movq 0x40(%rsp), %rdi
addq $0x40, %rdi
movslq 0x50(%rsp), %rsi
callq 0xd2750
movq (%rax), %rdi
callq 0xd9d60
movq %rax, %rdi
callq 0xdfee0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpl $0x0, %eax
jne 0x14a6aa
movq 0x40(%rsp), %rdi
movq 0x58(%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x40, %rdi
movslq 0x50(%rsp), %rsi
callq 0xd2750
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rax), %rdx
callq 0xcfb50
jmp 0x14a725
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x48, %esi
callq 0xd8620
jmp 0x14a74f
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x60(%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0x14a723
movq 0x40(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
movl 0x4c(%rsp), %esi
movq (%rdi), %rax
callq *0x48(%rax)
movq 0x40(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x40, %rdi
movslq 0x50(%rsp), %rsi
callq 0xd2750
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rax), %rdx
callq 0xcfb50
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x14a6b2
jmp 0x14a725
jmp 0x14a727
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x14a5ea
movq 0x40(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0xd5ec0
addq $0x78, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: DecisionProperties::identicalPattern(Constructor*, Constructor*)
void DecisionProperties::identicalPattern(Constructor *a,Constructor *b)

{ // Note that -a- and -b- have identical patterns
  if ((!a->isError())&&(!b->isError())) {
    a->setError(true);
    b->setError(true);
    ostringstream s;
    s << "Constructors with identical patterns: \n   ";
    a->printInfo(s);
    s << "\n   ";
    b->printInfo(s);
    s << endl;
    identerrors.push_back(s.str());
  }
}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x1d8(%rsp), %rdi
callq 0xd29f0
testb $0x1, %al
jne 0x14ad23
movq 0x1d0(%rsp), %rdi
callq 0xd29f0
testb $0x1, %al
jne 0x14ad23
movq 0x1d8(%rsp), %rdi
movl $0x1, %esi
movl %esi, 0x14(%rsp)
callq 0xdd5b0
movl 0x14(%rsp), %esi
movq 0x1d0(%rsp), %rdi
callq 0xdd5b0
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xdbe90
movq 0x18(%rsp), %rdi
leaq 0x3e8d2(%rip), %rsi     # 0x18952a
callq 0xd8300
jmp 0x14ac5f
movq 0x1d8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xe1b60
jmp 0x14ac73
leaq 0x3e909(%rip), %rsi     # 0x189583
leaq 0x58(%rsp), %rdi
callq 0xd8300
jmp 0x14ac86
movq 0x1d0(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xe1b60
jmp 0x14ac9a
movq 0x7ce1f(%rip), %rsi     # 0x1c7ac0
leaq 0x58(%rsp), %rdi
callq 0xd8a20
jmp 0x14acad
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xd8840
jmp 0x14acc8
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd5950
jmp 0x14acd9
leaq 0x28(%rsp), %rdi
callq 0xd4550
leaq 0x58(%rsp), %rdi
callq 0xd0160
jmp 0x14ad23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x14ad17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd4550
leaq 0x58(%rsp), %rdi
callq 0xd0160
jmp 0x14ad2b
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x50(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x1d8(%rsp), %rdi
callq 0xd29f0
testb $0x1, %al
jne 0x14aea7
movq 0x1d0(%rsp), %rdi
callq 0xd29f0
testb $0x1, %al
jne 0x14aea7
movq 0x1d8(%rsp), %rdi
movl $0x1, %esi
movl %esi, 0x14(%rsp)
callq 0xdd5b0
movl 0x14(%rsp), %esi
movq 0x1d0(%rsp), %rdi
callq 0xdd5b0
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xdbe90
movq 0x18(%rsp), %rdi
leaq 0x3e77d(%rip), %rsi     # 0x189555
callq 0xd8300
jmp 0x14addf
movq 0x1d8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xe1b60
jmp 0x14adf3
leaq 0x3e789(%rip), %rsi     # 0x189583
leaq 0x58(%rsp), %rdi
callq 0xd8300
jmp 0x14ae06
movq 0x1d0(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xe1b60
jmp 0x14ae1a
movq 0x7cc9f(%rip), %rsi     # 0x1c7ac0
leaq 0x58(%rsp), %rdi
callq 0xd8a20
jmp 0x14ae2d
movq 0x20(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xd8840
jmp 0x14ae4c
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd5950
jmp 0x14ae5d
leaq 0x28(%rsp), %rdi
callq 0xd4550
leaq 0x58(%rsp), %rdi
callq 0xd0160
jmp 0x14aea7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x14ae9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd4550
leaq 0x58(%rsp), %rdi
callq 0xd0160
jmp 0x14aeaf
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x50(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: DecisionNode::DecisionNode(DecisionNode*)
DecisionNode::DecisionNode(DecisionNode *p)

{
  parent = p;
  num = 0;
  startbit = 0;
  bitsize = 0;
  contextdecision = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xdbf00
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0xd2fd0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x40(%rax)
movl $0x0, 0x30(%rax)
movl $0x0, 0x38(%rax)
movl $0x0, 0x3c(%rax)
movb $0x0, 0x34(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)