LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rsi, 0x8(%rsp)
movq 0x8(%rdi), %rax
movq %rax, %rcx
subq (%rdi), %rcx
shrq $0x3, %rcx
movl %ecx, 0x28(%rsi)
cmpq 0x10(%rdi), %rax
je 0x6488d
movq %rsi, (%rax)
addq $0x8, 0x8(%rbx)
jmp 0x648a3
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x40580
movq (%r14), %rsi
movq 0x30(%rbx), %rdi
movl 0x38(%rdi), %eax
movl %eax, 0x2c(%rsi)
leaq 0x10(%rsp), %rbx
movq %rsi, (%rbx)
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x3fdd0
addq $0x20, %rax
testb $0x1, %dl
cmovneq %rbx, %rax
movq (%rax), %rax
cmpq 0x8(%rsp), %rax
jne 0x648df
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
movq 0x8(%rsp), %rdx
addq $0x8, %rdx
leaq 0x1c76c(%rip), %rsi     # 0x81068
leaq 0x10(%rsp), %rdi
callq 0x40510
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x3e571(%rip), %rsi     # 0xa2e90
movq 0x3e312(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6494c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x64956
jmp 0x6495e
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x64997
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x412f0
testq %rax, %rax
jne 0x6498f
movq (%r14), %r14
testq %r14, %r14
jne 0x64975
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13d
decq %r13
testl %r13d, %r13d
js 0x64a45
movl %r13d, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq 0x18(%r15), %rax
movq (%rax,%rbp,8), %rdi
movq %r12, %rsi
callq 0x412f0
decq %r13
cmpq %rbx, %rax
jne 0x649c4
movq 0x18(%r15), %rax
movq (%rax,%rbp,8), %r12
movq %rsp, %r13
movq %rbx, (%r13)
addq $0x8, %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3f970
movq %r12, %rdi
movq %rax, %rsi
callq 0x3fb50
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,%rbp,8), %rdi
movq %r14, (%r13)
addq $0x8, %rdi
movq %rsp, %rsi
callq 0x3fdd0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19939(%rip), %rsi     # 0x7f031
leaq 0x19936(%rip), %rdx     # 0x7f035
leaq 0x20(%rsp), %rdi
callq 0x3f8a0
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x40f80
leaq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x3fc60
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x65739
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a5c7(%rip), %rsi     # 0x7fd10
leaq 0x1a5c2(%rip), %rdx     # 0x7fd12
movq %rsp, %rdi
callq 0x3f8a0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x40f80
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c90
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6578b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x38(%rsp,%rax)
leaq 0x28(%rbx), %rsi
callq 0x41ec0
movq 0x3d564(%rip), %rsi     # 0xa2d10
leaq 0x20(%rsp), %rdi
callq 0x41450
leaq 0x98(%rsp), %rdi
callq 0x3f730
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1b919(%rip), %rsi     # 0x810e9
leaq 0x1b917(%rip), %rdx     # 0x810ee
callq 0x3f8a0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x40f80
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c90
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6580f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x38(%rsp,%rax)
addq $0x2c, %rbx
movq %rbx, %rsi
callq 0x41ec0
movq 0x3d4dd(%rip), %rsi     # 0xa2d10
leaq 0x20(%rsp), %rdi
callq 0x41450
leaq 0x98(%rsp), %rdi
callq 0x3f730
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6585b
jmp 0x65880
movq %rax, %rbx
movq 0x3d4ab(%rip), %rsi     # 0xa2d10
leaq 0x20(%rsp), %rdi
callq 0x41450
leaq 0x98(%rsp), %rdi
callq 0x3f730
jmp 0x658b4
jmp 0x65880
movq %rax, %rbx
jmp 0x658b4
jmp 0x65887
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x658b4
movq 0x10(%rsp), %rsi
jmp 0x658ac
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x658b4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x65c11
xorl %r12d, %r12d
leaq 0x20(%rsp), %r14
leaq 0x48(%rsp), %r15
movq (%rax,%r12,8), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x65bfa
movq 0x28(%rsp), %rsi
movq %rsi, %rcx
subq 0x20(%rsp), %rcx
shrq $0x3, %rcx
movl %ecx, 0x38(%rax)
cmpq 0x30(%rsp), %rsi
je 0x65bef
movq %rax, (%rsi)
addq $0x8, 0x28(%rsp)
jmp 0x65bfa
movq %r14, %rdi
movq %r15, %rdx
callq 0x41fd0
incq %r12
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x65bbb
leaq 0x18(%rbx), %r14
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x65c8d
xorl %r13d, %r13d
movq %rsp, %r15
leaq 0x40(%rsp), %r12
movq (%rax,%r13,8), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x65c77
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 0x65c6c
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x65c77
movq %r15, %rdi
movq %r12, %rdx
callq 0x40580
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x65c29
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x3fd90
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x41c10
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x65cbb
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x65cd2
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x65ce2
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x65d00
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
jmp 0x65d00
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x65d17
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a551(%rip), %rsi     # 0x80283
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x40b90
leaq 0x1b891(%rip), %r15     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b90
leaq 0x1b342(%rip), %rsi     # 0x810af
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b90
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 0x3ffc0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b90
leaq 0x1b366(%rip), %rsi     # 0x81118
movl $0xa, %edx
movq %rbx, %rdi
callq 0x40b90
movl 0x2c(%r14), %esi
movq %rbx, %rdi
callq 0x3ffc0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x40b90
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b332(%rip), %rsi     # 0x81123
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415c0
leaq 0x1aad3(%rip), %rsi     # 0x808e3
movl $0x8, %edx
movq %rbx, %rdi
callq 0x40b90
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 0x3ffc0
leaq 0x1b7a2(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b90
leaq 0x1a9bc(%rip), %rsi     # 0x80815
movl $0x3, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40b90
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3ccf9(%rip), %rax     # 0xa2cc0
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x18, %edi
callq 0x40810
movq 0x3cef1(%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 0x3caae(%rip), %rcx     # 0xa2ab0
addq $0x10, %rcx
movq %rcx, (%rbx)
movq %rax, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40810
movq %rax, %rbx
movq 0x38(%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x403a0
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40b20
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40b20
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x41ab0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x66127
jmp 0x66127
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x40880
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6628f
leaq 0x1ae49(%rip), %rsi     # 0x810b4
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b90
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
jmp 0x662bb
leaq 0x1aec1(%rip), %rsi     # 0x81157
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b90
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 0x40700
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ae7c(%rip), %rsi     # 0x8115b
movl $0xa, %edx
movq %rbx, %rdi
callq 0x40b90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415c0
leaq 0x1b4cb(%rip), %rsi     # 0x817c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
leaq 0x1ae47(%rip), %rsi     # 0x81166
movl $0xd, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40b90
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x663d1
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
setb %al
jmp 0x663e5
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorl %eax, %eax
movb %al, 0x50(%rbx)
cmpq %rcx, %rsi
je 0x66407
xorl %eax, %eax
cmpq $0xbadbeef, (%rcx,%rax,8) # imm = 0xBADBEEF
jne 0x663fd
movb $0x0, 0x50(%rbx)
incq %rax
movl %eax, %esi
cmpq %rsi, %rdx
ja 0x663ef
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x66454
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
js 0x66462
movq 0x38(%r14), %rcx
movq 0x40(%r14), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x66462
cmpq $0xbadbeef, (%rcx,%rax,8) # imm = 0xBADBEEF
je 0x66462
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x41120
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x6647b
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 0x40b90
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x664a2
movq (%rbx), %rdi
addq $0x50, %rdi
leaq 0x28(%rsp), %rsi
callq 0x407f0
leaq 0x1accd(%rip), %rsi     # 0x81184
leaq 0x28(%rsp), %rdi
movl $0x26, %edx
callq 0x40b90
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x418c0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x3c655(%rip), %rsi     # 0xa2b50
movq 0x3c736(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x66528
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x66532
jmp 0x6653f
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
jmp 0x6653f
movq %rax, %r14
movq 0x3c83a(%rip), %rsi     # 0xa2d80
leaq 0x28(%rsp), %rdi
callq 0x3fc30
leaq 0x98(%rsp), %rdi
callq 0x3f730
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x66601
leaq 0x1aad7(%rip), %rsi     # 0x810b4
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b90
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
jmp 0x6662d
leaq 0x1ab4f(%rip), %rsi     # 0x81157
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b90
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 0x40700
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ab53(%rip), %rsi     # 0x811ab
movl $0xd, %edx
movq %rbx, %rdi
callq 0x40b90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415c0
leaq 0x1b152(%rip), %rsi     # 0x817c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
movq 0x40(%r14), %rax
cmpq 0x38(%r14), %rax
je 0x6670c
movl $0x1, %ebp
xorl %r13d, %r13d
leaq 0x1ab0f(%rip), %r15     # 0x811b9
leaq 0x1a163(%rip), %r12     # 0x80814
movl $0xf, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x40b90
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 0x40700
movl $0x4, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b90
movq 0x40(%r14), %rax
subq 0x38(%r14), %rax
movl %ebp, %r13d
sarq $0x3, %rax
incl %ebp
cmpq %r13, %rax
ja 0x666b1
leaq 0x1aab6(%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 0x40b90
// File: /workspace/github_cpp_makefile_star2_O3/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 0x407d0
movq %rax, 0x30(%rbx)
incl 0x8(%rax)
addq $0x8, %r13
cmpq 0x80(%r14), %r13
je 0x66889
leaq 0x38(%rbx), %rax
movq %rax, 0x20(%rsp)
movq %rsp, %r12
leaq 0x28(%rsp), %r15
movq (%r13), %rbp
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %r12, %rdi
leaq 0x189d7(%rip), %rsi     # 0x7f1b0
leaq 0x189d3(%rip), %rdx     # 0x7f1b3
callq 0x3f8a0
movq %rbp, %rdi
movq %r12, %rsi
callq 0x40f80
movq %r15, %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c90
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6681b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x40(%rsp,%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x40890
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x6684f
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x40(%rbx)
jmp 0x6685c
movq 0x20(%rsp), %rdi
movq %r12, %rdx
callq 0x3f160
movq %r15, %rdi
movq 0x3c4aa(%rip), %rsi     # 0xa2d10
callq 0x41450
leaq 0xa0(%rsp), %rdi
callq 0x3f730
addq $0x8, %r13
cmpq 0x80(%r14), %r13
jne 0x667c2
movq %rbx, %rdi
callq 0x40240
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x668e9
movq %rax, %rbx
movq 0x3c45e(%rip), %rsi     # 0xa2d10
leaq 0x28(%rsp), %rdi
callq 0x41450
leaq 0xa0(%rsp), %rdi
callq 0x3f730
jmp 0x668e9
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x668e9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x66933
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rcx
movq %rcx, %rdx
subq %rdi, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rax
setb %al
jmp 0x6693d
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rcx
xorl %eax, %eax
movb %al, 0x50(%rbx)
cmpq %rdi, %rcx
je 0x669bb
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x1a899(%rip), %r14     # 0x811ed
leaq 0x1a894(%rip), %r15     # 0x811ef
shlq $0x5, %r12
addq %r12, %rdi
movq %r14, %rsi
callq 0x3f590
testl %eax, %eax
je 0x66981
movq 0x38(%rbx), %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x3f590
testl %eax, %eax
jne 0x669a2
movq 0x38(%rbx), %rax
leaq (%rax,%r12), %rdi
movq 0x8(%rax,%r12), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x417d0
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 0x6695b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x66a15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
js 0x66a23
movq 0x38(%r14), %rcx
movq 0x40(%r14), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rax
jae 0x66a23
shlq $0x5, %rax
cmpq $0x1, 0x8(%rcx,%rax)
jne 0x66a15
addq %rax, %rcx
movq (%rcx), %rax
cmpb $0x9, (%rax)
je 0x66a23
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x41120
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x66a3c
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 0x40b90
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x66a63
movq (%rbx), %rdi
addq $0x50, %rdi
leaq 0x28(%rsp), %rsi
callq 0x407f0
leaq 0x1a779(%rip), %rsi     # 0x811f1
leaq 0x28(%rsp), %rdi
movl $0x25, %edx
callq 0x40b90
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x418c0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x3c094(%rip), %rsi     # 0xa2b50
movq 0x3c175(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x66ae9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x66af3
jmp 0x66b00
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
jmp 0x66b00
movq %rax, %r14
movq 0x3c279(%rip), %rsi     # 0xa2d80
leaq 0x28(%rsp), %rdi
callq 0x3fc30
leaq 0x98(%rsp), %rdi
callq 0x3f730
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a69f(%rip), %rsi     # 0x81217
movl $0x9, %edx
movq %rbx, %rdi
callq 0x40b90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415c0
leaq 0x1ac32(%rip), %rsi     # 0x817c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
movq 0x38(%r14), %rdi
cmpq %rdi, 0x40(%r14)
je 0x66c47
xorl %r12d, %r12d
leaq 0x1a626(%rip), %r15     # 0x811ef
leaq 0x19c44(%rip), %rbp     # 0x80814
xorl %r13d, %r13d
addq %r12, %rdi
movq %r15, %rsi
callq 0x3f590
testl %eax, %eax
je 0x66c18
movl $0xf, %edx
movq %rbx, %rdi
leaq 0x1a63c(%rip), %rsi     # 0x8122d
callq 0x40b90
movq 0x38(%r14), %rax
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x40b90
movl $0x4, %edx
movq %rax, %rdi
movq %rbp, %rsi
jmp 0x66c27
movl $0xb, %edx
movq %rbx, %rdi
leaq 0x1a5fa(%rip), %rsi     # 0x81221
callq 0x40b90
incq %r13
movq 0x38(%r14), %rdi
movq 0x40(%r14), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r12
cmpq %r13, %rax
ja 0x66bd3
leaq 0x1a5ef(%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 0x40b90
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x407d0
movq %rbx, (%rsp)
movq %rax, 0x30(%rbx)
incl 0x8(%rax)
addq $0x8, %r12
cmpq 0x80(%r14), %r12
je 0x66d95
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 0x66d47
movq %r13, 0x8(%rsp)
movq %rbp, %rdi
leaq 0x1830e(%rip), %rsi     # 0x7f031
leaq 0x1830b(%rip), %rdx     # 0x7f035
callq 0x3f8a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x40f80
movq %r15, %rdi
movq %rax, %rsi
callq 0x3fbc0
jmp 0x66d6d
movq %r13, 0x8(%rsp)
movq %rbp, %rdi
leaq 0x1a499(%rip), %rsi     # 0x811ef
leaq 0x1a493(%rip), %rdx     # 0x811f0
callq 0x3f8a0
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3f7b0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x66d84
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
addq $0x8, %r12
cmpq 0x80(%r14), %r12
jne 0x66d00
movq (%rsp), %rdi
callq 0x41230
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x66db6
jmp 0x66db1
movq %rax, %rbx
jmp 0x66dd0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x66dd0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x410d0
movq 0x3c118(%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_O3/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 0x1a34d(%rip), %rsi     # 0x81259
movl $0xc, %edx
movq %rbx, %rdi
callq 0x40b90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415c0
leaq 0x1a33b(%rip), %rsi     # 0x81266
movl $0x8, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x38(%r14), %rax
movq 0x38(%rax), %rsi
movq 0x40(%rax), %rdx
movq %rbx, %rdi
callq 0x40b90
leaq 0x1a694(%rip), %r15     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b90
leaq 0x1a305(%rip), %rsi     # 0x8126f
movl $0xb, %edx
movq %rbx, %rdi
callq 0x40b90
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 0x3ffc0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b90
leaq 0x1a2cc(%rip), %rsi     # 0x8127b
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b90
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 0x3ffc0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b90
leaq 0x1a7d5(%rip), %rsi     # 0x817c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b90
leaq 0x1a27b(%rip), %rsi     # 0x81283
movl $0xf, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40b90
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18a97(%rip), %rsi     # 0x7fb1d
leaq 0x18a95(%rip), %rdx     # 0x7fb22
leaq 0x28(%rsp), %rdi
callq 0x3f8a0
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x40f80
movq %r15, %rdi
movq %rax, %rsi
callq 0x41fe0
movq %rax, 0x38(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x670ca
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x18c44(%rip), %rsi     # 0x7fd1e
leaq 0x18c43(%rip), %rdx     # 0x7fd24
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x40f80
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c90
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x67121
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x40(%rsp,%rax)
leaq 0x40(%rbx), %rsi
callq 0x3fc90
movq 0x3bbce(%rip), %rsi     # 0xa2d10
leaq 0x28(%rsp), %rdi
callq 0x41450
leaq 0xa0(%rsp), %rdi
callq 0x3f730
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x1e635(%rip), %rsi     # 0x8579d
leaq 0x1e632(%rip), %rdx     # 0x857a1
callq 0x3f8a0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x40f80
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c90
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x671aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x40(%rsp,%rax)
addq $0x48, %rbx
movq %rbx, %rsi
callq 0x41ec0
movq 0x3bb42(%rip), %rsi     # 0xa2d10
leaq 0x28(%rsp), %rdi
callq 0x41450
leaq 0xa0(%rsp), %rdi
callq 0x3f730
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x671f8
jmp 0x6721d
movq %rax, %rbx
movq 0x3bb0e(%rip), %rsi     # 0xa2d10
leaq 0x28(%rsp), %rdi
callq 0x41450
leaq 0xa0(%rsp), %rdi
callq 0x3f730
jmp 0x67252
jmp 0x6721d
movq %rax, %rbx
jmp 0x67252
jmp 0x67224
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x67252
movq 0x18(%rsp), %rsi
jmp 0x6724a
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x67252
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40560
movq %r15, 0x30(%r12)
incl 0x8(%r15)
movq 0x3b802(%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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19fd4(%rip), %rsi     # 0x812a5
movl $0xc, %edx
movq %rbx, %rdi
callq 0x40b90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x415c0
leaq 0x19fc2(%rip), %rsi     # 0x812b2
movl $0xc, %edx
movq %rbx, %rdi
callq 0x40b90
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 0x3ffc0
leaq 0x1a2bf(%rip), %r15     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b90
leaq 0x19f80(%rip), %rsi     # 0x812bf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x40b90
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 0x3ffc0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b90
leaq 0x19f42(%rip), %rsi     # 0x812c6
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b90
movl 0x44(%r14), %esi
movq %rbx, %rdi
callq 0x3ffc0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b90
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19f11(%rip), %rsi     # 0x812ce
leaq 0x19f0e(%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 0x40b90
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
leaq 0x1a358(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b90
leaq 0x17d7a(%rip), %rax     # 0x7f18e
leaq 0x17d78(%rip), %rsi     # 0x7f193
testb %bpl, %bpl
cmovneq %rax, %rsi
movzbl %bpl, %edx
xorq $0x5, %rdx
movq %rbx, %rdi
callq 0x40b90
leaq 0x1a1ae(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6745d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x1a365(%rip), %rsi     # 0x817c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
leaq 0x19e4e(%rip), %rsi     # 0x812d3
movl $0xf, %edx
movq %rbx, %rdi
callq 0x40b90
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x674b7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x678bf
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
setb %al
jmp 0x678d3
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorl %eax, %eax
movb %al, 0x50(%rbx)
cmpq %rcx, %rsi
je 0x678f2
xorl %eax, %eax
cmpq $0x0, (%rcx,%rax,8)
jne 0x678e8
movb $0x0, 0x50(%rbx)
incq %rax
movl %eax, %esi
cmpq %rsi, %rdx
ja 0x678dd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6793b
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
js 0x67949
movq 0x38(%r14), %rcx
movq 0x40(%r14), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x67949
cmpq $0x0, (%rcx,%rax,8)
je 0x67949
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x41120
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x67962
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 0x40b90
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x67989
movq (%rbx), %rdi
addq $0x50, %rdi
leaq 0x28(%rsp), %rsi
callq 0x407f0
leaq 0x19964(%rip), %rsi     # 0x81302
leaq 0x28(%rsp), %rdi
movl $0x28, %edx
callq 0x40b90
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x418c0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x3b16e(%rip), %rsi     # 0xa2b50
movq 0x3b24f(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67a0f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x67a19
jmp 0x67a26
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
jmp 0x67a26
movq %rax, %r14
movq 0x3b353(%rip), %rsi     # 0xa2d80
leaq 0x28(%rsp), %rdi
callq 0x3fc30
leaq 0x98(%rsp), %rdi
callq 0x3f730
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
je 0x67ac9
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rdi
testq %rdi, %rdi
jne 0x67b12
incq %rdx
cmpq %rdx, %rcx
jne 0x67ab8
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
addq $0x8, %r14
leaq 0x1984a(%rip), %rsi     # 0x8132b
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40510
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x3b38d(%rip), %rsi     # 0xa2e90
movq 0x3b12e(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq (%rdi), %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmpq *0x48(%rax)
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67b3e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x67b48
jmp 0x67b50
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x67ba9
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 0x40b90
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1977f(%rip), %rsi     # 0x81345
leaq 0x1979c(%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 0x3b2a0(%rip), %rsi     # 0xa2e90
movq 0x3b041(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x67c19
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x67c23
jmp 0x67c2b
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
nop