LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextDatabase::setVariableRegion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Address const&, Address const&, unsigned int)
void ContextDatabase::setVariableRegion(const string &nm,
				     const Address &begad,
				     const Address &endad,
				     uintm value)
{
  const ContextBitRange &bitrange( getVariable(nm) );

  vector<uintm *> vec;
  getRegionForSet(vec,begad,endad,bitrange.getWord(),bitrange.getMask() << bitrange.getShift());
  for(int4 i=0;i<vec.size();++i)
    bitrange.setValue(vec[i],value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movl (%rax), %r8d
movl 0x10(%rax), %r9d
movb 0xc(%rax), %cl
shll %cl, %r9d
movq (%r13), %rax
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq *0x10(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x4616e
sarq $0x3, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %edx, %edx
movq (%rdi,%rdx,8), %rsi
movslq (%r14), %r8
movl 0x10(%r14), %r9d
movb 0xc(%r14), %cl
movl %r9d, %r10d
shll %cl, %r10d
notl %r10d
andl (%rsi,%r8,4), %r10d
andl %ebx, %r9d
shll %cl, %r9d
orl %r10d, %r9d
movl %r9d, (%rsi,%r8,4)
incq %rdx
cmpq %rdx, %rax
jne 0x4613d
testq %rdi, %rdi
je 0x46180
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x461a7
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextDatabase::getTrackedValue(VarnodeData const&, Address const&) const
uintb ContextDatabase::getTrackedValue(const VarnodeData &mem,const Address &point) const

{
  const TrackedSet &tset(getTrackedSet(point));
  uintb endoff = mem.offset + mem.size - 1;
  uintb tendoff;
  for(int4 i=0;i<tset.size();++i) {
    const TrackedContext &tcont( tset[i] );
    // tcont must contain -mem-
    if (tcont.loc.space != mem.space) continue;
    if (tcont.loc.offset > mem.offset) continue;
    tendoff = tcont.loc.offset + tcont.loc.size - 1;
    if (tendoff < endoff) continue;
    uintb res = tcont.val;
    // If we have proper containment, trim value based on endianness
    if (tcont.loc.space->isBigEndian()) {
      if (endoff != tendoff)
	res >>= (8* (tendoff - mem.offset));
    }
    else {
      if (mem.offset != tcont.loc.offset)
	res >>= (8* (mem.offset-tcont.loc.offset));
    }
    res &= calc_mask( mem.size ); // Final trim based on size
    return res;
  }
  return (uintb)0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x68(%rax)
movq (%rax), %rdx
movq 0x8(%rax), %rsi
subq %rdx, %rsi
je 0x46270
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %eax
leaq (%rdi,%rax), %r8
leaq (%rdi,%rax), %r9
decq %r9
sarq $0x5, %rsi
movq (%rbx), %r10
cmpl $0x8, %eax
movl $0x8, %ecx
cmovll %eax, %ecx
movslq %ecx, %r11
cmpq $0x1, %rsi
adcq $0x0, %rsi
addq $0x18, %rdx
movq 0x5c9c2(%rip), %rbx     # 0xa2bd0
movq -0x18(%rdx), %r15
movb $0x1, %bpl
cmpq %r10, %r15
jne 0x46262
movq -0x10(%rdx), %r14
cmpq %r14, %rdi
jb 0x46262
movl -0x8(%rdx), %r12d
leaq (%r14,%r12), %rcx
decq %rcx
cmpq %r9, %rcx
jb 0x46262
movq (%rdx), %rax
testb $0x1, 0x24(%r15)
jne 0x4624c
cmpq %r14, %rdi
je 0x4625c
movl %edi, %ecx
subl %r14d, %ecx
shll $0x3, %ecx
jmp 0x46259
addq %r12, %r14
cmpq %r14, %r8
je 0x4625c
subl %edi, %ecx
shll $0x3, %ecx
shrq %cl, %rax
andq (%rbx,%r11,8), %rax
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x46272
addq $0x20, %rdx
decq %rsi
jne 0x4620e
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::FreeArray::reset(int)
void ContextInternal::FreeArray::reset(int4 sz)

{
  uintm *newarray = (uintm *)0;
  uintm *newmask = (uintm *)0;
  if (sz != 0) {
    newarray = new uintm[sz];
    newmask = new uintm[sz];
    int4 min;
    if (sz > size) {
      min = size;
      for(int4 i=min;i<sz;++i) {
	newarray[i] = 0;	// Pad new part with zero
	newmask[i] = 0;
      }
    }
    else
      min = sz;
    for(int4 i=0;i<min;++i) {	// Copy old part
      newarray[i] = array[i];
      newmask[i] = mask[i];
    }
  }
  if (size!=0) {
    delete [] array;
    delete [] mask;
  }
  array = newarray;
  mask = newmask;
  size = sz;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
je 0x46326
movslq %ebx, %rax
shlq $0x2, %rax
testl %ebx, %ebx
movq $-0x1, %r12
cmovnsq %rax, %r12
movq %r12, %rdi
callq 0x3f060
movq %rax, %r15
movq %r12, %rdi
callq 0x3f060
movq %rax, %r12
movl 0x10(%r14), %ebp
movl %ebx, %edx
cmpl %ebx, %ebp
jge 0x462ff
movslq %ebp, %rax
movq %rax, (%rsp)
leaq (%r15,%rax,4), %rdi
movl %ebp, %eax
notl %eax
addl %ebx, %eax
leaq 0x4(,%rax,4), %r13
xorl %esi, %esi
movq %r13, %rdx
callq 0x3fca0
movq (%rsp), %rax
leaq (%r12,%rax,4), %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x3fca0
movl %ebp, %edx
testl %edx, %edx
jle 0x4632c
movq (%r14), %rax
movq 0x8(%r14), %rcx
movl %edx, %edx
xorl %esi, %esi
movl (%rax,%rsi,4), %edi
movl %edi, (%r15,%rsi,4)
movl (%rcx,%rsi,4), %edi
movl %edi, (%r12,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x4630e
jmp 0x4632c
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpl $0x0, 0x10(%r14)
je 0x4634e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x46340
callq 0x40f00
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x4634e
callq 0x40f00
movq %r15, (%r14)
movq %r12, 0x8(%r14)
movl %ebx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::FreeArray::operator=(ContextInternal::FreeArray const&)
ContextInternal::FreeArray &ContextInternal::FreeArray::operator=(const FreeArray &op2)

{
  if (size!=0) {
    delete [] array;
    delete [] mask;
  }
  array = (uintm *)0;
  mask = (uintm *)0;
  size = op2.size;
  if (size != 0) {
    array = new uintm[size];
    mask = new uintm[size];
    for(int4 i=0;i<size;++i) {
      array[i] = op2.array[i];		// Copy value at split point
      mask[i] = 0;			// but not fact that value is being set
    }
  }
  return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
je 0x46397
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x46389
callq 0x40f00
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x46397
callq 0x40f00
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movslq 0x10(%r14), %rax
movl %eax, 0x10(%rbx)
testq %rax, %rax
je 0x46406
movq %rax, %rcx
shlq $0x2, %rcx
testl %eax, %eax
movq $-0x1, %r12
cmovnsq %rcx, %r12
movq %r12, %rdi
callq 0x3f060
movq %rax, %r15
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x3f060
movq %rax, 0x8(%rbx)
cmpl $0x0, 0x10(%rbx)
jle 0x46406
movq (%r14), %rcx
movl 0x10(%rbx), %esi
cmpl $0x2, %esi
movl $0x1, %edx
cmovgel %esi, %edx
xorl %esi, %esi
movl (%rcx,%rsi,4), %edi
movl %edi, (%r15,%rsi,4)
movl $0x0, (%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x463f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::getVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ContextBitRange &ContextInternal::getVariable(const string &nm)

{
  map<string,ContextBitRange>::iterator iter;

  iter = variables.find(nm);
  if (iter == variables.end())
    throw LowlevelError("Non-existent context variable: "+nm);
  return (*iter).second;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x407b0
addq $0x18, %rbx
cmpq %rbx, %rax
je 0x46a93
addq $0x40, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x387d0(%rip), %rsi     # 0x7f277
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40500
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x5c3df(%rip), %rsi     # 0xa2ea8
movq 0x5c168(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46afe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x46afe
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x46b0b
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::getVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const ContextBitRange &ContextInternal::getVariable(const string &nm) const

{
  map<string,ContextBitRange>::const_iterator iter;

  iter = variables.find(nm);
  if (iter == variables.end())
    throw LowlevelError("Non-existent context variable: "+nm);
  return (*iter).second;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x41630
addq $0x18, %rbx
cmpq %rbx, %rax
je 0x46b41
addq $0x40, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x38722(%rip), %rsi     # 0x7f277
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40500
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x5c331(%rip), %rsi     # 0xa2ea8
movq 0x5c0ba(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46bac
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x46bac
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x46bb9
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::getContext(Address const&, unsigned long&, unsigned long&) const
const uintm *ContextInternal::getContext(const Address &addr,
					       uintb &first,uintb &last) const
{
  int4 valid;
  Address before,after;
  const uintm *res = database.bounds(addr,before,after,valid).array;
  if (((valid&1)!=0)||(before.getSpace() != addr.getSpace()))
    first = 0;
  else
    first = before.getOffset();
  if (((valid&2)!=0)||(after.getSpace() != addr.getSpace()))
    last = addr.getSpace()->getHighest();
  else
    last = after.getOffset()-1;
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
xorl %r13d, %r13d
leaq 0x20(%rsp), %rdx
movq %r13, (%rdx)
leaq 0x10(%rsp), %rcx
movq %r13, (%rcx)
addq $0x40, %rdi
leaq 0xc(%rsp), %r12
movq %r12, %r8
callq 0x40d30
movl (%r12), %ecx
testb $0x1, %cl
jne 0x46c19
movq 0x20(%rsp), %rdx
cmpq (%r14), %rdx
je 0x46c14
xorl %r13d, %r13d
jmp 0x46c19
movq 0x28(%rsp), %r13
movq (%rax), %rax
movq %r13, (%r15)
testb $0x2, %cl
jne 0x46c2e
movq 0x10(%rsp), %rcx
cmpq (%r14), %rcx
je 0x46c46
movq (%r14), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x18(%rsp), %rcx
decq %rcx
jmp 0x46c35
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::getRegionForSet(std::vector<unsigned int*, std::allocator<unsigned int*>>&, Address const&, Address const&, int, unsigned int)
void ContextInternal::getRegionForSet(vector<uintm *> &res,const Address &addr1,const Address &addr2,
				      int4 num,uintm mask)
{
  database.split(addr1);
  partmap<Address,FreeArray>::iterator aiter,biter;

  aiter = database.begin(addr1);
  if (!addr2.isInvalid()) {
    database.split(addr2);
    biter = database.begin(addr2);
  }
  else
    biter = database.end();
  while(aiter != biter) {
    uintm *context = (*aiter).second.array;
    uintm *maskPtr = (*aiter).second.mask;
    res.push_back(context);
    maskPtr[num] |= mask;		// Mark that this value is being definitely set
    ++aiter;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rdi), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x41a10
movq 0x50(%rbx), %r12
movq %rbx, 0x10(%rsp)
addq $0x48, %rbx
movq %rbx, %r15
testq %r12, %r12
je 0x46cc0
movq %rbx, %r15
leaq 0x20(%r12), %rsi
movq %r13, %rdi
movq %rbp, %rdx
callq 0x42260
testb %al, %al
cmoveq %r12, %r15
movzbl %al, %eax
movq 0x10(%r12,%rax,8), %r12
testq %r12, %r12
jne 0x46c9d
movq 0x18(%rsp), %rbp
cmpq $0x0, (%rbp)
je 0x46d05
movq %r13, %rdi
movq %rbp, %rsi
callq 0x41a10
movq 0x10(%rsp), %rax
movq 0x50(%rax), %r12
testq %r12, %r12
je 0x46d05
leaq 0x20(%r12), %rsi
movq %r13, %rdi
movq %rbp, %rdx
callq 0x42260
testb %al, %al
cmoveq %r12, %rbx
movzbl %al, %eax
movq 0x10(%r12,%rax,8), %r12
jmp 0x46ce0
cmpq %rbx, %r15
je 0x46d59
movslq 0x8(%rsp), %r13
leaq 0x20(%rsp), %r12
movq 0x30(%r15), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%r15), %rbp
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x46d35
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x46d40
movq %r14, %rdi
movq %r12, %rdx
callq 0x3f4f0
movl 0xc(%rsp), %eax
orl %eax, (%rbp,%r13,4)
movq %r15, %rdi
callq 0x40030
movq %rax, %r15
cmpq %rbx, %rax
jne 0x46d14
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::getRegionToChangePoint(std::vector<unsigned int*, std::allocator<unsigned int*>>&, Address const&, int, unsigned int)
void ContextInternal::getRegionToChangePoint(vector<uintm *> &res,const Address &addr,int4 num,uintm mask)

{
  database.split(addr);
  partmap<Address,FreeArray>::iterator aiter,biter;
  uintm *maskArray,*vecArray;

  aiter = database.begin(addr);
  biter = database.end();
  if (aiter == biter) return;
  vecArray = (*aiter).second.array;
  res.push_back(vecArray);
  maskArray = (*aiter).second.mask;
  maskArray[num] |= mask;
  ++aiter;
  while(aiter != biter) {
    vecArray = (*aiter).second.array;
    maskArray = (*aiter).second.mask;
    if ((maskArray[num] & mask) != 0) break; // Reached point where this value was definitively set before
    res.push_back(vecArray);
    ++aiter;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
leaq 0x40(%rdi), %rbp
movq %rbp, %rdi
movq %rdx, %rsi
callq 0x41a10
movq 0x50(%r15), %rbx
addq $0x48, %r15
movq %r15, %r12
testq %rbx, %rbx
je 0x46dcc
movq %r15, %r12
leaq 0x20(%rbx), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x42260
testb %al, %al
cmoveq %rbx, %r12
movzbl %al, %eax
movq 0x10(%rbx,%rax,8), %rbx
testq %rbx, %rbx
jne 0x46daa
cmpq %r15, %r12
movl 0x14(%rsp), %ebx
je 0x46e69
movq 0x30(%r12), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x46df7
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x46e04
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x3f4f0
movq 0x38(%r12), %rax
movslq 0x10(%rsp), %rbp
orl %ebx, (%rax,%rbp,4)
movq %r12, %rdi
callq 0x40030
cmpq %r15, %rax
je 0x46e69
movq %rax, %r12
leaq 0x8(%rsp), %r13
movq 0x30(%r12), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%r12), %rcx
testl %ebx, (%rcx,%rbp,4)
jne 0x46e69
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x46e4e
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x46e59
movq %r14, %rdi
movq %r13, %rdx
callq 0x3f4f0
movq %r12, %rdi
callq 0x40030
movq %rax, %r12
cmpq %r15, %rax
jne 0x46e26
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::saveXml(std::ostream&) const
void ContextInternal::saveXml(ostream &s) const

{
  if (database.empty() && trackbase.empty()) return;
  
  s << "<context_points>\n";

  partmap<Address,FreeArray>::const_iterator fiter,fenditer;
  fiter = database.begin();
  fenditer = database.end();
  for(;fiter!=fenditer;++fiter)	// Save context at each changepoint
    saveContext(s,(*fiter).first,(*fiter).second.array);
  
  partmap<Address,TrackedSet>::const_iterator titer,tenditer;
  titer = trackbase.begin();
  tenditer = trackbase.end();
  for(;titer!=tenditer;++titer) 
    saveTracked(s,(*titer).first,(*titer).second);

  s << "</context_points>\n";
}

// Assembly:
movq 0xb0(%rdi), %rax
orq 0x68(%rdi), %rax
jne 0x46ea2
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x383e0(%rip), %rsi     # 0x7f297
movl $0x11, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x58(%r14), %r15
leaq 0x48(%r14), %r12
cmpq %r12, %r15
je 0x46ef4
leaq 0x20(%r15), %rdx
movq 0x30(%r15), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41340
movq %r15, %rdi
callq 0x40bc0
movq %rax, %r15
cmpq %r12, %rax
jne 0x46ed1
movq 0xa0(%r14), %r15
addq $0x90, %r14
cmpq %r14, %r15
je 0x46f27
leaq 0x20(%r15), %rsi
leaq 0x30(%r15), %rdx
movq %rbx, %rdi
callq 0x40fb0
movq %r15, %rdi
callq 0x40bc0
movq %rax, %r15
cmpq %r14, %rax
jne 0x46f07
leaq 0x3837b(%rip), %rsi     # 0x7f2a9
movl $0x12, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40b80
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::restoreXml(Element const*, AddrSpaceManager const*)
void ContextInternal::restoreXml(const Element *el,const AddrSpaceManager *manage)

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

  while(iter != list.end()) {
    const Element *subel = *iter;
    if (subel->getName() == "context_pointset") {
      if (subel->getNumAttributes()==0) {
	restoreContext(subel,Address(),Address());	// Restore the default value
      }
      else {
	Address addr = Address::restoreXml(subel,manage);
	restoreContext(subel,addr,Address());
      }
    }
    else if (subel->getName() == "tracked_pointset") {
      Address addr = Address::restoreXml(subel,manage);
      restoreTracked(subel,manage,trackbase.split(addr) );
    }
    else
      throw LowlevelError("Bad <context_points> tag: "+subel->getName());
    ++iter;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, (%rsp)
movq 0x78(%rsi), %r13
cmpq 0x80(%rsi), %r13
je 0x47030
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsp), %rax
leaq 0x88(%rax), %r12
leaq 0x18(%rsp), %rbp
movq (%r13), %r15
movq %r15, %rdi
leaq 0x3824f(%rip), %rsi     # 0x7f1dc
callq 0x3f590
testl %eax, %eax
je 0x46fd6
movq %r15, %rdi
leaq 0x38215(%rip), %rsi     # 0x7f1b5
callq 0x3f590
testl %eax, %eax
jne 0x4703f
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x42110
movq %r12, %rdi
movq %rbp, %rsi
callq 0x3f5f0
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40a70
jmp 0x4701f
movq 0x48(%r15), %rax
subq 0x40(%r15), %rax
shrq $0x5, %rax
testl %eax, %eax
je 0x46fff
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x42110
movq $0x0, 0x8(%rsp)
jmp 0x4700b
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
leaq 0x8(%rsp), %rcx
callq 0x3f520
addq $0x8, %r13
cmpq 0x80(%r14), %r13
jne 0x46f7f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x38269(%rip), %rsi     # 0x7f2bc
leaq 0x18(%rsp), %rdi
movq %r15, %rdx
callq 0x40500
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x5be2f(%rip), %rsi     # 0xa2ea8
movq 0x5bbb8(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x470ae
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x470ae
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x470bb
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextCache::getContext(Address const&, unsigned int*) const
void ContextCache::getContext(const Address &addr,uintm *buf) const

{
  if ((addr.getSpace()!=curspace)||(first>addr.getOffset())||(last<addr.getOffset())) {
    curspace = addr.getSpace();
    context = database->getContext(addr,first,last);
  }
  for(int4 i=0;i<database->getContextSize();++i) 
    buf[i] = context[i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq 0x10(%rdi), %rax
je 0x47302
movq %rax, 0x10(%r14)
movq (%r14), %rdi
leaq 0x18(%r14), %rdx
leaq 0x20(%r14), %rcx
movq (%rdi), %rax
callq *0x58(%rax)
movq %rax, 0x28(%r14)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testl %eax, %eax
jle 0x472fc
xorl %r15d, %r15d
movq 0x28(%r14), %rax
movl (%rax,%r15,4), %eax
movl %eax, (%rbx,%r15,4)
incq %r15
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cltq
cmpq %rax, %r15
jl 0x472dd
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsi), %rcx
cmpq %rcx, 0x18(%r14)
ja 0x472b4
cmpq %rcx, 0x20(%r14)
jae 0x472cd
jmp 0x472b4
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextCache::setContext(Address const&, int, unsigned int, unsigned int)
void ContextCache::setContext(const Address &addr,int4 num,uintm mask,uintm value)

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

// Assembly:
cmpb $0x1, 0x8(%rdi)
jne 0x47354
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3f200
movq (%r14), %rax
cmpq 0x10(%rbx), %rax
jne 0x4734d
movq 0x8(%r14), %rax
cmpq %rax, 0x18(%rbx)
ja 0x4734d
cmpq %rax, 0x20(%rbx)
jb 0x4734d
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextCache::setContext(Address const&, Address const&, int, unsigned int, unsigned int)
void ContextCache::setContext(const Address &addr1,const Address &addr2,int4 num,uintm mask,uintm value)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq $0x0, (%rdi)
movl $0x0, 0x10(%rdi)
movq 0x48(%rsi), %r12
subq 0x40(%rsi), %r12
shrq $0x5, %r12
testl %r12d, %r12d
jle 0x48bc9
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
shlq $0x5, %r12
xorl %r15d, %r15d
leaq 0x36fe7(%rip), %rbp     # 0x7fb1d
leaq 0x364f4(%rip), %r13     # 0x7f031
movq 0x40(%r14), %rdi
addq %r15, %rdi
movq %rbp, %rsi
callq 0x3f590
testl %eax, %eax
je 0x48b6e
movq 0x40(%r14), %rdi
addq %r15, %rdi
movq %r13, %rsi
callq 0x3f590
testl %eax, %eax
je 0x48b9e
addq $0x20, %r15
cmpq %r15, %r12
jne 0x48b3d
jmp 0x48bc9
movq 0x58(%r14), %rsi
addq %r15, %rsi
movq 0x8(%rsp), %rdi
callq 0x41fd0
movq %rax, (%rbx)
testq %rax, %rax
je 0x48bd8
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
callq *0x48(%rcx)
movq %rax, 0x8(%rbx)
jmp 0x48bc9
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rax
movq 0x18(%rax), %rdi
addq 0x58(%r14), %r15
movq (%rdi), %rax
movq %r15, %rsi
callq *0x38(%rax)
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
addq 0x58(%r14), %r15
leaq 0x36b21(%rip), %rsi     # 0x7f711
leaq 0x18(%rsp), %rdi
movq %r15, %rdx
callq 0x40500
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x5a292(%rip), %rsi     # 0xa2ea8
movq 0x5a01b(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48c4b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x48c4b
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x48c58
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::AddrSpace(AddrSpaceManager*, Translate const*, spacetype, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int, int, unsigned int, int)
AddrSpace::AddrSpace(AddrSpaceManager *m,const Translate *t,spacetype tp,const string &nm,
		     uint4 size,uint4 ws, int4 ind,uint4 fl,int4 dl)
{
  refcount = 0;			// No references to this space yet
  manage = m;
  trans = t;
  type = tp;
  name = nm;
  addressSize = size;
  wordsize = ws;
  index = ind;
  delay = dl;
  deadcodedelay = dl;		// Deadcode delay initially starts the same as heritage delay
  shortcut = ' ';		// Placeholder meaning shortcut is unassigned

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x5a11c(%rip), %rax     # 0xa2dc0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x38(%rdi), %r15
leaq 0x48(%rdi), %r12
movq %r12, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movb $0x0, 0x48(%rdi)
movl $0x0, 0x20(%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movl %ecx, 0x8(%rdi)
movq %r15, %rdi
movq %r8, %rsi
callq 0x3fc60
movl 0x48(%rsp), %edx
movl 0x40(%rsp), %ecx
movl 0x38(%rsp), %esi
movl 0x30(%rsp), %eax
movl %ebp, 0x58(%rbx)
movl %eax, 0x5c(%rbx)
movl %esi, 0x60(%rbx)
movl %edx, 0x64(%rbx)
movl %edx, 0x68(%rbx)
movb $0x20, 0x30(%rbx)
andl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x24(%rbx)
cmpb $0x1, 0x120(%r14)
jne 0x48d1c
orl $0x1, %ecx
movl %ecx, 0x24(%rbx)
orb $0x6, 0x24(%rbx)
cmpl $0x8, %ebp
movl $0x8, %ecx
cmovll %ebp, %ecx
movslq %ecx, %rcx
movq 0x59e9b(%rip), %rdx     # 0xa2bd0
movl %eax, %esi
imulq (%rdx,%rcx,8), %rsi
decl %eax
addq %rsi, %rax
movq %rax, 0x28(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x48d65
movq (%r12), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x5a04b(%rip), %rax     # 0xa2dc0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x48(%rdi), %rax
movq %rax, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movb $0x0, 0x48(%rdi)
movabsq $0x600000000, %rax      # imm = 0x600000000
movq %rax, 0x20(%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movl %ecx, 0x8(%rdi)
movl $0x1, 0x5c(%rdi)
movb $0x20, 0x30(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::saveXmlAttributes(std::ostream&, unsigned long) const
void AddrSpace::saveXmlAttributes(ostream &s,uintb offset) const

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x36754(%rip), %rsi     # 0x7fb1d
leaq 0x36752(%rip), %rdx     # 0x7fb22
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
leaq 0x38350(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x38(%r15), %rsi
movq %rbx, %rdi
callq 0x3f3d0
leaq 0x381bf(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4944c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x8(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
leaq 0x362ee(%rip), %rsi     # 0x7f756
movl $0x8, %edx
movq %rax, %rdi
callq 0x40b80
leaq 0x37c38(%rip), %rsi     # 0x810b4
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ffb0
leaq 0x38137(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x494e3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::saveXmlAttributes(std::ostream&, unsigned long, int) const
void AddrSpace::saveXmlAttributes(ostream &s,uintb offset,int4 size) const

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x365c1(%rip), %rsi     # 0x7fb1d
leaq 0x365bf(%rip), %rdx     # 0x7fb22
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b80
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
leaq 0x381bd(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x38(%r12), %rsi
movq %r14, %rdi
callq 0x3f3d0
leaq 0x3802b(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b80
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x495e0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x10(%rsp), %r12
movb $0x20, (%r12)
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x40b80
leaq 0x36155(%rip), %rsi     # 0x7f756
movl $0x8, %edx
movq %rax, %rdi
callq 0x40b80
leaq 0x37a9f(%rip), %rsi     # 0x810b4
movl $0x2, %edx
movq %r14, %rdi
callq 0x40b80
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r14,%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ffb0
leaq 0x37f9c(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b80
movq %r13, (%r12)
leaq 0x3c13a(%rip), %rsi     # 0x8579d
leaq 0x3c137(%rip), %rdx     # 0x857a1
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b80
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
movq %rax, %r14
leaq 0x380b3(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b80
movslq %ebx, %rsi
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
movq %r14, %rdi
callq 0x406f0
leaq 0x37f0c(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x496ff
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4970f
movq %rax, %rbx
jmp 0x49730
jmp 0x49716
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x49730
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::restoreXmlAttributes(Element const*, unsigned int&) const
uintb AddrSpace::restoreXmlAttributes(const Element *el,uint4 &size) const

{
  uintb offset;
  int4 num = el->getNumAttributes();
  bool foundoffset = false;
  for(int4 i=0;i<num;++i) {
    if (el->getAttributeName(i)=="offset") {
      foundoffset = true;
      istringstream s1(el->getAttributeValue(i));
      s1.unsetf(ios::dec | ios::hex | ios::oct);
      s1 >> offset;
    }
    else if (el->getAttributeName(i)=="size") {
      istringstream s2(el->getAttributeValue(i));
      s2.unsetf(ios::dec | ios::hex | ios::oct);
      s2 >> size;
    }
  }
  if (!foundoffset)
    throw LowlevelError("Address is missing offset");

  return offset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, 0x8(%rsp)
movq 0x48(%rsi), %rbx
subq 0x40(%rsi), %rbx
shrq $0x5, %rbx
testl %ebx, %ebx
jle 0x49870
movq %rsi, %r14
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %r12d, %r12d
leaq 0x365a9(%rip), %r13     # 0x7fd1e
leaq 0x18(%rsp), %rbp
xorl %r15d, %r15d
movq 0x40(%r14), %rdi
addq %r12, %rdi
movq %r13, %rsi
callq 0x3f590
testl %eax, %eax
je 0x497f8
movq 0x40(%r14), %rdi
addq %r12, %rdi
leaq 0x3bfff(%rip), %rsi     # 0x8579d
callq 0x3f590
testl %eax, %eax
jne 0x49846
movq 0x58(%r14), %rsi
addq %r12, %rsi
movq %rbp, %rdi
movl $0x8, %edx
callq 0x41c80
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x30(%rsp,%rax)
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
callq 0x41eb0
movq %rbp, %rdi
movq 0x5952c(%rip), %rsi     # 0xa2d10
callq 0x41440
leaq 0x90(%rsp), %rdi
callq 0x3f730
jmp 0x49846
movq 0x58(%r14), %rsi
addq %r12, %rsi
movq %rbp, %rdi
movl $0x8, %edx
callq 0x41c80
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x30(%rsp,%rax)
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3fc90
movq %rbp, %rdi
movq 0x594df(%rip), %rsi     # 0xa2d10
callq 0x41440
leaq 0x90(%rsp), %rdi
callq 0x3f730
movb $0x1, %r15b
addq $0x20, %r12
decq %rbx
jne 0x4977d
testb $0x1, %r15b
je 0x49870
movq 0x10(%rsp), %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x35ed2(%rip), %rsi     # 0x7f75f
leaq 0x35ee4(%rip), %rdx     # 0x7f778
leaq 0x18(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x595f1(%rip), %rsi     # 0xa2ea8
movq 0x5937a(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x498e8
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x498e8
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4991a
movq %rbx, %rdi
callq 0x40080
jmp 0x4991a
jmp 0x498f9
movq %rax, %r14
movq 0x5940d(%rip), %rsi     # 0xa2d10
leaq 0x18(%rsp), %rdi
callq 0x41440
leaq 0x90(%rsp), %rdi
callq 0x3f730
movq %r14, %rdi
callq 0x41f00