LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19699(%rip), %rsi     # 0x7f031
leaq 0x19696(%rip), %rdx     # 0x7f035
leaq 0x20(%rsp), %rdi
callq 0x3f8a0
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x40f70
leaq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x3fc60
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x659d9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a327(%rip), %rsi     # 0x7fd10
leaq 0x1a322(%rip), %rdx     # 0x7fd12
movq %rsp, %rdi
callq 0x3f8a0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x40f70
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c80
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x65a2b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x38(%rsp,%rax)
leaq 0x28(%rbx), %rsi
callq 0x41eb0
movq 0x3d2c4(%rip), %rsi     # 0xa2d10
leaq 0x20(%rsp), %rdi
callq 0x41440
leaq 0x98(%rsp), %rdi
callq 0x3f730
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1b679(%rip), %rsi     # 0x810e9
leaq 0x1b677(%rip), %rdx     # 0x810ee
callq 0x3f8a0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x40f70
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c80
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x65aaf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x38(%rsp,%rax)
addq $0x2c, %rbx
movq %rbx, %rsi
callq 0x41eb0
movq 0x3d23d(%rip), %rsi     # 0xa2d10
leaq 0x20(%rsp), %rdi
callq 0x41440
leaq 0x98(%rsp), %rdi
callq 0x3f730
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x65afb
jmp 0x65b20
movq %rax, %rbx
movq 0x3d20b(%rip), %rsi     # 0xa2d10
leaq 0x20(%rsp), %rdi
callq 0x41440
leaq 0x98(%rsp), %rdi
callq 0x3f730
jmp 0x65b54
jmp 0x65b20
movq %rax, %rbx
jmp 0x65b54
jmp 0x65b27
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x65b54
movq 0x10(%rsp), %rsi
jmp 0x65b4c
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x65b54
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/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
movaps %xmm0, 0x20(%rsp)
xorl %eax, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0x65ebd
xorl %r12d, %r12d
leaq 0x20(%rsp), %r14
leaq 0x48(%rsp), %r15
movq (%rax,%r12,8), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x65ea6
movq 0x28(%rsp), %rsi
movq %rsi, %rcx
subq 0x20(%rsp), %rcx
shrq $0x3, %rcx
movl %ecx, 0x38(%rax)
cmpq 0x30(%rsp), %rsi
je 0x65e9b
movq %rax, (%rsi)
addq $0x8, 0x28(%rsp)
jmp 0x65ea6
movq %r14, %rdi
movq %r15, %rdx
callq 0x41fc0
incq %r12
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x65e67
leaq 0x18(%rbx), %r14
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x65f39
xorl %r13d, %r13d
movq %rsp, %r15
leaq 0x40(%rsp), %r12
movq (%rax,%r13,8), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x65f23
movl 0x2c(%rax), %ecx
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0x2c(%rax)
movq 0x8(%rsp), %rsi
movq %rsi, %rcx
subq (%rsp), %rcx
shrq $0x3, %rcx
movl %ecx, 0x28(%rax)
cmpq 0x10(%rsp), %rsi
je 0x65f18
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x65f23
movq %r15, %rdi
movq %r12, %rdx
callq 0x40570
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x65ed5
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x3fd90
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x41c00
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x65f67
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x65f7e
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x65f90
jmp 0x65f90
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x65fa9
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x65fc0
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
leaq 0x1a2a9(%rip), %rsi     # 0x80283
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x40b80
leaq 0x1b5e9(%rip), %r15     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b80
leaq 0x1b09a(%rip), %rsi     # 0x810af
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x3ffb0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b80
leaq 0x1b0be(%rip), %rsi     # 0x81118
movl $0xa, %edx
movq %rbx, %rdi
callq 0x40b80
movl 0x2c(%r14), %esi
movq %rbx, %rdi
callq 0x3ffb0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x40b80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b08a(%rip), %rsi     # 0x81123
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415b0
leaq 0x1a82b(%rip), %rsi     # 0x808e3
movl $0x8, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
movl 0x30(%r14), %esi
movq %rbx, %rdi
callq 0x3ffb0
leaq 0x1b4fa(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b80
leaq 0x1a714(%rip), %rsi     # 0x80815
movl $0x3, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40b80
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq 0x3ca51(%rip), %rax     # 0xa2cc0
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x18, %edi
callq 0x40800
movl $0x0, 0x8(%rax)
movq 0x3cc42(%rip), %rcx     # 0xa2ed0
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x30(%rbx)
movl $0x1, 0x8(%rax)
popq %rbx
retq
movq 0x3c7ff(%rip), %rcx     # 0xa2ab0
addq $0x10, %rcx
movq %rcx, (%rbx)
movq %rax, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x68, %edi
callq 0x40800
movq %rax, %rbx
movq 0x38(%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x40390
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40b10
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40b10
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x41aa0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x663dd
jmp 0x663dd
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x40870
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rsi)
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x10(%rax)
movq %rax, 0x18(%rbx)
movl $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x10(%rax)
movq %rax, %r14
testq %rax, %rax
js 0x66545
leaq 0x1ab93(%rip), %rsi     # 0x810b4
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
jmp 0x66571
leaq 0x1ac0b(%rip), %rsi     # 0x81157
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
negq %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x406f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1abc6(%rip), %rsi     # 0x8115b
movl $0xa, %edx
movq %rbx, %rdi
callq 0x40b80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415b0
leaq 0x1b215(%rip), %rsi     # 0x817c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
leaq 0x1ab91(%rip), %rsi     # 0x81166
movl $0xd, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40b80
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x66681
movq 0x40(%rbx), %rcx
subq 0x38(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
setb %dl
jmp 0x66683
xorl %edx, %edx
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
movb %dl, 0x50(%rbx)
subq %rax, %rcx
je 0x666b1
sarq $0x3, %rcx
xorl %edx, %edx
cmpq $0xbadbeef, (%rax,%rdx,8) # imm = 0xBADBEEF
jne 0x666a7
movb $0x0, 0x50(%rbx)
incq %rdx
movl %edx, %esi
cmpq %rsi, %rcx
ja 0x66699
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x666fe
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
js 0x6670c
movq 0x38(%r14), %rcx
movq 0x40(%r14), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x6670c
cmpq $0xbadbeef, (%rcx,%rax,8) # imm = 0xBADBEEF
je 0x6670c
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x41110
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x66725
movq (%rbx), %rax
movq 0x50(%rax), %rax
movb 0x30(%rax), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b80
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x6674c
movq (%rbx), %rdi
addq $0x50, %rdi
leaq 0x28(%rsp), %rsi
callq 0x407e0
leaq 0x1aa23(%rip), %rsi     # 0x81184
leaq 0x28(%rsp), %rdi
movl $0x26, %edx
callq 0x40b80
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x418b0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x3c3ab(%rip), %rsi     # 0xa2b50
movq 0x3c48c(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x667da
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x667da
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x667ec
movq %rbx, %rdi
callq 0x40080
jmp 0x667ec
movq %rax, %r14
movq 0x3c58d(%rip), %rsi     # 0xa2d80
leaq 0x28(%rsp), %rdi
callq 0x3fc30
leaq 0x98(%rsp), %rdi
callq 0x3f730
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%r14)
movl %eax, %eax
movq 0x38(%r15), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x18(%r14)
movl $0x0, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x10(%rax)
movl %eax, %eax
movq 0x38(%r14), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
js 0x668ad
leaq 0x1a82b(%rip), %rsi     # 0x810b4
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
jmp 0x668d9
leaq 0x1a8a3(%rip), %rsi     # 0x81157
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
negq %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x406f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1a8a7(%rip), %rsi     # 0x811ab
movl $0xd, %edx
movq %rbx, %rdi
callq 0x40b80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415b0
leaq 0x1aea6(%rip), %rsi     # 0x817c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
movq 0x40(%r14), %rax
cmpq 0x38(%r14), %rax
je 0x669b8
movl $0x1, %ebp
xorl %r13d, %r13d
leaq 0x1a863(%rip), %r15     # 0x811b9
leaq 0x19eb7(%rip), %r12     # 0x80814
movl $0xf, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq 0x38(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
callq 0x406f0
movl $0x4, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b80
movq 0x40(%r14), %rax
subq 0x38(%r14), %rax
movl %ebp, %r13d
sarq $0x3, %rax
incl %ebp
cmpq %r13, %rax
ja 0x6695d
leaq 0x1a80a(%rip), %rsi     # 0x811c9
movl $0x10, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40b80
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rsi), %r13
movq (%r13), %rdi
movq %rdx, %rsi
callq 0x407c0
movq %rax, 0x30(%rbx)
incl 0x8(%rax)
addq $0x8, %r13
cmpq 0x80(%r14), %r13
je 0x66b35
leaq 0x38(%rbx), %rax
movq %rax, 0x20(%rsp)
movq %rsp, %r15
leaq 0x28(%rsp), %r12
movq (%r13), %rbp
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %r15, %rdi
leaq 0x1872b(%rip), %rsi     # 0x7f1b0
leaq 0x18727(%rip), %rdx     # 0x7f1b3
callq 0x3f8a0
movq %rbp, %rdi
movq %r15, %rsi
callq 0x40f70
movq %r12, %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c80
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x66ac7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x40(%rsp,%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x40880
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x66afb
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x40(%rbx)
jmp 0x66b08
movq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x3f160
movq %r12, %rdi
movq 0x3c1fe(%rip), %rsi     # 0xa2d10
callq 0x41440
leaq 0xa0(%rsp), %rdi
callq 0x3f730
addq $0x8, %r13
cmpq 0x80(%r14), %r13
jne 0x66a6e
movq %rbx, %rdi
callq 0x40230
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x66b95
movq %rax, %rbx
movq 0x3c1b2(%rip), %rsi     # 0xa2d10
leaq 0x28(%rsp), %rdi
callq 0x41440
leaq 0xa0(%rsp), %rdi
callq 0x3f730
jmp 0x66b95
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x66b95
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
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)
testq %r14, %r14
js 0x66bd9
movq 0x40(%rbx), %rcx
subq 0x38(%rbx), %rcx
sarq $0x5, %rcx
cmpq %rcx, %rax
setb %al
jmp 0x66bdb
xorl %eax, %eax
movb %al, 0x50(%rbx)
movq 0x38(%rbx), %rdi
cmpq %rdi, 0x40(%rbx)
je 0x66c5e
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x1a5f6(%rip), %r14     # 0x811ed
leaq 0x1a5f1(%rip), %r15     # 0x811ef
shlq $0x5, %r12
addq %r12, %rdi
movq %r14, %rsi
callq 0x3f590
testl %eax, %eax
je 0x66c24
movq 0x38(%rbx), %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x3f590
testl %eax, %eax
jne 0x66c45
movq 0x38(%rbx), %rax
leaq (%rax,%r12), %rdi
movq 0x8(%rax,%r12), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x417c0
movb $0x0, 0x50(%rbx)
movl %ebp, %r12d
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
incl %ebp
cmpq %r12, %rax
ja 0x66bfe
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x66cb9
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
js 0x66cc7
movq 0x38(%r14), %rcx
movq 0x40(%r14), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rax
jae 0x66cc7
shlq $0x5, %rax
cmpq $0x1, 0x8(%rcx,%rax)
jne 0x66cb9
addq %rax, %rcx
movq (%rcx), %rax
cmpb $0x9, (%rax)
je 0x66cc7
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x41110
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x66ce0
movq (%rbx), %rax
movq 0x50(%rax), %rax
movb 0x30(%rax), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b80
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x66d07
movq (%rbx), %rdi
addq $0x50, %rdi
leaq 0x28(%rsp), %rsi
callq 0x407e0
leaq 0x1a4d5(%rip), %rsi     # 0x811f1
leaq 0x28(%rsp), %rdi
movl $0x25, %edx
callq 0x40b80
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x418b0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x3bdf0(%rip), %rsi     # 0xa2b50
movq 0x3bed1(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x66d95
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x66d95
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x66da7
movq %rbx, %rdi
callq 0x40080
jmp 0x66da7
movq %rax, %r14
movq 0x3bfd2(%rip), %rsi     # 0xa2d80
leaq 0x28(%rsp), %rdi
callq 0x3fc30
leaq 0x98(%rsp), %rdi
callq 0x3f730
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a3f7(%rip), %rsi     # 0x81217
movl $0x9, %edx
movq %rbx, %rdi
callq 0x40b80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415b0
leaq 0x1a98a(%rip), %rsi     # 0x817c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
movq 0x38(%r14), %rdi
cmpq %rdi, 0x40(%r14)
je 0x66eef
xorl %r12d, %r12d
leaq 0x1a37e(%rip), %r15     # 0x811ef
leaq 0x1999c(%rip), %rbp     # 0x80814
xorl %r13d, %r13d
addq %r12, %rdi
movq %r15, %rsi
callq 0x3f590
testl %eax, %eax
je 0x66ec0
movl $0xf, %edx
movq %rbx, %rdi
leaq 0x1a394(%rip), %rsi     # 0x8122d
callq 0x40b80
movq 0x38(%r14), %rax
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x40b80
movl $0x4, %edx
movq %rax, %rdi
movq %rbp, %rsi
jmp 0x66ecf
movl $0xb, %edx
movq %rbx, %rdi
leaq 0x1a352(%rip), %rsi     # 0x81221
callq 0x40b80
incq %r13
movq 0x38(%r14), %rdi
movq 0x40(%r14), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r12
cmpq %r13, %rax
ja 0x66e7b
leaq 0x1a347(%rip), %rsi     # 0x8123d
movl $0xc, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40b80
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rsi), %r12
movq (%r12), %rdi
movq %rdx, %rsi
callq 0x407c0
movq %rbx, (%rsp)
movq %rax, 0x30(%rbx)
incl 0x8(%rax)
addq $0x8, %r12
cmpq 0x80(%r14), %r12
je 0x6703d
leaq 0x18(%rsp), %r13
movq (%rsp), %rax
leaq 0x38(%rax), %r15
leaq 0x8(%rsp), %rbp
movq (%r12), %rbx
movq 0x48(%rbx), %rax
subq 0x40(%rbx), %rax
shrq $0x5, %rax
testl %eax, %eax
jle 0x66fef
movq %r13, 0x8(%rsp)
movq %rbp, %rdi
leaq 0x18066(%rip), %rsi     # 0x7f031
leaq 0x18063(%rip), %rdx     # 0x7f035
callq 0x3f8a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x40f70
movq %r15, %rdi
movq %rax, %rsi
callq 0x3fbc0
jmp 0x67015
movq %r13, 0x8(%rsp)
movq %rbp, %rdi
leaq 0x1a1f1(%rip), %rsi     # 0x811ef
leaq 0x1a1eb(%rip), %rdx     # 0x811f0
callq 0x3f8a0
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3f7b0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6702c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
addq $0x8, %r12
cmpq 0x80(%r14), %r12
jne 0x66fa8
movq (%rsp), %rdi
callq 0x41220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6705e
jmp 0x67059
movq %rax, %rbx
jmp 0x67078
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x67078
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/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 0x410c0
movq 0x3be70(%rip), %rax     # 0xa2f10
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_O1/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)
movq $0x0, 0x10(%rsi)
movq 0x40(%rdi), %rax
movq %rax, 0x18(%rsi)
movl 0x48(%rdi), %eax
movl %eax, 0x8(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a0a5(%rip), %rsi     # 0x81259
movl $0xc, %edx
movq %rbx, %rdi
callq 0x40b80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415b0
leaq 0x1a093(%rip), %rsi     # 0x81266
movl $0x8, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x38(%r14), %rax
movq 0x38(%rax), %rsi
movq 0x40(%rax), %rdx
movq %rbx, %rdi
callq 0x40b80
leaq 0x1a3ec(%rip), %r15     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b80
leaq 0x1a05d(%rip), %rsi     # 0x8126f
movl $0xb, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x3ffb0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b80
leaq 0x1a024(%rip), %rsi     # 0x8127b
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
movl 0x48(%r14), %esi
movq %rbx, %rdi
callq 0x3ffb0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b80
leaq 0x1a52d(%rip), %rsi     # 0x817c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
leaq 0x19fd3(%rip), %rsi     # 0x81283
movl $0xf, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40b80
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x187ef(%rip), %rsi     # 0x7fb1d
leaq 0x187ed(%rip), %rdx     # 0x7fb22
leaq 0x28(%rsp), %rdi
callq 0x3f8a0
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x40f70
movq %r15, %rdi
movq %rax, %rsi
callq 0x41fd0
movq %rax, 0x38(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x67372
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1899c(%rip), %rsi     # 0x7fd1e
leaq 0x1899b(%rip), %rdx     # 0x7fd24
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x40f70
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c80
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x673c9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x40(%rsp,%rax)
leaq 0x40(%rbx), %rsi
callq 0x3fc90
movq 0x3b926(%rip), %rsi     # 0xa2d10
leaq 0x28(%rsp), %rdi
callq 0x41440
leaq 0xa0(%rsp), %rdi
callq 0x3f730
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x1e38d(%rip), %rsi     # 0x8579d
leaq 0x1e38a(%rip), %rdx     # 0x857a1
callq 0x3f8a0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x40f70
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c80
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x67452
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x40(%rsp,%rax)
addq $0x48, %rbx
movq %rbx, %rsi
callq 0x41eb0
movq 0x3b89a(%rip), %rsi     # 0xa2d10
leaq 0x28(%rsp), %rdi
callq 0x41440
leaq 0xa0(%rsp), %rdi
callq 0x3f730
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x674a0
jmp 0x674c5
movq %rax, %rbx
movq 0x3b866(%rip), %rsi     # 0xa2d10
leaq 0x28(%rsp), %rdi
callq 0x41440
leaq 0xa0(%rsp), %rdi
callq 0x3f730
jmp 0x674fa
jmp 0x674c5
movq %rax, %rbx
jmp 0x674fa
jmp 0x674cc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x674fa
movq 0x18(%rsp), %rsi
jmp 0x674f2
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x674fa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movb 0x40(%rsp), %r13b
callq 0x40550
movq 0x3b5ab(%rip), %rax     # 0xa2ad8
addq $0x10, %rax
movq %rax, (%r12)
movq %r15, 0x30(%r12)
incl 0x8(%r15)
movq 0x3b54b(%rip), %rax     # 0xa2a90
addq $0x10, %rax
movq %rax, (%r12)
movq %r14, 0x38(%r12)
movl %ebp, 0x40(%r12)
movl %ebx, 0x44(%r12)
movb %r13b, 0x48(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextSymbol::saveXml(std::ostream&) const
void ContextSymbol::saveXml(ostream &s) const

{
  s << "<context_sym";
  SleighSymbol::saveXmlHeader(s);
  s << " varnode=\"0x" << hex << vn->getId() << "\"";
  s << " low=\"" << dec << low << "\"";
  s << " high=\"" << high << "\"";
  a_v_b(s,"flow",flow);
  s << ">\n";
  patval->saveXml(s);
  s << "</context_sym>\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x19d1e(%rip), %rsi     # 0x812a5
movl $0xc, %edx
movq %rbx, %rdi
callq 0x40b80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415b0
leaq 0x19d0c(%rip), %rsi     # 0x812b2
movl $0xc, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq 0x38(%r14), %rax
movl 0x28(%rax), %esi
movq %rbx, %rdi
callq 0x3ffb0
leaq 0x1a009(%rip), %r15     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b80
leaq 0x19cca(%rip), %rsi     # 0x812bf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
movl 0x40(%r14), %esi
movq %rbx, %rdi
callq 0x3ffb0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b80
leaq 0x19c8c(%rip), %rsi     # 0x812c6
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b80
movl 0x44(%r14), %esi
movq %rbx, %rdi
callq 0x3ffb0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b80
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19c5b(%rip), %rsi     # 0x812ce
leaq 0x19c58(%rip), %rdx     # 0x812d2
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb 0x48(%r14), %bpl
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
leaq 0x1a0a2(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b80
leaq 0x17ac4(%rip), %rax     # 0x7f18e
leaq 0x17ac2(%rip), %rsi     # 0x7f193
testb %bpl, %bpl
cmovneq %rax, %rsi
movzbl %bpl, %edx
xorq $0x5, %rdx
movq %rbx, %rdi
callq 0x40b80
leaq 0x19ef8(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x67713
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x1a0af(%rip), %rsi     # 0x817c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
leaq 0x19b98(%rip), %rsi     # 0x812d3
movl $0xf, %edx
movq %rbx, %rdi
callq 0x40b80
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6776d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: VarnodeListSymbol::checkTableFill()
void VarnodeListSymbol::checkTableFill(void)

{
  intb min = patval->minValue();
  intb max = patval->maxValue();
  tableisfilled = (min>=0)&&(max<varnode_table.size());
  for(uint4 i=0;i<varnode_table.size();++i) {
    if (varnode_table[i] == (VarnodeSymbol *)0)
      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 0x67b75
movq 0x40(%rbx), %rcx
subq 0x38(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
setb %dl
jmp 0x67b77
xorl %edx, %edx
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
movb %dl, 0x50(%rbx)
subq %rax, %rcx
je 0x67ba2
sarq $0x3, %rcx
xorl %edx, %edx
cmpq $0x0, (%rax,%rdx,8)
jne 0x67b98
movb $0x0, 0x50(%rbx)
incq %rdx
movl %edx, %esi
cmpq %rsi, %rcx
ja 0x67b8d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: VarnodeListSymbol::resolve(ParserWalker&)
Constructor *VarnodeListSymbol::resolve(ParserWalker &walker)

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
cmpb $0x0, 0x50(%rdi)
jne 0x67beb
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
js 0x67bf9
movq 0x38(%r14), %rcx
movq 0x40(%r14), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x67bf9
cmpq $0x0, (%rcx,%rax,8)
je 0x67bf9
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x41110
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x67c12
movq (%rbx), %rax
movq 0x50(%rax), %rax
movb 0x30(%rax), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b80
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x67c39
movq (%rbx), %rdi
addq $0x50, %rdi
leaq 0x28(%rsp), %rsi
callq 0x407e0
leaq 0x196b4(%rip), %rsi     # 0x81302
leaq 0x28(%rsp), %rdi
movl $0x28, %edx
callq 0x40b80
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x418b0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x3aebe(%rip), %rsi     # 0xa2b50
movq 0x3af9f(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67cc7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x67cc7
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x67cd9
movq %rbx, %rdi
callq 0x40080
jmp 0x67cd9
movq %rax, %r14
movq 0x3b0a0(%rip), %rsi     # 0xa2d80
leaq 0x28(%rsp), %rdi
callq 0x3fc30
leaq 0x98(%rsp), %rdi
callq 0x3f730
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: VarnodeListSymbol::getFixedHandle(FixedHandle&, ParserWalker&) const
void VarnodeListSymbol::getFixedHandle(FixedHandle &hand,ParserWalker &walker) const

{
  uint4 ind = (uint4) patval->getValue(walker);
  // The resolve routine has checked that -ind- must be a valid index
  const VarnodeData &fix( varnode_table[ind]->getFixedVarnode() );
  hand.space = fix.space;
  hand.offset_space = (AddrSpace *)0; // Not a dynamic value
  hand.offset_offset = fix.offset;
  hand.size = fix.size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x10(%rax)
movl %eax, %eax
movq 0x38(%r14), %rcx
movq (%rcx,%rax,8), %rax
movq 0x38(%rax), %rcx
movq %rcx, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x40(%rax), %rcx
movq %rcx, 0x18(%rbx)
movl 0x48(%rax), %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: VarnodeListSymbol::getSize() const
int4 VarnodeListSymbol::getSize(void) const

{
  for(int4 i=0;i<varnode_table.size();++i) {
    VarnodeSymbol *vnsym = varnode_table[i]; // Assume all are same size
    if (vnsym != (VarnodeSymbol *)0)
      return vnsym->getSize();
  }
  throw SleighError("No register attached to: "+getName());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rcx
cmpq %rcx, 0x40(%rdi)
setne %bpl
je 0x67d98
xorl %r15d, %r15d
movq (%rcx,%r15,8), %r14
testq %r14, %r14
je 0x67d76
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
testq %r14, %r14
jne 0x67d98
incq %r15
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
seta %bpl
ja 0x67d64
jmp 0x67d98
testb $0x1, %bpl
je 0x67da9
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %r14
addq $0x8, %rbx
leaq 0x1956a(%rip), %rsi     # 0x8132b
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x40500
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x3b0a9(%rip), %rsi     # 0xa2e90
movq 0x3ae4a(%rip), %rdx     # 0xa2c38
movq %r14, %rdi
callq 0x41d60
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67e1c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x67e1c
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x67e29
movq %r14, %rdi
callq 0x40080
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x10(%rax)
movl %eax, %eax
movq 0x38(%r14), %rcx
movq 0x40(%r14), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x67e83
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x40b80
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x194a5(%rip), %rsi     # 0x81345
leaq 0x194c2(%rip), %rdx     # 0x81369
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x3afc6(%rip), %rsi     # 0xa2e90
movq 0x3ad67(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x67efb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x67efb
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x67f08
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x19442(%rip), %rsi     # 0x8136a
movl $0xc, %edx
movq %rbx, %rdi
callq 0x40b80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415b0
leaq 0x19882(%rip), %rsi     # 0x817c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
movq 0x38(%r14), %rax
cmpq %rax, 0x40(%r14)
je 0x67ff9
xorl %ebp, %ebp
leaq 0x18418(%rip), %r15     # 0x80390
leaq 0x193f8(%rip), %r12     # 0x81377
leaq 0x1888e(%rip), %r13     # 0x80814
cmpq $0x0, (%rax,%rbp,8)
je 0x67fd2
movl $0xb, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq 0x38(%r14), %rax
movq (%rax,%rbp,8), %rax
movl 0x28(%rax), %esi
movq %rbx, %rdi
callq 0x3ffb0
movl $0x4, %edx
movq %rax, %rdi
movq %r13, %rsi
jmp 0x67fdd
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x40b80
incq %rbp
movq 0x38(%r14), %rax
movq 0x40(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
ja 0x67f86
leaq 0x19383(%rip), %rsi     # 0x81383
movl $0xf, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40b80
nop