LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x13d921
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xdc7e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x13d910
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x13d92a
movq 0x10(%rsp), %rdi
callq 0xdbcc0
movq %rax, 0x10(%rsp)
jmp 0x13d8e3
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x18, %rdi
callq 0xdd9b0
subq $0x1, %rax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jl 0x13da71
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movslq 0x24(%rsp), %rsi
callq 0xe19d0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd1f90
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xdc7e0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x13da61
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movslq 0x24(%rsp), %rsi
callq 0xe19d0
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0xd3230
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movl 0x28(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x38(%rsp), %rax
movl 0x2c(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x2c(%rax)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, %esi
callq 0xd7fa0
movq (%rsp), %rcx
movq 0x18(%rsp), %rdi
movq %rcx, (%rax)
addq $0x18, %rdi
movslq 0x24(%rsp), %rsi
callq 0xe19d0
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0xde8d0
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x13da5f
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x13da71
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x13d96e
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xddc30
leaq 0x60(%rsp), %rdi
callq 0xd5d30
movl $0x0, 0x54(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x54(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x18, %rdi
callq 0xdd9b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x13fa69
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
movslq 0x54(%rsp), %rsi
callq 0xe19d0
movq (%rax), %rax
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x13fa57
leaq 0x78(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xdd9b0
movq 0x18(%rsp), %rdi
movl %eax, %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x38(%rax)
leaq 0x58(%rsp), %rsi
callq 0xd0890
jmp 0x13fa2e
jmp 0x13fa57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd9420
leaq 0x78(%rsp), %rdi
callq 0xd4a40
jmp 0x13fb5b
jmp 0x13fa59
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x13f9b8
movl $0x0, 0x34(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x34(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xd6170
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x13fb19
movq 0x28(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0xd7fa0
movq (%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x13fb07
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
movq 0x38(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, %esi
callq 0xe19d0
movq (%rax), %rax
movl 0x38(%rax), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x2c(%rax)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd6170
movq 0x8(%rsp), %rdi
movl %eax, %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x28(%rax)
leaq 0x38(%rsp), %rsi
callq 0xd2240
jmp 0x13fb05
jmp 0x13fb07
jmp 0x13fb09
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x13fa71
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
leaq 0x78(%rsp), %rsi
callq 0xd3db0
jmp 0x13fb2e
movq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xdfb30
jmp 0x13fb3f
leaq 0x60(%rsp), %rdi
callq 0xd9420
leaq 0x78(%rsp), %rdi
callq 0xd4a40
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x486ec(%rip), %rsi     # 0x18827f
callq 0xd8300
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0xd7350
movq %rax, %rdi
leaq 0x498da(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x8(%rsp), %rdi
leaq 0x4938c(%rip), %rsi     # 0x188f4f
callq 0xd8300
movq %rax, %rdi
movq 0x883f6(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rdi
movq (%rsp), %rax
movl 0x28(%rax), %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x4989c(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x8(%rsp), %rdi
leaq 0x493b7(%rip), %rsi     # 0x188fb8
callq 0xd8300
movq %rax, %rdi
movq (%rsp), %rax
movl 0x2c(%rax), %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x4986d(%rip), %rsi     # 0x18948c
callq 0xd8300
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x49370(%rip), %rsi     # 0x188fc3
callq 0xd8300
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xdd790
movq 0x8(%rsp), %rdi
leaq 0x48c79(%rip), %rsi     # 0x1888eb
callq 0xd8300
movq %rax, %rdi
movq 0x88117(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movq (%rsp), %rax
movl 0x30(%rax), %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x497ed(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x8(%rsp), %rdi
leaq 0x48b6d(%rip), %rsi     # 0x18881d
callq 0xd8300
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xdc760
movq (%rsp), %rax
movq 0x87dc6(%rip), %rcx     # 0x1c7c68
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x18, %edi
callq 0xd8380
movq %rax, 0x8(%rsp)
jmp 0x13feba
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd0d30
jmp 0x13feca
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rdi
callq 0xd99b0
jmp 0x13fee2
addq $0x28, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x13ff14
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x18, %esi
callq 0xd8620
movq (%rsp), %rdi
callq 0xdf230
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: EpsilonSymbol::getFixedHandle(FixedHandle&, ParserWalker&) const
void EpsilonSymbol::getFixedHandle(FixedHandle &hand,ParserWalker &walker) const

{
  hand.space = const_space;
  hand.offset_space = (AddrSpace *)0; // Not a dynamic value
  hand.offset_offset = 0;
  hand.size = 0;		// Cannot provide size
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
retq
nopw (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x68, %edi
callq 0xd8380
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x38(%rax), %rsi
leaq 0x68(%rsp), %rdi
callq 0xd69a0
jmp 0x140113
xorl %esi, %esi
movl %esi, %edx
leaq 0x38(%rsp), %rdi
callq 0xd9880
jmp 0x140123
xorl %esi, %esi
movl %esi, %edx
leaq 0x18(%rsp), %rdi
callq 0xd9880
jmp 0x140133
movq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0xdf370
jmp 0x14014e
movq 0x10(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0x60(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xd04d0
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x18(%rsp), %rcx
movq $0x0, 0x10(%rcx)
movq 0x30(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movl $0x0, 0x8(%rax)
addq $0x28, %rsp
retq
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jl 0x140463
movq 0x18(%rsp), %rdi
leaq 0x48b14(%rip), %rsi     # 0x188f54
callq 0xd8300
movq %rax, %rdi
movq 0x87b79(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0xe1550
jmp 0x140494
movq 0x18(%rsp), %rdi
leaq 0x48b88(%rip), %rsi     # 0x188ff7
callq 0xd8300
movq %rax, %rdi
movq 0x87b4a(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
subq 0x8(%rsp), %rsi
callq 0xe1550
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x48b38(%rip), %rsi     # 0x188ffb
callq 0xd8300
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xdd790
movq 0x8(%rsp), %rdi
leaq 0x4918c(%rip), %rsi     # 0x18966e
callq 0xd8300
movq (%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x8(%rsp), %rdi
leaq 0x48b00(%rip), %rsi     # 0x189006
callq 0xd8300
addq $0x18, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq %rax, 0x20(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x28(%rsp)
movb %al, 0x1b(%rsp)
jl 0x140651
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
callq 0xcee50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0x1b(%rsp)
movq 0x10(%rsp), %rax
movb 0x1b(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x50(%rax)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, (%rsp)
addq $0x38, %rdi
callq 0xcee50
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x1406bf
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xd9450
cmpq $0xbadbeef, (%rax)      # imm = 0xBADBEEF
jne 0x1406b0
movq 0x10(%rsp), %rax
movb $0x0, 0x50(%rax)
jmp 0x1406b2
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x140668
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq 0x1f0(%rsp), %rax
movq %rax, 0x28(%rsp)
testb $0x1, 0x50(%rax)
jne 0x140898
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x1e8(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x28(%rsp), %rdi
movq %rax, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x38, %rdi
callq 0xcee50
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x140773
cmpq $0x0, 0x1e0(%rsp)
jl 0x140773
movq 0x28(%rsp), %rdi
addq $0x38, %rdi
movq 0x1e0(%rsp), %rsi
callq 0xd9450
cmpq $0xbadbeef, (%rax)      # imm = 0xBADBEEF
jne 0x140896
leaq 0x68(%rsp), %rdi
callq 0xdbe90
movq 0x1e8(%rsp), %rdi
callq 0xcee30
movq %rax, 0x18(%rsp)
jmp 0x140791
movq 0x18(%rsp), %rdi
callq 0xd5b50
movb %al, 0x17(%rsp)
jmp 0x1407a1
movb 0x17(%rsp), %al
movsbl %al, %esi
leaq 0x68(%rsp), %rdi
callq 0xda0c0
jmp 0x1407b4
movq 0x1e8(%rsp), %rdi
callq 0xcee30
movq %rax, 0x8(%rsp)
jmp 0x1407c8
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd82c0
jmp 0x1407d9
leaq 0x48844(%rip), %rsi     # 0x189024
leaq 0x68(%rsp), %rdi
callq 0xd8300
jmp 0x1407ec
movb $0x1, 0x37(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd8840
jmp 0x140810
movq (%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xde3d0
jmp 0x140820
movq (%rsp), %rdi
movb $0x0, 0x37(%rsp)
movq 0x87288(%rip), %rsi     # 0x1c7ab8
movq 0x87641(%rip), %rdx     # 0x1c7e78
callq 0xe01f0
jmp 0x1408ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x14088a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x140876
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x37(%rsp)
jne 0x14087f
jmp 0x140888
movq (%rsp), %rdi
callq 0xd5400
jmp 0x14088a
leaq 0x68(%rsp), %rdi
callq 0xd0160
jmp 0x1408a2
jmp 0x140898
xorl %eax, %eax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x60(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0xd04d0
movq (%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
addq $0x38, %rdi
movl 0xc(%rsp), %eax
movl %eax, %esi
callq 0xd6f80
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movl $0x0, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
addq $0x38, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xd6f80
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jl 0x1409c3
movq 0x28(%rsp), %rdi
leaq 0x485b4(%rip), %rsi     # 0x188f54
callq 0xd8300
movq %rax, %rdi
movq 0x87619(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0xe1550
jmp 0x1409f4
movq 0x28(%rsp), %rdi
leaq 0x48628(%rip), %rsi     # 0x188ff7
callq 0xd8300
movq %rax, %rdi
movq 0x875ea(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
subq 0x10(%rsp), %rsi
callq 0xe1550
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x48627(%rip), %rsi     # 0x18904b
callq 0xd8300
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdd790
movq 0x28(%rsp), %rdi
leaq 0x48c2a(%rip), %rsi     # 0x18966e
callq 0xd8300
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x38, %rdi
callq 0xcee50
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x140aee
movq 0x28(%rsp), %rdi
leaq 0x485c4(%rip), %rsi     # 0x189059
callq 0xd8300
movq %rax, %rdi
movq 0x872f4(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0xd6f80
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0xe1550
movq %rax, %rdi
leaq 0x47d43(%rip), %rsi     # 0x18881c
callq 0xd8300
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x140a65
movq 0x28(%rsp), %rdi
leaq 0x4856f(%rip), %rsi     # 0x189069
callq 0xd8300
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq %rdx, 0x220(%rsp)
movq 0x230(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x228(%rsp), %rdi
callq 0xde930
movq %rax, 0x218(%rsp)
leaq 0x210(%rsp), %rdi
callq 0xd03e0
movq 0x218(%rsp), %rdi
callq 0xd4960
movq %rax, 0x208(%rsp)
movq 0x208(%rsp), %rax
movq %rax, 0x210(%rsp)
leaq 0x210(%rsp), %rdi
callq 0xddc90
movq (%rax), %rdi
movq 0x220(%rsp), %rsi
callq 0xd8230
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rdi
callq 0xd99b0
leaq 0x210(%rsp), %rdi
callq 0xd0700
movq 0x218(%rsp), %rdi
callq 0xd7a70
movq %rax, 0x200(%rsp)
leaq 0x210(%rsp), %rdi
leaq 0x200(%rsp), %rsi
callq 0xd72b0
testb $0x1, %al
jne 0x140c45
jmp 0x140daf
leaq 0x210(%rsp), %rdi
callq 0xddc90
movq (%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xe0c80
movq 0x30(%rsp), %rdx
leaq 0x4656c(%rip), %rsi     # 0x1871e1
leaq 0x60(%rsp), %rdi
callq 0xe00a0
jmp 0x140c81
movq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xdb6f0
movq %rax, 0x20(%rsp)
jmp 0x140c97
movq 0x20(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movl $0x8, %edx
callq 0xdfcc0
jmp 0x140cb0
leaq 0x60(%rsp), %rdi
callq 0xd4550
leaq 0x5f(%rsp), %rdi
callq 0xd8ec0
movq 0x80(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x80(%rsp,%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x2, %edi
movl $0x8, %esi
callq 0xe0e70
movl %eax, 0x1c(%rsp)
jmp 0x140cf2
movl 0x1c(%rsp), %edi
movl $0x40, %esi
callq 0xe0e70
movl %eax, 0xc(%rsp)
jmp 0x140d06
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdi
callq 0xda6e0
jmp 0x140d16
leaq 0x80(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd4070
jmp 0x140d2a
movq 0x38(%rsp), %rdi
addq $0x38, %rdi
leaq 0x40(%rsp), %rsi
callq 0xdad60
jmp 0x140d3f
leaq 0x210(%rsp), %rdi
callq 0xd0700
leaq 0x80(%rsp), %rdi
callq 0xd25a0
jmp 0x140c12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x140d86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd4550
leaq 0x5f(%rsp), %rdi
callq 0xd8ec0
jmp 0x140dc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xd25a0
jmp 0x140dc1
movq 0x38(%rsp), %rdi
callq 0xd5f60
addq $0x238, %rsp            # imm = 0x238
retq
movq 0x50(%rsp), %rdi
callq 0xe0be0
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq %rax, 0x20(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x28(%rsp)
movb %al, 0x1b(%rsp)
jl 0x140e41
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
callq 0xe1670
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0x1b(%rsp)
movq 0x10(%rsp), %rax
movb 0x1b(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x50(%rax)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, (%rsp)
addq $0x38, %rdi
callq 0xe1670
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x140f0c
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xe1770
movq %rax, %rdi
leaq 0x481f1(%rip), %rsi     # 0x18908d
callq 0xe30f0
testb $0x1, %al
jne 0x140ece
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xe1770
movq %rax, %rdi
leaq 0x481cc(%rip), %rsi     # 0x18908f
callq 0xe30f0
testb $0x1, %al
jne 0x140ece
jmp 0x140efa
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xe1770
movq %rax, %rdi
leaq 0x481a3(%rip), %rsi     # 0x18908f
callq 0xdc010
movq 0x10(%rsp), %rax
movb $0x0, 0x50(%rax)
jmp 0x140efc
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x140e58
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq 0x1f0(%rsp), %rax
movq %rax, 0x28(%rsp)
testb $0x1, 0x50(%rax)
jne 0x14111b
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x1e8(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x28(%rsp), %rdi
movq %rax, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x38, %rdi
callq 0xe1670
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x140ff6
cmpq $0x0, 0x1e0(%rsp)
jl 0x140ff6
movq 0x28(%rsp), %rdi
addq $0x38, %rdi
movq 0x1e0(%rsp), %rsi
callq 0xe1770
movq %rax, %rdi
callq 0xd5290
cmpq $0x1, %rax
jne 0x141119
movq 0x28(%rsp), %rdi
addq $0x38, %rdi
movq 0x1e0(%rsp), %rsi
callq 0xe1770
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe2f50
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x141119
leaq 0x68(%rsp), %rdi
callq 0xdbe90
movq 0x1e8(%rsp), %rdi
callq 0xcee30
movq %rax, 0x18(%rsp)
jmp 0x141014
movq 0x18(%rsp), %rdi
callq 0xd5b50
movb %al, 0x17(%rsp)
jmp 0x141024
movb 0x17(%rsp), %al
movsbl %al, %esi
leaq 0x68(%rsp), %rdi
callq 0xda0c0
jmp 0x141037
movq 0x1e8(%rsp), %rdi
callq 0xcee30
movq %rax, 0x8(%rsp)
jmp 0x14104b
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd82c0
jmp 0x14105c
leaq 0x4802e(%rip), %rsi     # 0x189091
leaq 0x68(%rsp), %rdi
callq 0xd8300
jmp 0x14106f
movb $0x1, 0x37(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd8840
jmp 0x141093
movq (%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xde3d0
jmp 0x1410a3
movq (%rsp), %rdi
movb $0x0, 0x37(%rsp)
movq 0x86a05(%rip), %rsi     # 0x1c7ab8
movq 0x86dbe(%rip), %rdx     # 0x1c7e78
callq 0xe01f0
jmp 0x14112f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x14110d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1410f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x37(%rsp)
jne 0x141102
jmp 0x14110b
movq (%rsp), %rdi
callq 0xd5400
jmp 0x14110d
leaq 0x68(%rsp), %rdi
callq 0xd0160
jmp 0x141125
jmp 0x14111b
xorl %eax, %eax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x60(%rsp), %rdi
callq 0xe0be0
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x47f03(%rip), %rsi     # 0x1890b7
callq 0xd8300
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdd790
movq 0x28(%rsp), %rdi
leaq 0x4849a(%rip), %rsi     # 0x18966e
callq 0xd8300
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x38, %rdi
callq 0xe1670
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x1412b0
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
movslq 0x24(%rsp), %rsi
callq 0xda3d0
movq %rax, %rdi
leaq 0x47e54(%rip), %rsi     # 0x18908f
callq 0xe30f0
testb $0x1, %al
jne 0x141246
jmp 0x141259
movq 0x28(%rsp), %rdi
leaq 0x47e6f(%rip), %rsi     # 0x1890c1
callq 0xd8300
jmp 0x14129e
movq 0x28(%rsp), %rdi
leaq 0x47e68(%rip), %rsi     # 0x1890cd
callq 0xd8300
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
movslq 0x24(%rsp), %rsi
callq 0xda3d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xd7350
movq %rax, %rdi
leaq 0x47583(%rip), %rsi     # 0x18881c
callq 0xd8300
jmp 0x1412a0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1411f5
movq 0x28(%rsp), %rdi
leaq 0x47e21(%rip), %rsi     # 0x1890dd
callq 0xd8300
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xc8(%rsp), %rdi
callq 0xde930
movq %rax, 0xb8(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0xd03e0
movq 0xb8(%rsp), %rdi
callq 0xd4960
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0xb0(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0xddc90
movq (%rax), %rdi
movq 0xc0(%rsp), %rsi
callq 0xd8230
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rdi
callq 0xd99b0
leaq 0xb0(%rsp), %rdi
callq 0xd0700
movq 0xb8(%rsp), %rdi
callq 0xd7a70
movq %rax, 0xa0(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0xd72b0
testb $0x1, %al
jne 0x141405
jmp 0x14158c
leaq 0xb0(%rsp), %rdi
callq 0xddc90
movq (%rax), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0xd2b80
cmpl $0x1, %eax
jl 0x1414ec
movq 0x30(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x18(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x77(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xe0c80
movq 0x28(%rsp), %rdx
leaq 0x45bc8(%rip), %rsi     # 0x187031
leaq 0x78(%rsp), %rdi
callq 0xe00a0
jmp 0x141475
movq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xdb6f0
movq %rax, 0x10(%rsp)
jmp 0x14148b
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0xd3180
jmp 0x14149c
leaq 0x78(%rsp), %rdi
callq 0xd4550
leaq 0x77(%rsp), %rdi
callq 0xd8ec0
jmp 0x14157a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x1414dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xd4550
leaq 0x77(%rsp), %rdi
callq 0xd8ec0
jmp 0x14159e
movq 0x30(%rsp), %rax
addq $0x38, %rax
movq %rax, (%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x47b7b(%rip), %rsi     # 0x18908f
leaq 0x40(%rsp), %rdi
callq 0xe00a0
jmp 0x141520
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd5950
jmp 0x141530
leaq 0x40(%rsp), %rdi
callq 0xd4550
leaq 0x3f(%rsp), %rdi
callq 0xd8ec0
jmp 0x14157a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x14156e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd4550
leaq 0x3f(%rsp), %rdi
callq 0xd8ec0
jmp 0x14159e
leaq 0xb0(%rsp), %rdi
callq 0xd0700
jmp 0x1413d2
movq 0x30(%rsp), %rdi
callq 0xdc450
addq $0xd8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0xe0be0
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0xdbd20
movq 0x8(%rsp), %rax
movq 0x86913(%rip), %rcx     # 0x1c7f00
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x40(%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x48(%rax)
movb $0x0, 0x50(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rdx
movq -0x10(%rsp), %rcx
movq %rdx, (%rcx)
movq -0x10(%rsp), %rcx
movq $0x0, 0x10(%rcx)
movq 0x40(%rax), %rdx
movq -0x10(%rsp), %rcx
movq %rdx, 0x18(%rcx)
movl 0x48(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x47965(%rip), %rsi     # 0x1890f9
callq 0xd8300
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdd790
movq 0x18(%rsp), %rdi
leaq 0x47952(%rip), %rsi     # 0x189106
callq 0xd8300
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x38(%rax), %rdi
callq 0xd06f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xd7350
movq %rax, %rdi
leaq 0x47ca6(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x18(%rsp), %rdi
leaq 0x47918(%rip), %rsi     # 0x18910f
callq 0xd8300
movq %rax, %rdi
movq 0x867c2(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0xd0050
movq %rax, %rdi
leaq 0x47c66(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x18(%rsp), %rdi
leaq 0x478e4(%rip), %rsi     # 0x18911b
callq 0xd8300
movq %rax, %rdi
movq 0x86552(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x48(%rax), %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x47c27(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x18(%rsp), %rdi
leaq 0x47df8(%rip), %rsi     # 0x18966e
callq 0xd8300
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xddba0
movq 0x18(%rsp), %rdi
leaq 0x4788d(%rip), %rsi     # 0x189123
callq 0xd8300
addq $0x28, %rsp
retq
// File: 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:
subq $0x38, %rsp
movb 0x40(%rsp), %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl %r9d, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xcf560
movq (%rsp), %rax
movq 0x85c99(%rip), %rcx     # 0x1c79e8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x40(%rax)
movl 0x10(%rsp), %ecx
movl %ecx, 0x44(%rax)
movb 0xf(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x48(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x473a1(%rip), %rsi     # 0x189145
callq 0xd8300
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xdd790
movq 0x68(%rsp), %rdi
leaq 0x4738e(%rip), %rsi     # 0x189152
callq 0xd8300
movq %rax, %rdi
movq 0x861f5(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x38(%rax), %rdi
callq 0xdbac0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x47688(%rip), %rsi     # 0x18948c
movq %rsi, 0x18(%rsp)
callq 0xd8300
movq 0x68(%rsp), %rdi
leaq 0x47345(%rip), %rsi     # 0x18915f
callq 0xd8300
movq %rax, %rdi
movq 0x85f6f(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x40(%rax), %esi
callq 0xdbce0
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0xd8300
movq 0x68(%rsp), %rdi
leaq 0x4730f(%rip), %rsi     # 0x189166
callq 0xd8300
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x44(%rax), %esi
callq 0xdbce0
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0xd8300
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xe0c80
movq 0x28(%rsp), %rdx
leaq 0x472d0(%rip), %rsi     # 0x18916e
leaq 0x48(%rsp), %rdi
callq 0xe00a0
jmp 0x141eaa
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x48(%rax), %edx
andl $0x1, %edx
leaq 0x48(%rsp), %rsi
callq 0xd0a30
jmp 0x141ec7
leaq 0x48(%rsp), %rdi
callq 0xd4550
leaq 0x47(%rsp), %rdi
callq 0xd8ec0
movq 0x68(%rsp), %rdi
leaq 0x47787(%rip), %rsi     # 0x18966e
callq 0xd8300
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x68(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x68(%rsp), %rdi
leaq 0x47267(%rip), %rsi     # 0x189173
callq 0xd8300
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x141f3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd4550
leaq 0x47(%rsp), %rdi
callq 0xd8ec0
movq 0x38(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq %rax, 0x20(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x28(%rsp)
movb %al, 0x1b(%rsp)
jl 0x1426a1
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
callq 0xcf930
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0x1b(%rsp)
movq 0x10(%rsp), %rax
movb 0x1b(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x50(%rax)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, (%rsp)
addq $0x38, %rdi
callq 0xcf930
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x14270c
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xdee70
cmpq $0x0, (%rax)
jne 0x1426fd
movq 0x10(%rsp), %rax
movb $0x0, 0x50(%rax)
jmp 0x1426ff
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1426b8
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq 0x1f0(%rsp), %rax
movq %rax, 0x28(%rsp)
testb $0x1, 0x50(%rax)
jne 0x1428e5
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x1e8(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x1e0(%rsp)
cmpq $0x0, 0x1e0(%rsp)
jl 0x1427c0
movq 0x28(%rsp), %rdi
movq 0x1e0(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x38, %rdi
callq 0xcf930
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x1427c0
movq 0x28(%rsp), %rdi
addq $0x38, %rdi
movq 0x1e0(%rsp), %rsi
callq 0xdee70
cmpq $0x0, (%rax)
jne 0x1428e3
leaq 0x68(%rsp), %rdi
callq 0xdbe90
movq 0x1e8(%rsp), %rdi
callq 0xcee30
movq %rax, 0x18(%rsp)
jmp 0x1427de
movq 0x18(%rsp), %rdi
callq 0xd5b50
movb %al, 0x17(%rsp)
jmp 0x1427ee
movb 0x17(%rsp), %al
movsbl %al, %esi
leaq 0x68(%rsp), %rdi
callq 0xda0c0
jmp 0x142801
movq 0x1e8(%rsp), %rdi
callq 0xcee30
movq %rax, 0x8(%rsp)
jmp 0x142815
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd82c0
jmp 0x142826
leaq 0x46975(%rip), %rsi     # 0x1891a2
leaq 0x68(%rsp), %rdi
callq 0xd8300
jmp 0x142839
movb $0x1, 0x37(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd8840
jmp 0x14285d
movq (%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xde3d0
jmp 0x14286d
movq (%rsp), %rdi
movb $0x0, 0x37(%rsp)
movq 0x8523b(%rip), %rsi     # 0x1c7ab8
movq 0x855f4(%rip), %rdx     # 0x1c7e78
callq 0xe01f0
jmp 0x1428f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1428d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1428c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x37(%rsp)
jne 0x1428cc
jmp 0x1428d5
movq (%rsp), %rdi
callq 0xd5400
jmp 0x1428d7
leaq 0x68(%rsp), %rdi
callq 0xd0160
jmp 0x1428ef
jmp 0x1428e5
xorl %eax, %eax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x60(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
addq $0x38, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xd99e0
movq (%rax), %rdi
callq 0xd0730
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x5c(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x38, %rdi
callq 0xcf930
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x142a22
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
movslq 0x5c(%rsp), %rsi
callq 0xd99e0
movq (%rax), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x142a13
movq 0x50(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
addq $0x68, %rsp
retq
jmp 0x142a15
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x1429bb
movb $0x1, 0x23(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq 0x18(%rsp), %rdi
movq %rax, (%rsp)
callq 0xd1f90
movq %rax, 0x8(%rsp)
jmp 0x142a46
movq 0x8(%rsp), %rdx
leaq 0x46779(%rip), %rsi     # 0x1891cb
leaq 0x30(%rsp), %rdi
callq 0xd7370
jmp 0x142a5e
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd06e0
jmp 0x142a6e
movq (%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0x853ea(%rip), %rsi     # 0x1c7e68
movq 0x84f9b(%rip), %rdx     # 0x1c7a20
callq 0xe01f0
jmp 0x142ad2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x142ab4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x23(%rsp)
jne 0x142abd
jmp 0x142ac6
movq (%rsp), %rdi
callq 0xd5400
jmp 0x142ac8
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)