LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: OrPattern::doOr(Pattern const*, int) const
Pattern *OrPattern::doOr(const Pattern *b,int4 sa) const

{
  const OrPattern *b2 = dynamic_cast<const OrPattern *>(b);
  vector<DisjointPattern *> newlist;
  vector<DisjointPattern *>::const_iterator iter;

  for(iter=orlist.begin();iter!=orlist.end();++iter)
    newlist.push_back((DisjointPattern *)(*iter)->simplifyClone());
  if (sa < 0)
    for(iter=orlist.begin();iter!=orlist.end();++iter)
      (*iter)->shiftInstruction(-sa);

  if (b2 == (const OrPattern *)0)
    newlist.push_back((DisjointPattern *)b->simplifyClone());
  else {
    for(iter=b2->orlist.begin();iter!=b2->orlist.end();++iter)
      newlist.push_back((DisjointPattern *)(*iter)->simplifyClone());
  }
  if (sa > 0)
    for(int4 i=0;i<newlist.size();++i)
      newlist[i]->shiftInstruction(sa);

  OrPattern *tmpor = new OrPattern(newlist);
  return tmpor;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rdi, %r12
testq %rsi, %rsi
movq %rsi, 0x30(%rsp)
je 0x6dedb
movq %rsi, %rax
movq 0x40e33(%rip), %rsi     # 0xaecf8
movq 0x40eb4(%rip), %rdx     # 0xaed80
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x4fa60
movq %rax, %r14
jmp 0x6dede
xorl %r14d, %r14d
leaq 0x10(%rsp), %r13
andq $0x0, 0x10(%r13)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
movq 0x8(%r12), %r15
leaq 0x8(%rsp), %rbp
cmpq 0x10(%r12), %r15
je 0x6df20
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x50b90
addq $0x8, %r15
jmp 0x6defa
testl %ebx, %ebx
js 0x6df5d
testq %r14, %r14
je 0x6df82
movq 0x8(%r14), %r13
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq 0x10(%r14), %r13
je 0x6df9f
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x50b90
addq $0x8, %r13
jmp 0x6df37
movq 0x8(%r12), %r13
movl %ebx, %ebp
negl %ebp
cmpq %r15, %r13
je 0x6df24
movq (%r13), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x18(%rax)
addq $0x8, %r13
movq 0x10(%r12), %r15
jmp 0x6df66
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x50b90
testl %ebx, %ebx
jle 0x6dfcd
xorl %r14d, %r14d
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x6dfcd
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x18(%rax)
incq %r14
jmp 0x6dfa6
pushq $0x20
popq %rdi
callq 0x4f5d0
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x51950
leaq 0x10(%rsp), %rdi
callq 0x4ecd0
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e01b
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x4f670
jmp 0x6e01e
jmp 0x6e01b
jmp 0x6e01b
jmp 0x6e01b
jmp 0x6e01b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4ecd0
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: OrPattern::simplifyClone() const
Pattern *OrPattern::simplifyClone(void) const

{				// Look for alwaysTrue eliminate alwaysFalse
  vector<DisjointPattern *>::const_iterator iter;

  for(iter=orlist.begin();iter!=orlist.end();++iter) // Look for alwaysTrue
    if ((*iter)->alwaysTrue())
      return new InstructionPattern(true);

  vector<DisjointPattern *> newlist;
  for(iter=orlist.begin();iter!=orlist.end();++iter) // Look for alwaysFalse
    if (!(*iter)->alwaysFalse())
      newlist.push_back((DisjointPattern *)(*iter)->simplifyClone());
  
  if (newlist.empty())
    return new InstructionPattern(false);
  else if (newlist.size() == 1)
    return newlist[0];
  return new OrPattern(newlist);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r13
cmpq 0x10(%rbx), %r13
je 0x6e077
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
addq $0x8, %r13
testb %al, %al
je 0x6e044
pushq $0x10
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x50360
jmp 0x6e117
movq %rsp, %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq 0x8(%rbx), %r12
leaq 0x18(%rsp), %r15
cmpq %r13, %r12
je 0x6e0c6
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
testb %al, %al
jne 0x6e0bc
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x50b90
addq $0x8, %r12
movq 0x10(%rbx), %r13
jmp 0x6e08f
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x6e0e2
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x6e0f9
movq (%rax), %rbx
jmp 0x6e10f
pushq $0x10
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x50360
jmp 0x6e10f
pushq $0x20
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
movq %rsp, %rsi
movq %rax, %rdi
callq 0x51950
movq %rsp, %rdi
callq 0x4ecd0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x20
jmp 0x6e134
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x4f670
jmp 0x6e156
jmp 0x6e153
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x4f670
jmp 0x6e15e
jmp 0x6e153
movq %rax, %r14
movq %rsp, %rdi
callq 0x4ecd0
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: OrPattern::saveXml(std::ostream&) const
void OrPattern::saveXml(ostream &s) const

{
  s << "<or_pat>\n";
  for(int4 i=0;i<orlist.size();++i)
    orlist[i]->saveXml(s);
  s << "</or_pat>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x19ce8(%rip), %rsi     # 0x87e60
movq %rbx, %rdi
callq 0x4f5b0
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x6e1a9
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x68(%rax)
incq %r15
jmp 0x6e183
leaq 0x19cba(%rip), %rsi     # 0x87e6a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4f5b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghpattern.cc
// Function: OrPattern::restoreXml(Element const*)
void OrPattern::restoreXml(const Element *el)

{
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  while(iter != list.end()) {
    DisjointPattern *pat = DisjointPattern::restoreDisjoint(*iter);
    orlist.push_back(pat);
    ++iter;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x78(%rsi), %r12
addq $0x8, %r14
movq %rsp, %r15
cmpq 0x80(%rbx), %r12
je 0x6e1fe
movq (%r12), %rdi
callq 0x520b0
movq %rax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x513c0
addq $0x8, %r12
jmp 0x6e1d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolScope::findSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
SleighSymbol *SymbolScope::findSymbol(const string &nm) const

{
  SleighSymbol dummy(nm);
  SymbolTree::const_iterator iter;

  iter = tree.find( &dummy );
  if (iter != tree.end())
    return *iter;
  return (SleighSymbol *)0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4f220
leaq 0x8(%rbx), %rdi
movq %rsp, %rsi
movq %r14, (%rsi)
callq 0x4e810
addq $0x10, %rbx
cmpq %rbx, %rax
je 0x6e99f
movq 0x20(%rax), %rbx
jmp 0x6e9a1
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x50a30
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x50a30
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolTable::~SymbolTable()
SymbolTable::~SymbolTable(void)

{
  vector<SymbolScope *>::iterator iter;
  for(iter=table.begin();iter!=table.end();++iter)
    delete *iter;
  vector<SleighSymbol *>::iterator siter;
  for(siter=symbollist.begin();siter!=symbollist.end();++siter)
    delete *siter;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %r13
pushq $0x40
popq %r15
cmpq 0x20(%rbx), %r13
je 0x6ea0e
movq (%r13), %r12
testq %r12, %r12
je 0x6e9fd
leaq 0x8(%r12), %rdi
callq 0x4f510
movq %r12, %rdi
movq %r15, %rsi
callq 0x4f670
addq $0x8, %r13
jmp 0x6e9e4
movq (%rbx), %r15
cmpq 0x8(%rbx), %r15
je 0x6ea2b
movq (%r15), %rdi
testq %rdi, %rdi
je 0x6ea25
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
jmp 0x6ea11
movq %r14, %rdi
callq 0x4e2d0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4eb60
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolTable::skipScope(int) const
SymbolScope *SymbolTable::skipScope(int4 i) const

{
  SymbolScope *res = curscope;
  while(i>0) {
    if (res->parent == (SymbolScope *)0) return res;
    res = res->parent;
    --i;
  }
  return res;
}

// Assembly:
movq 0x30(%rdi), %rcx
incl %esi
movq %rcx, %rax
decl %esi
testl %esi, %esi
jle 0x6eabb
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x6eaaa
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolTable::addGlobalSymbol(SleighSymbol*)
void SymbolTable::addGlobalSymbol(SleighSymbol *a)

{
  a->id = symbollist.size();
  symbollist.push_back(a);
  SymbolScope *scope = getGlobalScope();
  a->scopeid = scope->getId();
  SleighSymbol *res = scope->addSymbol(a);
  if (res != a)
    throw SleighError("Duplicate symbol name: "+a->getName());
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x3, %rax
movl %eax, 0x28(%rsi)
movq %r14, %rsi
callq 0x4df90
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movl 0x38(%rdi), %eax
movq (%r14), %rsi
movl %eax, 0x2c(%rsi)
callq 0x50f40
cmpq (%r14), %rax
jne 0x6eb08
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
movq 0x8(%rsp), %rdx
addq $0x8, %rdx
leaq 0x19515(%rip), %rsi     # 0x88038
leaq 0x10(%rsp), %rdi
callq 0x4f1c0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x40342(%rip), %rsi     # 0xaee88
movq 0x400eb(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x6eb6c
jmp 0x6eb74
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: SymbolTable::addSymbol(SleighSymbol*)
void SymbolTable::addSymbol(SleighSymbol *a)

{
  a->id = symbollist.size();
  symbollist.push_back(a);
  a->scopeid = curscope->getId();
  SleighSymbol *res = curscope->addSymbol(a);
  if (res != a)
    throw SleighError("Duplicate symbol name: "+a->getName());
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x3, %rax
movl %eax, 0x28(%rsi)
movq %r14, %rsi
callq 0x4df90
movq 0x30(%rbx), %rdi
movl 0x38(%rdi), %eax
movq (%r14), %rsi
movl %eax, 0x2c(%rsi)
callq 0x50f40
cmpq (%r14), %rax
jne 0x6ebc5
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
movq 0x8(%rsp), %rdx
addq $0x8, %rdx
leaq 0x19458(%rip), %rsi     # 0x88038
leaq 0x10(%rsp), %rdi
callq 0x4f1c0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x40285(%rip), %rsi     # 0xaee88
movq 0x4002e(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x6ec29
jmp 0x6ec31
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolTable::findSymbolInternal(SymbolScope*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
SleighSymbol *SymbolTable::findSymbolInternal(SymbolScope *scope,const string &nm) const

{
  SleighSymbol *res;
  
  while(scope != (SymbolScope *)0) {
    res = scope->findSymbol(nm);
    if (res != (SleighSymbol *)0)
      return res;
    scope = scope->getParent();	// Try higher scope
  }
  return (SleighSymbol *)0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
xorl %ebx, %ebx
testq %r15, %r15
je 0x6ec64
movq %r15, %rdi
movq %r14, %rsi
callq 0x50720
testq %rax, %rax
jne 0x6ec61
movq (%r15), %r15
jmp 0x6ec47
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolTable::replaceSymbol(SleighSymbol*, SleighSymbol*)
void SymbolTable::replaceSymbol(SleighSymbol *a,SleighSymbol *b)

{				// Replace symbol a with symbol b
				// assuming a and b have the same name
  SleighSymbol *sym;
  int4 i = table.size()-1;
  
  while(i>=0) {			// Find the particular symbol
    sym = table[i]->findSymbol( a->getName() );
    if (sym == a) {
      table[i]->removeSymbol(a);
      b->id = a->id;
      b->scopeid = a->scopeid;
      symbollist[b->id] = b;
      table[i]->addSymbol(b);
      delete a;
      return;
    }
    --i;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
shrq $0x3, %rax
leaq 0x8(%rsi), %r12
movl %eax, %ebp
decq %rbp
testl %ebp, %ebp
js 0x6ed05
movl %ebp, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %rdi
movq %r12, %rsi
callq 0x50720
decq %rbp
cmpq %rbx, %rax
jne 0x6ec97
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %rdi
movq %rbx, %rsi
callq 0x4e350
movq 0x28(%rbx), %rax
movq %rax, 0x28(%r14)
movl %eax, %eax
movq (%r15), %rcx
movq %r14, (%rcx,%rax,8)
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %rdi
movq %r14, %rsi
callq 0x50f40
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x8(%rax)
addq $0x8, %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/slghsymbol.cc
// Function: SleighSymbol::restoreXmlHeader(Element const*)
void SleighSymbol::restoreXmlHeader(const Element *el)

{
  name = el->getAttributeValue("name");
  {
    istringstream s(el->getAttributeValue("id"));
    s.unsetf(ios::dec | ios::hex | ios::oct);
    s >> id;
  }
  {
    istringstream s(el->getAttributeValue("scope"));
    s.unsetf(ios::dec | ios::hex | ios::oct);
    s >> scopeid;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x168ce(%rip), %rsi     # 0x86031
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x515e0
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x50230
leaq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x4e400
leaq 0x28(%rsp), %rdi
callq 0x4e020
leaq 0x17554(%rip), %rsi     # 0x86cf0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x50230
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rax, %rsi
callq 0x51500
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x40(%rsp,%rax)
leaq 0x28(%rbx), %rsi
callq 0x51830
leaq 0x28(%rsp), %rdi
callq 0x4e070
leaq 0x188bc(%rip), %rsi     # 0x880b9
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x50230
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rax, %rsi
callq 0x51500
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x40(%rsp,%rax)
addq $0x2c, %rbx
movq %rbx, %rsi
callq 0x51830
leaq 0x28(%rsp), %rdi
callq 0x4e070
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x6f869
jmp 0x6f87a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4e070
jmp 0x6f898
jmp 0x6f87a
movq %rax, %rbx
jmp 0x6f898
jmp 0x6f881
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x6f893
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SymbolTable::renumber()
void SymbolTable::renumber(void)

{				// Renumber all the scopes and symbols
				// so that there are no gaps
  vector<SymbolScope *> newtable;
  vector<SleighSymbol *> newsymbol;
				// First renumber the scopes
  SymbolScope *scope;
  for(int4 i=0;i<table.size();++i) {
    scope = table[i];
    if (scope != (SymbolScope *)0) {
      scope->id = newtable.size();
      newtable.push_back(scope);
    }
  }
				// Now renumber the symbols
  SleighSymbol *sym;
  for(int4 i=0;i<symbollist.size();++i) {
    sym = symbollist[i];
    if (sym != (SleighSymbol *)0) {
      sym->scopeid = table[sym->scopeid]->id;
      sym->id = newsymbol.size();
      newsymbol.push_back(sym);
    }
  }
  table = newtable;
  symbollist = newsymbol;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
andq $0x0, 0x10(%rsp)
movaps %xmm0, (%rsp)
leaq 0x18(%rdi), %r14
xorl %r13d, %r13d
leaq 0x48(%rsp), %r12
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x6fae8
movq (%rax,%r13,8), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x6fae3
movq 0x28(%rsp), %rcx
subq 0x20(%rsp), %rcx
shrq $0x3, %rcx
movl %ecx, 0x38(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4d9a0
incq %r13
jmp 0x6faa5
xorl %r13d, %r13d
movq %rsp, %r15
leaq 0x40(%rsp), %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x6fb44
movq (%rax,%r13,8), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x6fb3f
movl 0x2c(%rax), %ecx
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0x2c(%rax)
movq 0x8(%rsp), %rcx
subq (%rsp), %rcx
shrq $0x3, %rcx
movl %ecx, 0x28(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4df90
incq %r13
jmp 0x6faf3
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x4e600
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x51470
movq %rsp, %rdi
callq 0x4eb60
leaq 0x20(%rsp), %rdi
callq 0x4e2d0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x6fb80
jmp 0x6fb80
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4eb60
leaq 0x20(%rsp), %rdi
callq 0x4e2d0
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: SleighSymbol::saveXmlHeader(std::ostream&) const
void SleighSymbol::saveXmlHeader(ostream &s) const

{				// Save the basic attributes of a symbol
  s << " name=\"" << name << "\"";
  s << " id=\"0x" << hex << id << "\"";
  s << " scope=\"0x" << scopeid << "\"";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x176b3(%rip), %rsi     # 0x87263
movq %r14, %rdi
callq 0x4f5b0
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x4f1b0
leaq 0x189f1(%rip), %r15     # 0x885bc
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f5b0
leaq 0x184a2(%rip), %rsi     # 0x8807f
movq %r14, %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 0x28(%rbx), %esi
movq %rax, %rdi
callq 0x4e990
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f5b0
leaq 0x184d1(%rip), %rsi     # 0x880e8
movq %r14, %rdi
callq 0x4f5b0
movl 0x2c(%rbx), %esi
movq %rax, %rdi
callq 0x4e990
movq %rax, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4f5b0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: UserOpSymbol::saveXml(std::ostream&) const
void UserOpSymbol::saveXml(ostream &s) const

{
  s << "<userop";
  SleighSymbol::saveXmlHeader(s);
  s << " index=\"" << dec << index << "\"";
  s << "/>\n";
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x184a8(%rip), %rsi     # 0x880f3
movq %rbx, %rdi
callq 0x4f5b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x50b40
leaq 0x17c5e(%rip), %rsi     # 0x878c3
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 0x30(%r14), %esi
movq %rax, %rdi
callq 0x4e990
leaq 0x18927(%rip), %rsi     # 0x885bc
movq %rax, %rdi
callq 0x4f5b0
leaq 0x17b51(%rip), %rsi     # 0x877f5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4f5b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: PatternlessSymbol::PatternlessSymbol()
PatternlessSymbol::PatternlessSymbol(void)

{				// The void constructor must explicitly build
				// the ConstantValue because it is not stored
				// or restored via xml
  patexp = new ConstantValue((intb)0);
  patexp->layClaim();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq 0x3ef0b(%rip), %rax     # 0xaecc0
addq $0x10, %rax
movq %rax, (%rdi)
pushq $0x18
popq %rdi
callq 0x4f5d0
movq 0x3f0fd(%rip), %rcx     # 0xaeec8
addq $0x10, %rcx
movq %rcx, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x30(%rbx)
movl $0x1, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x50a30
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: EpsilonSymbol::getVarnode() const
VarnodeTpl *EpsilonSymbol::getVarnode(void) const

{
  VarnodeTpl *res = new VarnodeTpl(ConstTpl(const_space),
				     ConstTpl(ConstTpl::real,0),
				     ConstTpl(ConstTpl::real,0));
  return res;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
movq 0x38(%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4ef60
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4fa20
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4fa20
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x51230
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x6fee1
jmp 0x6fee1
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x4f670
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ValueSymbol::getFixedHandle(FixedHandle&, ParserWalker&) const
void ValueSymbol::getFixedHandle(FixedHandle &hand,ParserWalker &walker) const

{
  hand.space = walker.getConstSpace();
  hand.offset_space = (AddrSpace *)0;
  hand.offset_offset = (uintb) patval->getValue(walker);
  hand.size = 0;		// Cannot provide size
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rdx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsi)
andq $0x0, 0x10(%rsi)
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x10(%rax)
movq %rax, 0x18(%rbx)
andl $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ValueSymbol::print(std::ostream&, ParserWalker&) const
void ValueSymbol::print(ostream &s,ParserWalker &walker) const

{
  intb val = patval->getValue(walker);
  if (val >= 0)
    s << "0x" << hex << val;
  else
    s << "-0x" << hex << -val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x10(%rax)
movq %rax, %rbx
testq %rax, %rax
js 0x70026
leaq 0x1807d(%rip), %rsi     # 0x88084
movq %r14, %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)
jmp 0x7004d
leaq 0x180fa(%rip), %rsi     # 0x88127
movq %r14, %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)
negq %rbx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4f440
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ValueSymbol::saveXml(std::ostream&) const
void ValueSymbol::saveXml(ostream &s) const

{
  s << "<value_sym";
  SleighSymbol::saveXmlHeader(s);
  s << ">\n";
  patval->saveXml(s);
  s << "</value_sym>\n";
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x180ba(%rip), %rsi     # 0x8812b
movq %rbx, %rdi
callq 0x4f5b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x50b40
leaq 0x18713(%rip), %rsi     # 0x8879e
movq %rbx, %rdi
callq 0x4f5b0
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
leaq 0x1808f(%rip), %rsi     # 0x88136
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4f5b0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ValueMapSymbol::checkTableFill()
void ValueMapSymbol::checkTableFill(void)

{ // Check if all possible entries in the table have been filled
  intb min = patval->minValue();
  intb max = patval->maxValue();
  tableisfilled = (min>=0)&&(max<valuetable.size());
  for(uint4 i=0;i<valuetable.size();++i) {
    if (valuetable[i] == 0xBADBEEF)
      tableisfilled = false;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %r14
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
testq %r14, %r14
js 0x70146
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
setb %al
jmp 0x70157
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorl %eax, %eax
movb %al, 0x50(%rbx)
xorl %eax, %eax
movl %eax, %eax
cmpq %rax, %rdx
jbe 0x70175
cmpq $0xbadbeef, (%rcx,%rax,8) # imm = 0xBADBEEF
jne 0x70171
movb $0x0, 0x50(%rbx)
incl %eax
jmp 0x7015c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ValueMapSymbol::resolve(ParserWalker&)
Constructor *ValueMapSymbol::resolve(ParserWalker &walker)

{
  if (!tableisfilled) {
    intb ind = patval->getValue(walker);
    if ((ind >= valuetable.size())||(ind<0)||(valuetable[ind] == 0xBADBEEF)) {
      ostringstream s;
      s << walker.getAddr().getShortcut();
      walker.getAddr().printRaw(s);
      s << ": No corresponding entry in valuetable";
      throw BadDataError(s.str());
    }
  }
  return (Constructor *)0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
cmpb $0x0, 0x50(%rdi)
jne 0x701c2
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
js 0x701d0
movq 0x38(%r14), %rcx
movq 0x40(%r14), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x701d0
cmpq $0xbadbeef, (%rcx,%rax,8) # imm = 0xBADBEEF
je 0x701d0
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x504a0
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x701e9
movq (%rbx), %rax
movq 0x50(%rax), %rax
movsbl 0x30(%rax), %esi
movq %r14, %rdi
callq 0x4fc10
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x70205
movq (%rbx), %rdi
addq $0x50, %rdi
leaq 0x28(%rsp), %rsi
callq 0x4f5a0
leaq 0x17f3a(%rip), %rsi     # 0x88154
leaq 0x28(%rsp), %rdi
callq 0x4f5b0
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x50fb0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x3e8f9(%rip), %rsi     # 0xaeb50
movq 0x3e9da(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x7027d
jmp 0x7028a
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
jmp 0x7028a
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x4d7c0
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ValueMapSymbol::getFixedHandle(FixedHandle&, ParserWalker&) const
void ValueMapSymbol::getFixedHandle(FixedHandle &hand,ParserWalker &walker) const

{
  uint4 ind = (uint4) patval->getValue(walker);
  // The resolve routine has checked that -ind- must be a valid index
  hand.space = walker.getConstSpace();
  hand.offset_space = (AddrSpace *)0; // Not a dynamic value
  hand.offset_offset = (uintb)valuetable[ind];
  hand.size = 0;		// Cannot provide size
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x10(%rax)
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%r14)
andq $0x0, 0x10(%r14)
movl %eax, %eax
movq 0x38(%r15), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x18(%r14)
andl $0x0, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ValueMapSymbol::print(std::ostream&, ParserWalker&) const
void ValueMapSymbol::print(ostream &s,ParserWalker &walker) const

{
  uint4 ind = (uint4)patval->getValue(walker);
  // ind is already checked to be in range by the resolve routine
  intb val = valuetable[ind];
  if (val >= 0)
    s << "0x" << hex << val;
  else
    s << "-0x" << hex << -val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x10(%rax)
movl %eax, %eax
movq 0x38(%rbx), %rcx
movq (%rcx,%rax,8), %rbx
testq %rbx, %rbx
js 0x7032c
leaq 0x17d77(%rip), %rsi     # 0x88084
movq %r14, %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)
jmp 0x70353
leaq 0x17df4(%rip), %rsi     # 0x88127
movq %r14, %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)
negq %rbx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4f440
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ValueMapSymbol::saveXml(std::ostream&) const
void ValueMapSymbol::saveXml(ostream &s) const

{
  s << "<valuemap_sym";
  SleighSymbol::saveXmlHeader(s);
  s << ">\n";
  patval->saveXml(s);
  for(uint4 i=0;i<valuetable.size();++i)
    s << "<valuetab val=\"" << dec << valuetable[i] << "\"/>\n";
  s << "</valuemap_sym>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x17dff(%rip), %rsi     # 0x8817b
movq %rbx, %rdi
callq 0x4f5b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x50b40
leaq 0x18408(%rip), %rsi     # 0x8879e
movq %rbx, %rdi
callq 0x4f5b0
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
xorl %eax, %eax
leaq 0x17dd5(%rip), %r15     # 0x88189
leaq 0x17439(%rip), %r12     # 0x877f4
movl %eax, %r13d
movq 0x40(%r14), %rax
subq 0x38(%r14), %rax
sarq $0x3, %rax
cmpq %r13, %rax
jbe 0x70410
movq %rbx, %rdi
movq %r15, %rsi
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 0x38(%r14), %rcx
movq (%rcx,%r13,8), %rsi
movq %rax, %rdi
callq 0x4f440
movq %rax, %rdi
movq %r12, %rsi
callq 0x4f5b0
leal 0x1(%r13), %eax
jmp 0x703bb
leaq 0x17d82(%rip), %rsi     # 0x88199
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4f5b0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ValueMapSymbol::restoreXml(Element const*, SleighBase*)
void ValueMapSymbol::restoreXml(const Element *el,SleighBase *trans)

{
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  patval = (PatternValue *) PatternExpression::restoreExpression(*iter,trans);
  patval->layClaim();
  ++iter;
  while(iter != list.end()) {
    istringstream s((*iter)->getAttributeValue("val"));
    s.unsetf(ios::dec | ios::hex | ios::oct);
    intb val;
    s >> val;
    valuetable.push_back(val);
    ++iter;
  }
  checkTableFill();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rsi), %r12
movq (%r12), %rdi
movq %rdx, %rsi
callq 0x4f580
movq %rax, 0x30(%rbx)
incl 0x8(%rax)
movq %rbx, 0x10(%rsp)
leaq 0x38(%rbx), %r15
addq $0x8, %r12
leaq 0x18(%rsp), %r13
leaq 0x38(%rsp), %rbx
cmpq 0x80(%r14), %r12
je 0x7051b
movq (%r12), %rbp
movq %r13, %rdi
leaq 0x15cf2(%rip), %rsi     # 0x861b0
leaq 0xf(%rsp), %rdx
callq 0x515e0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x50230
movq %rbx, %rdi
movq %rax, %rsi
pushq $0x8
popq %rdx
callq 0x51500
movq %r13, %rdi
callq 0x4e020
movq 0x38(%rsp), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x50(%rsp,%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4f690
movq %r15, %rdi
movq %r13, %rsi
callq 0x4ffb0
movq %rbx, %rdi
callq 0x4e070
addq $0x8, %r12
jmp 0x704a7
movq 0x10(%rsp), %rdi
callq 0x4ed00
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x70558
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4e070
jmp 0x70558
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: NameSymbol::checkTableFill()
void NameSymbol::checkTableFill(void)

{ // Check if all possible entries in the table have been filled
  intb min = patval->minValue();
  intb max = patval->maxValue();
  tableisfilled = (min>=0)&&(max<nametable.size());
  for(uint4 i=0;i<nametable.size();++i) {
    if ((nametable[i] == "_")||(nametable[i] == "\t")) {
      nametable[i] = "\t";		// TAB indicates illegal index
      tableisfilled = false;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %r14
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
xorl %r13d, %r13d
testq %r14, %r14
js 0x7059f
movq 0x40(%rbx), %rcx
subq 0x38(%rbx), %rcx
sarq $0x5, %rcx
cmpq %rcx, %rax
setb %al
jmp 0x705a1
xorl %eax, %eax
movb %al, 0x50(%rbx)
leaq 0x17c12(%rip), %r14     # 0x881bd
leaq 0x17c0d(%rip), %r15     # 0x881bf
movl %r13d, %r13d
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x7060a
movq %r13, %r12
shlq $0x5, %r12
addq %r12, %rdi
movq %r14, %rsi
callq 0x520f0
testb %al, %al
jne 0x705f2
movq 0x38(%rbx), %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x520f0
testb %al, %al
je 0x70605
addq 0x38(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x51eb0
movb $0x0, 0x50(%rbx)
incl %r13d
jmp 0x705b2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: NameSymbol::resolve(ParserWalker&)
Constructor *NameSymbol::resolve(ParserWalker &walker)

{
  if (!tableisfilled) {
    intb ind = patval->getValue(walker);
    if ((ind >= nametable.size())||(ind<0)||((nametable[ind].size()==1)&&(nametable[ind][0]=='\t'))) {
      ostringstream s;
      s << walker.getAddr().getShortcut();
      walker.getAddr().printRaw(s);
      s << ": No corresponding entry in nametable";
      throw BadDataError(s.str());
    }
  }
  return (Constructor *)0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
cmpb $0x0, 0x50(%rdi)
jne 0x70665
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
js 0x70673
movq 0x38(%r14), %rcx
movq 0x40(%r14), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rax
jae 0x70673
shlq $0x5, %rax
cmpq $0x1, 0x8(%rcx,%rax)
jne 0x70665
addq %rax, %rcx
movq (%rcx), %rax
cmpb $0x9, (%rax)
je 0x70673
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x504a0
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x7068c
movq (%rbx), %rax
movq 0x50(%rax), %rax
movsbl 0x30(%rax), %esi
movq %r14, %rdi
callq 0x4fc10
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x706a8
movq (%rbx), %rdi
addq $0x50, %rdi
leaq 0x28(%rsp), %rsi
callq 0x4f5a0
leaq 0x17b04(%rip), %rsi     # 0x881c1
leaq 0x28(%rsp), %rdi
callq 0x4f5b0
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x50fb0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x3e456(%rip), %rsi     # 0xaeb50
movq 0x3e537(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x70720
jmp 0x7072d
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
jmp 0x7072d
movq %rax, %r14
leaq 0x28(%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: NameSymbol::saveXml(std::ostream&) const
void NameSymbol::saveXml(ostream &s) const

{
  s << "<name_sym";
  SleighSymbol::saveXmlHeader(s);
  s << ">\n";
  patval->saveXml(s);
  for(int4 i=0;i<nametable.size();++i) {
    if (nametable[i] == "\t")		// TAB indicates an illegal index
      s << "<nametab/>\n";		// Emit tag with no name attribute
    else
      s << "<nametab name=\"" << nametable[i] << "\"/>\n";
  }
  s << "</name_sym>\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x17a5f(%rip), %rsi     # 0x881e7
movq %rbx, %rdi
callq 0x4f5b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x50b40
leaq 0x17ffc(%rip), %rsi     # 0x8879e
movq %rbx, %rdi
callq 0x4f5b0
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
xorl %r12d, %r12d
leaq 0x179fe(%rip), %r15     # 0x881bf
leaq 0x1702c(%rip), %rbp     # 0x877f4
xorl %r13d, %r13d
movq 0x38(%r14), %rdi
movq 0x40(%r14), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x70829
addq %r12, %rdi
movq %r15, %rsi
callq 0x520f0
movq %rbx, %rdi
testb %al, %al
je 0x707fa
leaq 0x179f9(%rip), %rsi     # 0x881f1
jmp 0x7081b
leaq 0x179fc(%rip), %rsi     # 0x881fd
callq 0x4f5b0
movq 0x38(%r14), %rsi
addq %r12, %rsi
movq %rax, %rdi
callq 0x4f1b0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4f5b0
incq %r13
addq $0x20, %r12
jmp 0x707cb
leaq 0x179dd(%rip), %rsi     # 0x8820d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f5b0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: NameSymbol::restoreXml(Element const*, SleighBase*)
void NameSymbol::restoreXml(const Element *el,SleighBase *trans)

{
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  patval = (PatternValue *) PatternExpression::restoreExpression(*iter,trans);
  patval->layClaim();
  ++iter;
  while(iter != list.end()) {
    const Element *subel = *iter;
    if (subel->getNumAttributes() >= 1)
      nametable.push_back(subel->getAttributeValue("name"));
    else
      nametable.push_back("\t");		// TAB indicates an illegal index
    ++iter;
  }
  checkTableFill();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rsi), %r12
movq (%r12), %rdi
movq %rdx, %rsi
callq 0x4f580
movq %rax, 0x30(%rbx)
incl 0x8(%rax)
movq %rbx, 0x10(%rsp)
leaq 0x38(%rbx), %r15
addq $0x8, %r12
leaq 0x18(%rsp), %r13
leaq 0xf(%rsp), %rbp
cmpq 0x80(%r14), %r12
je 0x70934
movq (%r12), %rbx
movq 0x48(%rbx), %rax
subq 0x40(%rbx), %rax
shrq $0x5, %rax
testl %eax, %eax
jle 0x70909
movq %r13, %rdi
leaq 0x15748(%rip), %rsi     # 0x86031
movq %rbp, %rdx
callq 0x515e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x50230
movq %r15, %rdi
movq %rax, %rsi
callq 0x4e310
jmp 0x70926
movq %r13, %rdi
leaq 0x178ac(%rip), %rsi     # 0x881bf
movq %rbp, %rdx
callq 0x515e0
movq %r15, %rdi
movq %r13, %rsi
callq 0x4dc80
movq %r13, %rdi
callq 0x4e020
addq $0x8, %r12
jmp 0x708c2
movq 0x10(%rsp), %rdi
callq 0x50610
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x70956
jmp 0x70951
movq %rax, %rbx
jmp 0x70963
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: VarnodeSymbol::VarnodeSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, AddrSpace*, unsigned long, int)
VarnodeSymbol::VarnodeSymbol(const string &nm,AddrSpace *base,uintb offset,int4 size)
  : PatternlessSymbol(nm)
{
  fix.space = base;
  fix.offset = offset;
  fix.size = size;
  context_bits = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
callq 0x50430
movq 0x3e57c(%rip), %rax     # 0xaef08
addq $0x10, %rax
movq %rax, (%r12)
movq %r15, 0x38(%r12)
movq %r14, 0x40(%r12)
movl %ebx, 0x48(%r12)
movb $0x0, 0x50(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: VarnodeSymbol::getFixedHandle(FixedHandle&, ParserWalker&) const
void VarnodeSymbol::getFixedHandle(FixedHandle &hand,ParserWalker &walker) const

{
  hand.space = fix.space;
  hand.offset_space = (AddrSpace *)0; // Not a dynamic symbol
  hand.offset_offset = fix.offset;
  hand.size = fix.size;
}

// Assembly:
movq 0x38(%rdi), %rax
movq %rax, (%rsi)
andq $0x0, 0x10(%rsi)
movq 0x40(%rdi), %rax
movq %rax, 0x18(%rsi)
movl 0x48(%rdi), %eax
movl %eax, 0x8(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: VarnodeSymbol::saveXml(std::ostream&) const
void VarnodeSymbol::saveXml(ostream &s) const

{
  s << "<varnode_sym";
  SleighSymbol::saveXmlHeader(s);
  s << " space=\"" << fix.space->getName() << "\"";
  s << " offset=\"0x" << hex << fix.offset << "\"";
  s << " size=\"" << dec << fix.size << "\"";
  s << ">\n";
  PatternlessSymbol::saveXml(s);
  s << "</varnode_sym>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x177a7(%rip), %rsi     # 0x88229
movq %rbx, %rdi
callq 0x4f5b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x50b40
leaq 0x1779a(%rip), %rsi     # 0x88236
movq %rbx, %rdi
callq 0x4f5b0
movq 0x38(%r14), %rsi
addq $0x38, %rsi
movq %rax, %rdi
callq 0x4f1b0
leaq 0x17b01(%rip), %r15     # 0x885bc
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f5b0
leaq 0x17772(%rip), %rsi     # 0x8823f
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)
movq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x4e990
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f5b0
leaq 0x17743(%rip), %rsi     # 0x8824b
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 0x48(%r14), %esi
movq %rax, %rdi
callq 0x4e990
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f5b0
leaq 0x17c5b(%rip), %rsi     # 0x8879e
movq %rbx, %rdi
callq 0x4f5b0
leaq 0x17701(%rip), %rsi     # 0x88253
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4f5b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: VarnodeSymbol::restoreXml(Element const*, SleighBase*)
void VarnodeSymbol::restoreXml(const Element *el,SleighBase *trans)

{
  fix.space = trans->getSpaceByName(el->getAttributeValue("space"));
  {
    istringstream s(el->getAttributeValue("offset"));
    s.unsetf(ios::dec | ios::hex | ios::oct);
    s >> fix.offset;
  }
  {
    istringstream s(el->getAttributeValue("size"));
    s.unsetf(ios::dec | ios::hex | ios::oct);
    s >> fix.size;
  }
				// PatternlessSymbol does not need restoring
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x15f47(%rip), %rsi     # 0x86afd
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x515e0
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x50230
movq %r15, %rdi
movq %rax, %rsi
callq 0x519f0
movq %rax, 0x38(%rbx)
leaq 0x30(%rsp), %rdi
callq 0x4e020
leaq 0x1610c(%rip), %rsi     # 0x86cfe
leaq 0x10(%rsp), %rdi
leaq 0xf(%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 0x40(%rbx), %rsi
callq 0x4e460
leaq 0x30(%rsp), %rdi
callq 0x4e070
leaq 0x1bb1a(%rip), %rsi     # 0x8c76d
leaq 0x10(%rsp), %rdi
leaq 0xf(%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)
addq $0x48, %rbx
movq %rbx, %rsi
callq 0x51830
leaq 0x30(%rsp), %rdi
callq 0x4e070
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x70cc1
jmp 0x70cd2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4e070
jmp 0x70cf0
jmp 0x70cd2
movq %rax, %rbx
jmp 0x70cf0
jmp 0x70cd9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x70ceb
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextSymbol::ContextSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ContextField*, VarnodeSymbol*, unsigned int, unsigned int, bool)
ContextSymbol::ContextSymbol(const string &nm,ContextField *pate,VarnodeSymbol *v,
			     uint4 l,uint4 h,bool fl)
  : ValueSymbol(nm,pate)
{
  vn = v;
  low = l;
  high = h;
  flow = fl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdi, %r15
movb 0x30(%rsp), %r12b
callq 0x4d500
movq 0x3dd73(%rip), %rax     # 0xaea90
addq $0x10, %rax
movq %rax, (%r15)
movq %r14, 0x38(%r15)
movl %ebp, 0x40(%r15)
movl %ebx, 0x44(%r15)
movb %r12b, 0x48(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop