LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
callq 0xdd9c0
shrq %rax
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x50(%rsp), %rdi
callq 0xdac60
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xd55d0
movq 0x10(%rsp), %rdi
movq %rax, 0x48(%rsp)
callq 0xdc5d0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xcf5f0
testb $0x1, %al
jne 0xe50ce
jmp 0xe510a
leaq 0x48(%rsp), %rdi
callq 0xe2ec0
leaq 0x48(%rsp), %rdi
callq 0xd1290
movq %rax, %rdi
callq 0xe23a0
cmpq 0x70(%rsp), %rax
jne 0xe5108
leaq 0x48(%rsp), %rdi
callq 0xd1290
movq %rax, 0x80(%rsp)
jmp 0xe51e7
jmp 0xe510a
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
callq 0xdd9c0
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
callq 0xdd9c0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x28(%rsp), %rdi
callq 0xdac60
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x50(%rsp), %rsi
callq 0xd55d0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
callq 0xdc5d0
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xcf5f0
testb $0x1, %al
jne 0xe51a2
jmp 0xe51db
leaq 0x48(%rsp), %rdi
callq 0xe2ec0
leaq 0x48(%rsp), %rdi
callq 0xd1290
movq %rax, %rdi
callq 0xe23a0
cmpq 0x70(%rsp), %rax
jne 0xe51d9
leaq 0x48(%rsp), %rdi
callq 0xd1290
movq %rax, 0x80(%rsp)
jmp 0xe51e7
jmp 0xe51db
movq $0x0, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe25e0
testb $0x1, %al
jne 0xe5223
jmp 0xe5245
movq 0x28(%rsp), %rdi
leaq 0xa869d(%rip), %rsi     # 0x18d8cc
callq 0xd8300
movq %rax, %rdi
movq 0xe2882(%rip), %rsi     # 0x1c7ac0
callq 0xd8a20
jmp 0xe52c2
leaq 0x20(%rsp), %rdi
callq 0xd3ea0
movq 0x8(%rsp), %rdi
callq 0xdc5d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
callq 0xdf030
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xcf5f0
testb $0x1, %al
jne 0xe528c
jmp 0xe52c0
leaq 0x20(%rsp), %rdi
callq 0xd1290
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0xe0670
movq 0x28(%rsp), %rdi
movq 0xe2811(%rip), %rsi     # 0x1c7ac0
callq 0xd8a20
leaq 0x20(%rsp), %rdi
callq 0xdca10
jmp 0xe5268
jmp 0xe52c2
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd3ea0
movq 0x28(%rsp), %rdi
leaq 0xa1d60(%rip), %rsi     # 0x18705e
callq 0xd8300
movq 0x8(%rsp), %rdi
callq 0xdc5d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
callq 0xdf030
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xcf5f0
testb $0x1, %al
jne 0xe5340
jmp 0xe5363
leaq 0x20(%rsp), %rdi
callq 0xd1290
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0xddee0
leaq 0x20(%rsp), %rdi
callq 0xdca10
jmp 0xe531c
movq 0x28(%rsp), %rdi
leaq 0xa1cfc(%rip), %rsi     # 0x18706b
callq 0xd8300
addq $0x38, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::restoreXml(Element const*, AddrSpaceManager const*)
void RangeList::restoreXml(const Element *el,const AddrSpaceManager *manage)

{
  const List &list(el->getChildren());
  List::const_iterator iter;

  for(iter=list.begin();iter!=list.end();++iter) {
    const Element *subel = *iter;
    Range range;
    range.restoreXml(subel,manage);
    tree.insert(range);
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
callq 0xde930
movq %rax, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd03e0
movq 0x58(%rsp), %rdi
callq 0xd4960
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0xd7a70
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd72b0
testb $0x1, %al
jne 0xe53f3
jmp 0xe5447
leaq 0x50(%rsp), %rdi
callq 0xddc90
movq (%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd90b0
movq 0x38(%rsp), %rsi
movq 0x60(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0xe1ba0
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xdd8b0
movq %rax, 0x10(%rsp)
movb %dl, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd0700
jmp 0xe53cf
addq $0x78, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/address.cc
// Function: signbit_negative(unsigned long, int)
bool signbit_negative(uintb val,int4 size)

{				// Return true if signbit is set (negative)
  uintb mask = 0x80;
  mask <<= 8*(size-1);
  return ((val&mask) != 0);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq $0x80, -0x18(%rsp)
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
shll $0x3, %ecx
movq -0x18(%rsp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
andq -0x18(%rsp), %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl 0x24(%rsp), %eax
shll $0x3, %eax
subl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x24(%rsp), %edi
callq 0xcfa60
andq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jl 0xe5518
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xe5574
movq 0x28(%rsp), %rax
movl 0x1c(%rsp), %ecx
shrq %cl, %rax
cmpq $0x0, %rax
je 0xe556a
movl 0x20(%rsp), %edi
callq 0xcfa60
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
shlq %cl, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shlq %rax
andq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
orq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/address.cc
// Function: sign_extend(long&, int)
void sign_extend(intb &val,int4 bit)

{
  intb mask = 0;
  mask = (~mask)<<bit;
  if (((val>>bit)&1)!=0)
    val |= mask;
  else
    val &= (~mask);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
xorq $-0x1, %rax
movl -0xc(%rsp), %ecx
shlq %cl, %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl -0xc(%rsp), %ecx
sarq %cl, %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xe55d2
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0xe55e6
movq -0x18(%rsp), %rcx
xorq $-0x1, %rcx
movq -0x8(%rsp), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/address.cc
// Function: zero_extend(long&, int)
void zero_extend(intb &val,int4 bit)

{
  intb mask = 0;
  mask = (~mask)<<bit;
  mask <<= 1;
  val &= (~mask);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
xorq $-0x1, %rax
movl -0xc(%rsp), %ecx
shlq %cl, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
shlq %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rcx
xorq $-0x1, %rcx
movq -0x8(%rsp), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq $0x0, -0x18(%rsp)
cmpl $0x0, -0xc(%rsp)
jle 0xe569b
movq -0x18(%rsp), %rax
shlq $0x8, %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
andq $0xff, %rax
orq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
sarq $0x8, %rcx
movq %rcx, (%rax)
movl -0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xe5652
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq $0x0, -0x18(%rsp)
cmpl $0x0, -0xc(%rsp)
jle 0xe5707
movq -0x18(%rsp), %rax
shlq $0x8, %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
andq $0xff, %rax
orq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x8(%rsp)
movl -0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xe56c2
movq -0x18(%rsp), %rax
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xe5727
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0xe579b
movl $0x0, -0x14(%rsp)
movl $0x20, -0x18(%rsp)
movq $-0x1, -0x20(%rsp)
movl -0x18(%rsp), %ecx
movq -0x20(%rsp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
andq -0x10(%rsp), %rax
cmpq $0x0, %rax
jne 0xe5782
movl -0x18(%rsp), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0x18(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x10(%rsp)
movl -0x18(%rsp), %eax
sarl %eax
movl %eax, -0x18(%rsp)
cmpl $0x0, -0x18(%rsp)
jne 0xe5740
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: 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:
movq %rdi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xe57b7
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0xe582d
movl $0x3f, -0x14(%rsp)
movl $0x20, -0x18(%rsp)
movq $-0x1, -0x20(%rsp)
movl -0x18(%rsp), %ecx
movq -0x20(%rsp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
andq -0x10(%rsp), %rax
cmpq $0x0, %rax
jne 0xe5814
movl -0x18(%rsp), %ecx
movl -0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rsp)
movl -0x18(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x10(%rsp)
movl -0x18(%rsp), %eax
sarl %eax
movl %eax, -0x18(%rsp)
cmpl $0x0, -0x18(%rsp)
jne 0xe57d0
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xe585a
movl $0x40, -0x4(%rsp)
jmp 0xe58f8
movq $-0x1, -0x18(%rsp)
movl $0x20, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movl -0x1c(%rsp), %ecx
shlq %cl, %rax
andq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x20(%rsp)
movq -0x18(%rsp), %rax
andq -0x10(%rsp), %rax
cmpq $0x0, %rax
jne 0xe58c7
movl -0x1c(%rsp), %eax
addl -0x20(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %eax
sarl %eax
movl %eax, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movl -0x1c(%rsp), %ecx
shrq %cl, %rax
orq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0xe58e7
movl -0x1c(%rsp), %eax
sarl %eax
movl %eax, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movl -0x1c(%rsp), %ecx
shlq %cl, %rax
andq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0xe58e9
cmpl $0x0, -0x1c(%rsp)
jne 0xe5889
movl -0x20(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: 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, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movl $0x1, -0x14(%rsp)
movslq -0x14(%rsp), %rax
cmpq $0x40, %rax
jae 0xe594a
movq -0x10(%rsp), %rax
movq -0x10(%rsp), %rdx
movl -0x14(%rsp), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rsp)
movl -0x14(%rsp), %eax
shll %eax
movl %eax, -0x14(%rsp)
jmp 0xe5917
movq -0x10(%rsp), %rax
retq
// File: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
andq $0x1, %rax
movl %eax, -0x14(%rsp)
movl $0x1, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movl -0xc(%rsp), %ecx
shll $0x3, %ecx
cmpl %ecx, %eax
jge 0xe59d5
movq -0x8(%rsp), %rax
shrq %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
andq $0x1, %rax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
je 0xe59bc
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
movl -0x18(%rsp), %eax
movl %eax, -0x14(%rsp)
cmpq $0x0, -0x8(%rsp)
jne 0xe59c6
jmp 0xe59d5
jmp 0xe59c8
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xe5976
movl -0x10(%rsp), %eax
retq
nopw (%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
shrq $0x20, %rax
movq %rax, -0x28(%rsp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
shrq $0x20, %rax
movq %rax, -0x38(%rsp)
movq -0x20(%rsp), %rax
imulq -0x30(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x20(%rsp), %rax
imulq -0x38(%rsp), %rax
movq %rax, -0x48(%rsp)
movq -0x28(%rsp), %rax
imulq -0x30(%rsp), %rax
movq %rax, -0x50(%rsp)
movq -0x28(%rsp), %rax
imulq -0x38(%rsp), %rax
movq %rax, -0x58(%rsp)
movq -0x40(%rsp), %rax
shrq $0x20, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq -0x48(%rsp), %rcx
addq %rcx, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq -0x50(%rsp), %rcx
addq %rcx, %rax
movq %rax, -0x60(%rsp)
movq -0x60(%rsp), %rcx
shrq $0x20, %rcx
movq -0x48(%rsp), %rax
shrq $0x20, %rax
addq %rax, %rcx
movq -0x50(%rsp), %rax
shrq $0x20, %rax
addq %rax, %rcx
addq -0x58(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x60(%rsp), %rcx
shlq $0x20, %rcx
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x40(%rsp), %rax
addq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/address.cc
// Function: unsignedSubtract128(unsigned long*, unsigned long*)
void unsignedSubtract128(uint8 *a,uint8 *b)

{
  bool borrow = (a[0] < b[0]);
  a[0] -= b[0];
  a[1] -= b[1];
  if (borrow)
    a[1] -= 1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
cmpq (%rcx), %rax
setb %al
andb $0x1, %al
movb %al, -0x11(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rdx
movq -0x8(%rsp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
testb $0x1, -0x11(%rsp)
je 0xe5b6a
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x8(%rax)
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/address.cc
// Function: unsignedCompare128(unsigned long*, unsigned long*)
int4 unsignedCompare128(uint8 *a,uint8 *b)

{
  if (a[1] != b[1])
    return (a[1] < b[1]) ? -1 : 1;
  if (a[0] != b[0])
    return (a[0] < b[0]) ? -1 : 1;
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
je 0xe5bb6
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, -0x4(%rsp)
jmp 0xe5bf6
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
je 0xe5bee
movq -0x10(%rsp), %rax
movq (%rax), %rdx
movq -0x18(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, -0x4(%rsp)
jmp 0xe5bf6
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/include/address.hh
// Function: Address::printRaw(std::ostream&) const
inline void Address::printRaw(ostream &s) const {
  if (base == (AddrSpace *)0) {
    s << "invalid_addr";
    return;
  }
  base->printRaw(s,offset);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rax)
jne 0xe5f10
movq 0x8(%rsp), %rdi
leaq 0xa1170(%rip), %rsi     # 0x187079
callq 0xd8300
jmp 0xe5f26
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movq 0x8(%rax), %rdx
movq (%rdi), %rax
callq *0x50(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/include/space.hh
// Function: AddrSpace::wrapOffset(unsigned long) const
inline uintb AddrSpace::wrapOffset(uintb off) const {
  if (off <= highest)		// Comparison is unsigned
    return off;
  intb mod = (intb)(highest+1);
  intb res = (intb)off % mod;	// remainder is signed
  if (res<0)			// Remainder may be negative
    res += mod;			// Adding mod guarantees res is in (0,mod)
  return (uintb)res;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x30(%rsp)
movq -0x18(%rsp), %rax
cmpq 0x28(%rcx), %rax
ja 0xe622b
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xe626f
movq -0x30(%rsp), %rax
movq 0x28(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
cqto
idivq -0x20(%rsp)
movq %rdx, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
jge 0xe6265
movq -0x20(%rsp), %rax
addq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::FloatFormat(int)
FloatFormat::FloatFormat(int4 sz)

{
  size = sz;

  if (size == 4) {
    signbit_pos = 31;
    exp_pos = 23;
    exp_size = 8;
    frac_pos = 0;
    frac_size = 23;
    bias = 127;
    jbitimplied = true;
  }
  else if (size == 8) {
    signbit_pos = 63;
    exp_pos = 52;
    exp_size = 11;
    frac_pos = 0;
    frac_size = 52;
    bias = 1023;
    jbitimplied = true;
  }
  maxexponent = (1<<exp_size)-1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0xc(%rsp), %ecx
movl %ecx, (%rax)
cmpl $0x4, (%rax)
jne 0xe8293
movq -0x18(%rsp), %rax
movl $0x1f, 0x4(%rax)
movl $0x17, 0x10(%rax)
movl $0x8, 0x14(%rax)
movl $0x0, 0x8(%rax)
movl $0x17, 0xc(%rax)
movl $0x7f, 0x18(%rax)
movb $0x1, 0x20(%rax)
jmp 0xe82d2
movq -0x18(%rsp), %rax
cmpl $0x8, (%rax)
jne 0xe82d0
movq -0x18(%rsp), %rax
movl $0x3f, 0x4(%rax)
movl $0x34, 0x10(%rax)
movl $0xb, 0x14(%rax)
movl $0x0, 0x8(%rax)
movl $0x34, 0xc(%rax)
movl $0x3ff, 0x18(%rax)      # imm = 0x3FF
movb $0x1, 0x20(%rax)
jmp 0xe82d2
movq -0x18(%rsp), %rax
movl 0x14(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
movl %ecx, 0x1c(%rax)
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::createFloat(bool, unsigned long, int)
double FloatFormat::createFloat(bool sign,uintb signif,int4 exp)

{
  signif >>= 1;		      // Throw away 1 bit of precision we will
				// lose anyway, to make sure highbit is 0
  int4 precis = 8*sizeof(uintb) - 1;   // fullword - 1 we threw away
  double res = (double)signif;
  int4 expchange = exp - precis + 1; // change in exponent is precis
				// -1 integer bit
  res = ldexp(res,expchange);
  if (sign)
    res = res * -1.0;
  return res;
}

// Assembly:
subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
shrq %rax
movq %rax, 0x18(%rsp)
movl $0x3f, 0x10(%rsp)
movaps 0x9ee0e(%rip), %xmm1    # 0x187130
movq 0x18(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x9ee0c(%rip), %xmm1    # 0x187140
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x14(%rsp), %eax
subl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
movl 0x4(%rsp), %edi
callq 0xdddf0
movsd %xmm0, 0x8(%rsp)
testb $0x1, 0x27(%rsp)
je 0xe8388
movsd 0x9ede4(%rip), %xmm0    # 0x187160
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::extractExpSig(double, bool*, unsigned long*, int*)
FloatFormat::floatclass FloatFormat::extractExpSig(double x,bool *sgn,uintb *signif,int4 *exp)

{
  int4 e;

  *sgn = (signbit(x) != 0);
  if (x == 0.0) return zero;
  if (isinf(x)!=0) return infinity;
  if (isnan(x)!=0) return nan;
  if (*sgn)
    x = -x;
  double norm = frexp(x,&e);  // norm is between 1/2 and 1
  norm = ldexp(norm,8*sizeof(uintb)-1); // norm between 2^62 and 2^63
					   
  *signif = (uintb)norm;    // Convert to normalized integer
  *signif <<= 1;

  e -= 1;    // Consider normalization between 1 and 2  
  *exp = e;
  return normalized;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0xdb570
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %cl
movq 0x20(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movsd 0x28(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe83f7
jp 0xe83f7
movl $0x2, 0x34(%rsp)
jmp 0xe84f0
movsd 0x28(%rsp), %xmm0
callq 0xd0d40
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xe8419
movl $0x1, 0x34(%rsp)
jmp 0xe84f0
movsd 0x28(%rsp), %xmm0
callq 0xce760
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xe843b
movl $0x3, 0x34(%rsp)
jmp 0xe84f0
movq 0x20(%rsp), %rax
testb $0x1, (%rax)
je 0xe8468
movsd 0x28(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
leaq 0xc(%rsp), %rdi
callq 0xe1a50
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movl $0x3f, %edi
callq 0xdddf0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd 0x9ecca(%rip), %xmm2    # 0x187168
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
shlq %rcx
movq %rcx, (%rax)
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl 0x10(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq -0x20(%rsp), %rcx
movq %rax, -0x10(%rsp)
movq $0x1, -0x18(%rsp)
movq -0x18(%rsp), %rax
movl 0x14(%rcx), %ecx
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
andq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: 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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movslq 0xc(%rax), %rdx
movl $0x40, %ecx
subq %rdx, %rcx
movq -0x18(%rsp), %rdx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, -0x18(%rsp)
movl 0x8(%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
orq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::setSign(unsigned long, bool) const
uintb FloatFormat::setSign(uintb x,bool sign) const

{
  if (!sign) return x;		// Assume bit is already zero
  uintb mask = 1;
  mask <<= signbit_pos;
  x |= mask;			// Stick in the bit
  return x;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
andb $0x1, %al
movb %al, -0x19(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
testb $0x1, -0x19(%rsp)
jne 0xe867f
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xe86b8
movq -0x30(%rsp), %rax
movq $0x1, -0x28(%rsp)
movl 0x4(%rax), %ecx
movq -0x28(%rsp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
orq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::getZeroEncoding(bool) const
uintb FloatFormat::getZeroEncoding(bool sgn) const

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

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xe13b0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd89b0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movb 0x1f(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xd14b0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x10(%rsp)
movq $0x1, 0x8(%rsp)
movq 0x8(%rsp), %rax
shlq $0x3f, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xe13b0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movslq 0x1c(%rdi), %rdx
callq 0xd89b0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movb 0x1f(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xd14b0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x30(%rsp), %xmm0
leaq 0x2b(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
callq 0xddce0
movl %eax, 0x2c(%rsp)
cmpl $0x2, 0x2c(%rsp)
jne 0xe8adb
movq 0x8(%rsp), %rdi
movb 0x2b(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xd2e40
movq %rax, 0x40(%rsp)
jmp 0xe8bfa
cmpl $0x1, 0x2c(%rsp)
jne 0xe8aff
movq 0x8(%rsp), %rdi
movb 0x2b(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xdc510
movq %rax, 0x40(%rsp)
jmp 0xe8bfa
cmpl $0x3, 0x2c(%rsp)
jne 0xe8b23
movq 0x8(%rsp), %rdi
movb 0x2b(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xd2dc0
movq %rax, 0x40(%rsp)
jmp 0xe8bfa
jmp 0xe8b25
jmp 0xe8b27
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jge 0xe8b5b
movq 0x8(%rsp), %rdi
movb 0x2b(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xd2e40
movq %rax, 0x40(%rsp)
jmp 0xe8bfa
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jle 0xe8b83
movq 0x8(%rsp), %rdi
movb 0x2b(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xdc510
movq %rax, 0x40(%rsp)
jmp 0xe8bfa
movq 0x8(%rsp), %rax
testb $0x1, 0x20(%rax)
je 0xe8ba2
cmpl $0x0, 0x1c(%rsp)
je 0xe8ba2
movq 0x20(%rsp), %rax
shlq %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xe13b0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movslq 0x1c(%rsp), %rdx
callq 0xd89b0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movb 0x2b(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xd14b0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::convertEncoding(unsigned long, FloatFormat const*) const
uintb FloatFormat::convertEncoding(uintb encoding,const FloatFormat *formin) const

{
  bool sgn = formin->extractSign(encoding);
  uintb frac = formin->extractFractionalCode(encoding);
  int4 exp = formin->extractExponentCode(encoding);
  
  if (exp == formin->maxexponent) { // NaN or INFINITY encoding
    exp = maxexponent;
  }
  else {
    exp -= formin->bias;
    exp += bias;
    if (exp < 0)
      return getZeroEncoding(sgn);
    if (exp > maxexponent)
      return getInfinityEncoding(sgn);
  }
  if (jbitimplied && !formin->jbitimplied)
    frac <<= 1;			// Cut off top bit (which should be 1)
  else if (formin->jbitimplied && !jbitimplied) {
    frac >>= 1;			// Make room for 1 jbit
    uintb highbit = 1;
    highbit <<= 8*sizeof(uintb)-1;
    frac |= highbit;		// Stick bit in at top
  }

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

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xd6dd0
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xd1a90
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xdad40
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x38(%rsp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0xe8c85
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xe8cf8
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
movl 0x18(%rcx), %edx
movl 0x24(%rsp), %ecx
subl %edx, %ecx
movl %ecx, 0x24(%rsp)
movl 0x18(%rax), %eax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jge 0xe8ccb
movq 0x8(%rsp), %rdi
movb 0x37(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xd2e40
movq %rax, 0x50(%rsp)
jmp 0xe8dc0
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jle 0xe8cf6
movq 0x8(%rsp), %rdi
movb 0x37(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xdc510
movq %rax, 0x50(%rsp)
jmp 0xe8dc0
jmp 0xe8cf8
movq 0x8(%rsp), %rax
testb $0x1, 0x20(%rax)
je 0xe8d1d
movq 0x38(%rsp), %rax
testb $0x1, 0x20(%rax)
jne 0xe8d1d
movq 0x28(%rsp), %rax
shlq %rax
movq %rax, 0x28(%rsp)
jmp 0xe8d68
movq 0x38(%rsp), %rax
testb $0x1, 0x20(%rax)
je 0xe8d66
movq 0x8(%rsp), %rax
testb $0x1, 0x20(%rax)
jne 0xe8d66
movq 0x28(%rsp), %rax
shrq %rax
movq %rax, 0x28(%rsp)
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
shlq $0x3f, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
orq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0xe8d68
movq 0x8(%rsp), %rdi
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xe13b0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movslq 0x24(%rsp), %rdx
callq 0xd89b0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movb 0x37(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xd14b0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0xd9500
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0xd9500
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
xorl %eax, %eax
movl $0x1, %ecx
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cltq
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::opNotEqual(unsigned long, unsigned long) const
uintb FloatFormat::opNotEqual(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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0xd9500
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0xd9500
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
xorl %eax, %eax
movl $0x1, %ecx
ucomisd %xmm1, %xmm0
setp %sil
setne %dl
orb %sil, %dl
cmovnel %ecx, %eax
cltq
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0xd9500
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0xd9500
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
xorl %eax, %eax
movl $0x1, %ecx
ucomisd %xmm1, %xmm0
cmoval %ecx, %eax
cltq
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x24(%rsp), %esi
shll $0x3, %esi
subl $0x1, %esi
leaq 0x18(%rsp), %rdi
callq 0xd74e0
movq 0x8(%rsp), %rdi
cvtsi2sdq 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0xd1fa0
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xd9500
movsd %xmm0, 0x18(%rsp)
cvttsd2si 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %edi
callq 0xcfa60
andq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/include/xml.hh
// Function: a_v_b(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
inline void a_v_b(ostream &s,const string &attr,bool val)

{
  s << ' ' << attr << "=\"";
  if (val)
    s << "true";
  else
    s << "false";
  s << "\"";
}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rdi
movl $0x20, %esi
callq 0xda0c0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0xd7350
movq %rax, %rdi
leaq 0x9edd1(%rip), %rsi     # 0x1895fd
callq 0xd8300
testb $0x1, 0x7(%rsp)
je 0xea84b
movq 0x10(%rsp), %rdi
leaq 0x9c992(%rip), %rsi     # 0x1871d6
callq 0xd8300
jmp 0xea85c
movq 0x10(%rsp), %rdi
leaq 0x9c984(%rip), %rsi     # 0x1871db
callq 0xd8300
movq 0x10(%rsp), %rdi
leaq 0x9ec24(%rip), %rsi     # 0x18948c
callq 0xd8300
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/include/xml.hh
// Function: xml_readbool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool xml_readbool(const string &attr)

{
  if (attr.size()==0) return false;
  char firstc = attr[0];
  if (firstc=='t') return true;
  if (firstc=='1') return true;
  if (firstc=='y') return true;         // For backward compatibility
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xd5290
cmpq $0x0, %rax
jne 0xea8a0
movb $0x0, 0x17(%rsp)
jmp 0xea8ec
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd9290
movb (%rax), %al
movb %al, 0x7(%rsp)
movsbl 0x7(%rsp), %eax
cmpl $0x74, %eax
jne 0xea8c5
movb $0x1, 0x17(%rsp)
jmp 0xea8ec
movsbl 0x7(%rsp), %eax
cmpl $0x31, %eax
jne 0xea8d6
movb $0x1, 0x17(%rsp)
jmp 0xea8ec
movsbl 0x7(%rsp), %eax
cmpl $0x79, %eax
jne 0xea8e7
movb $0x1, 0x17(%rsp)
jmp 0xea8ec
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
shrq $0x5, %rcx
movl %ecx, (%rax)
movslq -0xc(%rsp), %rcx
movl (%rax), %edx
shll $0x3, %edx
movslq %edx, %rdx
shlq $0x2, %rdx
subq %rdx, %rcx
movl %ecx, 0x4(%rax)
movslq -0x10(%rsp), %rcx
movl (%rax), %edx
shll $0x3, %edx
movslq %edx, %rdx
shlq $0x2, %rdx
subq %rdx, %rcx
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rdx
movl $0x20, %ecx
subq %rdx, %rcx
subq $0x1, %rcx
movl %ecx, 0xc(%rax)
movl 0x4(%rax), %ecx
addl 0xc(%rax), %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x9c85c(%rip), %rsi     # 0x187220
callq 0xd8300
movq 0x8(%rsp), %rax
movq 0x58(%rsp), %rsi
movq (%rax), %rdi
movq 0x8(%rax), %rdx
movl 0x10(%rax), %ecx
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xe0c80
movq 0x18(%rsp), %rdx
leaq 0x9c7d6(%rip), %rsi     # 0x1871e1
leaq 0x38(%rsp), %rdi
callq 0xe00a0
jmp 0xeaa17
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
leaq 0x38(%rsp), %rsi
callq 0xd7c30
jmp 0xeaa31
leaq 0x38(%rsp), %rdi
callq 0xd4550
leaq 0x37(%rsp), %rdi
callq 0xd8ec0
movq 0x58(%rsp), %rdi
leaq 0x9ddcc(%rip), %rsi     # 0x18881d
callq 0xd8300
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xeaa83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4550
leaq 0x37(%rsp), %rdi
callq 0xd8ec0
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: 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:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq %rdx, 0x220(%rsp)
movq 0x230(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x228(%rsp), %rsi
movq 0x220(%rsp), %rdx
leaq 0x208(%rsp), %rdi
leaq 0x21c(%rsp), %rcx
callq 0xd8a80
movq 0x228(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0xe0c80
movq 0x48(%rsp), %rdx
leaq 0x9c6c8(%rip), %rsi     # 0x1871e1
leaq 0x68(%rsp), %rdi
callq 0xe00a0
jmp 0xeab25
movq 0x40(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xdb6f0
movq %rax, 0x30(%rsp)
jmp 0xeab3b
movq 0x30(%rsp), %rsi
leaq 0x88(%rsp), %rdi
movl $0x8, %edx
callq 0xdfcc0
jmp 0xeab54
leaq 0x68(%rsp), %rdi
callq 0xd4550
leaq 0x67(%rsp), %rdi
callq 0xd8ec0
movq 0x88(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x88(%rsp,%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x2, %edi
movl $0x8, %esi
callq 0xe0e70
movl %eax, 0x2c(%rsp)
jmp 0xeab96
movl 0x2c(%rsp), %edi
movl $0x40, %esi
callq 0xe0e70
movl %eax, 0x1c(%rsp)
jmp 0xeabaa
movl 0x1c(%rsp), %esi
movq 0x20(%rsp), %rdi
callq 0xda6e0
jmp 0xeabba
movq 0x38(%rsp), %rsi
addq $0x18, %rsi
leaq 0x88(%rsp), %rdi
callq 0xdcd70
jmp 0xeabd2
leaq 0x208(%rsp), %rdi
callq 0xd9cf0
movq %rax, 0x10(%rsp)
jmp 0xeabe6
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x208(%rsp), %rdi
callq 0xe03b0
movq %rax, 0x8(%rsp)
jmp 0xeac07
movq 0x38(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x21c(%rsp), %ecx
movl %ecx, 0x10(%rax)
leaq 0x88(%rsp), %rdi
callq 0xd25a0
addq $0x238, %rsp            # imm = 0x238
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xeac5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xd4550
leaq 0x67(%rsp), %rdi
callq 0xd8ec0
jmp 0xeac83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xd25a0
movq 0x58(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextDatabase::saveTracked(std::ostream&, Address const&, std::vector<TrackedContext, std::allocator<TrackedContext>> const&)
void ContextDatabase::saveTracked(ostream &s,const Address &addr,
				  const TrackedSet &vec)
{
  if (vec.empty()) return;
  s << "<tracked_pointset";
  addr.getSpace()->saveXmlAttributes(s,addr.getOffset() );
  s << ">\n";
  for(int4 i=0;i<vec.size();++i) {
    s << "  ";
    vec[i].saveXml(s);
  }
  s << "</tracked_pointset>\n";
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xd5020
testb $0x1, %al
jne 0xeacb3
jmp 0xeacb8
jmp 0xead82
movq 0x30(%rsp), %rdi
leaq 0x9c521(%rip), %rsi     # 0x1871e5
callq 0xd8300
movq 0x28(%rsp), %rdi
callq 0xd9cf0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe03b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x30(%rsp), %rdi
leaq 0x9e963(%rip), %rsi     # 0x18966e
callq 0xd8300
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0xdbd60
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xead71
movq 0x30(%rsp), %rdi
leaq 0x9e842(%rip), %rsi     # 0x189585
callq 0xd8300
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xd8c50
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0xda180
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xead18
movq 0x30(%rsp), %rdi
leaq 0x9c47a(%rip), %rsi     # 0x1871f7
callq 0xd8300
addq $0x38, %rsp
retq
nopw (%rax,%rax)