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

{
  uintm uniq = ~((uintm)0);
  Address pc = Address::restoreXml(el,manage); // Recover address
  for(int4 i=0;i<el->getNumAttributes();++i)
    if (el->getAttributeName(i) == "uniq") {
      istringstream s2(el->getAttributeValue(i)); // Recover unique (if present)
      s2.unsetf(ios::dec | ios::hex | ios::oct);
      s2 >> uniq;
      break;
    }
  return SeqNum(pc,uniq);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x42050
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r15), %rbp
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rax
subq %rdi, %rax
shrq $0x5, %rax
testl %eax, %eax
jle 0x42e04
xorl %r15d, %r15d
leaq 0x3c285(%rip), %r12     # 0x7f008
xorl %r13d, %r13d
addq %r15, %rdi
movq %r12, %rsi
callq 0x3f590
testl %eax, %eax
je 0x42db4
incq %r13
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rax
subq %rdi, %rax
shrq $0x5, %rax
cltq
addq $0x20, %r15
cmpq %rax, %r13
jl 0x42d86
jmp 0x42e04
addq 0x58(%r14), %r15
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x41c80
movq (%r14), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x30(%rsp,%rax)
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x41eb0
movq 0x5ff23(%rip), %rsi     # 0xa2d10
leaq 0x18(%rsp), %rdi
callq 0x41440
leaq 0x90(%rsp), %rdi
callq 0x3f730
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
movq %rcx, (%rbx)
movq %rbp, 0x8(%rbx)
movl %eax, 0x10(%rbx)
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x5feda(%rip), %rsi     # 0xa2d10
leaq 0x18(%rsp), %rdi
callq 0x41440
leaq 0x90(%rsp), %rdi
callq 0x3f730
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Address::containedBy(int, Address const&, int) const
bool Address::containedBy(int4 sz,const Address &op2,int4 sz2) const

{
  if (base != op2.base) return false;
  if (op2.offset > offset) return false;
  uintb off1 = offset + (sz-1);
  uintb off2 = op2.offset + (sz2-1);
  return (off2 >= off1);
}

// Assembly:
movq (%rdi), %rax
cmpq (%rdx), %rax
jne 0x42ec7
movq 0x8(%rdx), %rax
movq 0x8(%rdi), %rdx
cmpq %rdx, %rax
jbe 0x42eca
xorl %eax, %eax
retq
movslq %esi, %rsi
addq %rsi, %rdx
decq %rdx
movslq %ecx, %rcx
addq %rcx, %rax
decq %rax
cmpq %rdx, %rax
setae %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Address::justifiedContain(int, Address const&, int, bool) const
int4 Address::justifiedContain(int4 sz,const Address &op2,int4 sz2,bool forceleft) const

{ if (base != op2.base) return -1;
  if (op2.offset < offset) return -1;
  uintb off1 = offset + (sz-1);
  uintb off2 = op2.offset + (sz2-1);
  if (off2 > off1) return -1;
  if (base->isBigEndian()&&(!forceleft)) {
    return (int4)(off1 - off2);
  }
  return (int4)(op2.offset - offset);
}

// Assembly:
movq (%rdi), %r9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq (%rdx), %r9
je 0x42ef2
retq
movq 0x8(%rdx), %rdx
movq 0x8(%rdi), %rdi
cmpq %rdi, %rdx
jb 0x42ef1
movslq %esi, %rsi
addq %rdi, %rsi
decq %rsi
movslq %ecx, %rcx
addq %rdx, %rcx
decq %rcx
cmpq %rcx, %rsi
jb 0x42ef1
testb $0x1, 0x24(%r9)
sete %al
orb %r8b, %al
je 0x42f28
subl %edi, %edx
movl %edx, %eax
retq
subl %ecx, %esi
movl %esi, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Address::overlap(int, Address const&, int) const
int4 Address::overlap(int4 skip,const Address &op,int4 size) const

{
  uintb dist;

  if (base != op.base) return -1; // Must be in same address space to overlap
  if (base->getType()==IPTR_CONSTANT) return -1; // Must not be constants

  dist = base->wrapOffset(offset+skip-op.offset);

  if (dist >= size) return -1; // but must fall before op+size
  return (int4) dist;
}

// Assembly:
movq (%rdi), %r9
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmpq (%rdx), %r9
jne 0x42f76
cmpl $0x0, 0x8(%r9)
je 0x42f76
movslq %esi, %rax
addq 0x8(%rdi), %rax
subq 0x8(%rdx), %rax
movq 0x28(%r9), %rsi
cmpq %rax, %rsi
jae 0x42f6c
incq %rsi
cqto
idivq %rsi
movq %rdx, %rax
sarq $0x3f, %rax
andq %rsi, %rax
addq %rdx, %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
cmovbl %eax, %r8d
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Address::isContiguous(int, Address const&, int) const
bool Address::isContiguous(int4 sz,const Address &loaddr,int4 losz) const

{
  if (base != loaddr.base) return false;
  if (base->isBigEndian()) {
    uintb nextoff = base->wrapOffset(offset+sz);
    if (nextoff == loaddr.offset) return true;
  }
  else {
    uintb nextoff = base->wrapOffset(loaddr.offset+losz);
    if (nextoff == offset) return true;
  }
  return false;
}

// Assembly:
movq (%rdi), %rax
cmpq (%rdx), %rax
je 0x42f87
xorl %edx, %edx
movl %edx, %eax
retq
movq %rdx, %r8
testb $0x1, 0x24(%rax)
movq 0x28(%rax), %r9
jne 0x42fbf
movslq %ecx, %rax
addq 0x8(%r8), %rax
cmpq %rax, %r9
jae 0x42fb5
incq %r9
cqto
idivq %r9
movq %rdx, %rax
sarq $0x3f, %rax
andq %r9, %rax
addq %rdx, %rax
movb $0x1, %dl
cmpq 0x8(%rdi), %rax
jne 0x42f82
jmp 0x42f84
movslq %esi, %rax
addq 0x8(%rdi), %rax
cmpq %rax, %r9
jae 0x42fe0
incq %r9
cqto
idivq %r9
movq %rdx, %rax
sarq $0x3f, %rax
andq %r9, %rax
addq %rdx, %rax
movb $0x1, %dl
cmpq 0x8(%r8), %rax
jne 0x42f82
jmp 0x42f84
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Address::restoreXml(Element const*, AddrSpaceManager const*, int&)
Address Address::restoreXml(const Element *el,const AddrSpaceManager *manage,int4 &size)

{
  VarnodeData var;

  var.restoreXml(el,manage);
  size = var.size;
  return Address(var.space,var.offset);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x42050
movl 0x10(%r15), %eax
movl %eax, (%rbx)
movups (%r15), %xmm0
movups %xmm0, (%r14)
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Range::getLastAddrOpen(AddrSpaceManager const*) const
Address Range::getLastAddrOpen(const AddrSpaceManager *manage) const

{
  AddrSpace *curspc = spc;
  uintb curlast = last;
  if (curlast == curspc->getHighest()) {
    curspc = manage->getNextSpaceInOrder(curspc);
    curlast = 0;
  }
  else
    curlast += 1;
  if (curspc == (AddrSpace *)0)
    return Address(Address::m_maximal);
  return Address(curspc,curlast);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x10(%rsi), %rcx
cmpq 0x28(%rax), %rcx
jne 0x43042
movq %rdx, %rdi
movq %rax, %rsi
callq 0x400f0
xorl %ecx, %ecx
jmp 0x43045
incq %rcx
testq %rax, %rax
je 0x43053
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
jmp 0x43060
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3f320
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Range::saveXml(std::ostream&) const
void Range::saveXml(ostream &s) const

{
  s << "<range";
  a_v(s,"space",spc->getName());
  a_v_u(s,"first",first);
  a_v_u(s,"last",last);
  s << "/>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3bf0f(%rip), %rsi     # 0x7f00d
movl $0x6, %edx
movq %rbx, %rdi
callq 0x40b80
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x3ca02(%rip), %rsi     # 0x7fb1d
leaq 0x3ca00(%rip), %rdx     # 0x7fb22
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
movq (%r14), %r15
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
leaq 0x3e5fb(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x38(%r15), %rsi
movq %rbx, %rdi
callq 0x3f3d0
leaq 0x3e46a(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x431a1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x10(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x3be64(%rip), %rsi     # 0x7f014
leaq 0x3be62(%rip), %rdx     # 0x7f019
callq 0x3f8a0
movq 0x8(%r14), %r15
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
movq %rax, %r12
leaq 0x3dec1(%rip), %rsi     # 0x810b2
movl $0x4, %edx
movq %rax, %rdi
callq 0x40b80
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r12,%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x3ffb0
leaq 0x3e3bf(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4324c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x10(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x3bdbf(%rip), %rsi     # 0x7f01a
leaq 0x3bdbc(%rip), %rdx     # 0x7f01e
callq 0x3f8a0
movq 0x10(%r14), %r14
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
movq %rax, %r15
leaq 0x3de16(%rip), %rsi     # 0x810b2
movl $0x4, %edx
movq %rax, %rdi
callq 0x40b80
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3ffb0
leaq 0x3e315(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x432f6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x3d518(%rip), %rsi     # 0x80815
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b80
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4331c
jmp 0x4331c
movq %rax, %rbx
jmp 0x4333f
jmp 0x43325
jmp 0x43325
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4333f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::insertRange(AddrSpace*, unsigned long, unsigned long)
void RangeList::insertRange(AddrSpace *spc,uintb first,uintb last)

{
  set<Range>::iterator iter1,iter2;

  // we must have iter1.first > first
  iter1 = tree.upper_bound(Range(spc,first,first));

  // Set iter1 to first range with range.last >=first
  // It is either current iter1 or the one before
  if (iter1 != tree.begin()) {
    --iter1;
    if (((*iter1).spc!=spc)||((*iter1).last < first))
      ++iter1;
  }

  // Set iter2 to first range with range.first > last
  iter2 = tree.upper_bound(Range(spc,last,last));
  
  while(iter1!=iter2) {
    if ((*iter1).first < first)
      first = (*iter1).first;
    if ((*iter1).last > last)
      last = (*iter1).last;
    tree.erase(iter1++);
  }
  tree.insert(Range(spc,first,last));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movq 0x10(%rdi), %rbp
leaq 0x8(%rdi), %r12
movq %r12, %r13
testq %rbp, %rbp
je 0x436d0
movq 0x8(%rsp), %rax
movl 0x60(%rax), %eax
movq %rbp, %rcx
movq %r12, %r13
xorl %edx, %edx
cmpq %r15, 0x28(%rcx)
seta %dl
movq 0x20(%rcx), %rsi
xorl %edi, %edi
cmpl 0x60(%rsi), %eax
setl %dil
cmovel %edx, %edi
testb %dil, %dil
cmovneq %rcx, %r13
xorb $0x1, %dil
movzbl %dil, %edx
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x4369e
cmpq 0x18(%r14), %r13
je 0x436fd
movq %r13, %rdi
callq 0x3fe70
movq %rax, %r13
movq 0x8(%rsp), %rax
cmpq %rax, 0x20(%r13)
jne 0x436f2
cmpq %r15, 0x30(%r13)
jae 0x436fd
movq %r13, %rdi
callq 0x40bc0
movq %rax, %r13
testq %rbp, %rbp
je 0x4373c
movq 0x8(%rsp), %rax
movl 0x60(%rax), %eax
xorl %ecx, %ecx
cmpq %rbx, 0x28(%rbp)
seta %cl
movq 0x20(%rbp), %rdx
xorl %esi, %esi
cmpl 0x60(%rdx), %eax
setl %sil
cmovel %ecx, %esi
testb %sil, %sil
cmovneq %rbp, %r12
xorb $0x1, %sil
movzbl %sil, %ecx
movq 0x10(%rbp,%rcx,8), %rbp
testq %rbp, %rbp
jne 0x4370a
cmpq %r12, %r13
je 0x43775
movq 0x28(%r13), %rax
movq 0x30(%r13), %rcx
cmpq %r15, %rax
cmovbq %rax, %r15
cmpq %rbx, %rcx
cmovaq %rcx, %rbx
movq %r13, %rdi
callq 0x40bc0
movq %rax, %rbp
movq %r14, %rdi
movq %r13, %rsi
callq 0x402f0
movq %rbp, %r13
cmpq %r12, %rbp
jne 0x43741
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, 0x10(%rsi)
movq %r14, %rdi
callq 0x41910
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::removeRange(AddrSpace*, unsigned long, unsigned long)
void RangeList::removeRange(AddrSpace *spc,uintb first,uintb last)

{				// remove a range
  set<Range>::iterator iter1,iter2;

  if (tree.empty()) return;	// Nothing to do

  // we must have iter1.first > first
  iter1 = tree.upper_bound(Range(spc,first,first));

  // Set iter1 to first range with range.last >=first
  // It is either current iter1 or the one before
  if (iter1 != tree.begin()) {
    --iter1;
    if (((*iter1).spc!=spc)||((*iter1).last < first))
      ++iter1;
  }

  // Set iter2 to first range with range.first > last
  iter2 = tree.upper_bound(Range(spc,last,last));
  
  while(iter1!=iter2) {
    uintb a,b;

    a = (*iter1).first;
    b = (*iter1).last;
    tree.erase(iter1++);
    if (a <first)
      tree.insert(Range(spc,a,first-1));
    if (b > last)
      tree.insert(Range(spc,last+1,b));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x28(%rdi)
je 0x43940
movq %rcx, %r12
movq 0x10(%rsp), %rax
movq 0x10(%rax), %r15
leaq 0x8(%rax), %rbp
movq %rbp, %r13
testq %r15, %r15
movq 0x18(%rsp), %rbx
je 0x43827
movq 0x8(%rsp), %rax
movl 0x60(%rax), %eax
movq %r15, %rcx
movq %rbp, %r13
xorl %edx, %edx
cmpq %rbx, 0x28(%rcx)
seta %dl
movq 0x20(%rcx), %rsi
xorl %edi, %edi
cmpl 0x60(%rsi), %eax
setl %dil
cmovel %edx, %edi
testb %dil, %dil
cmovneq %rcx, %r13
xorb $0x1, %dil
movzbl %dil, %edx
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x437f5
movq 0x10(%rsp), %rax
cmpq 0x18(%rax), %r13
je 0x43859
movq %r13, %rdi
callq 0x3fe70
movq %rax, %r13
movq 0x8(%rsp), %rax
cmpq %rax, 0x20(%r13)
jne 0x4384e
cmpq %rbx, 0x30(%r13)
jae 0x43859
movq %r13, %rdi
callq 0x40bc0
movq %rax, %r13
testq %r15, %r15
je 0x43898
movq 0x8(%rsp), %rax
movl 0x60(%rax), %eax
xorl %ecx, %ecx
cmpq %r12, 0x28(%r15)
seta %cl
movq 0x20(%r15), %rdx
xorl %esi, %esi
cmpl 0x60(%rdx), %eax
setl %sil
cmovel %ecx, %esi
testb %sil, %sil
cmovneq %r15, %rbp
xorb $0x1, %sil
movzbl %sil, %ecx
movq 0x10(%r15,%rcx,8), %r15
testq %r15, %r15
jne 0x43866
cmpq %rbp, %r13
je 0x43940
movq 0x18(%rsp), %rax
decq %rax
movq %rax, 0x40(%rsp)
leaq 0x1(%r12), %rax
movq %rax, 0x38(%rsp)
movq 0x28(%r13), %r14
movq 0x30(%r13), %rbx
movq %r13, %rdi
callq 0x40bc0
movq %rax, %r15
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x402f0
cmpq 0x18(%rsp), %r14
jae 0x43907
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x41910
cmpq %r12, %rbx
jbe 0x43934
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x41910
movq %r15, %r13
cmpq %rbp, %r15
jne 0x438b8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::merge(RangeList const&)
void RangeList::merge(const RangeList &op2)

{ // Merge -op2- into this rangelist
  set<Range>::const_iterator iter1,iter2;
  iter1 = op2.tree.begin();
  iter2 = op2.tree.end();
  while(iter1 != iter2) {
    const Range &range( *iter1 );
    ++iter1;
    insertRange(range.spc, range.first, range.last);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rsi), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x43992
movq %rdi, %r14
movq %r15, %rdi
callq 0x40bc0
movq %rax, %r12
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq 0x30(%r15), %rcx
movq %r14, %rdi
callq 0x3fd30
movq %r12, %r15
cmpq %rbx, %r12
jne 0x4396b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::getLastSignedRange(AddrSpace*) const
const Range *RangeList::getLastSignedRange(AddrSpace *spaceid) const

{
  uintb midway = spaceid->getHighest() / 2;		// Maximal signed value
  Range range(spaceid,midway,midway);
  set<Range>::const_iterator iter = tree.upper_bound(range);	// First element greater than -range- (should be MOST negative)

  if (iter!=tree.begin()) {
    --iter;
    if ((*iter).getSpace() == spaceid)
      return &(*iter);
  }

  // If there were no "positive" ranges, search for biggest negative range
  range = Range(spaceid,spaceid->getHighest(),spaceid->getHighest());
  iter = tree.upper_bound(range);
  if (iter != tree.begin()) {
    --iter;
    if ((*iter).getSpace() == spaceid)
      return &(*iter);
  }
  return (const Range *)0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x28(%rsi), %r15
movq 0x10(%rdi), %r12
leaq 0x8(%rdi), %r14
movq %r14, %rax
testq %r12, %r12
je 0x43c2a
movq %r15, %rcx
shrq %rcx
movl 0x60(%rbx), %edx
movq %r12, %rsi
movq %r14, %rax
movq 0x20(%rsi), %r8
xorl %r9d, %r9d
cmpq 0x28(%rsi), %rcx
setb %r9b
xorl %r10d, %r10d
cmpl 0x60(%r8), %edx
setl %r10b
cmovel %r9d, %r10d
testb %r10b, %r10b
cmovneq %rsi, %rax
xorb $0x1, %r10b
movzbl %r10b, %r8d
movq 0x10(%rsi,%r8,8), %rsi
testq %rsi, %rsi
jne 0x43bf3
movq 0x18(%rdi), %r13
cmpq %r13, %rax
je 0x43c41
movq %rax, %rdi
callq 0x3fe70
cmpq %rbx, 0x20(%rax)
je 0x43ca1
testq %r12, %r12
je 0x43c7d
movl 0x60(%rbx), %eax
movq 0x20(%r12), %rcx
xorl %edx, %edx
cmpq 0x28(%r12), %r15
setb %dl
xorl %esi, %esi
cmpl 0x60(%rcx), %eax
setl %sil
cmovel %edx, %esi
testb %sil, %sil
cmovneq %r12, %r14
xorb $0x1, %sil
movzbl %sil, %ecx
movq 0x10(%r12,%rcx,8), %r12
testq %r12, %r12
jne 0x43c49
cmpq %r13, %r14
je 0x43c9d
movq %r14, %rdi
callq 0x3fe70
movq %rax, %rcx
leaq 0x20(%rax), %rdx
xorl %eax, %eax
cmpq %rbx, 0x20(%rcx)
cmoveq %rdx, %rax
jmp 0x43ca5
xorl %eax, %eax
jmp 0x43ca5
addq $0x20, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::printBounds(std::ostream&) const
void RangeList::printBounds(ostream &s) const

{
  if (tree.empty())
    s << "all" << endl;
  else {
    set<Range>::const_iterator iter;
    for(iter=tree.begin();iter!=tree.end();++iter) {
      (*iter).printBounds(s);
      s << endl;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x43d18
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x43d12
leaq 0x20(%r15), %rdi
movq %rbx, %rsi
callq 0x41e20
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x40740
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3f0a0
movq %rax, %rdi
callq 0x3ffc0
movq %r15, %rdi
callq 0x40bc0
movq %rax, %r15
cmpq %r14, %rax
jne 0x43ccf
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4199d(%rip), %rsi     # 0x856bc
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x40740
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3f0a0
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3ffc0
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::saveXml(std::ostream&) const
void RangeList::saveXml(ostream &s) const

{
  set<Range>::const_iterator iter;

  s << "<rangelist>\n";
  for(iter=tree.begin();iter!=tree.end();++iter) {
    (*iter).saveXml(s);
  }
  s << "</rangelist>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3b2f4(%rip), %rsi     # 0x7f05e
movl $0xc, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x43da0
leaq 0x20(%r15), %rdi
movq %rbx, %rsi
callq 0x416e0
movq %r15, %rdi
callq 0x40bc0
movq %rax, %r15
cmpq %r14, %rax
jne 0x43d84
leaq 0x3b2c4(%rip), %rsi     # 0x7f06b
movl $0xd, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40b80
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: sign_extend(unsigned long, int, int)
uintb sign_extend(uintb in,int4 sizein,int4 sizeout)

{
  int4 signbit;
  uintb mask;

  signbit = sizein*8 - 1;
  in &= calc_mask(sizein);
  if (sizein >= sizeout) return in;
  if ((in>>signbit) != 0) {
    mask = calc_mask(sizeout);
    uintb tmp = mask << signbit; // Split shift into two pieces
    tmp = (tmp<<1) & mask;	// In case, everything is shifted out
    in |= tmp;
  }
  return in;
}

// Assembly:
movq %rdi, %rax
cmpl $0x8, %esi
movl $0x8, %ecx
cmovll %esi, %ecx
movslq %ecx, %rcx
movq 0x5ed6d(%rip), %rdi     # 0xa2bd0
andq (%rdi,%rcx,8), %rax
cmpl %edx, %esi
jge 0x43e9e
leal -0x1(,%rsi,8), %ecx
movq %rax, %rsi
shrq %cl, %rsi
testq %rsi, %rsi
je 0x43e9e
cmpl $0x8, %edx
movl $0x8, %esi
cmovll %edx, %esi
movslq %esi, %rdx
movq (%rdi,%rdx,8), %rdx
movq %rdx, %rsi
shlq %cl, %rsi
addq %rsi, %rsi
andq %rdx, %rsi
orq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: byte_swap(long&, int)
void byte_swap(intb &val,int4 size)

{
  intb res = 0;
  while(size>0) {
    res <<= 8;
    res |= (val&0xff);
    val >>= 8;
    size -= 1;
  }
  val = res;
}

// Assembly:
testl %esi, %esi
jle 0x43f01
movq (%rdi), %rcx
incl %esi
xorl %eax, %eax
movq %rax, %rdx
shlq $0x8, %rdx
movzbl %cl, %eax
orq %rdx, %rax
sarq $0x8, %rcx
decl %esi
cmpl $0x1, %esi
jg 0x43ee4
movq %rcx, (%rdi)
jmp 0x43f03
xorl %eax, %eax
movq %rax, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: byte_swap(unsigned long, int)
uintb byte_swap(uintb val,int4 size)

{
  uintb res=0;
  while(size>0) {
    res <<= 8;
    res |= (val&0xff);
    val >>= 8;
    size -= 1;
  }
  return res;
}

// Assembly:
testl %esi, %esi
jle 0x43f26
incl %esi
xorl %eax, %eax
shlq $0x8, %rax
movzbl %dil, %ecx
orq %rcx, %rax
shrq $0x8, %rdi
decl %esi
cmpl $0x1, %esi
jg 0x43f0f
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: leastsigbit_set(unsigned long)
int4 leastsigbit_set(uintb val)

{
  if (val==0) return -1;
  int4 res = 0;
  int4 sz = 4*sizeof(uintb);
  uintb mask = ~((uintb)0);
  do {
    mask >>= sz;
    if ((mask&val)==0) {
      res += sz;
      val >>= sz;
    }
    sz >>= 1;
  } while(sz!=0);
  return res;
}

// Assembly:
testq %rdi, %rdi
je 0x43f5b
movq $-0x1, %rsi
movl $0x20, %edx
xorl %eax, %eax
movl %edx, %ecx
shrq %cl, %rsi
movl %edx, %ecx
testq %rdi, %rsi
je 0x43f4a
xorl %ecx, %ecx
shrq %cl, %rdi
addl %ecx, %eax
movl %edx, %ecx
shrl %ecx
cmpl $0x1, %edx
movl %ecx, %edx
ja 0x43f3c
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: mostsigbit_set(unsigned long)
int4 mostsigbit_set(uintb val)

{
  if (val==0) return -1;
  int4 res = 8*sizeof(uintb)-1;
  int4 sz = 4*sizeof(uintb);
  uintb mask = ~((uintb)0);
  do {
    mask <<= sz;
    if ((mask&val)==0) {
      res -= sz;
      val <<= sz;
    }
    sz >>= 1;
  } while(sz != 0);
  return res;
}

// Assembly:
testq %rdi, %rdi
je 0x43f96
movq $-0x1, %rsi
movl $0x20, %edx
movl $0x3f, %eax
movl %edx, %ecx
shlq %cl, %rsi
movl %edx, %ecx
testq %rdi, %rsi
je 0x43f85
xorl %ecx, %ecx
shlq %cl, %rdi
subl %ecx, %eax
movl %edx, %ecx
shrl %ecx
cmpl $0x1, %edx
movl %ecx, %edx
ja 0x43f77
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: count_leading_zeros(unsigned long)
int4 count_leading_zeros(uintb val)

{
  if (val == 0)
    return 8*sizeof(uintb);
  uintb mask = ~((uintb)0);
  int4 maskSize = 4*sizeof(uintb);
  mask &= (mask << maskSize);
  int4 bit = 0;

  do {
    if ((mask & val)==0) {
      bit += maskSize;
      maskSize >>= 1;
      mask |= (mask >> maskSize);
    }
    else {
      maskSize >>= 1;
      mask &= (mask << maskSize);
    }
  } while(maskSize != 0);
  return bit;
}

// Assembly:
testq %rdi, %rdi
je 0x43fd6
xorl %eax, %eax
movl $0x20, %ecx
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
testq %rdi, %rdx
je 0x43fc4
sarl %ecx
movq %rdx, %rsi
shlq %cl, %rsi
andq %rsi, %rdx
jmp 0x43fd1
addl %ecx, %eax
sarl %ecx
movq %rdx, %rsi
shrq %cl, %rsi
orq %rsi, %rdx
testl %ecx, %ecx
jne 0x43fb2
retq
movl $0x40, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: coveringmask(unsigned long)
uintb coveringmask(uintb val)

{
  uintb res = val;
  int4 sz = 1;
  while(sz < 8*sizeof(uintb)) {
    res = res | (res>>sz);
    sz <<= 1;
  }
  return res;
}

// Assembly:
movq %rdi, %rax
movl $0x1, %ecx
movq %rax, %rdx
shrq %cl, %rax
orq %rdx, %rax
leal (%rcx,%rcx), %edx
cmpl $0x20, %ecx
movl %edx, %ecx
jb 0x43fe4
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: bit_transitions(unsigned long, int)
int4 bit_transitions(uintb val,int4 sz)

{
  int4 res = 0;
  int4 last = val & 1;
  int4 cur;
  for(int4 i=1;i<8*sz;++i) {
    val >>= 1;
    cur = val & 1;
    if (cur != last) {
      res += 1;
      last = cur;
    }
    if (val==0) break;
  }
  return res;
}

// Assembly:
testl %esi, %esi
jle 0x44041
shll $0x3, %esi
movl %edi, %edx
andl $0x1, %edx
cmpl $0x3, %esi
movl $0x2, %ecx
cmovgel %esi, %ecx
addl $-0x2, %ecx
xorl %eax, %eax
movl %eax, %esi
movl %edx, %r8d
movq %rdi, %r9
shrq %rdi
movl %edi, %edx
andl $0x1, %edx
xorl %eax, %eax
cmpl %r8d, %edx
setne %al
addl %esi, %eax
subl $0x1, %ecx
setb %sil
cmpq $0x2, %r9
jb 0x44040
testb %sil, %sil
je 0x44014
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: mult64to128(unsigned long*, unsigned long, unsigned long)
void mult64to128(uint8 *res,uint8 x,uint8 y)

{
  uint8 f = x & 0xffffffff;
  uint8 e = x >> 32;
  uint8 d = y & 0xffffffff;
  uint8 c = y >> 32;
  uint8 fd = f * d;
  uint8 fc = f * c;
  uint8 ed = e * d;
  uint8 ec = e * c;
  uint8 tmp = (fd >> 32) + (fc & 0xffffffff) + (ed & 0xffffffff);
  res[1] = (tmp>>32) + (fc>>32) + (ed>>32) + ec;
  res[0] = (tmp<<32) + (fd & 0xffffffff);
}

// Assembly:
movl %esi, %eax
shrq $0x20, %rsi
movl %edx, %ecx
shrq $0x20, %rdx
movq %rcx, %r8
imulq %rax, %r8
imulq %rdx, %rax
imulq %rsi, %rcx
imulq %rsi, %rdx
movl %r8d, %esi
shrq $0x20, %r8
movl %eax, %r9d
addq %r8, %r9
movl %ecx, %r8d
addq %r9, %r8
movq %r8, %r9
shrq $0x20, %r9
shrq $0x20, %rax
addq %rdx, %rax
shrq $0x20, %rcx
addq %rax, %rcx
addq %r9, %rcx
movq %rcx, 0x8(%rdi)
shlq $0x20, %r8
orq %r8, %rsi
movq %rsi, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::extractExponentCode(unsigned long) const
int4 FloatFormat::extractExponentCode(uintb x) const

{
  x >>= exp_pos;
  uintb mask = 1;
  mask = (mask<<exp_size) - 1;
  return (int4)(x & mask);
}

// Assembly:
movb 0x10(%rdi), %cl
movb 0x14(%rdi), %dl
shrq %cl, %rsi
movq $-0x1, %rax
movl %edx, %ecx
shlq %cl, %rax
notl %eax
andl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::setFractionalCode(unsigned long, unsigned long) const
uintb FloatFormat::setFractionalCode(uintb x,uintb code) const

{
  // Align with bottom of word, also drops bits of precision
  // we don't have room for
  code >>= 8*sizeof(uintb) - frac_size;
  code <<= frac_pos;		// Move bits into position;
  x |= code;
  return x;
}

// Assembly:
movq %rdx, %rax
xorl %ecx, %ecx
subb 0xc(%rdi), %cl
shrq %cl, %rax
movb 0x8(%rdi), %cl
shlq %cl, %rax
orq %rsi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::getInfinityEncoding(bool) const
uintb FloatFormat::getInfinityEncoding(bool sgn) const

{
  uintb res = 0;
  // Use IEEE 754 standard for infinity encoding
  res = setFractionalCode(res,0);
  res = setExponentCode(res,(uintb)maxexponent);
  return setSign(res,sgn);
}

// Assembly:
movslq 0x1c(%rdi), %rdx
movb 0x10(%rdi), %cl
shlq %cl, %rdx
movb 0x4(%rdi), %cl
movl $0x1, %edi
shlq %cl, %rdi
xorl %eax, %eax
testl %esi, %esi
cmovneq %rdi, %rax
orq %rdx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::getNaNEncoding(bool) const
uintb FloatFormat::getNaNEncoding(bool sgn) const

{
  uintb res = 0;
  // Use IEEE 754 standard for NaN encoding
  uintb mask = 1;
  mask <<= 8*sizeof(uintb)-1;	// Create "quiet" NaN
  res = setFractionalCode(res,mask);
  res = setExponentCode(res,(uintb)maxexponent);
  return setSign(res,sgn);
}

// Assembly:
movb 0xc(%rdi), %al
xorl %ecx, %ecx
subb %al, %cl
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movb 0x8(%rdi), %cl
shlq %cl, %rdx
movb 0x4(%rdi), %al
movslq 0x1c(%rdi), %r8
movb 0x10(%rdi), %cl
shlq %cl, %r8
movl $0x1, %edi
movl %eax, %ecx
shlq %cl, %rdi
xorl %eax, %eax
testl %esi, %esi
cmovneq %rdi, %rax
orq %r8, %rax
orq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::getHostFloat(unsigned long, FloatFormat::floatclass*) const
double FloatFormat::getHostFloat(uintb encoding,floatclass *type) const

{
  bool sgn = extractSign(encoding);
  uintb frac = extractFractionalCode(encoding);
  int4 exp = extractExponentCode(encoding);
  bool normal = true;

  if (exp == 0) {
    if ( frac == 0 ) {		// Floating point zero
      *type = zero;
      // FIXME:  add on sign-bit  for +0 or -0 allowed by standard
      return sgn ? -0.0 : +0.0;
    }
    *type = denormalized;
    // Number is denormalized
    normal = false;
  }
  else if (exp == maxexponent) {
    if ( frac == 0 ) {		// Floating point infinity
      *type = infinity;
      // FIXME: add on sign-bit for +inf or -inf allowed by standard
      return sgn ? -INFINITY : +INFINITY;
    }
    *type = nan;
    // encoding is "Not a Number" NaN
    return sgn ? -NAN : +NAN; // Sign is usually ignored
  }
  else
    *type = normalized;

  // Get "true" exponent and fractional
  exp -= bias;
  if (normal && jbitimplied) {
    frac >>= 1;			// Make room for 1 jbit
    uintb highbit = 1;
    highbit <<= 8*sizeof(uintb)-1;
    frac |= highbit;		// Stick bit in at top
  }
  return createFloat(sgn,frac,exp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rax
movb 0x4(%rdi), %cl
movb 0x8(%rdi), %sil
movl $0x1, %r14d
shlq %cl, %r14
movq %rbx, %r8
movl %esi, %ecx
shrq %cl, %r8
movb 0xc(%rdi), %sil
xorl %ecx, %ecx
subb %sil, %cl
shlq %cl, %r8
movb 0x10(%rdi), %cl
movq %rbx, %rdi
shrq %cl, %rdi
movb 0x14(%rax), %cl
movq $-0x1, %rsi
shlq %cl, %rsi
xorl %ecx, %ecx
notl %esi
andl %esi, %edi
je 0x44925
cmpl %edi, 0x1c(%rax)
jne 0x4492f
xorl %eax, %eax
testq %r8, %r8
je 0x44980
testq %rbx, %r14
sete %al
movl $0x3, (%rdx)
leaq 0x3a7dd(%rip), %rcx     # 0x7f100
jmp 0x44993
movl $0x4, %ecx
testq %r8, %r8
je 0x44967
movl %ecx, (%rdx)
movl 0x18(%rax), %ecx
testl %edi, %edi
je 0x44946
cmpb $0x1, 0x20(%rax)
jne 0x44946
shrq %r8
btsq $0x3f, %r8
shrq %r8
cvtsi2sd %r8, %xmm0
subl %ecx, %edi
addl $-0x3e, %edi
callq 0x416d0
testq %rbx, %r14
je 0x44998
xorpd 0x3a77b(%rip), %xmm0    # 0x7f0e0
jmp 0x44998
movl $0x2, (%rdx)
xorpd %xmm0, %xmm0
testq %rbx, %r14
je 0x44998
movsd 0x3a7aa(%rip), %xmm0    # 0x7f128
jmp 0x44998
testq %rbx, %r14
sete %al
movl $0x1, (%rdx)
leaq 0x3a77d(%rip), %rcx     # 0x7f110
movsd (%rcx,%rax,8), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::getEncoding(double) const
uintb FloatFormat::getEncoding(double host) const

{
  floatclass type;
  bool sgn;
  uintb signif;
  int4 exp;

  type = extractExpSig(host,&sgn,&signif,&exp);
  if (type == zero)
    return getZeroEncoding(sgn);
  else if (type == infinity)
    return getInfinityEncoding(sgn);
  else if (type == nan)
    return getNaNEncoding(sgn);

  // convert exponent and fractional to their encodings
  exp += bias;
  if (exp < 0)			// Exponent is too small to represent
    return getZeroEncoding(sgn);
  if (exp > maxexponent)	// Exponent is too big to represent
    return getInfinityEncoding(sgn);
  if (jbitimplied && (exp !=0))
    signif <<= 1;		// Cut off top bit (which should be 1)

  uintb res = 0;
  res = setFractionalCode(res,signif);
  res = setExponentCode(res,(uintb)exp);
  return setSign(res,sgn);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x3(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x41680
movl %eax, %eax
leaq 0x3a773(%rip), %rcx     # 0x7f138
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x4(%rsp), %edx
addl 0x18(%rbx), %edx
movl %edx, 0x4(%rsp)
js 0x44a0a
movslq 0x1c(%rbx), %rsi
cmpl %esi, %edx
jle 0x44a8d
movb 0x4(%rbx), %al
movb 0x10(%rbx), %cl
shlq %cl, %rsi
movl $0x1, %edx
movl %eax, %ecx
shlq %cl, %rdx
xorl %eax, %eax
cmpb $0x0, 0x3(%rsp)
cmovneq %rdx, %rax
jmp 0x44ad4
movb 0x4(%rbx), %cl
movl $0x1, %edx
shlq %cl, %rdx
xorl %eax, %eax
cmpb $0x0, 0x3(%rsp)
cmovneq %rdx, %rax
jmp 0x44ad7
movslq 0x1c(%rbx), %rdx
movb 0x4(%rbx), %al
movb 0x10(%rbx), %cl
shlq %cl, %rdx
movl $0x1, %esi
movl %eax, %ecx
shlq %cl, %rsi
xorl %eax, %eax
cmpb $0x0, 0x3(%rsp)
cmovneq %rsi, %rax
jmp 0x44a88
movb 0xc(%rbx), %al
xorl %ecx, %ecx
subb %al, %cl
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movb 0x8(%rbx), %cl
shlq %cl, %rdx
movb 0x4(%rbx), %al
movslq 0x1c(%rbx), %rsi
movb 0x10(%rbx), %cl
shlq %cl, %rsi
movl $0x1, %edi
movl %eax, %ecx
shlq %cl, %rdi
xorl %eax, %eax
cmpb $0x0, 0x3(%rsp)
cmovneq %rdi, %rax
orq %rsi, %rax
orq %rdx, %rax
jmp 0x44ad7
testl %edx, %edx
je 0x44a9c
cmpb $0x0, 0x20(%rbx)
je 0x44a9c
shlq 0x8(%rsp)
movq 0x8(%rsp), %rsi
movb 0xc(%rbx), %al
xorl %ecx, %ecx
subb %al, %cl
shrq %cl, %rsi
movb 0x8(%rbx), %cl
shlq %cl, %rsi
movb 0x4(%rbx), %al
movl %edx, %edx
movb 0x10(%rbx), %cl
shlq %cl, %rdx
movl $0x1, %edi
movl %eax, %ecx
shlq %cl, %rdi
xorl %eax, %eax
cmpb $0x0, 0x3(%rsp)
cmovneq %rdi, %rax
orq %rdx, %rax
orq %rsi, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::opEqual(unsigned long, unsigned long) const
uintb FloatFormat::opEqual(uintb a,uintb b) const

{
  floatclass type;
  double val1 = getHostFloat(a,&type);
  double val2 = getHostFloat(b,&type);
  uintb res = (val1 == val2) ? 1 : 0;
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rdx
callq 0x40a40
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x40a40
cmpeqsd (%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::opLess(unsigned long, unsigned long) const
uintb FloatFormat::opLess(uintb a,uintb b) const

{
  floatclass type;
  double val1 = getHostFloat(a,&type);
  double val2 = getHostFloat(b,&type);
  uintb res = (val1 < val2) ? 1 : 0;
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rdx
callq 0x40a40
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x40a40
xorl %eax, %eax
ucomisd (%rsp), %xmm0
seta %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::opInt2Float(unsigned long, int) const
uintb FloatFormat::opInt2Float(uintb a,int4 sizein) const

{
  intb ival = (intb)a;
  sign_extend(ival,8*sizein-1);
  double val = (double) ival;	// Convert integer to float
  return getEncoding(val);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
leal -0x1(,%rdx,8), %esi
movq %r14, %rdi
callq 0x40540
cvtsi2sdq (%r14), %xmm0
movq %rbx, %rdi
callq 0x3f980
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::opTrunc(unsigned long, int) const
uintb FloatFormat::opTrunc(uintb a,int4 sizeout) const

{
  floatclass type;
  double val = getHostFloat(a,&type);
  intb ival = (intb) val;	// Convert to integer
  uintb res = (uintb) ival;	// Convert to unsigned
  res &= calc_mask(sizeout);	// Truncate to proper size
  return res;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
leaq 0xc(%rsp), %rdx
callq 0x40a40
cvttsd2si %xmm0, %rax
cmpl $0x8, %ebx
movl $0x8, %ecx
cmovll %ebx, %ecx
movslq %ecx, %rcx
movq 0x5dcaf(%rip), %rdx     # 0xa2bd0
andq (%rdx,%rcx,8), %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextBitRange::ContextBitRange(int, int)
ContextBitRange::ContextBitRange(int4 sbit,int4 ebit)

{
  word = sbit/(8*sizeof(uintm));
  startbit = sbit - word*8*sizeof(uintm);
  endbit = ebit - word*8*sizeof(uintm);
  shift = 8*sizeof(uintm)-endbit-1;
  mask = (~((uintm)0))>>(startbit+shift);
}

// Assembly:
movl %esi, %eax
sarl $0x5, %eax
movl %eax, (%rdi)
movl %esi, %eax
andl $0x1f, %eax
movl %eax, 0x4(%rdi)
andl $-0x20, %esi
subl %esi, %edx
movl %edx, 0x8(%rdi)
movl $0x1f, %ecx
subl %edx, %ecx
movl %ecx, 0xc(%rdi)
addl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shrl %cl, %eax
movl %eax, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: TrackedContext::saveXml(std::ostream&) const
void TrackedContext::saveXml(ostream &s) const

{
  s << "<set";
  loc.space->saveXmlAttributes(s,loc.offset,loc.size);
  a_v_u(s,"val",val);
  s << "/>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x39765(%rip), %rsi     # 0x7f1ef
movl $0x4, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movl 0x10(%r14), %ecx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x40(%rax)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x396f4(%rip), %rsi     # 0x7f1b0
leaq 0x396f0(%rip), %rdx     # 0x7f1b3
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movq 0x18(%r14), %r14
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
movq %rax, %r15
leaq 0x3b5b0(%rip), %rsi     # 0x810b2
movl $0x4, %edx
movq %rax, %rdi
callq 0x40b80
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3ffb0
leaq 0x3baaf(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x45b5c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x3acb2(%rip), %rsi     # 0x80815
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b80
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x45b96
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: TrackedContext::restoreXml(Element const*, AddrSpaceManager const*)
void TrackedContext::restoreXml(const Element *el,const AddrSpaceManager *manage)

{
  int4 size;
  Address addr = Address::restoreXml(el,manage,size);
  
  istringstream s(el->getAttributeValue("val"));
  s.unsetf(ios::dec | ios::hex | ios::oct);
  s >> val;

  loc.space = addr.getSpace();
  loc.offset = addr.getOffset();
  loc.size = size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rcx
callq 0x40900
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x395e1(%rip), %rsi     # 0x7f1b0
leaq 0x395dd(%rip), %rdx     # 0x7f1b3
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x40f70
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c80
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x45c16
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x40(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x58(%rsp,%rax)
leaq 0x18(%rbx), %rsi
callq 0x3fc90
movq 0x30(%rsp), %rax
movq %rax, (%rbx)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rbx)
movq 0x5d0c1(%rip), %rsi     # 0xa2d10
leaq 0x40(%rsp), %rdi
callq 0x41440
leaq 0xb8(%rsp), %rdi
callq 0x3f730
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x5d093(%rip), %rsi     # 0xa2d10
leaq 0x40(%rsp), %rdi
callq 0x41440
leaq 0xb8(%rsp), %rdi
callq 0x3f730
jmp 0x45cb5
movq %rax, %rbx
jmp 0x45cb5
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x45cb5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextDatabase::restoreTracked(Element const*, AddrSpaceManager const*, std::vector<TrackedContext, std::allocator<TrackedContext>>&)
void ContextDatabase::restoreTracked(const Element *el,const AddrSpaceManager *manage,
				     TrackedSet &vec)

{
  vec.clear();			// Clear out any old stuff
  const List &list(el->getChildren());
  List::const_iterator iter = list.begin();

  while(iter != list.end()) {
    const Element *subel = *iter;
    vec.push_back(TrackedContext());
    vec.back().restoreXml(subel,manage);
    ++iter;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x45da0
movq %rax, 0x8(%rbx)
movq 0x78(%r15), %rbp
cmpq 0x80(%r15), %rbp
je 0x45e06
xorps %xmm0, %xmm0
movq %rsp, %r12
movq (%rbp), %r13
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x45dd8
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x8(%rbx)
jmp 0x45de3
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3fa10
movq 0x8(%rbx), %rdi
addq $-0x20, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x3f870
addq $0x8, %rbp
cmpq 0x80(%r15), %rbp
xorps %xmm0, %xmm0
jne 0x45db3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextDatabase::setVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Address const&, unsigned int)
void ContextDatabase::setVariable(const string &nm,const Address &addr,
			       uintm value)
{
  const ContextBitRange &bitrange( getVariable(nm) );
  int4 num = bitrange.getWord();
  uintm mask = bitrange.getMask()<<bitrange.getShift();

  vector<uintm *> contvec;
  getRegionToChangePoint(contvec,addr,num,mask);
  for(uint4 i=0;i<contvec.size();++i)
    bitrange.setValue(contvec[i],value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rdi, %r12
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movl (%rax), %eax
movl 0x10(%r14), %r8d
movb 0xc(%r14), %cl
shll %cl, %r8d
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq (%r12), %r9
movq %r12, %rdi
movq %r15, %rdx
movl %eax, %ecx
callq *0x18(%r9)
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x45f14
sarq $0x3, %rax
xorl %edx, %edx
movq (%rdi,%rdx,8), %rsi
movslq (%r14), %r8
movl 0x10(%r14), %r9d
movb 0xc(%r14), %cl
movl %r9d, %r10d
shll %cl, %r10d
notl %r10d
andl (%rsi,%r8,4), %r10d
andl %ebx, %r9d
shll %cl, %r9d
orl %r10d, %r9d
movl %r9d, (%rsi,%r8,4)
incq %rdx
movl %edx, %ecx
cmpq %rcx, %rax
ja 0x45ee1
testq %rdi, %rdi
je 0x45f26
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x45f4b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextDatabase::setContextChangePoint(Address const&, int, unsigned int, unsigned int)
void ContextDatabase::setContextChangePoint(const Address &addr,int4 num,uintm mask,uintm value)

{
  vector<uintm *> contvec;
  getRegionToChangePoint(contvec,addr,num,mask);
  for(uint4 i=0;i<contvec.size();++i) {
    uintm *newcontext = contvec[i];
    uintm val = newcontext[ num ];
    val &= ~mask;			// Clear range to zero
    val |= value;
    newcontext[ num ] = val;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rdx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq (%rdi), %rax
movl %r14d, %ecx
movl %ebp, %r8d
callq *0x18(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x45fef
sarq $0x3, %rax
movslq %r14d, %rcx
notl %ebp
xorl %edx, %edx
movq (%rdi,%rdx,8), %rsi
movl (%rsi,%rcx,4), %r8d
andl %ebp, %r8d
orl %ebx, %r8d
movl %r8d, (%rsi,%rcx,4)
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0x45fd3
testq %rdi, %rdi
je 0x46001
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x46023
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextDatabase::setContextRegion(Address const&, Address const&, int, unsigned int, unsigned int)
void ContextDatabase::setContextRegion(const Address &addr1,const Address &addr2,
				       int4 num,uintm mask,uintm value)
{
  vector<uintm *> vec;
  getRegionForSet(vec,addr1,addr2,num,mask);
  for(uint4 i=0;i<vec.size();++i)
    vec[i][num] = (vec[i][num] & ~mask) | value;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %rcx
movq %rsi, %rdx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq (%rdi), %rax
movl %r14d, %r8d
movl %ebp, %r9d
callq *0x10(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x46095
sarq $0x3, %rax
movslq %r14d, %rcx
notl %ebp
xorl %edx, %edx
movq (%rdi,%rdx,8), %rsi
movl (%rsi,%rcx,4), %r8d
andl %ebp, %r8d
orl %ebx, %r8d
movl %r8d, (%rsi,%rcx,4)
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0x46079
testq %rdi, %rdi
je 0x460a7
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x460c9
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop