LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::AddrSpace(AddrSpaceManager*, Translate const*, spacetype, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int, int, unsigned int, int)
AddrSpace::AddrSpace(AddrSpaceManager *m,const Translate *t,spacetype tp,const string &nm,
		     uint4 size,uint4 ws, int4 ind,uint4 fl,int4 dl)
{
  refcount = 0;			// No references to this space yet
  manage = m;
  trans = t;
  type = tp;
  name = nm;
  addressSize = size;
  wordsize = ws;
  index = ind;
  delay = dl;
  deadcodedelay = dl;		// Deadcode delay initially starts the same as heritage delay
  shortcut = ' ';		// Placeholder meaning shortcut is unassigned

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

// Assembly:
subq $0x58, %rsp
movl 0x78(%rsp), %eax
movl 0x70(%rsp), %eax
movl 0x68(%rsp), %eax
movl 0x60(%rsp), %eax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0xd2916(%rip), %rax     # 0x1c7d78
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x38, %rdi
movq %rdi, 0x10(%rsp)
callq 0xdc610
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movl $0x0, 0x20(%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl 0x3c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x30(%rsp), %rsi
callq 0xce450
jmp 0xf54ad
movq 0x8(%rsp), %rax
movl 0x2c(%rsp), %ecx
movl %ecx, 0x58(%rax)
movl 0x60(%rsp), %ecx
movl %ecx, 0x5c(%rax)
movl 0x68(%rsp), %ecx
movl %ecx, 0x60(%rax)
movl 0x78(%rsp), %ecx
movl %ecx, 0x64(%rax)
movl 0x78(%rsp), %ecx
movl %ecx, 0x68(%rax)
movb $0x20, 0x30(%rax)
movl 0x70(%rsp), %ecx
andl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x24(%rax)
movq 0x40(%rsp), %rdi
callq 0xd2330
movb %al, 0x7(%rsp)
jmp 0xf54f6
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xf5500
jmp 0xf552a
movq 0x8(%rsp), %rax
movl 0x24(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0xf552a
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xd4550
jmp 0xf5543
movq 0x8(%rsp), %rdi
movb 0x24(%rdi), %al
orb $0x6, %al
movb %al, 0x24(%rdi)
callq 0xd4760
jmp 0xf553e
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::AddrSpace(AddrSpaceManager*, Translate const*, spacetype)
AddrSpace::AddrSpace(AddrSpaceManager *m,const Translate *t,spacetype tp)

{
  refcount = 0;
  manage = m;
  trans = t;
  type = tp;
  flags = (heritaged | does_deadcode);		// Always on unless explicitly turned off in derived constructor
  wordsize = 1;
  shortcut = ' ';
  // We let big_endian get set by attribute
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq 0xd2801(%rip), %rax     # 0x1c7d78
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x38, %rdi
callq 0xdc610
movq (%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl $0x6, 0x24(%rax)
movl $0x1, 0x5c(%rax)
movb $0x20, 0x30(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::saveXmlAttributes(std::ostream&, unsigned long) const
void AddrSpace::saveXmlAttributes(ostream &s,uintb offset) const

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

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xe0c80
movq 0x20(%rsp), %rdx
leaq 0x91e47(%rip), %rsi     # 0x187b19
leaq 0x40(%rsp), %rdi
callq 0xe00a0
jmp 0xf5cde
movq 0x10(%rsp), %rdi
callq 0xd06f0
movq %rax, 0x8(%rsp)
jmp 0xf5cef
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd18c0
jmp 0xf5d05
leaq 0x40(%rsp), %rdi
callq 0xd4550
leaq 0x3f(%rsp), %rdi
callq 0xd8ec0
movq 0x68(%rsp), %rdi
movl $0x20, %esi
callq 0xda0c0
movq %rax, %rdi
leaq 0x91aa4(%rip), %rsi     # 0x1877d6
callq 0xd8300
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0xd68f0
movq 0x68(%rsp), %rdi
leaq 0x93735(%rip), %rsi     # 0x18948c
callq 0xd8300
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xf5d89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd4550
leaq 0x3f(%rsp), %rdi
callq 0xd8ec0
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::saveXmlAttributes(std::ostream&, unsigned long, int) const
void AddrSpace::saveXmlAttributes(ostream &s,uintb offset,int4 size) const

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

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movl %ecx, 0x9c(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x77(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xe0c80
movq 0x30(%rsp), %rdx
leaq 0x91cce(%rip), %rsi     # 0x187b19
leaq 0x78(%rsp), %rdi
callq 0xe00a0
jmp 0xf5e57
movq 0x20(%rsp), %rdi
callq 0xd06f0
movq %rax, 0x18(%rsp)
jmp 0xf5e68
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xd18c0
jmp 0xf5e7e
leaq 0x78(%rsp), %rdi
callq 0xd4550
leaq 0x77(%rsp), %rdi
callq 0xd8ec0
movq 0xa8(%rsp), %rdi
movl $0x20, %esi
callq 0xda0c0
movq %rax, %rdi
leaq 0x91928(%rip), %rsi     # 0x1877d6
callq 0xd8300
movq 0x20(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0xd68f0
movq 0xa8(%rsp), %rdi
leaq 0x935b0(%rip), %rsi     # 0x18948c
callq 0xd8300
movq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x97aa4(%rip), %rsi     # 0x18d9ad
leaq 0x40(%rsp), %rdi
callq 0xe00a0
jmp 0xf5f15
movq 0x8(%rsp), %rdi
movslq 0x9c(%rsp), %rdx
leaq 0x40(%rsp), %rsi
callq 0xde2b0
jmp 0xf5f2e
leaq 0x40(%rsp), %rdi
callq 0xd4550
leaq 0x3f(%rsp), %rdi
callq 0xd8ec0
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xf5f72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xd4550
leaq 0x77(%rsp), %rdi
callq 0xd8ec0
jmp 0xf5fb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xf5fa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd4550
leaq 0x3f(%rsp), %rdi
callq 0xd8ec0
movq 0x68(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::printRaw(std::ostream&, unsigned long) const
void AddrSpace::printRaw(ostream &s,uintb offset) const

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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd7510
movl %eax, 0x2c(%rsp)
cmpl $0x4, 0x2c(%rsp)
jle 0xf6371
movq 0x30(%rsp), %rax
shrq $0x20, %rax
cmpq $0x0, %rax
jne 0xf6356
movl $0x4, 0x2c(%rsp)
jmp 0xf636f
movq 0x30(%rsp), %rax
shrq $0x30, %rax
cmpq $0x0, %rax
jne 0xf636d
movl $0x6, 0x2c(%rsp)
jmp 0xf636f
jmp 0xf6371
movq 0x38(%rsp), %rdi
leaq 0x92bd7(%rip), %rsi     # 0x188f54
callq 0xd8300
movq %rax, (%rsp)
movl $0x30, %edi
callq 0xdaa80
movq (%rsp), %rdi
movb %al, 0x2b(%rsp)
movzbl 0x2b(%rsp), %esi
callq 0xde640
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %edi
shll %edi
callq 0xe2d10
movq 0x8(%rsp), %rdi
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %esi
callq 0xd9d70
movq %rax, %rdi
movq 0xd1bfa(%rip), %rsi     # 0x1c7fc8
callq 0xd1180
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x5c(%rax), %esi
callq 0xd29c0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xd0050
movq 0x18(%rsp), %rax
cmpl $0x1, 0x5c(%rax)
jbe 0xf6450
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movl 0x5c(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
je 0xf644e
movq 0x38(%rsp), %rdi
movl $0x2b, %esi
callq 0xda0c0
movq %rax, %rdi
movq 0xd195b(%rip), %rsi     # 0x1c7d98
callq 0xd1180
movq %rax, %rdi
movl 0x20(%rsp), %esi
callq 0xe03e0
jmp 0xf6450
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/space.cc
// Function: get_offset_size(char const*, unsigned long&)
static int4 get_offset_size(const char *ptr,uintb &offset)

{				// Get optional size and offset fields from string
  int4 size;
  uint4 val;
  char *ptr2;

  val = 0;			// Defaults
  size = -1;
  if (*ptr == ':') {
    size = strtoul(ptr+1,&ptr2,0);
    if (*ptr2 == '+')
      val = strtoul(ptr2+1,&ptr2,0);
  }
  if (*ptr == '+')
    val = strtoul(ptr+1,&ptr2,0);

  offset += val;		// Adjust offset
  return size;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0xf68ac
movq 0x20(%rsp), %rdi
addq $0x1, %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xd0fb0
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0xf68aa
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xd0fb0
movl %eax, 0x10(%rsp)
jmp 0xf68ac
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0xf68d2
movq 0x20(%rsp), %rdi
addq $0x1, %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xd0fb0
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, %ecx
movq 0x18(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/space.cc
// Function: JoinSpace::printRaw(std::ostream&, unsigned long) const
void JoinSpace::printRaw(ostream &s,uintb offset) const

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0xd6150
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0xdcde0
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd2b90
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x7b, %esi
callq 0xda0c0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0xf8ad4
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xdd0e0
movq %rax, (%rsp)
movq (%rsp), %rax
movl 0x10(%rax), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0xf8aad
movq 0x28(%rsp), %rdi
movl $0x2c, %esi
callq 0xda0c0
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
movq (%rsp), %rax
movq 0x8(%rax), %rdx
movq (%rdi), %rax
callq *0x50(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xf8a6c
cmpl $0x1, 0x10(%rsp)
jne 0xf8b07
movq 0x18(%rsp), %rdi
callq 0xd20e0
movl 0x10(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3a, %esi
callq 0xda0c0
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0xe03e0
movq 0x28(%rsp), %rdi
movl $0x7d, %esi
callq 0xda0c0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/space.cc
// Function: OverlaySpace::saveXml(std::ostream&) const
void OverlaySpace::saveXml(ostream &s) const

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

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xc8(%rsp), %rdi
leaq 0x8e64b(%rip), %rsi     # 0x18795e
callq 0xd8300
movq 0xc8(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0xa7(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xe0c80
movq 0x38(%rsp), %rdx
leaq 0x8dcee(%rip), %rsi     # 0x187031
leaq 0xa8(%rsp), %rdi
callq 0xe00a0
jmp 0xf9352
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
addq $0x38, %rdx
leaq 0xa8(%rsp), %rsi
callq 0xd18c0
jmp 0xf936f
leaq 0xa8(%rsp), %rdi
callq 0xd4550
leaq 0xa7(%rsp), %rdi
callq 0xd8ec0
movq 0xc8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xe0c80
movq 0x20(%rsp), %rdx
leaq 0x8e3f5(%rip), %rsi     # 0x1877a6
leaq 0x70(%rsp), %rdi
callq 0xe00a0
jmp 0xf93bd
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movslq 0x60(%rax), %rdx
leaq 0x70(%rsp), %rsi
callq 0xde2b0
jmp 0xf93d7
leaq 0x70(%rsp), %rdi
callq 0xd4550
leaq 0x6f(%rsp), %rdi
callq 0xd8ec0
movq 0xc8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x8e690(%rip), %rsi     # 0x187aa3
leaq 0x48(%rsp), %rdi
callq 0xe00a0
jmp 0xf941f
movq 0x28(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0xd06f0
movq %rax, (%rsp)
jmp 0xf9433
movq (%rsp), %rdx
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd18c0
jmp 0xf9448
leaq 0x48(%rsp), %rdi
callq 0xd4550
leaq 0x47(%rsp), %rdi
callq 0xd8ec0
movq 0xc8(%rsp), %rdi
leaq 0x8f3b2(%rip), %rsi     # 0x18881d
callq 0xd8300
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0xf94af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0xd4550
leaq 0xa7(%rsp), %rdi
callq 0xd8ec0
jmp 0xf953c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0xf94f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xd4550
leaq 0x6f(%rsp), %rdi
callq 0xd8ec0
jmp 0xf953c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0xf9532
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd4550
leaq 0x47(%rsp), %rdi
callq 0xd8ec0
movq 0x98(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: TruncationTag::restoreXml(Element const*)
void TruncationTag::restoreXml(const Element *el)

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

// Assembly:
subq $0x248, %rsp            # imm = 0x248
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq 0x240(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x238(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x217(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0xe0c80
movq 0x50(%rsp), %rdx
leaq 0x8d1ba(%rip), %rsi     # 0x187b19
leaq 0x218(%rsp), %rdi
callq 0xe00a0
jmp 0xfa96e
movq 0x48(%rsp), %rdi
leaq 0x218(%rsp), %rsi
callq 0xdb6f0
movq %rax, 0x38(%rsp)
jmp 0xfa987
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0xce450
jmp 0xfa998
leaq 0x218(%rsp), %rdi
callq 0xd4550
leaq 0x217(%rsp), %rdi
callq 0xd8ec0
movq 0x238(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xe0c80
movq 0x30(%rsp), %rdx
leaq 0x92fd3(%rip), %rsi     # 0x18d9ad
leaq 0x60(%rsp), %rdi
callq 0xe00a0
jmp 0xfa9e6
movq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xdb6f0
movq %rax, 0x20(%rsp)
jmp 0xfa9fc
movq 0x20(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movl $0x8, %edx
callq 0xdfcc0
jmp 0xfaa15
leaq 0x60(%rsp), %rdi
callq 0xd4550
leaq 0x5f(%rsp), %rdi
callq 0xd8ec0
movq 0x80(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x80(%rsp,%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x2, %edi
movl $0x8, %esi
callq 0xe0e70
movl %eax, 0x1c(%rsp)
jmp 0xfaa57
movl 0x1c(%rsp), %edi
movl $0x40, %esi
callq 0xe0e70
movl %eax, 0xc(%rsp)
jmp 0xfaa6b
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdi
callq 0xda6e0
jmp 0xfaa7b
movq 0x40(%rsp), %rsi
addq $0x20, %rsi
leaq 0x80(%rsp), %rdi
callq 0xceae0
jmp 0xfaa93
leaq 0x80(%rsp), %rdi
callq 0xd25a0
addq $0x248, %rsp            # imm = 0x248
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0xfaadf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
leaq 0x218(%rsp), %rdi
callq 0xd4550
leaq 0x217(%rsp), %rdi
callq 0xd8ec0
jmp 0xfab4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0xfab22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd4550
leaq 0x5f(%rsp), %rdi
callq 0xd8ec0
jmp 0xfab4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xd25a0
movq 0x208(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: SpacebaseSpace::setBaseRegister(VarnodeData const&, int, bool)
void SpacebaseSpace::setBaseRegister(const VarnodeData &data,int4 truncSize,bool stackGrowth)

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

// Assembly:
subq $0x68, %rsp
movb %cl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
andb $0x1, %al
movb %al, 0x53(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x78(%rax)
je 0xfade9
movq 0x18(%rsp), %rdi
addq $0x80, %rdi
movq 0x58(%rsp), %rsi
callq 0xe24a0
testb $0x1, %al
jne 0xfad37
movq 0x18(%rsp), %rax
movb 0x79(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x53(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0xfade7
movb $0x1, 0x23(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0xd06f0
movq %rax, 0x10(%rsp)
jmp 0xfad5c
movq 0x10(%rsp), %rdx
leaq 0x8ccd4(%rip), %rsi     # 0x187a3c
leaq 0x30(%rsp), %rdi
callq 0xd7370
jmp 0xfad74
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd1ae0
jmp 0xfad85
movq 0x8(%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0xcd0fa(%rip), %rsi     # 0x1c7e90
movq 0xcce33(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0xfaea5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xfadcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x23(%rsp)
jne 0xfadd8
jmp 0xfade2
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0xfae9b
jmp 0xfade9
movq 0x18(%rsp), %rcx
movb $0x1, 0x78(%rcx)
movb 0x53(%rsp), %al
andb $0x1, %al
movb %al, 0x79(%rcx)
movq 0x58(%rsp), %rax
movq (%rax), %rdx
movq %rdx, 0x98(%rcx)
movq 0x8(%rax), %rdx
movq %rdx, 0xa0(%rcx)
movq 0x10(%rax), %rax
movq %rax, 0xa8(%rcx)
movq 0x58(%rsp), %rax
movq (%rax), %rdx
movq %rdx, 0x80(%rcx)
movq 0x8(%rax), %rdx
movq %rdx, 0x88(%rcx)
movq 0x10(%rax), %rax
movq %rax, 0x90(%rcx)
movl 0x54(%rsp), %eax
cmpl 0x90(%rcx), %eax
je 0xfae96
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0xddec0
testb $0x1, %al
jne 0xfae68
jmp 0xfae87
movq 0x18(%rsp), %rax
movl 0x90(%rax), %ecx
subl 0x54(%rsp), %ecx
movl %ecx, %ecx
addq 0x88(%rax), %rcx
movq %rcx, 0x88(%rax)
movq 0x18(%rsp), %rax
movl 0x54(%rsp), %ecx
movl %ecx, 0x90(%rax)
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: SpacebaseSpace::saveXml(std::ostream&) const
void SpacebaseSpace::saveXml(ostream &s) const

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

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x8c9c8(%rip), %rsi     # 0x187a9c
callq 0xd8300
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xd9e10
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xe0c80
movq 0x18(%rsp), %rdx
leaq 0x8c99b(%rip), %rsi     # 0x187aa8
leaq 0x38(%rsp), %rdi
callq 0xe00a0
jmp 0xfb119
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0xd06f0
movq %rax, (%rsp)
jmp 0xfb12d
movq (%rsp), %rdx
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd18c0
jmp 0xfb142
leaq 0x38(%rsp), %rdi
callq 0xd4550
leaq 0x37(%rsp), %rdi
callq 0xd8ec0
movq 0x58(%rsp), %rdi
leaq 0x8d6bb(%rip), %rsi     # 0x18881d
callq 0xd8300
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xfb194
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
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::getSpaceByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
AddrSpace *AddrSpaceManager::getSpaceByName(const string &nm) const

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x38, %rdi
movq 0x20(%rsp), %rsi
callq 0xd1c60
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x38, %rdi
callq 0xd9dc0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xdcd80
testb $0x1, %al
jne 0xfb2f3
jmp 0xfb2fe
movq $0x0, 0x30(%rsp)
jmp 0xfb311
leaq 0x18(%rsp), %rdi
callq 0xdb610
movq 0x20(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: JoinRecord::operator<(JoinRecord const&) const
bool JoinRecord::operator<(const JoinRecord &op2) const

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x28(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x28(%rcx), %eax
je 0xfb363
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x28(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xfb436
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
callq 0xdf340
movslq 0x1c(%rsp), %rcx
cmpq %rcx, %rax
jne 0xfb39f
movq 0x20(%rsp), %rdi
callq 0xdf340
movslq 0x1c(%rsp), %rcx
cmpq %rcx, %rax
seta %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xfb436
movq 0x20(%rsp), %rdi
callq 0xdf340
movslq 0x1c(%rsp), %rcx
cmpq %rcx, %rax
jne 0xfb3ba
movb $0x0, 0x37(%rsp)
jmp 0xfb436
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xd8960
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xd8960
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xe24a0
testb $0x1, %al
jne 0xfb3f0
jmp 0xfb426
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xd8960
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xd8960
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xd8090
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xfb436
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xfb36b
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::AddrSpaceManager()
AddrSpaceManager::AddrSpaceManager(void)

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0xccb3e(%rip), %rax     # 0x1c7fa8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0xd38c0
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0xd3fe0
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0xcfe70
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
callq 0xd0030
movq 0x8(%rsp), %rdi
addq $0xd8, %rdi
callq 0xd52c0
movq 0x8(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0xd5cf0
movq 0x8(%rsp), %rax
movq $0x0, 0xa0(%rax)
movq $0x0, 0x98(%rax)
movq $0x0, 0xa8(%rax)
movq $0x0, 0xb0(%rax)
movq $0x0, 0xb8(%rax)
movq $0x0, 0xc0(%rax)
movq $0x0, 0xc8(%rax)
movq $0x0, 0xd0(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::setDefaultSpace(int)
void AddrSpaceManager::setDefaultSpace(int4 index)

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

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0xa0(%rax)
je 0xfc799
movb $0x1, 0x53(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x10(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xe0c80
movq 0x18(%rsp), %rdx
leaq 0x8b3d2(%rip), %rsi     # 0x187ae2
leaq 0x68(%rsp), %rdi
callq 0xe00a0
jmp 0xfc71c
movq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd1ae0
jmp 0xfc72d
movq 0x10(%rsp), %rdi
movb $0x0, 0x53(%rsp)
movq 0xcb752(%rip), %rsi     # 0x1c7e90
movq 0xcb48b(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0xfc8bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xfc777
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
testb $0x1, 0x53(%rsp)
jne 0xfc78a
jmp 0xfc794
movq 0x10(%rsp), %rdi
callq 0xd5400
jmp 0xfc8b5
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0xd1e70
movslq 0x8c(%rsp), %rcx
cmpq %rcx, %rax
jbe 0xfc7d4
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movslq 0x8c(%rsp), %rsi
callq 0xd1c20
cmpq $0x0, (%rax)
jne 0xfc885
movb $0x1, 0x2e(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x8b301(%rip), %rsi     # 0x187b03
leaq 0x30(%rsp), %rdi
callq 0xe00a0
jmp 0xfc80e
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd1ae0
jmp 0xfc81e
movq (%rsp), %rdi
movb $0x0, 0x2e(%rsp)
movq 0xcb662(%rip), %rsi     # 0x1c7e90
movq 0xcb39b(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0xfc8bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xfc867
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd4550
leaq 0x2f(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x2e(%rsp)
jne 0xfc87a
jmp 0xfc883
movq (%rsp), %rdi
callq 0xd5400
jmp 0xfc8b5
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movslq 0x8c(%rsp), %rsi
callq 0xd1c20
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0xa0(%rax)
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0xe0be0
nop
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::copySpaces(AddrSpaceManager const*)
void AddrSpaceManager::copySpaces(const AddrSpaceManager *op2)

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0xd1e70
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xfcb96
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0xd6c20
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xfcb87
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd26f0
jmp 0xfcb89
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xfcb30
movq 0x28(%rsp), %rdi
callq 0xd9770
movq %rax, %rdi
callq 0xd89c0
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0xe3130
addq $0x38, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::insertResolver(AddrSpace*, AddressResolver*)
void AddrSpaceManager::insertResolver(AddrSpace *spc,AddressResolver *rsolv)

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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd89c0
movl %eax, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0xe19f0
movslq 0x2c(%rsp), %rcx
cmpq %rcx, %rax
ja 0xfcc71
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movq $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xd1ce0
jmp 0xfcc3b
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xde8b0
cmpq $0x0, (%rax)
je 0xfccb8
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xde8b0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xfccb6
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xfccb8
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xde8b0
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::~AddrSpaceManager()
AddrSpaceManager::~AddrSpaceManager(void)

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

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0xcb29e(%rip), %rax     # 0x1c7fa8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0xe2ea0
movq %rax, 0x48(%rsp)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0xd1680
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd5f20
testb $0x1, %al
jne 0xfcd47
jmp 0xfcdac
leaq 0x48(%rsp), %rdi
callq 0xddc50
movq (%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0xfcd63
jmp 0xfcd9d
movq 0x38(%rsp), %rax
cmpl $0x1, 0x20(%rax)
jle 0xfcd7e
movq 0x38(%rsp), %rax
movl 0x20(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0xfcd9b
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0xfcd99
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xfcd9b
jmp 0xfcd9d
leaq 0x48(%rsp), %rdi
callq 0xd2d40
jmp 0xfcd1f
movl $0x0, 0x34(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x34(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x20, %rdi
callq 0xe19f0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0xfce2f
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
movslq 0x34(%rsp), %rsi
callq 0xde8b0
cmpq $0x0, (%rax)
je 0xfce20
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
movslq 0x34(%rsp), %rsi
callq 0xde8b0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xfce1e
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xfce20
jmp 0xfce22
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xfcdb4
movl $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x108, %rdi            # imm = 0x108
callq 0xd4340
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xfcea8
movq 0x28(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
movslq 0x30(%rsp), %rsi
callq 0xd1960
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xfce99
movq (%rsp), %rdi
callq 0xdaf70
movq (%rsp), %rdi
movl $0x30, %esi
callq 0xd8620
jmp 0xfce9b
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xfce37
movq 0x28(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0xd8b30
movq 0x28(%rsp), %rdi
addq $0xd8, %rdi
callq 0xd26a0
movq 0x28(%rsp), %rdi
addq $0x68, %rdi
callq 0xde350
movq 0x28(%rsp), %rdi
addq $0x38, %rdi
callq 0xe0510
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
callq 0xda150
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0xd2830
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::getSpaceByShortcut(char) const
AddrSpace *AddrSpaceManager::getSpaceByShortcut(char sc) const

{
  map<int4,AddrSpace *>::const_iterator iter;
  iter = shortcut2Space.find(sc);
  if (iter == shortcut2Space.end())
    return (AddrSpace *)0;
  return (*iter).second;
}

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x38(%rsp)
movb %al, 0x37(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xdb680
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
movsbl 0x37(%rsp), %eax
movl %eax, 0x1c(%rsp)
leaq 0x1c(%rsp), %rsi
callq 0xd21e0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x68, %rdi
callq 0xd6350
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xdcba0
testb $0x1, %al
jne 0xfcfb7
jmp 0xfcfc2
movq $0x0, 0x40(%rsp)
jmp 0xfcfd5
leaq 0x28(%rsp), %rdi
callq 0xdf390
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::resolveConstant(AddrSpace*, unsigned long, int, Address const&, unsigned long&) const
Address AddrSpaceManager::resolveConstant(AddrSpace *spc,uintb val,int4 sz,const Address &point,uintb &fullEncoding) const

{
  int4 ind = spc->getIndex();
  if (ind < resolvelist.size()) {
    AddressResolver *resolve = resolvelist[ind];
    if (resolve != (AddressResolver *)0)
      return resolve->resolve(val,sz,point,fullEncoding);
  }
  fullEncoding = val;
  val = AddrSpace::addressToByte(val,spc->getWordSize());
  val = spc->wrapOffset(val);
  return Address(spc,val);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movq %r9, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0xd89c0
movq 0x18(%rsp), %rdi
movl %eax, 0x34(%rsp)
movslq 0x34(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x20, %rdi
callq 0xe19f0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0xfd09b
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movslq 0x34(%rsp), %rsi
callq 0xd12a0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0xfd099
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x48(%rsp), %rdx
movl 0x44(%rsp), %ecx
movq 0x38(%rsp), %r8
movq 0x70(%rsp), %r9
movq (%rsi), %rax
callq *0x10(%rax)
jmp 0xfd0f3
jmp 0xfd09b
movq 0x48(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, (%rax)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0xde1c0
movq (%rsp), %rdi
movl %eax, %esi
callq 0xe2550
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xcfa10
movq 0x8(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0xd81b0
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::getNextSpaceInOrder(AddrSpace*) const
AddrSpace *AddrSpaceManager::getNextSpaceInOrder(AddrSpace *spc) const
{
  if (spc == (AddrSpace *)0) {
    return baselist[0];
  }
  if (spc == (AddrSpace *) ~((uintp)0)) {
    return (AddrSpace *)0;
  }
  int4 index = spc->getIndex() + 1;
  while (index < baselist.size()) {
    AddrSpace *res = baselist[index];
    if (res != (AddrSpace *)0)
      return res;
    index += 1;
  }
  return (AddrSpace *) ~((uintp)0);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xfd13f
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd6c20
movq (%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0xfd1d4
movq $-0x1, %rax
cmpq %rax, 0x20(%rsp)
jne 0xfd158
movq $0x0, 0x30(%rsp)
jmp 0xfd1d4
movq 0x20(%rsp), %rdi
callq 0xd89c0
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0xd1e70
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xfd1c8
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xd6c20
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xfd1bb
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xfd1d4
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xfd169
movq $-0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::findJoin(unsigned long) const
JoinRecord *AddrSpaceManager::findJoin(uintb offset) const

{ // Find a split record given the unified (join space) offset
  int4 min=0;
  int4 max=splitlist.size()-1;
  while(min<=max) {		// Binary search
    int4 mid = (min+max)/2;
    JoinRecord *rec = splitlist[mid];
    uintb val = rec->unified.offset;
    if (val == offset) return rec;
    if (val < offset)
      min = mid + 1;
    else
      max = mid - 1;
  }
  throw LowlevelError("Unlinked join address");
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x0, 0x74(%rsp)
addq $0x108, %rdi            # imm = 0x108
callq 0xd4340
subq $0x1, %rax
movl %eax, 0x70(%rsp)
movl 0x74(%rsp), %eax
cmpl 0x70(%rsp), %eax
jg 0xfd9ad
movq 0x18(%rsp), %rdi
movl 0x74(%rsp), %eax
addl 0x70(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x6c(%rsp)
addq $0x108, %rdi            # imm = 0x108
movslq 0x6c(%rsp), %rsi
callq 0xdac70
movq (%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
cmpq 0x78(%rsp), %rax
jne 0xfd984
movq 0x60(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x58(%rsp), %rax
cmpq 0x78(%rsp), %rax
jae 0xfd99d
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0xfd9a8
movl 0x6c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x70(%rsp)
jmp 0xfd91d
movb $0x1, 0x23(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x8a2b7(%rip), %rsi     # 0x187c93
leaq 0x38(%rsp), %rdi
callq 0xe00a0
jmp 0xfd9e8
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd1ae0
jmp 0xfd9f9
movq 0x8(%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0xca486(%rip), %rsi     # 0x1c7e90
movq 0xca1bf(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0xfda69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xfda40
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
testb $0x1, 0x23(%rsp)
jne 0xfda53
jmp 0xfda5d
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0xfda5f
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::truncateSpace(TruncationTag const&)
void AddrSpaceManager::truncateSpace(const TruncationTag &tag)

{
  AddrSpace *spc = getSpaceByName(tag.getName());
  if (spc == (AddrSpace *)0)
    throw LowlevelError("Unknown space in <truncate_space> command: "+tag.getName());
  spc->truncateSpace(tag.getSize());
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0xdb4d0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xe10d0
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0xfdb7a
movb $0x1, 0x23(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0xdb4d0
movq %rax, 0x10(%rsp)
jmp 0xfdaf5
movq 0x10(%rsp), %rdx
leaq 0x8a1a8(%rip), %rsi     # 0x187ca9
leaq 0x30(%rsp), %rdi
callq 0xd7370
jmp 0xfdb0d
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd1ae0
jmp 0xfdb1e
movq 0x8(%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0xca361(%rip), %rsi     # 0x1c7e90
movq 0xca09a(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0xfdba7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xfdb65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x23(%rsp)
jne 0xfdb6e
jmp 0xfdb78
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0xfdb9d
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
callq 0xdcf60
movq (%rsp), %rdi
movl %eax, %esi
callq 0xdcf90
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::constructFloatExtensionAddress(Address const&, int, int)
Address AddrSpaceManager::constructFloatExtensionAddress(const Address &realaddr,int4 realsize,
							 int4 logicalsize)
{
  if (logicalsize == realsize)
    return realaddr;
  vector<VarnodeData> pieces;
  pieces.push_back(VarnodeData());
  pieces.back().space = realaddr.getSpace();
  pieces.back().offset = realaddr.getOffset();
  pieces.back().size = realsize;

  JoinRecord *join = findAddJoin(pieces,logicalsize);
  return join->getUnified().getAddr();
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movl %ecx, 0xac(%rsp)
movl %r8d, 0xa8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0xa8(%rsp), %eax
cmpl 0xac(%rsp), %eax
jne 0xfdc1f
movq 0x40(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0xd6c50
jmp 0xfdd3f
leaq 0x90(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xdc410
movq 0x38(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movq $0x0, 0x80(%rsp)
leaq 0x70(%rsp), %rsi
callq 0xde8e0
jmp 0xfdc56
movq 0xb0(%rsp), %rdi
callq 0xd9cf0
movq %rax, 0x30(%rsp)
jmp 0xfdc6a
leaq 0x90(%rsp), %rdi
callq 0xd3a60
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq 0xb0(%rsp), %rdi
callq 0xe03b0
movq %rax, 0x28(%rsp)
jmp 0xfdc93
leaq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd3a60
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rdi
movq %rcx, 0x8(%rax)
movl 0xac(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0xd3a60
movl 0x14(%rsp), %ecx
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl %ecx, 0x10(%rax)
movl 0xa8(%rsp), %edx
callq 0xdbc00
movq %rax, 0x20(%rsp)
jmp 0xfdce7
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0xd20e0
movq %rax, 0x8(%rsp)
jmp 0xfdd02
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0xd9250
jmp 0xfdd13
leaq 0x90(%rsp), %rdi
callq 0xdc1e0
jmp 0xfdd3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xdc1e0
jmp 0xfdd4c
movq 0x48(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: Translate::getFloatFormat(int) const
const FloatFormat *Translate::getFloatFormat(int4 size) const

{
  vector<FloatFormat>::const_iterator iter;

  for(iter=floatformats.begin();iter!=floatformats.end();++iter) {
    if ((*iter).getSize() == size)
      return &(*iter);
  }
  return (const FloatFormat *)0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0xce900
movq (%rsp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0xe00e0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0xdaec0
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xce6f0
testb $0x1, %al
jne 0xfe509
jmp 0xfe540
leaq 0x18(%rsp), %rdi
callq 0xdc2d0
movq %rax, %rdi
callq 0xd77e0
cmpl 0x24(%rsp), %eax
jne 0xfe532
leaq 0x18(%rsp), %rdi
callq 0xdc2d0
movq %rax, 0x30(%rsp)
jmp 0xfe549
jmp 0xfe534
leaq 0x18(%rsp), %rdi
callq 0xd29d0
jmp 0xfe4df
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: PcodeEmit::unpackOffset(unsigned char const*, unsigned long&)
const uint1 *PcodeEmit::unpackOffset(const uint1 *ptr,uintb &off)

{
  uintb res = 0;
  int4 shift;
  for(shift=0;shift<67;shift+=6) {
    uint1 val = *ptr++;
    if (val == end_tag) {
      off = res;
      return ptr;
    }
    uintb bits = ((uintb)(val-0x20))<<shift;
    res |= bits;
  }
  throw LowlevelError("Bad packed offset");
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq $0x0, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
cmpl $0x43, 0x5c(%rsp)
jge 0xfeae0
movq 0x70(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x70(%rsp)
movb (%rax), %al
movb %al, 0x5b(%rsp)
movzbl 0x5b(%rsp), %eax
cmpl $0x60, %eax
jne 0xfeaae
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movzbl 0x5b(%rsp), %eax
subl $0x20, %eax
cltq
movl 0x5c(%rsp), %ecx
shlq %cl, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
orq 0x60(%rsp), %rax
movq %rax, 0x60(%rsp)
movl 0x5c(%rsp), %eax
addl $0x6, %eax
movl %eax, 0x5c(%rsp)
jmp 0xfea6f
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x89200(%rip), %rsi     # 0x187d0f
leaq 0x30(%rsp), %rdi
callq 0xe00a0
jmp 0xfeb1b
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd1ae0
jmp 0xfeb2c
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0xc9353(%rip), %rsi     # 0x1c7e90
movq 0xc908c(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0xfeb9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0xfeb73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd4550
leaq 0x2f(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x1b(%rsp)
jne 0xfeb86
jmp 0xfeb90
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0xfeb92
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopl (%rax)