LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: VarnodeTpl::restoreXml(Element const*, AddrSpaceManager const*)
void VarnodeTpl::restoreXml(const Element *el,const AddrSpaceManager *manage)

{
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  space.restoreXml(*iter,manage);
  ++iter;
  offset.restoreXml(*iter,manage);
  ++iter;
  size.restoreXml(*iter,manage);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xde930
movq %rax, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd03e0
movq 0x28(%rsp), %rdi
callq 0xd4960
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xddc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
movq 0x30(%rsp), %rdx
callq 0xd6660
leaq 0x20(%rsp), %rdi
callq 0xd0700
movq 0x8(%rsp), %rax
addq $0x20, %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0xddc90
movq (%rsp), %rdi
movq (%rax), %rsi
movq 0x30(%rsp), %rdx
callq 0xd6660
leaq 0x20(%rsp), %rdi
callq 0xd0700
movq 0x8(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xddc90
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
movq 0x30(%rsp), %rdx
callq 0xd6660
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: VarnodeTpl::operator<(VarnodeTpl const&) const
bool VarnodeTpl::operator<(const VarnodeTpl &op2) const

{
  if (!(space==op2.space)) return (space<op2.space);
  if (!(offset==op2.offset)) return (offset<op2.offset);
  if (!(size==op2.size)) return (size<op2.size);
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
callq 0xd7450
testb $0x1, %al
jne 0x116ecd
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe1410
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x116f46
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
callq 0xd7450
testb $0x1, %al
jne 0x116f07
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
callq 0xe1410
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x116f46
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x10(%rsp), %rsi
addq $0x40, %rsi
callq 0xd7450
testb $0x1, %al
jne 0x116f41
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x10(%rsp), %rsi
addq $0x40, %rsi
callq 0xe1410
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x116f46
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: HandleTpl::HandleTpl(VarnodeTpl const*)
HandleTpl::HandleTpl(const VarnodeTpl *vn)

{				// Build handle which indicates given varnode
  space = vn->getSpace();
  size = vn->getSize();
  ptrspace = ConstTpl(ConstTpl::real,0);
  ptroffset = vn->getOffset();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd4400
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0xd4400
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0xd4400
movq (%rsp), %rdi
addq $0x60, %rdi
callq 0xd4400
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0xd4400
movq (%rsp), %rdi
addq $0xa0, %rdi
callq 0xd4400
movq (%rsp), %rdi
addq $0xc0, %rdi
callq 0xd4400
movq 0x28(%rsp), %rdi
callq 0xe3000
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq 0x28(%rsp), %rdi
callq 0xd4930
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x30(%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x38(%rax)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd9880
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x50(%rax)
movl 0x20(%rsp), %ecx
movl %ecx, 0x58(%rax)
movq 0x28(%rsp), %rdi
callq 0xdbaf0
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rdx
movq %rdx, 0x60(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x68(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x70(%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x78(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: HandleTpl::fix(FixedHandle&, ParserWalker const&) const
void HandleTpl::fix(FixedHandle &hand,const ParserWalker &walker) const

{
  if (ptrspace.getType() == ConstTpl::real) {
    // The export is unstarred, but this doesn't mean the varnode
    // being exported isn't dynamic
    space.fillinSpace(hand,walker);
    hand.size = size.fix(walker);
    ptroffset.fillinOffset(hand,walker);
  }
  else {
    hand.space = space.fixSpace(walker);
    hand.size = size.fix(walker);
    hand.offset_offset = ptroffset.fix(walker);
    hand.offset_space = ptrspace.fixSpace(walker);
    if (hand.offset_space->getType()==IPTR_CONSTANT) {
				// Handle could have been dynamic but wasn't
      hand.offset_space = (AddrSpace *)0;
      hand.offset_offset = AddrSpace::addressToByte(hand.offset_offset,hand.space->getWordSize());
      hand.offset_offset = hand.space->wrapOffset(hand.offset_offset);
    }
    else {
      hand.offset_size = ptrsize.fix(walker);
      hand.temp_space = temp_space.fixSpace(walker);
      hand.temp_offset = temp_offset.fix(walker);
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x40, %rdi
callq 0xde5d0
cmpl $0x0, %eax
jne 0x117209
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xdc1c0
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rsi
callq 0xd5220
movq 0x8(%rsp), %rdi
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
addq $0x60, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xe2350
jmp 0x117359
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xd4e60
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
addq $0x20, %rdi
movq 0x10(%rsp), %rsi
callq 0xd5220
movq 0x8(%rsp), %rdi
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
addq $0x60, %rdi
movq 0x10(%rsp), %rsi
callq 0xd5220
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x40, %rdi
movq 0x10(%rsp), %rsi
callq 0xd4e60
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xcfb80
cmpl $0x0, %eax
jne 0x1172f3
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0xde1c0
movq (%rsp), %rdi
movl %eax, %esi
callq 0xe2550
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xcfa10
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x117357
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
movq 0x10(%rsp), %rsi
callq 0xd5220
movq 0x8(%rsp), %rdi
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x20(%rax)
addq $0xa0, %rdi
movq 0x10(%rsp), %rsi
callq 0xd4e60
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
addq $0xc0, %rdi
movq 0x10(%rsp), %rsi
callq 0xd5220
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x117359
addq $0x28, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: HandleTpl::changeHandleIndex(std::vector<int, std::allocator<int>> const&)
void HandleTpl::changeHandleIndex(const vector<int4> &handmap)

{
  space.changeHandleIndex(handmap);
  size.changeHandleIndex(handmap);
  ptrspace.changeHandleIndex(handmap);
  ptroffset.changeHandleIndex(handmap);
  ptrsize.changeHandleIndex(handmap);
  temp_space.changeHandleIndex(handmap);
  temp_offset.changeHandleIndex(handmap);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0xd5090
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rsi
callq 0xd5090
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x8(%rsp), %rsi
callq 0xd5090
movq (%rsp), %rdi
addq $0x60, %rdi
movq 0x8(%rsp), %rsi
callq 0xd5090
movq (%rsp), %rdi
addq $0x80, %rdi
movq 0x8(%rsp), %rsi
callq 0xd5090
movq (%rsp), %rdi
addq $0xa0, %rdi
movq 0x8(%rsp), %rsi
callq 0xd5090
movq (%rsp), %rdi
addq $0xc0, %rdi
movq 0x8(%rsp), %rsi
callq 0xd5090
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: HandleTpl::saveXml(std::ostream&) const
void HandleTpl::saveXml(ostream &s) const

{
  s << "<handle_tpl>";
  space.saveXml(s);
  size.saveXml(s);
  ptrspace.saveXml(s);
  ptroffset.saveXml(s);
  ptrsize.saveXml(s);
  temp_space.saveXml(s);
  temp_offset.saveXml(s);
  s << "</handle_tpl>\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 0x70f3b(%rip), %rsi     # 0x18835e
callq 0xd8300
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xdbee0
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rsi
callq 0xdbee0
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x8(%rsp), %rsi
callq 0xdbee0
movq (%rsp), %rdi
addq $0x60, %rdi
movq 0x8(%rsp), %rsi
callq 0xdbee0
movq (%rsp), %rdi
addq $0x80, %rdi
movq 0x8(%rsp), %rsi
callq 0xdbee0
movq (%rsp), %rdi
addq $0xa0, %rdi
movq 0x8(%rsp), %rsi
callq 0xdbee0
movq (%rsp), %rdi
addq $0xc0, %rdi
movq 0x8(%rsp), %rsi
callq 0xdbee0
movq 0x8(%rsp), %rdi
leaq 0x70eb4(%rip), %rsi     # 0x18836b
callq 0xd8300
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: HandleTpl::restoreXml(Element const*, AddrSpaceManager const*)
void HandleTpl::restoreXml(const Element *el,const AddrSpaceManager *manage)

{
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  space.restoreXml(*iter,manage);
  ++iter;
  size.restoreXml(*iter,manage);
  ++iter;
  ptrspace.restoreXml(*iter,manage);
  ++iter;
  ptroffset.restoreXml(*iter,manage);
  ++iter;
  ptrsize.restoreXml(*iter,manage);
  ++iter;
  temp_space.restoreXml(*iter,manage);
  ++iter;
  temp_offset.restoreXml(*iter,manage);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
callq 0xde930
movq %rax, 0x48(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd03e0
movq 0x48(%rsp), %rdi
callq 0xd4960
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xddc90
movq 0x28(%rsp), %rdi
movq (%rax), %rsi
movq 0x50(%rsp), %rdx
callq 0xd6660
leaq 0x40(%rsp), %rdi
callq 0xd0700
movq 0x28(%rsp), %rax
addq $0x20, %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0xddc90
movq (%rsp), %rdi
movq (%rax), %rsi
movq 0x50(%rsp), %rdx
callq 0xd6660
leaq 0x40(%rsp), %rdi
callq 0xd0700
movq 0x28(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xddc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
movq 0x50(%rsp), %rdx
callq 0xd6660
leaq 0x40(%rsp), %rdi
callq 0xd0700
movq 0x28(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xddc90
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
movq 0x50(%rsp), %rdx
callq 0xd6660
leaq 0x40(%rsp), %rdi
callq 0xd0700
movq 0x28(%rsp), %rax
addq $0x80, %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xddc90
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
movq 0x50(%rsp), %rdx
callq 0xd6660
leaq 0x40(%rsp), %rdi
callq 0xd0700
movq 0x28(%rsp), %rax
addq $0xa0, %rax
movq %rax, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xddc90
movq 0x20(%rsp), %rdi
movq (%rax), %rsi
movq 0x50(%rsp), %rdx
callq 0xd6660
leaq 0x40(%rsp), %rdi
callq 0xd0700
movq 0x28(%rsp), %rax
addq $0xc0, %rax
movq %rax, 0x30(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xddc90
movq 0x30(%rsp), %rdi
movq (%rax), %rsi
movq 0x50(%rsp), %rdx
callq 0xd6660
addq $0x68, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: OpTpl::~OpTpl()
OpTpl::~OpTpl(void)

{				// An OpTpl owns its varnode_tpls
  if (output != (VarnodeTpl *)0)
    delete output;
  vector<VarnodeTpl *>::iterator iter;
  for(iter=input.begin();iter!=input.end();++iter)
    delete *iter;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rax)
je 0x1176bd
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1176bb
movq 0x8(%rsp), %rdi
movl $0x68, %esi
callq 0xd8620
jmp 0x1176bd
leaq 0x28(%rsp), %rdi
callq 0xd4e40
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0xdf220
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0xda800
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd2550
testb $0x1, %al
jne 0x11770c
jmp 0x11773f
leaq 0x28(%rsp), %rdi
callq 0xd0f60
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x117731
movq (%rsp), %rdi
movl $0x68, %esi
callq 0xd8620
jmp 0x117733
leaq 0x28(%rsp), %rdi
callq 0xd9480
jmp 0x1176e4
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0xde750
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: OpTpl::isZeroSize() const
bool OpTpl::isZeroSize(void) const

{				// Return if any input or output has zero size
  vector<VarnodeTpl *>::const_iterator iter;

  if (output != (VarnodeTpl *)0)
    if (output->isZeroSize()) return true;
  for(iter=input.begin();iter!=input.end();++iter)
    if ((*iter)->isZeroSize()) return true;
  return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd1050
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1177a4
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xdd230
testb $0x1, %al
jne 0x11779b
jmp 0x1177a2
movb $0x1, 0x37(%rsp)
jmp 0x11781b
jmp 0x1177a4
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xd3e20
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xe00f0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xcf020
testb $0x1, %al
jne 0x1177e9
jmp 0x117816
leaq 0x20(%rsp), %rdi
callq 0xd54d0
movq (%rax), %rdi
callq 0xdd230
testb $0x1, %al
jne 0x117801
jmp 0x117808
movb $0x1, 0x37(%rsp)
jmp 0x11781b
jmp 0x11780a
leaq 0x20(%rsp), %rdi
callq 0xd11f0
jmp 0x1177c1
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: OpTpl::removeInput(int)
void OpTpl::removeInput(int4 index)

{ // Remove the indicated input
  delete input[index];
  for(int4 i=index;i<input.size()-1;++i)
    input[i] = input[i+1];
  input.pop_back();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x10, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xe07b0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x117872
movq 0x20(%rsp), %rdi
movl $0x68, %esi
callq 0xd8620
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x10, %rdi
callq 0xe23b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1178eb
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movl 0x28(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0xe07b0
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
movslq 0x28(%rsp), %rsi
callq 0xe07b0
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x11787a
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0xe2900
addq $0x38, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: OpTpl::changeHandleIndex(std::vector<int, std::allocator<int>> const&)
void OpTpl::changeHandleIndex(const vector<int4> &handmap)

{
  if (output != (VarnodeTpl *)0)
    output->changeHandleIndex(handmap);
  vector<VarnodeTpl *>::const_iterator iter;

  for(iter=input.begin();iter!=input.end();++iter)
    (*iter)->changeHandleIndex(handmap);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rax)
je 0x11792e
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xdeac0
leaq 0x20(%rsp), %rdi
callq 0xd1050
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0xdf220
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd2cb0
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0xda800
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xd1a20
testb $0x1, %al
jne 0x11798a
jmp 0x1179ad
leaq 0x20(%rsp), %rdi
callq 0xd54d0
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xdeac0
leaq 0x20(%rsp), %rdi
callq 0xd11f0
jmp 0x117963
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: OpTpl::saveXml(std::ostream&) const
void OpTpl::saveXml(ostream &s) const

{
  s << "<op_tpl code=\"" << get_opname(opc) << "\">";
  if (output == (VarnodeTpl *)0)
    s << "<null/>\n";
  else
    output->saveXml(s);
  for(int4 i=0;i<input.size();++i)
    input[i]->saveXml(s);
  s << "</op_tpl>\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 0x70996(%rip), %rsi     # 0x18837a
callq 0xd8300
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rsp)
movl 0x8(%rax), %edi
callq 0xd64a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xd8300
movq %rax, %rdi
leaq 0x70974(%rip), %rsi     # 0x188389
callq 0xd8300
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x117a38
movq 0x28(%rsp), %rdi
leaq 0x7095b(%rip), %rsi     # 0x18838c
callq 0xd8300
jmp 0x117a4a
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xd35e0
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
callq 0xe23b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x117aa4
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movslq 0x24(%rsp), %rsi
callq 0xd7840
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xd35e0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x117a52
movq 0x28(%rsp), %rdi
leaq 0x708e5(%rip), %rsi     # 0x188395
callq 0xd8300
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::~ConstructTpl()
ConstructTpl::~ConstructTpl(void)

{				// Constructor owns its ops and handles
  vector<OpTpl *>::iterator oiter;
  for(oiter=vec.begin();oiter!=vec.end();++oiter)
    delete *oiter;
  if (result != (HandleTpl *)0)
    delete result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xcf8f0
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xd1660
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xdcb70
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd92e0
testb $0x1, %al
jne 0x117de2
jmp 0x117e21
leaq 0x28(%rsp), %rdi
callq 0xce980
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x117e13
movq 0x8(%rsp), %rdi
callq 0xcea00
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0xd8620
jmp 0x117e15
leaq 0x28(%rsp), %rdi
callq 0xd52f0
jmp 0x117dba
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x117e50
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x117e4e
movq (%rsp), %rdi
movl $0xe0, %esi
callq 0xd8620
jmp 0x117e50
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xd7770
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::addOp(OpTpl*)
bool ConstructTpl::addOp(OpTpl *ot)

{
  if (ot->getOpcode() == DELAY_SLOT) {
    if (delayslot != 0)
      return false;		// Cannot have multiple delay slots
    delayslot = ot->getIn(0)->getOffset().getReal();
  }
  else if (ot->getOpcode() == LABELBUILD)
    numlabels += 1;		// Count labels
  vec.push_back(ot);
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xe2420
cmpl $0x3d, %eax
jne 0x117ed0
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
je 0x117ea8
movb $0x0, 0x27(%rsp)
jmp 0x117f07
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0xd3b80
movq %rax, %rdi
callq 0xdbaf0
movq %rax, %rdi
callq 0xdd890
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
jmp 0x117eef
movq 0x10(%rsp), %rdi
callq 0xe2420
cmpl $0x41, %eax
jne 0x117eed
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x117eef
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
leaq 0x10(%rsp), %rsi
callq 0xdc8a0
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::addOpList(std::vector<OpTpl*, std::allocator<OpTpl*>> const&)
bool ConstructTpl::addOpList(const vector<OpTpl *> &oplist)

{
  for(int4 i=0;i<oplist.size();++i)
    if (!addOp(oplist[i]))
      return false;
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xdd5e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x117f97
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xdc190
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
callq 0xd3530
testb $0x1, %al
jne 0x117f88
movb $0x0, 0x37(%rsp)
jmp 0x117f9c
jmp 0x117f8a
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x117f40
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::buildOnly() const
bool ConstructTpl::buildOnly(void) const

{
  vector<OpTpl *>::const_iterator iter;
  OpTpl *op;
  for(iter=vec.begin();iter!=vec.end();++iter) {
    op = *iter;
    if (op->getOpcode() != BUILD)
      return false;
  }
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd8d80
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0xdc0c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0xd3030
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xcfac0
testb $0x1, %al
jne 0x11834f
jmp 0x118385
leaq 0x20(%rsp), %rdi
callq 0xdd340
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe2420
cmpl $0x3c, %eax
je 0x118377
movb $0x0, 0x37(%rsp)
jmp 0x11838a
jmp 0x118379
leaq 0x20(%rsp), %rdi
callq 0xd8000
jmp 0x118328
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::changeHandleIndex(std::vector<int, std::allocator<int>> const&)
void ConstructTpl::changeHandleIndex(const vector<int4> &handmap)

{
  vector<OpTpl *>::const_iterator iter;
  OpTpl *op;

  for(iter=vec.begin();iter!=vec.end();++iter) {
    op = *iter;
    if (op->getOpcode() == BUILD) {
      int4 index = op->getIn(0)->getOffset().getReal();
      index = handmap[index];
      op->getIn(0)->setOffset(index);
    }
    else
      op->changeHandleIndex(handmap);
  }
  if (result != (HandleTpl *)0)
    result->changeHandleIndex(handmap);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd8d80
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0xd1660
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd90f0
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0xdcb70
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xdfdf0
testb $0x1, %al
jne 0x118416
jmp 0x1184a7
leaq 0x30(%rsp), %rdi
callq 0xdd340
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe2420
cmpl $0x3c, %eax
jne 0x118487
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0xd3b80
movq %rax, %rdi
callq 0xdbaf0
movq %rax, %rdi
callq 0xdd890
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0xdbd50
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0xd3b80
movq %rax, %rdi
movslq 0xc(%rsp), %rsi
callq 0xd8f20
jmp 0x118496
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xd74c0
jmp 0x118498
leaq 0x30(%rsp), %rdi
callq 0xd8000
jmp 0x1183ec
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1184c4
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0xd40c0
addq $0x48, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::setInput(VarnodeTpl*, int, int)
void ConstructTpl::setInput(VarnodeTpl *vn,int4 index,int4 slot)

{ // set the VarnodeTpl input for a particular op
  // for use with optimization routines
  OpTpl *op = vec[index];
  VarnodeTpl *oldvn = op->getIn(slot);
  op->setInput(vn,slot);
  if (oldvn != (VarnodeTpl *)0)
    delete oldvn;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0xdaef0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0xd3b80
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x20(%rsp), %edx
callq 0xdde40
cmpq $0x0, 0x10(%rsp)
je 0x118550
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x11854e
movq 0x8(%rsp), %rdi
movl $0x68, %esi
callq 0xd8620
jmp 0x118550
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::setOutput(VarnodeTpl*, int)
void ConstructTpl::setOutput(VarnodeTpl *vn,int4 index)

{ // set the VarnodeTpl output for a particular op
  // for use with optimization routines
  OpTpl *op = vec[index];
  VarnodeTpl *oldvn = op->getOut();
  op->setOutput(vn);
  if (oldvn != (VarnodeTpl *)0)
    delete oldvn;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0xdaef0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xdab40
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xddc10
cmpq $0x0, 0x10(%rsp)
je 0x1185d4
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1185d2
movq 0x8(%rsp), %rdi
movl $0x68, %esi
callq 0xd8620
jmp 0x1185d4
addq $0x38, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::deleteOps(std::vector<int, std::allocator<int>> const&)
void ConstructTpl::deleteOps(const vector<int4> &indices)

{ // delete a particular set of ops
  for(uint4 i=0;i<indices.size();++i) {
    delete vec[indices[i]];
    vec[indices[i]] = (OpTpl *)0;
  }
  uint4 poscur = 0;
  for(uint4 i=0;i<vec.size();++i) {
    OpTpl *op = vec[i];
    if (op != (OpTpl *)0) {
      vec[poscur] = op;
      poscur += 1;
    }
  }
  while(vec.size() > poscur)
    vec.pop_back();
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
callq 0xe30e0
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jae 0x1186b8
movq 0x38(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, %esi
callq 0xdbd50
movq 0x20(%rsp), %rdi
movslq (%rax), %rsi
callq 0xdaef0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x118676
movq 0x28(%rsp), %rdi
callq 0xcea00
movq 0x28(%rsp), %rdi
movl $0x28, %esi
callq 0xd8620
movq 0x38(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, %esi
callq 0xdbd50
movq 0x18(%rsp), %rdi
movslq (%rax), %rsi
callq 0xdaef0
movq $0x0, (%rax)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x118600
movl $0x0, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movq 0x38(%rsp), %rdi
movl 0x4c(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0xdd5e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x118753
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0xdaef0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x118741
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
movl 0x50(%rsp), %eax
movl %eax, %esi
callq 0xdaef0
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x118743
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x1186c8
jmp 0x118755
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
callq 0xdd5e0
movl 0x50(%rsp), %ecx
cmpq %rcx, %rax
jbe 0x11877c
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
callq 0xcf920
jmp 0x118755
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::saveXml(std::ostream&, int) const
void ConstructTpl::saveXml(ostream &s,int4 sectionid) const

{
  s << "<construct_tpl";
  if (sectionid >=0 )
    s << " section=\"" << dec << sectionid << "\"";
  if (delayslot != 0)
    s << " delay=\"" << dec << delayslot << "\"";
  if (numlabels != 0)
    s << " labels=\"" << dec << numlabels << "\"";
  s << ">\n";
  if (result != (HandleTpl *)0)
    result->saveXml(s);
  else
    s << "<null/>";
  for(int4 i=0;i<vec.size();++i)
    vec[i]->saveXml(s);
  s << "</construct_tpl>\n";
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x6fbed(%rip), %rsi     # 0x1883a5
callq 0xd8300
cmpl $0x0, 0x14(%rsp)
jl 0x1187ff
movq 0x18(%rsp), %rdi
leaq 0x6fbe4(%rip), %rsi     # 0x1883b4
callq 0xd8300
movq %rax, %rdi
movq 0xaf5b9(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0xe03e0
movq %rax, %rdi
leaq 0x70c92(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
je 0x118847
movq 0x18(%rsp), %rdi
leaq 0x6fbaa(%rip), %rsi     # 0x1883bf
callq 0xd8300
movq %rax, %rdi
movq 0xaf574(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl (%rax), %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x70c4a(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
je 0x118891
movq 0x18(%rsp), %rdi
leaq 0x6fb6a(%rip), %rsi     # 0x1883c8
callq 0xd8300
movq %rax, %rdi
movq 0xaf52b(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
callq 0xdbce0
movq %rax, %rdi
leaq 0x70c00(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0x18(%rsp), %rdi
leaq 0x70dd1(%rip), %rsi     # 0x18966e
callq 0xd8300
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1188c3
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0xda540
jmp 0x1188d4
movq 0x18(%rsp), %rdi
leaq 0x6fb03(%rip), %rsi     # 0x1883d2
callq 0xd8300
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0xdd5e0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x11892c
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movslq 0x10(%rsp), %rsi
callq 0xdc190
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0xdfc50
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1188dc
movq 0x18(%rsp), %rdi
leaq 0x6faa2(%rip), %rsi     # 0x1883da
callq 0xd8300
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: PcodeCacher::PcodeCacher()
PcodeCacher::PcodeCacher (void)

{
    // We aim to allocate this array only once
    uint4 maxsize = 600;
    poolstart = new VarnodeData[maxsize];
    endpool = poolstart + maxsize;
    curpool = poolstart;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x18, %rdi
movq %rdi, (%rsp)
callq 0xe28f0
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x8(%rsp)
callq 0xe20b0
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x18(%rsp)
callq 0xe1ea0
movl $0x258, 0x3c(%rsp)      # imm = 0x258
movl 0x3c(%rsp), %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
callq 0xce140
movq %rax, 0x20(%rsp)
jmp 0x119f26
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movl 0x3c(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xd0cc0
movq 0x8(%rsp), %rdi
callq 0xdd200
movq (%rsp), %rdi
callq 0xdeb10
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: PcodeCacher::addLabelRef(VarnodeData*)
void PcodeCacher::addLabelRef (VarnodeData* ptr)

{ // Store off a reference to a label and the next instruction
    // address
    label_refs.push_back (RelativeRecord ());
    label_refs.back ().dataptr = ptr;
    label_refs.back ().calling_index = issued.size ();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x30, %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xd36e0
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xe0cc0
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x30, %rdi
callq 0xcfea0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdi
movq %rcx, (%rax)
addq $0x18, %rdi
callq 0xde7e0
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x30, %rdi
callq 0xcfea0
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x48, %rsp
retq
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: PcodeCacher::addLabel(unsigned int)
void PcodeCacher::addLabel (uint4 id)

{ // Attach a label to the address of the next instruction
    while (labels.size () <= id)
        labels.push_back (0xbadbeef);
    labels[id] = issued.size ();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0xdd2a0
movl 0x1c(%rsp), %ecx
cmpq %rcx, %rax
ja 0x11a4ec
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movq $0xbadbeef, 0x10(%rsp)  # imm = 0xBADBEEF
leaq 0x10(%rsp), %rsi
callq 0xd6640
jmp 0x11a4b7
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0xde7e0
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
addq $0x48, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xd05a0
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: PcodeCacher::clear()
void PcodeCacher::clear (void)

{
    curpool = poolstart;
    issued.clear ();
    label_refs.clear ();
    labels.clear ();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq (%rdi), %rax
movq %rax, 0x8(%rdi)
addq $0x18, %rdi
callq 0xde540
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0xdec00
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0xd5070
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: PcodeCacher::resolveRelatives()
void PcodeCacher::resolveRelatives (void)

{ // Assuming all the PcodeData has been generated for an
    // instruction, go resolve any relative offsets and back
    // patch their value(s) into the PcodeData
    list<RelativeRecord>::const_iterator iter;
    for (iter = label_refs.begin (); iter != label_refs.end (); ++iter) {
        VarnodeData* ptr = (*iter).dataptr;
        uint4 id = ptr->offset;
        if ((id >= labels.size ()) || (labels[id] == 0xbadbeef))
            throw LowlevelError ("Reference to non-existant sleigh label");
        // Calculate the relative index given the two absolute indices
        uintb res = labels[id] - (*iter).calling_index;
        res &= calc_mask (ptr->size);
        ptr->offset = res;
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xdb520
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
callq 0xd97f0
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xdb210
movq 0x90(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
callq 0xd9130
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xdb210
leaq 0x98(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xd3f90
testb $0x1, %al
jne 0x11a617
jmp 0x11a7a2
leaq 0x98(%rsp), %rdi
callq 0xdcbc0
movq 0x20(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rax
movl %eax, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movq %rax, 0x18(%rsp)
addq $0x48, %rdi
callq 0xdd2a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x11a67e
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movl 0x6c(%rsp), %eax
movl %eax, %esi
callq 0xd05a0
cmpq $0xbadbeef, (%rax)      # imm = 0xBADBEEF
jne 0x11a733
movb $0x1, 0x33(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x6dd54(%rip), %rsi     # 0x188401
leaq 0x48(%rsp), %rdi
callq 0xe00a0
jmp 0x11a6b9
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd1ae0
jmp 0x11a6ca
movq 0x8(%rsp), %rdi
movb $0x0, 0x33(%rsp)
movq 0xad7b5(%rip), %rsi     # 0x1c7e90
movq 0xad4ee(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x11a7b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x11a714
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd4550
leaq 0x47(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x33(%rsp)
jne 0x11a727
jmp 0x11a731
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x11a7aa
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movl 0x6c(%rsp), %eax
movl %eax, %esi
callq 0xd05a0
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x98(%rsp), %rdi
callq 0xdcbc0
movq %rax, %rcx
movq (%rsp), %rax
subq 0x8(%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rax
movl 0x10(%rax), %edi
callq 0xcfa60
andq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x8(%rax)
leaq 0x98(%rsp), %rdi
callq 0xce830
jmp 0x11a5d4
addq $0xa8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: PcodeCacher::emit(Address const&, PcodeEmit*) const
void PcodeCacher::emit (const Address& addr, PcodeEmit* emt) const
// Emit any cached pcode
{
    vector<PcodeData>::const_iterator iter;

    for (iter = issued.begin (); iter != issued.end (); ++iter)
        emt->dump (addr, (*iter).opc, (*iter).outvar, (*iter).invar,
                   (*iter).isize);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xdd290
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0xda610
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0xd4b50
movq %rax, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xdaa40
testb $0x1, %al
jne 0x11a82f
jmp 0x11a8b4
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xdab80
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xdab80
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xdab80
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xdab80
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movl 0x18(%rax), %r9d
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x48(%rsp), %rdi
callq 0xe07f0
jmp 0x11a804
addq $0x68, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: PcodeCacher::hutch_emitIR() const
vector<struct PcodeData> PcodeCacher::hutch_emitIR () const

{
    vector<PcodeData> result;
    struct PcodeData tmp;
    vector<PcodeData>::const_iterator iter;

    for (iter = issued.begin (); iter != issued.end (); ++iter) {
        tmp.outvar = (*iter).outvar;
        tmp.invar = (*iter).invar;
        tmp.isize = (*iter).isize;
        tmp.opc = (*iter).opc;

        result.push_back (tmp);
    }
    return result;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x77(%rsp)
callq 0xe28f0
leaq 0x50(%rsp), %rdi
callq 0xd8030
leaq 0x48(%rsp), %rdi
callq 0xdd290
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0xda610
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0xd4b50
movq %rax, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xdaa40
testb $0x1, %al
jne 0x11a951
jmp 0x11a9d9
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xdab80
movq 0x8(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
callq 0xdab80
movq 0x8(%rsp), %rdi
movq 0x10(%rax), %rax
movq %rax, 0x60(%rsp)
callq 0xdab80
movq 0x8(%rsp), %rdi
movl 0x18(%rax), %eax
movl %eax, 0x68(%rsp)
callq 0xdab80
movq 0x10(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x50(%rsp)
leaq 0x50(%rsp), %rsi
callq 0xdc4e0
jmp 0x11a9ae
jmp 0x11a9b0
leaq 0x48(%rsp), %rdi
callq 0xe07f0
jmp 0x11a926
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xdeb10
jmp 0x11a9fc
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x11a9ef
movq 0x10(%rsp), %rdi
callq 0xdeb10
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: SleighBuilder::generateLocation(VarnodeTpl const*, VarnodeData&)
void SleighBuilder::generateLocation (const VarnodeTpl* vntpl, VarnodeData& vn)

{ // Generate a concrete varnode -vn- from the template -vntpl-
    vn.space = vntpl->getSpace ().fixSpace (*walker);
    vn.size = vntpl->getSize ().fix (*walker);
    if (vn.space == const_space)
        vn.offset = vntpl->getOffset ().fix (*walker) & calc_mask (vn.size);
    else if (vn.space == uniq_space) {
        vn.offset = vntpl->getOffset ().fix (*walker);
        vn.offset |= uniqueoffset;
    } else
        vn.offset = vn.space->wrapOffset (vntpl->getOffset ().fix (*walker));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe3000
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xd4e60
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rdi
callq 0xd4930
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xd5220
movq 0x18(%rsp), %rcx
movl %eax, %edx
movq 0x20(%rsp), %rax
movl %edx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpq 0x18(%rcx), %rax
jne 0x11aace
movq 0x28(%rsp), %rdi
callq 0xdbaf0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xd5220
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x10(%rax), %edi
callq 0xcfa60
movq 0x10(%rsp), %rcx
andq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x11ab63
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpq 0x20(%rcx), %rax
jne 0x11ab20
movq 0x28(%rsp), %rdi
callq 0xdbaf0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xd5220
movq %rax, %rdx
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq 0x30(%rax), %rcx
movq 0x20(%rsp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x11ab61
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xdbaf0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xd5220
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xcfa10
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x11ab63
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: SleighBuilder::generatePointer(VarnodeTpl const*, VarnodeData&)
AddrSpace* SleighBuilder::generatePointer (const VarnodeTpl* vntpl,
                                           VarnodeData& vn)

{ // Generate the pointer varnode -vn- from a dynamic template -vntpl-
    const FixedHandle& hand (
        walker->getFixedHandle (vntpl->getOffset ().getHandleIndex ()));
    vn.space = hand.offset_space;
    vn.size = hand.offset_size;
    if (vn.space == const_space)
        vn.offset = hand.offset_offset & calc_mask (vn.size);
    else if (vn.space == uniq_space)
        vn.offset = hand.offset_offset | uniqueoffset;
    else
        vn.offset = vn.space->wrapOffset (hand.offset_offset);
    return hand.space;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xdbaf0
movq %rax, %rdi
callq 0xd1b90
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0xdb860
movq 0x10(%rsp), %rcx
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x20(%rsp), %rax
movq %rdx, (%rax)
movq 0x18(%rsp), %rax
movl 0x20(%rax), %edx
movq 0x20(%rsp), %rax
movl %edx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpq 0x18(%rcx), %rax
jne 0x11ac19
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movl 0x10(%rax), %edi
callq 0xcfa60
movq (%rsp), %rcx
andq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x11ac6d
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpq 0x20(%rcx), %rax
jne 0x11ac49
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rcx
orq 0x30(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x11ac6b
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xcfa10
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x11ac6d
movq 0x18(%rsp), %rax
movq (%rax), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/sleigh.cc
// Function: SleighBuilder::buildEmpty(Constructor*, int)
void SleighBuilder::buildEmpty (Constructor* ct, int4 secnum)
// Build a named p-code section of a constructor that contains only implied
// BUILD directives
{
    int4 numops = ct->getNumOperands ();

    for (int4 i = 0; i < numops; ++i) {
        SubtableSymbol* sym =
            (SubtableSymbol*)ct->getOperand (i)->getDefiningSymbol ();
        if (sym == (SubtableSymbol*)0)
            continue;
        if (sym->getType () != SleighSymbol::subtable_symbol)
            continue;

        walker->pushOperand (i);
        ConstructTpl* construct =
            walker->getConstructor ()->getNamedTempl (secnum);
        if (construct == (ConstructTpl*)0)
            buildEmpty (walker->getConstructor (), secnum);
        else
            build (construct, secnum);
        walker->popOperand ();
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0xd0880
movl %eax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x11b0de
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0xd3060
movq %rax, %rdi
callq 0xdf550
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x11b047
jmp 0x11b0ce
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0xb, %eax
je 0x11b059
jmp 0x11b0ce
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x1c(%rsp), %esi
callq 0xcf7d0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xd81d0
movq %rax, %rdi
movl 0x24(%rsp), %esi
callq 0xe0d30
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x11b0af
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xd81d0
movq (%rsp), %rdi
movq %rax, %rsi
movl 0x24(%rsp), %edx
callq 0xde230
jmp 0x11b0c1
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x24(%rsp), %edx
callq 0xd0740
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xceb70
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x11b011
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)