LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextCache::setContext(Address const&, Address const&, int, unsigned int, unsigned int)
void ContextCache::setContext(const Address &addr1,const Address &addr2,int4 num,uintm mask,uintm value)

{
  if (!allowset) return;
  database->setContextRegion(addr1,addr2,num,mask,value);
  if ((addr1.getSpace()==curspace)&&(first<=addr1.getOffset())&&(last>=addr1.getOffset()))
    curspace = (AddrSpace *)0;	// Invalidate cache
  if ((first<=addr2.getOffset())&&(last>=addr2.getOffset()))
    curspace = (AddrSpace *)0;	// Invalidate cache
  if ((first>=addr1.getOffset())&&(first<=addr2.getOffset()))
    curspace = (AddrSpace *)0;	// Invalidate cache
}

// Assembly:
cmpb $0x1, 0x8(%rdi)
jne 0x4730e
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3f3e0
movq (%r14), %rcx
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rcx
jne 0x472e4
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
ja 0x472e4
cmpq %rcx, 0x20(%rbx)
jb 0x472e4
movq $0x0, 0x10(%rbx)
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
ja 0x47309
cmpq %rcx, 0x20(%rbx)
jb 0x472fb
movq $0x0, 0x10(%rbx)
cmpq 0x8(%r14), %rax
jb 0x47309
movq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/include/partmap.hh
// Function: partmap<Address, ContextInternal::FreeArray>::bounds(Address const&, Address&, Address&, int&) const
const _valuetype &partmap<_linetype,_valuetype>::
  bounds(const _linetype &pnt,_linetype &before,_linetype &after,int &valid) const
  {
    if (database.empty()) {
      valid = 3;
      return defaultvalue;
    }
    const_iterator iter,enditer;
    
    enditer = database.upper_bound(pnt);
    if (enditer != database.begin()) {
      iter = enditer;
      --iter;
      before = (*iter).first;
      if (enditer == database.end())
	valid = 2;		// No upperbound
      else {
	after = (*enditer).first;
	valid = 0;		// Fully bounded
      }
      return (*iter).second;
    }
    valid = 1;			// No lowerbound
    after = (*enditer).first;
    return defaultvalue;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x4742e
movq %rdx, %r12
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x10(%rbx), %r15
leaq 0x8(%rbx), %r14
movq %r14, %r13
testq %r15, %r15
je 0x473ef
movq %rsi, %rbp
movq %r14, %r13
leaq 0x20(%r15), %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x42270
testb %al, %al
cmovneq %r15, %r13
xorb $0x1, %al
movzbl %al, %eax
movq 0x10(%r15,%rax,8), %r15
testq %r15, %r15
jne 0x473cb
cmpq 0x18(%rbx), %r13
je 0x47437
movq %r13, %rdi
callq 0x3fe70
movq %rax, %rbx
movq 0x20(%rax), %rax
movq %rax, (%r12)
movq 0x28(%rbx), %rax
movq %rax, 0x8(%r12)
cmpq %r14, %r13
je 0x47458
movq 0x20(%r13), %rax
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq 0x28(%r13), %rax
movq %rax, 0x8(%rcx)
xorl %eax, %eax
jmp 0x4745d
movl $0x3, (%r8)
jmp 0x47464
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movq 0x20(%r13), %rax
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq 0x28(%r13), %rax
movq %rax, 0x8(%rcx)
jmp 0x47464
movl $0x2, %eax
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
addq $0x30, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/include/partmap.hh
// Function: partmap<Address, ContextInternal::FreeArray>::split(Address const&)
_valuetype &partmap<_linetype,_valuetype>::
  split(const _linetype &pnt)

  {
    iterator iter;
    
    iter = database.upper_bound(pnt);
    if (iter != database.begin()) {
      --iter;
      if ((*iter).first == pnt)	// point matches exactly
	return (*iter).second;	// Return old ref
      _valuetype &newref( database[pnt] ); // Create new ref at point
      newref = (*iter).second;	// Copy of original partition value
      return newref;
    }
    _valuetype &newref( database[pnt] ); // Create new ref at point
    newref = defaultvalue;	// Copy of defaultvalue
    return newref;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %r12
leaq 0x8(%rdi), %r15
testq %r12, %r12
je 0x474b7
leaq 0x20(%r12), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42270
testb %al, %al
cmovneq %r12, %r15
xorb $0x1, %al
movzbl %al, %eax
movq 0x10(%r12,%rax,8), %r12
jmp 0x47490
cmpq 0x18(%rbx), %r15
je 0x474e4
movq %r15, %rdi
callq 0x408f0
movq %rax, %r15
movq 0x20(%rax), %rax
cmpq (%r14), %rax
jne 0x474fe
movq 0x8(%r14), %rax
cmpq %rax, 0x28(%r15)
jne 0x474fe
addq $0x30, %r15
movq %r15, %r14
jmp 0x4751b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f2c0
movq %rax, %r14
addq $0x30, %rbx
movq %rax, %rdi
movq %rbx, %rsi
jmp 0x47516
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f2c0
movq %rax, %r14
addq $0x30, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3fe20
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/include/partmap.hh
// Function: partmap<Address, std::vector<TrackedContext, std::allocator<TrackedContext>>>::clearRange(Address const&, Address const&)
_valuetype &partmap<_linetype,_valuetype>::
  clearRange(const _linetype &pnt1,const _linetype &pnt2)
  {
    split(pnt1);
    split(pnt2);
    iterator beg = begin(pnt1);
    iterator end = begin(pnt2);
    
    _valuetype &ref( (*beg).second );
    ++beg;
    database.erase(beg,end);
    return ref;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
callq 0x3f5f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f5f0
movq 0x10(%rbx), %rbp
leaq 0x8(%rbx), %r14
movq %r14, %r12
testq %rbp, %rbp
je 0x475a8
leaq 0x20(%rbp), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x42270
testb %al, %al
cmoveq %rbp, %r12
movzbl %al, %eax
movq 0x10(%rbp,%rax,8), %rbp
testq %rbp, %rbp
jne 0x4755e
movq 0x10(%rbx), %r13
testq %r13, %r13
je 0x475a8
leaq 0x20(%r13), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x42270
testb %al, %al
cmoveq %r13, %r14
movzbl %al, %eax
movq 0x10(%r13,%rax,8), %r13
jmp 0x47584
leaq 0x30(%r12), %r15
movq %r12, %rdi
callq 0x40040
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x41ca0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/include/partmap.hh
// Function: partmap<Address, ContextInternal::FreeArray>::getValue(Address const&) const
const _valuetype &partmap<_linetype,_valuetype>::
  getValue(const _linetype &pnt) const
  
  {
    const_iterator iter;
    
    iter = database.upper_bound(pnt);
    if (iter == database.begin())
      return defaultvalue;
    --iter;
    return (*iter).second;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r12
leaq 0x8(%rdi), %r14
testq %r12, %r12
je 0x47984
movq %rsi, %r15
leaq 0x20(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x42270
testb %al, %al
cmovneq %r12, %r14
xorb $0x1, %al
movzbl %al, %eax
movq 0x10(%r12,%rax,8), %r12
testq %r12, %r12
jne 0x4795f
cmpq 0x18(%rbx), %r14
je 0x47995
movq %r14, %rdi
callq 0x3fe70
movq %rax, %rbx
addq $0x30, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/include/address.hh
// Function: std::less<Address>::operator()(Address const&, Address const&) const
inline bool Address::operator<(const Address &op2) const {
  if (base != op2.base)  {
    if (base == (AddrSpace *)0) {
      return true;
    }
    else if (base == (AddrSpace *) ~((uintp)0)) {
      return false;
    }
    else if (op2.base == (AddrSpace *)0) {
      return false;
    }
    else if (op2.base == (AddrSpace *) ~((uintp)0)) {
      return true;
    }
    return (base->getIndex() < op2.base->getIndex());
  }
  if (offset != op2.offset) return (offset < op2.offset);
  return false;
}

// Assembly:
movq (%rsi), %rcx
movq (%rdx), %rdi
cmpq %rdi, %rcx
je 0x479d5
movb $0x1, %al
testq %rcx, %rcx
je 0x479d4
cmpq $-0x1, %rcx
je 0x479e1
testq %rdi, %rdi
je 0x479e1
cmpq $-0x1, %rdi
je 0x479d4
movl 0x60(%rcx), %eax
cmpl 0x60(%rdi), %eax
setl %al
retq
movq 0x8(%rsi), %rax
cmpq 0x8(%rdx), %rax
setb %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opcodes.cc
// Function: get_opcode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
OpCode get_opcode(const string &nm)

{
  int4 min = 1;			// Don't include BLANK
  int4 max = CPUI_MAX-1;
  int4 cur,ind;

  while(min <= max) {		// Binary search
    cur = (min + max)/2;
    ind = opcode_indices[cur];	// Get opcode in cur's sort slot
    if (opcode_name[ind] < nm)
      min = cur + 1;		// Everything equal or below cur is less
    else if (opcode_name[ind] > nm)
      max = cur - 1;		// Everything equal or above cur is greater
    else
      return (OpCode)ind;	// Found the match
  }
  return (OpCode)0;	// Name isn't an op
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x45, %r12d
movl $0x1, %ebp
leal (%r12,%rbp), %eax
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
movslq %r13d, %rax
leaq 0x36a2e(%rip), %rcx     # 0x7f390
movslq (%rcx,%rax,4), %r14
leaq 0x55e33(%rip), %rax     # 0x9e7a0
movq (%rax,%r14,8), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f590
testl %eax, %eax
jle 0x48988
incl %r13d
movl %r13d, %ebp
jmp 0x4899d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f590
testl %eax, %eax
jns 0x489a5
decl %r13d
movl %r13d, %r12d
cmpl %r12d, %ebp
jle 0x48947
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/opcodes.cc
// Function: get_booleanflip(OpCode, bool&)
OpCode get_booleanflip(OpCode opc,bool &reorder)

{
  switch(opc) {
  case CPUI_INT_EQUAL:
    reorder = false;
    return CPUI_INT_NOTEQUAL;
  case CPUI_INT_NOTEQUAL:
    reorder = false;
    return CPUI_INT_EQUAL;
  case CPUI_INT_SLESS:
    reorder = true;
    return CPUI_INT_SLESSEQUAL;
  case CPUI_INT_SLESSEQUAL:
    reorder = true;
    return CPUI_INT_SLESS;
  case CPUI_INT_LESS:
    reorder = true;
    return CPUI_INT_LESSEQUAL;
  case CPUI_INT_LESSEQUAL:
    reorder = true;
    return CPUI_INT_LESS;
  case CPUI_BOOL_NEGATE:
    reorder = false;
    return CPUI_COPY;
  case CPUI_FLOAT_EQUAL:
    reorder = false;
    return CPUI_FLOAT_NOTEQUAL;
  case CPUI_FLOAT_NOTEQUAL:
    reorder = false;
    return CPUI_FLOAT_EQUAL;
  case CPUI_FLOAT_LESS:
    reorder = true;
    return CPUI_FLOAT_LESSEQUAL;
  case CPUI_FLOAT_LESSEQUAL:
    reorder = true;
    return CPUI_FLOAT_LESS;
  default:
    break;
  }
  return CPUI_MAX;
}

// Assembly:
leal -0xb(%rdi), %eax
cmpl $0x5, %eax
ja 0x489d6
leaq 0x3698a(%rip), %rcx     # 0x7f350
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xc, %eax
jmp 0x48a30
movl $0x46, %eax
addl $-0x25, %edi
cmpl $0x7, %edi
ja 0x48a3d
leaq 0x3697e(%rip), %rcx     # 0x7f368
movslq (%rcx,%rdi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movl $0x1, %eax
jmp 0x48a30
movl $0x2a, %eax
jmp 0x48a30
movl $0x2c, %eax
jmp 0x48a39
movl $0x29, %eax
jmp 0x48a30
movl $0x2b, %eax
jmp 0x48a39
movl $0x10, %eax
jmp 0x48a39
movl $0xe, %eax
jmp 0x48a39
movl $0xd, %eax
jmp 0x48a39
movl $0xb, %eax
xorl %ecx, %ecx
jmp 0x48a3b
movl $0xf, %eax
movb $0x1, %cl
movb %cl, (%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcoderaw.cc
// Function: VarnodeData::restoreXml(Element const*, AddrSpaceManager const*)
void VarnodeData::restoreXml(const Element *el,const AddrSpaceManager *manage)

{
  space = (AddrSpace *)0;
  size = 0;
  int4 num = el->getNumAttributes();
  for(int4 i=0;i<num;++i) {
    if (el->getAttributeName(i)=="space") {
      space = manage->getSpaceByName(el->getAttributeValue(i));
      if (space == (AddrSpace *)0)
	throw LowlevelError("Unknown space name: "+el->getAttributeValue(i));
      offset = space->restoreXmlAttributes(el,size);
      return;
    }
    else if (el->getAttributeName(i)=="name") {
      const Translate *trans = manage->getDefaultSpace()->getTrans();
      const VarnodeData &point(trans->getRegister(el->getAttributeValue(i)));
      *this = point;
      return;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq $0x0, (%rdi)
movl $0x0, 0x10(%rdi)
movq 0x48(%rsi), %r12
subq 0x40(%rsi), %r12
shrq $0x5, %r12
testl %r12d, %r12d
jle 0x48b2d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
shlq $0x5, %r12
xorl %r15d, %r15d
leaq 0x37083(%rip), %rbp     # 0x7fb1d
leaq 0x36590(%rip), %r13     # 0x7f031
movq 0x40(%r14), %rdi
addq %r15, %rdi
movq %rbp, %rsi
callq 0x3f590
testl %eax, %eax
je 0x48ad2
movq 0x40(%r14), %rdi
addq %r15, %rdi
movq %r13, %rsi
callq 0x3f590
testl %eax, %eax
je 0x48b02
addq $0x20, %r15
cmpq %r15, %r12
jne 0x48aa1
jmp 0x48b2d
movq 0x58(%r14), %rsi
addq %r15, %rsi
movq 0x8(%rsp), %rdi
callq 0x41fe0
movq %rax, (%rbx)
testq %rax, %rax
je 0x48b3c
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
callq *0x48(%rcx)
movq %rax, 0x8(%rbx)
jmp 0x48b2d
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rax
movq 0x18(%rax), %rdi
addq 0x58(%r14), %r15
movq (%rdi), %rax
movq %r15, %rsi
callq *0x38(%rax)
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
addq 0x58(%r14), %r15
leaq 0x36bbd(%rip), %rsi     # 0x7f711
leaq 0x18(%rsp), %rdi
movq %r15, %rdx
callq 0x40510
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x5a32e(%rip), %rsi     # 0xa2ea8
movq 0x5a0b7(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48ba7
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x48bb1
jmp 0x48bb9
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::AddrSpace(AddrSpaceManager*, Translate const*, spacetype, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int, int, unsigned int, int)
AddrSpace::AddrSpace(AddrSpaceManager *m,const Translate *t,spacetype tp,const string &nm,
		     uint4 size,uint4 ws, int4 ind,uint4 fl,int4 dl)
{
  refcount = 0;			// No references to this space yet
  manage = m;
  trans = t;
  type = tp;
  name = nm;
  addressSize = size;
  wordsize = ws;
  index = ind;
  delay = dl;
  deadcodedelay = dl;		// Deadcode delay initially starts the same as heritage delay
  shortcut = ' ';		// Placeholder meaning shortcut is unassigned

  // These are the flags we allow to be set from constructor
  flags = (fl & hasphysical);
  if (t->isBigEndian())
    flags |= big_endian;
  flags |= (heritaged | does_deadcode);		// Always on unless explicitly turned off in derived constructor
  
  calcScaleMask();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x5a1b8(%rip), %rax     # 0xa2dc0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x38(%rdi), %r15
leaq 0x48(%rdi), %r12
movq %r12, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movb $0x0, 0x48(%rdi)
movl $0x0, 0x20(%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movl %ecx, 0x8(%rdi)
movq %r15, %rdi
movq %r8, %rsi
callq 0x3fc60
movl 0x48(%rsp), %edx
movl 0x40(%rsp), %ecx
movl 0x38(%rsp), %esi
movl 0x30(%rsp), %eax
movl %ebp, 0x58(%rbx)
movl %eax, 0x5c(%rbx)
movl %esi, 0x60(%rbx)
movl %edx, 0x64(%rbx)
movl %edx, 0x68(%rbx)
movb $0x20, 0x30(%rbx)
andl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x24(%rbx)
cmpb $0x1, 0x120(%r14)
jne 0x48c80
orl $0x1, %ecx
movl %ecx, 0x24(%rbx)
orl $0x6, %ecx
movl %ecx, 0x24(%rbx)
cmpl $0x8, %ebp
movl $0x8, %ecx
cmovll %ebp, %ecx
movslq %ecx, %rcx
movq 0x59f35(%rip), %rdx     # 0xa2bd0
movl %eax, %esi
imulq (%rdx,%rcx,8), %rsi
decl %eax
addq %rsi, %rax
movq %rax, 0x28(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x48ccb
movq (%r12), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::saveXmlAttributes(std::ostream&, unsigned long) const
void AddrSpace::saveXmlAttributes(ostream &s,uintb offset) const

{
  a_v(s,"space",getName());	// Just append the proper attributes
  s << ' ' << "offset=\"";
  printOffset(s,offset);
  s << "\"";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x367ee(%rip), %rsi     # 0x7fb1d
leaq 0x367ec(%rip), %rdx     # 0x7fb22
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
leaq 0x383ea(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x38(%r15), %rsi
movq %rbx, %rdi
callq 0x3f3d0
leaq 0x38259(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x493b2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x8(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
leaq 0x36388(%rip), %rsi     # 0x7f756
movl $0x8, %edx
movq %rax, %rdi
callq 0x40b90
leaq 0x37cd2(%rip), %rsi     # 0x810b4
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b90
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ffc0
leaq 0x381d1(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x49449
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::saveXmlAttributes(std::ostream&, unsigned long, int) const
void AddrSpace::saveXmlAttributes(ostream &s,uintb offset,int4 size) const

{
  a_v(s,"space",getName());	// Just append the proper attributes
  s << ' ' << "offset=\"";
  printOffset(s,offset);
  s << "\"";
  a_v_i(s,"size",size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x3665b(%rip), %rsi     # 0x7fb1d
leaq 0x36659(%rip), %rdx     # 0x7fb22
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b90
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
leaq 0x38257(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x38(%r12), %rsi
movq %r14, %rdi
callq 0x3f3d0
leaq 0x380c5(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b90
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x49546
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x10(%rsp), %r12
movb $0x20, (%r12)
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x40b90
leaq 0x361ef(%rip), %rsi     # 0x7f756
movl $0x8, %edx
movq %rax, %rdi
callq 0x40b90
leaq 0x37b39(%rip), %rsi     # 0x810b4
movl $0x2, %edx
movq %r14, %rdi
callq 0x40b90
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r14,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ffc0
leaq 0x38036(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b90
movq %r13, (%r12)
leaq 0x3c1d4(%rip), %rsi     # 0x8579d
leaq 0x3c1d1(%rip), %rdx     # 0x857a1
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b90
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
movq %rax, %r14
leaq 0x3814d(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b90
movslq %ebx, %rsi
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
movq %r14, %rdi
callq 0x40700
leaq 0x37fa6(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x49665
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x49675
movq %rax, %rbx
jmp 0x49696
jmp 0x4967c
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x49696
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::printRaw(std::ostream&, unsigned long) const
void AddrSpace::printRaw(ostream &s,uintb offset) const

{
  int4 sz = getAddrSize();
  if (sz > 4) {
    if ((offset>>32) == 0)
      sz = 4;			// Don't print a bunch of zeroes at front of address
    else if ((offset>>48) == 0)
      sz = 6;
  }
  s << "0x" << setfill('0') << setw(2*sz) << hex << byteToAddress(offset,wordsize);
  if (wordsize>1) {
    int4 cut = offset % wordsize;
    if (cut != 0)
      s << '+' << dec << cut;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl 0x58(%rdi), %eax
cmpl $0x5, %eax
jl 0x498ee
movq %r14, %rcx
shrq $0x20, %rcx
movl $0x4, %ebp
je 0x498f0
movq %r14, %rcx
shrq $0x30, %rcx
movl $0x6, %ecx
cmovel %ecx, %eax
movl %eax, %ebp
leaq 0x377bd(%rip), %rsi     # 0x810b4
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b90
movq (%rbx), %rax
movq -0x18(%rax), %rcx
leaq (%rbx,%rcx), %r12
cmpb $0x0, 0xe1(%rbx,%rcx)
jne 0x49932
movq %r12, %rdi
movl $0x20, %esi
callq 0x40750
movb $0x1, 0xe1(%r12)
movq (%rbx), %rax
movb $0x30, 0xe0(%r12)
addl %ebp, %ebp
movq -0x18(%rax), %rcx
movslq %ebp, %rdx
movq %rdx, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movl 0x5c(%r15), %ecx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3ffc0
movl 0x5c(%r15), %ecx
cmpq $0x2, %rcx
jb 0x499c1
movq %r14, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x499c1
movq %rdx, %r14
leaq 0xf(%rsp), %rsi
movb $0x2b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movl %r14d, %esi
callq 0x41db0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: JoinSpace::printRaw(std::ostream&, unsigned long) const
void JoinSpace::printRaw(ostream &s,uintb offset) const

{
  JoinRecord *rec = getManager()->findJoin(offset);
  int4 szsum = 0;
  int4 num = rec->numPieces();
  s << '{';
  for(int4 i=0;i<num;++i) {
    const VarnodeData &vdat( rec->getPiece(i) );
    szsum += vdat.size;
    if (i!=0)
      s << ',';
    vdat.space->printRaw(s,vdat.offset);
  }
  if (num == 1) {
    szsum = rec->getUnified().size;
    s << ':' << szsum;
  }
  s << '}';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x10(%rdi), %rdi
movq %rdx, %rsi
callq 0x41420
movq %rax, %r14
movq 0x8(%rax), %rax
subq (%r14), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r13
leaq 0xd(%rsp), %rsi
movb $0x7b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
testl %r13d, %r13d
jle 0x4b3ce
movq %r13, 0x10(%rsp)
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
movl $0x8, %ebp
xorl %r12d, %r12d
movq (%r14), %r15
testq %r12, %r12
je 0x4b386
movb $0x2c, 0xc(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
callq 0x40b90
movq -0x8(%r15,%rbp), %rdi
movq (%r15,%rbp), %rdx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
incq %r12
addq $0x18, %rbp
cmpq %r12, %r13
jne 0x4b367
cmpl $0x1, 0x10(%rsp)
jne 0x4b3ce
movl 0x28(%r14), %ebp
leaq 0xe(%rsp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq %rax, %rdi
movl %ebp, %esi
callq 0x41db0
leaq 0xf(%rsp), %rsi
movb $0x7d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: OverlaySpace::saveXml(std::ostream&) const
void OverlaySpace::saveXml(ostream &s) const

{
  s << "<space_overlay";
  a_v(s,"name",name);
  a_v_i(s,"index",index);
  a_v(s,"base",baseSpace->getName());
  s << "/>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3405c(%rip), %rsi     # 0x7f8de
movl $0xe, %edx
movq %rbx, %rdi
callq 0x40b90
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x33792(%rip), %rsi     # 0x7f031
leaq 0x3378f(%rip), %rdx     # 0x7f035
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
leaq 0x35e7a(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3f3d0
leaq 0x35ce9(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4b922
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x10(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x33df5(%rip), %rsi     # 0x7f726
leaq 0x33df3(%rip), %rdx     # 0x7f72b
callq 0x3f8a0
movslq 0x60(%r14), %r15
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
movq %rax, %r12
leaq 0x35de6(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b90
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r12,%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x40700
leaq 0x35c3e(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4b9cd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x10(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x340cb(%rip), %rsi     # 0x7faa7
leaq 0x340c8(%rip), %rdx     # 0x7faab
callq 0x3f8a0
movq 0x70(%r14), %r14
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
leaq 0x35d3e(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3f3d0
leaq 0x35bad(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4ba5e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x34db0(%rip), %rsi     # 0x80815
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b90
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4ba84
jmp 0x4ba84
movq %rax, %rbx
jmp 0x4baa7
jmp 0x4ba8d
jmp 0x4ba8d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4baa7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: TruncationTag::restoreXml(Element const*)
void TruncationTag::restoreXml(const Element *el)

{
  spaceName = el->getAttributeValue("space");
  istringstream s(el->getAttributeValue("size"));
  s.unsetf(ios::dec | ios::hex | ios::oct);
  s >> size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x338d3(%rip), %rsi     # 0x7fb1d
leaq 0x338d1(%rip), %rdx     # 0x7fb22
leaq 0x20(%rsp), %rdi
callq 0x3f8a0
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x40f80
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3fc60
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c28a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x39503(%rip), %rsi     # 0x8579d
leaq 0x39500(%rip), %rdx     # 0x857a1
movq %rsp, %rdi
callq 0x3f8a0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x40f80
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c90
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4c2dc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x38(%rsp,%rax)
addq $0x20, %rbx
movq %rbx, %rsi
callq 0x41ec0
movq 0x56a10(%rip), %rsi     # 0xa2d10
leaq 0x20(%rsp), %rdi
callq 0x41450
leaq 0x98(%rsp), %rdi
callq 0x3f730
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x569e2(%rip), %rsi     # 0xa2d10
leaq 0x20(%rsp), %rdi
callq 0x41450
leaq 0x98(%rsp), %rdi
callq 0x3f730
jmp 0x4c37b
jmp 0x4c349
movq %rax, %rbx
jmp 0x4c37b
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4c37b
movq 0x10(%rsp), %rsi
jmp 0x4c373
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c37b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: SpacebaseSpace::setBaseRegister(VarnodeData const&, int, bool)
void SpacebaseSpace::setBaseRegister(const VarnodeData &data,int4 truncSize,bool stackGrowth)

{
  if (hasbaseregister) {
    if ((baseloc != data)||(isNegativeStack != stackGrowth))
      throw LowlevelError("Attempt to assign more than one base register to space: "+getName());
  }
  hasbaseregister = true;
  isNegativeStack = stackGrowth;
  baseOrig = data;
  baseloc = data;
  if (truncSize != baseloc.size) {
    if (baseloc.space->isBigEndian())
      baseloc.offset += (baseloc.size - truncSize);
    baseloc.size = truncSize;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
cmpb $0x1, 0x78(%rdi)
jne 0x4c438
movq 0x80(%r14), %rax
cmpq (%rsi), %rax
jne 0x4c498
movq 0x88(%r14), %rax
cmpq 0x8(%rsi), %rax
jne 0x4c498
movl 0x90(%r14), %eax
cmpl 0x10(%rsi), %eax
jne 0x4c498
cmpb %cl, 0x79(%r14)
jne 0x4c498
movb $0x1, 0x78(%r14)
movb %cl, 0x79(%r14)
movups (%rsi), %xmm0
movups %xmm0, 0x98(%r14)
movq 0x10(%rsi), %rax
movq %rax, 0xa8(%r14)
movups (%rsi), %xmm0
movups %xmm0, 0x80(%r14)
movq 0x10(%rsi), %rax
movq %rax, 0x90(%r14)
subl %edx, %eax
je 0x4c48f
leaq 0x80(%r14), %rcx
movq (%rcx), %rcx
testb $0x1, 0x24(%rcx)
je 0x4c488
addq %rax, 0x88(%r14)
movl %edx, 0x90(%r14)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
addq $0x38, %r14
leaq 0x33590(%rip), %rsi     # 0x7fa40
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40510
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x569d6(%rip), %rsi     # 0xa2ea8
movq 0x5675f(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c4ff
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x4c509
jmp 0x4c511
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: SpacebaseSpace::saveXml(std::ostream&) const
void SpacebaseSpace::saveXml(ostream &s) const

{
  s << "<space_base";
  saveBasicAttributes(s);
  a_v(s,"contain",contain->getName());
  s << "/>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x33418(%rip), %rsi     # 0x7faa0
movl $0xb, %edx
movq %rbx, %rdi
callq 0x40b90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40bc0
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x333fc(%rip), %rsi     # 0x7faac
leaq 0x333fc(%rip), %rdx     # 0x7fab3
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
movq 0x70(%r14), %r14
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
leaq 0x35065(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3f3d0
leaq 0x34ed4(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c737
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x340d7(%rip), %rsi     # 0x80815
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b90
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c76f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::getSpaceByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
AddrSpace *AddrSpaceManager::getSpaceByName(const string &nm) const

{
  map<string,AddrSpace *>::const_iterator iter = name2Space.find(nm);
  if (iter == name2Space.end())
    return (AddrSpace *)0;
  return (*iter).second;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x41ed0
addq $0x40, %rbx
cmpq %rbx, %rax
je 0x4c844
movq 0x40(%rax), %rax
jmp 0x4c846
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: JoinRecord::operator<(JoinRecord const&) const
bool JoinRecord::operator<(const JoinRecord &op2) const

{
  // Some joins may have same piece but different unified size  (floating point)
  if (unified.size != op2.unified.size) // Compare size first
    return (unified.size < op2.unified.size);
  // Lexigraphic sort on pieces
  int4 i=0;
  for(;;) {
    if (pieces.size()==i) {
      return (op2.pieces.size()>i); // If more pieces in op2, it is bigger (return true), if same number this==op2, return false
    }
    if (op2.pieces.size()==i) return false; // More pieces in -this-, so it is bigger, return false
    if (pieces[i] != op2.pieces[i])
      return (pieces[i] < op2.pieces[i]);
    i += 1;
  }
}

// Assembly:
movl 0x28(%rsi), %eax
cmpl %eax, 0x28(%rdi)
jne 0x4c8c6
movq (%rdi), %rdx
movq 0x8(%rdi), %r9
movq %r9, %rax
subq %rdx, %rax
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
movq (%rsi), %rdi
movq 0x8(%rsi), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
imulq %r8, %rcx
cmpq %rdx, %r9
je 0x4c8ca
sarq $0x3, %rax
imulq %r8, %rax
movl $0x10, %esi
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x4c8d3
movq -0x10(%rdx,%rsi), %r9
movq -0x10(%rdi,%rsi), %r10
cmpq %r10, %r9
jne 0x4c8d6
movq -0x8(%rdi,%rsi), %r9
cmpq %r9, -0x8(%rdx,%rsi)
jne 0x4c8c6
movl (%rdx,%rsi), %r9d
cmpl (%rdi,%rsi), %r9d
jne 0x4c8e2
incq %r8
addq $0x18, %rsi
cmpq %r8, %rax
jne 0x4c88e
jmp 0x4c8cc
setb %al
retq
xorl %eax, %eax
cmpq %rax, %rcx
seta %al
retq
xorl %eax, %eax
retq
movl 0x60(%r9), %eax
cmpl 0x60(%r10), %eax
setl %al
retq
movl (%rdx,%rsi), %eax
cmpl (%rdi,%rsi), %eax
jmp 0x4c8cf
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::AddrSpaceManager()
AddrSpaceManager::AddrSpaceManager(void)

{
  defaultspace = (AddrSpace *)0;
  constantspace = (AddrSpace *)0;
  iopspace = (AddrSpace *)0;
  fspecspace = (AddrSpace *)0;
  joinspace = (AddrSpace *)0;
  stackspace = (AddrSpace *)0;
  uniqspace = (AddrSpace *)0;
  joinallocate = 0;
}

// Assembly:
movq 0x566bf(%rip), %rax     # 0xa2fb0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x40(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movq %rcx, 0x60(%rdi)
leaq 0x70(%rdi), %rax
movl %ecx, 0x70(%rdi)
movq %rcx, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movq %rax, 0x88(%rdi)
movq %rcx, 0x90(%rdi)
leaq 0xe0(%rdi), %rax
movl %ecx, 0xe0(%rdi)
movq %rcx, 0xe8(%rdi)
movq %rax, 0xf0(%rdi)
movq %rax, 0xf8(%rdi)
movups %xmm0, 0xc8(%rdi)
movups %xmm0, 0xb8(%rdi)
movups %xmm0, 0xa8(%rdi)
movups %xmm0, 0x98(%rdi)
movups %xmm0, 0x110(%rdi)
movups %xmm0, 0x100(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::restoreXmlSpace(Element const*, Translate const*)
AddrSpace *AddrSpaceManager::restoreXmlSpace(const Element *el,const Translate *trans)

{
  AddrSpace *res;
  const string &tp(el->getName());
  if (tp == "space_base")
    res = new SpacebaseSpace(this,trans);
  else if (tp == "space_unique")
    res = new UniqueSpace(this,trans);
  else if (tp == "space_other")
    res = new OtherSpace(this,trans);
  else if (tp == "space_overlay")
    res = new OverlaySpace(this,trans);
  else
    res = new AddrSpace(this,trans,IPTR_PROCESSOR);

  res->restoreXml(el);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x330fb(%rip), %rsi     # 0x7faa1
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x4ca0d
leaq 0x32e35(%rip), %rsi     # 0x7f7ee
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x4ca2a
leaq 0x32e15(%rip), %rsi     # 0x7f7e1
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x4ca47
leaq 0x32f00(%rip), %rsi     # 0x7f8df
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x4ca64
movl $0x70, %edi
callq 0x40810
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x3f680
jmp 0x4ca7f
movl $0xb0, %edi
callq 0x40810
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x41b20
jmp 0x4ca7f
movl $0x70, %edi
callq 0x40810
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x40000
jmp 0x4ca7f
movl $0x70, %edi
callq 0x40810
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3ff30
jmp 0x4ca7f
movl $0x78, %edi
callq 0x40810
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x41700
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x68(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x78, %esi
jmp 0x4caba
jmp 0x4caa8
jmp 0x4caa8
movq %rax, %rbx
movl $0x70, %esi
jmp 0x4caba
movq %rax, %rbx
movl $0xb0, %esi
movq %r14, %rdi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::setDefaultSpace(int)
void AddrSpaceManager::setDefaultSpace(int4 index)

{
  if (defaultspace != (AddrSpace *)0)
    throw LowlevelError("Default space set multiple times");
  if (baselist.size()<=index || baselist[index] == (AddrSpace *)0)
    throw LowlevelError("Bad index for default space");
  defaultspace = baselist[index];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0xa0(%rdi)
jne 0x4d41a
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movslq %esi, %rcx
cmpq %rcx, %rdx
jbe 0x4d3c2
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x4d3c2
movq %rax, 0xa0(%rdi)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x32728(%rip), %rsi     # 0x7fb07
leaq 0x3273c(%rip), %rdx     # 0x7fb22
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x55a9f(%rip), %rsi     # 0xa2ea8
movq 0x55828(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
jmp 0x4d470
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x326af(%rip), %rsi     # 0x7fae6
leaq 0x326c8(%rip), %rdx     # 0x7fb06
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x55a47(%rip), %rsi     # 0xa2ea8
movq 0x557d0(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
jmp 0x4d474
jmp 0x4d495
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4d48e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x4d498
jmp 0x4d4a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::assignShortcut(AddrSpace*)
void AddrSpaceManager::assignShortcut(AddrSpace *spc)

{
  if (spc->shortcut != ' ') {	// If the shortcut is already assigned
    shortcut2Space.insert(pair<int4,AddrSpace *>(spc->shortcut,spc));
    return;
  }
  char shortcut;
  switch(spc->getType()) {
  case IPTR_CONSTANT:
    shortcut = '#';
    break;
  case IPTR_PROCESSOR:
    if (spc->getName() == "register")
      shortcut = '%';
    else
      shortcut = spc->getName()[0];
    break;
  case IPTR_SPACEBASE:
    shortcut = 's';
    break;
  case IPTR_INTERNAL:
    shortcut = 'u';
    break;
  case IPTR_FSPEC:
    shortcut = 'f';
    break;
  case IPTR_JOIN:
    shortcut = 'j';
    break;
  case IPTR_IOP:
    shortcut = 'i';
    break;
  default:
    shortcut = 'x';
    break;
  }

  if (shortcut >= 'A' && shortcut <= 'Z')
    shortcut += 0x20;

  int4 collisionCount = 0;
  while(!shortcut2Space.insert(pair<int4,AddrSpace *>(shortcut,spc)).second) {
    collisionCount += 1;
    if (collisionCount >26) {
      // Could not find a unique shortcut, but we just re-use 'z' as we
      // can always use the long form to specify the address if there are really so many
      // spaces that need to be distinguishable (in the console mode)
      spc->shortcut = 'z';
      return;
    }
    shortcut += 1;
    if (shortcut < 'a' || shortcut > 'z')
      shortcut = 'a';
  }
  spc->shortcut = (char)shortcut;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsbl 0x30(%rsi), %eax
cmpl $0x20, %eax
jne 0x4d4e9
movl 0x8(%rbx), %eax
cmpq $0x6, %rax
ja 0x4d514
leaq 0x32505(%rip), %rcx     # 0x7f9e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x23, %r12b
jmp 0x4d558
addq $0x68, %r14
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, 0x8(%rsi)
movq %r14, %rdi
callq 0x41d90
jmp 0x4d5c8
movb $0x66, %r12b
jmp 0x4d558
movb $0x73, %r12b
jmp 0x4d558
movb $0x75, %r12b
jmp 0x4d558
movb $0x78, %r12b
jmp 0x4d558
leaq 0x38(%rbx), %r15
leaq 0x32428(%rip), %rsi     # 0x7f94c
movq %r15, %rdi
callq 0x3f590
testl %eax, %eax
je 0x4d555
movq (%r15), %rax
movzbl (%rax), %eax
leal -0x41(%rax), %ecx
movl %eax, %edx
orb $0x20, %dl
cmpb $0x1a, %cl
movzbl %dl, %r12d
cmovael %eax, %r12d
jmp 0x4d558
movb $0x69, %r12b
jmp 0x4d558
movb $0x6a, %r12b
jmp 0x4d558
movb $0x25, %r12b
addq $0x68, %r14
movsbl %r12b, %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, 0x8(%rsi)
movq %r14, %rdi
callq 0x41d90
testb $0x1, %dl
jne 0x4d5be
movl $0x1b, %ebp
movl $0x61, %r13d
leaq 0x8(%rsp), %r15
decl %ebp
je 0x4d5c4
leal 0x1(%r12), %eax
addb $-0x7a, %r12b
cmpb $-0x1a, %r12b
movzbl %al, %r12d
cmovbl %r13d, %r12d
movsbl %r12b, %eax
movl %eax, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x41d90
testb $0x1, %dl
je 0x4d588
movb %r12b, 0x30(%rbx)
jmp 0x4d5c8
movb $0x7a, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::copySpaces(AddrSpaceManager const*)
void AddrSpaceManager::copySpaces(const AddrSpaceManager *op2)

{ // Insert every space in -op2- into -this- manager
  for(int4 i=0;i<op2->baselist.size();++i) {
    AddrSpace *spc = op2->baselist[i];
    if (spc != (AddrSpace *)0)
      insertSpace(spc);
  }
  setDefaultSpace(op2->getDefaultSpace()->getIndex());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
cmpq %rax, %rcx
je 0x4d61e
xorl %r15d, %r15d
movq (%rax,%r15,8), %rsi
testq %rsi, %rsi
je 0x4d60c
movq %rbx, %rdi
callq 0x3faa0
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
incq %r15
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
ja 0x4d5f3
movq 0xa0(%r14), %rax
movl 0x60(%rax), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x42470
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::insertResolver(AddrSpace*, AddressResolver*)
void AddrSpaceManager::insertResolver(AddrSpace *spc,AddressResolver *rsolv)

{
  int4 ind = spc->getIndex();
  while(resolvelist.size() <= ind)
    resolvelist.push_back((AddressResolver *)0);
  if (resolvelist[ind] != (AddressResolver *)0)
    delete resolvelist[ind];
  resolvelist[ind] = rsolv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movslq 0x60(%rsi), %r13
leaq 0x20(%rdi), %r14
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x4d6a2
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3f4c0
movq 0x20(%r15), %rax
movq 0x28(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x4d67a
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x4d6b4
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %rax
movq %rbx, (%rax,%r13,8)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::~AddrSpaceManager()
AddrSpaceManager::~AddrSpaceManager(void)

{
  for(vector<AddrSpace *>::iterator iter=baselist.begin();iter!=baselist.end();++iter) {
    AddrSpace *spc = *iter;
    if (spc == (AddrSpace *)0) continue;
    if (spc->refcount > 1)
      spc->refcount -= 1;
    else
      delete spc;
  }
  for(int4 i=0;i<resolvelist.size();++i) {
    if (resolvelist[i] != (AddressResolver *)0)
      delete resolvelist[i];
  }
  for(int4 i=0;i<splitlist.size();++i)
    delete splitlist[i];	// Delete any join records
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x558db(%rip), %rax     # 0xa2fb0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %rax
cmpq %rax, %r14
je 0x4d710
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4d70a
movl 0x20(%rdi), %ecx
cmpl $0x2, %ecx
jl 0x4d700
decl %ecx
movl %ecx, 0x20(%rdi)
jmp 0x4d70a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rax
addq $0x8, %r14
jmp 0x4d6e4
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
cmpq %rax, %rcx
je 0x4d749
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4d737
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
incq %r14
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
ja 0x4d720
movq 0x108(%rbx), %rdi
cmpq %rdi, 0x110(%rbx)
je 0x4d7a3
xorl %r15d, %r15d
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x4d779
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4d779
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x40880
movl $0x30, %esi
movq %r14, %rdi
callq 0x40880
incq %r15
movq 0x108(%rbx), %rdi
movq 0x110(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r15, %rax
ja 0x4d75c
testq %rdi, %rdi
je 0x4d7b7
movq 0x118(%rbx), %rsi
subq %rdi, %rsi
callq 0x40880
leaq 0xd8(%rbx), %rdi
callq 0x41d50
leaq 0x68(%rbx), %rdi
callq 0x3f130
leaq 0x38(%rbx), %rdi
callq 0x40a70
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x4d7ea
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x40880
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4d804
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x40880
popq %rbx
popq %r14
popq %r15
retq