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

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %rcx
movq %rsi, %rdx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq (%rdi), %rax
movl %r14d, %r8d
movl %ebp, %r9d
callq *0x10(%rax)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movslq %r14d, %rdx
notl %ebp
xorl %esi, %esi
movl %esi, %esi
cmpq %rsi, %rcx
jbe 0x54da7
movq (%rax,%rsi,8), %rdi
movl (%rdi,%rdx,4), %r8d
andl %ebp, %r8d
orl %ebx, %r8d
movl %r8d, (%rdi,%rdx,4)
incl %esi
jmp 0x54d8a
movq %rsp, %rdi
callq 0x50a60
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x50a60
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $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)
xorl %r15d, %r15d
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x54e43
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x51ba0
incq %r15
jmp 0x54e1b
movq %rsp, %rdi
callq 0x50a60
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x50a60
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x68(%rax)
movq (%rbx), %r8
movq 0x8(%rbx), %rcx
movl 0x10(%rbx), %esi
leaq (%rcx,%rsi), %rdi
leaq (%rcx,%rsi), %r10
decq %r10
movq (%rax), %r9
movq 0x8(%rax), %r11
subq %r9, %r11
sarq $0x5, %r11
addq $0x18, %r9
xorl %eax, %eax
subq $0x1, %r11
jb 0x54f13
movq -0x18(%r9), %r14
cmpq %r8, %r14
jne 0x54ece
movq -0x10(%r9), %rbx
cmpq %rbx, %rcx
jb 0x54ece
movl -0x8(%r9), %r15d
leaq (%rbx,%r15), %rdx
decq %rdx
cmpq %r10, %rdx
jae 0x54ed4
addq $0x20, %r9
jmp 0x54ea6
movq (%r9), %rax
testb $0x1, 0x24(%r14)
jne 0x54eea
cmpq %rbx, %rcx
je 0x54efc
subl %ebx, %ecx
shll $0x3, %ecx
jmp 0x54ef9
addq %r15, %rbx
cmpq %rbx, %rdi
je 0x54efc
subl %ecx, %edx
shll $0x3, %edx
movl %edx, %ecx
shrq %cl, %rax
cmpl $0x8, %esi
pushq $0x8
popq %rcx
cmovll %esi, %ecx
movslq %ecx, %rcx
movq 0x59cc1(%rip), %rdx     # 0xaebd0
andq (%rdx,%rcx,8), %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
je 0x54f75
movl %ebx, %eax
shlq $0x2, %rax
testl %ebx, %ebx
pushq $-0x1
popq %r12
cmovnsq %rax, %r12
movq %r12, %rdi
callq 0x4d060
movq %rax, %r15
movq %r12, %rdi
callq 0x4d060
movq %rax, %r12
movl 0x10(%r14), %eax
movl %ebx, %ecx
cmpl %ebx, %eax
jge 0x54fb7
movslq %eax, %rcx
movslq %ebx, %rdx
cmpq %rdx, %rcx
jge 0x54fb5
andl $0x0, (%r15,%rcx,4)
andl $0x0, (%r12,%rcx,4)
incq %rcx
jmp 0x54f61
movl 0x10(%r14), %eax
xorl %r15d, %r15d
xorl %r12d, %r12d
testl %eax, %eax
je 0x54f9e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x54f90
callq 0x50170
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x54f9e
callq 0x50170
movq %r15, (%r14)
movq %r12, 0x8(%r14)
movl %ebx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %eax, %ecx
movq (%r14), %rdx
movq 0x8(%r14), %rsi
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %edi, %ecx
cmpq %rdi, %rcx
je 0x54f7f
movl (%rdx,%rdi,4), %r8d
movl %r8d, (%r15,%rdi,4)
movl (%rsi,%rdi,4), %r8d
movl %r8d, (%r12,%rdi,4)
incq %rdi
jmp 0x54fc5
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
je 0x55012
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x55004
callq 0x50170
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x55012
callq 0x50170
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movslq 0x10(%r14), %rax
movl %eax, 0x10(%rbx)
testq %rax, %rax
je 0x55074
movq %rax, %rcx
shlq $0x2, %rcx
xorl %r13d, %r13d
testl %eax, %eax
pushq $-0x1
popq %r12
cmovnsq %rcx, %r12
movl $0x0, %ebp
cmovgl %eax, %ebp
movq %r12, %rdi
callq 0x4d060
movq %rax, %r15
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x4d060
movq %rax, 0x8(%rbx)
movq (%r14), %rcx
cmpq %r13, %rbp
je 0x55074
movl (%rcx,%r13,4), %edx
movl %edx, (%r15,%r13,4)
andl $0x0, (%rax,%r13,4)
incq %r13
jmp 0x5505d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::saveContext(std::ostream&, Address const&, unsigned int const*) const
void ContextInternal::saveContext(ostream &s,const Address &addr,
				  const uintm *vec) const
{
  s << "<context_pointset";
  addr.getSpace()->saveXmlAttributes(s,addr.getOffset() );
  s << ">\n";
  map<string,ContextBitRange>::const_iterator iter;
  for(iter=variables.begin();iter!=variables.end();++iter) {
    uintm val = (*iter).second.getValue(vec);
    s << "  <set";
    a_v(s,"name",(*iter).first);
    a_v_u(s,"val",val);
    s << "/>\n";
  }
  s << "</context_pointset>\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x31132(%rip), %rsi     # 0x861db
movq %rbx, %rdi
callq 0x4f5b0
movq (%r12), %rdi
movq 0x8(%r12), %rdx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
leaq 0x336d4(%rip), %rsi     # 0x8879e
movq %rbx, %rdi
callq 0x4f5b0
movq 0x28(%r15), %r13
addq $0x18, %r15
leaq 0x18(%rsp), %r12
leaq 0xf(%rsp), %rbp
cmpq %r15, %r13
je 0x55184
movslq 0x40(%r13), %rax
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %r14d
movb 0x4c(%r13), %cl
shrl %cl, %r14d
andl 0x50(%r13), %r14d
movq %rbx, %rdi
leaq 0x310de(%rip), %rsi     # 0x861ed
callq 0x4f5b0
movq %r12, %rdi
leaq 0x30f13(%rip), %rsi     # 0x86031
movq %rbp, %rdx
callq 0x515e0
leaq 0x20(%r13), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4dd90
movq %r12, %rdi
callq 0x4e020
movq %r12, %rdi
leaq 0x31069(%rip), %rsi     # 0x861b0
movq %rbp, %rdx
callq 0x515e0
movl %r14d, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4f410
movq %r12, %rdi
callq 0x4e020
movq %rbx, %rdi
leaq 0x32686(%rip), %rsi     # 0x877f5
callq 0x4f5b0
movq %r13, %rdi
callq 0x4fb80
movq %rax, %r13
jmp 0x550e4
leaq 0x31069(%rip), %rsi     # 0x861f4
movq %rbx, %rdi
callq 0x4f5b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x551a6
jmp 0x551ab
movq %rax, %rbx
jmp 0x551b8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f570
addq $0x18, %rbx
cmpq %rbx, %rax
je 0x5552b
addq $0x40, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x30d3a(%rip), %rsi     # 0x86277
movq %rsp, %rdi
movq %r14, %rdx
callq 0x4f1c0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x59941(%rip), %rsi     # 0xaeea0
movq 0x596d2(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
movq %rsp, %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x55583
jmp 0x5558b
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x50bc0
addq $0x18, %rbx
cmpq %rbx, %rax
je 0x555c1
addq $0x40, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x30ca4(%rip), %rsi     # 0x86277
movq %rsp, %rdi
movq %r14, %rdx
callq 0x4f1c0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x598ab(%rip), %rsi     # 0xaeea0
movq 0x5963c(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
movq %rsp, %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x55619
jmp 0x55621
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rsi, %r15
leaq 0x20(%rsp), %r12
andq $0x0, (%r12)
leaq 0x10(%rsp), %rcx
andq $0x0, (%rcx)
addq $0x40, %rdi
leaq 0xc(%rsp), %r13
movq %r12, %rdx
movq %r13, %r8
callq 0x4fe20
movl (%r13), %edx
movq (%r15), %rcx
xorl %esi, %esi
movl $0x0, %edi
cmpq %rcx, (%r12)
jne 0x55680
movq 0x28(%rsp), %rdi
movq (%rax), %rax
testb $0x1, %dl
cmoveq %rdi, %rsi
movq %rsi, (%r14)
testb $0x2, %dl
jne 0x556a3
cmpq %rcx, 0x10(%rsp)
jne 0x556a3
movq 0x18(%rsp), %rcx
decq %rcx
jmp 0x556a7
movq 0x28(%rcx), %rcx
movq %rcx, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movl %r9d, %ebx
movl %r8d, 0xc(%rsp)
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x40(%rdi), %rbp
movq %rbp, %rdi
movq %rdx, %rsi
callq 0x51190
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4df60
movq %rax, %r12
cmpq $0x0, (%r13)
je 0x55719
movq %rbp, %rdi
movq %r13, %rsi
callq 0x51190
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4df60
movq %rax, %r15
jmp 0x5571d
addq $0x48, %r15
movslq 0xc(%rsp), %rbp
cmpq %r15, %r12
je 0x55755
movq 0x30(%r12), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%r12), %r13
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x4db50
orl %ebx, (%r13,%rbp,4)
movq %r12, %rdi
callq 0x4ea10
movq %rax, %r12
jmp 0x55722
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x40(%rdi), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x51190
movq %r13, %rdi
movq %r12, %rsi
callq 0x4df60
addq $0x48, %r15
cmpq %r15, %rax
je 0x557f1
movq %rax, %r13
movq 0x30(%rax), %rax
movq %rsp, %r12
movq %rax, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x4db50
movq 0x38(%r13), %rax
movslq %ebp, %rbp
orl %ebx, (%rax,%rbp,4)
movq %r13, %rdi
callq 0x4ea10
movq %rax, %r13
cmpq %r15, %rax
je 0x557f1
movq 0x30(%r13), %rax
movq %rax, (%rsp)
movq 0x38(%r13), %rax
testl %ebx, (%rax,%rbp,4)
jne 0x557f1
movq %r14, %rdi
movq %r12, %rsi
callq 0x4db50
jmp 0x557c3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5582a
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30a58(%rip), %rsi     # 0x86297
movq %rbx, %rdi
callq 0x4f5b0
movq 0x58(%r14), %r15
leaq 0x48(%r14), %r12
cmpq %r12, %r15
je 0x55874
leaq 0x20(%r15), %rdx
movq 0x30(%r15), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x507d0
movq %r15, %rdi
callq 0x4fb80
movq %rax, %r15
jmp 0x5584f
movq 0xa0(%r14), %r15
addq $0x90, %r14
cmpq %r14, %r15
je 0x558a4
leaq 0x20(%r15), %rsi
leaq 0x30(%r15), %rdx
movq %rbx, %rdi
callq 0x502a0
movq %r15, %rdi
callq 0x4fb80
movq %rax, %r15
jmp 0x55882
leaq 0x309fe(%rip), %rsi     # 0x862a9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4f5b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x78(%rsi), %r12
leaq 0x88(%rdi), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rbp
cmpq 0x80(%r14), %r12
je 0x55992
movq (%r12), %r13
movq %r13, %rdi
leaq 0x308d8(%rip), %rsi     # 0x861dc
callq 0x520f0
testb %al, %al
je 0x5592d
movq 0x48(%r13), %rax
subq 0x40(%r13), %rax
shrq $0x5, %rax
testl %eax, %eax
je 0x5596a
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x51bd0
jmp 0x55970
movq %r13, %rdi
leaq 0x3087e(%rip), %rsi     # 0x861b5
callq 0x520f0
testb %al, %al
je 0x559a1
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x51bd0
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x4d9b0
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x4f960
jmp 0x55989
andq $0x0, 0x18(%rsp)
andq $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
leaq 0x8(%rsp), %rcx
callq 0x4d860
addq $0x8, %r12
jmp 0x558e9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x30909(%rip), %rsi     # 0x862bc
leaq 0x18(%rsp), %rdi
movq %r13, %rdx
callq 0x4f1c0
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x594c7(%rip), %rsi     # 0xaeea0
movq 0x59258(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x559ff
jmp 0x55a07
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::restoreFromSpec(Element const*, AddrSpaceManager const*)
void ContextInternal::restoreFromSpec(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_set") {
      Range range;
      range.restoreXml(subel,manage); // There MUST be a range
      Address addr1,addr2;
      addr1 = range.getFirstAddr();
      addr2 = range.getLastAddrOpen(manage);
      restoreContext(subel,addr1,addr2);
    }
    else if (subel->getName() == "tracked_set") {
      Range range;
      range.restoreXml(subel,manage); // There MUST be a range
      Address addr1,addr2;
      addr1 = range.getFirstAddr();
      addr2 = range.getLastAddrOpen(manage);
      restoreTracked(subel,manage,createSet(addr1,addr2));
    }
    else
      throw LowlevelError("Bad <context_data> tag: "+subel->getName());
    ++iter;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x78(%rsi), %rbp
leaq 0x38(%rsp), %r13
cmpq 0x80(%r14), %rbp
je 0x55b18
movq (%rbp), %r12
movq %r12, %rdi
leaq 0x3088c(%rip), %rsi     # 0x862d7
callq 0x520f0
testb %al, %al
je 0x55aa3
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x51c90
andq $0x0, 0x8(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x4d730
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x4d860
jmp 0x55b0f
movq %r12, %rdi
leaq 0x30836(%rip), %rsi     # 0x862e3
callq 0x520f0
testb %al, %al
je 0x55b27
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x51c90
andq $0x0, 0x8(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x4d730
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movq (%r15), %rax
movq %r15, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq *0x70(%rax)
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x4f960
addq $0x8, %rbp
jmp 0x55a30
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x307b6(%rip), %rsi     # 0x862ef
leaq 0x38(%rsp), %rdi
movq %r12, %rdx
callq 0x4f1c0
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x59341(%rip), %rsi     # 0xaeea0
movq 0x590d2(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x55b85
jmp 0x55b8d
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55bfb
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)
xorl %r15d, %r15d
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cltq
cmpq %rax, %r15
jge 0x55bf5
movq 0x28(%r14), %rax
movl (%rax,%r15,4), %eax
movl %eax, (%rbx,%r15,4)
incq %r15
jmp 0x55bd4
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsi), %rcx
cmpq %rcx, 0x18(%r14)
ja 0x55bb8
cmpq %rcx, 0x20(%r14)
jae 0x55bd1
jmp 0x55bb8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55c4b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4d2d0
movq (%r14), %rax
cmpq 0x10(%rbx), %rax
jne 0x55c44
movq 0x8(%r14), %rax
cmpq %rax, 0x18(%rbx)
ja 0x55c44
cmpq %rax, 0x20(%rbx)
jb 0x55c44
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55cad
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4d640
movq (%r14), %rcx
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rcx
jne 0x55c89
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
ja 0x55c89
cmpq %rcx, 0x20(%rbx)
jb 0x55c89
andq $0x0, 0x10(%rbx)
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
ja 0x55ca8
cmpq %rcx, 0x20(%rbx)
jb 0x55c9d
andq $0x0, 0x10(%rbx)
cmpq 0x8(%r14), %rax
jb 0x55ca8
andq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/include/globalcontext.hh
// Function: ContextBitRange::setValue(unsigned int*, unsigned int) const
void setValue(uintm *vec,uintm val) const {
    uintm newval = vec[word];
    newval &= ~(mask<<shift);
    newval |= ((val & mask)<<shift);
    vec[word] = newval;
  }

// Assembly:
movslq (%rdi), %rax
movl 0x10(%rdi), %r8d
movb 0xc(%rdi), %cl
andl %r8d, %edx
shll %cl, %r8d
notl %r8d
shll %cl, %edx
andl (%rsi,%rax,4), %r8d
orl %r8d, %edx
movl %edx, (%rsi,%rax,4)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rdi, %r14
cmpq $0x0, 0x28(%rdi)
je 0x55db5
movq %rcx, %r15
movq %rdx, %r13
movq %r14, %rdi
callq 0x52140
movq %rax, %r12
cmpq 0x18(%r14), %rax
je 0x55dbd
movq %r12, %rdi
callq 0x4e740
movq 0x20(%rax), %rcx
movq %rcx, (%r13)
movq 0x28(%rax), %rcx
movq %rcx, 0x8(%r13)
addq $0x8, %r14
cmpq %r14, %r12
je 0x55dd6
movq 0x20(%r12), %rcx
movq %rcx, (%r15)
movq 0x28(%r12), %rcx
movq %rcx, 0x8(%r15)
xorl %ecx, %ecx
jmp 0x55dd9
movl $0x3, (%rbx)
jmp 0x55dde
movl $0x1, (%rbx)
movq 0x20(%r12), %rax
movq %rax, (%r15)
movq 0x28(%r12), %rax
movq %rax, 0x8(%r15)
jmp 0x55dde
pushq $0x2
popq %rcx
movl %ecx, (%rbx)
movq %rax, %r14
addq $0x30, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x51b30
cmpq 0x18(%rbx), %rax
je 0x55e2d
movq %rax, %rdi
callq 0x4f720
movq %rax, %r15
movq 0x20(%rax), %rax
cmpq (%r14), %rax
jne 0x55e47
movq 0x8(%r14), %rax
cmpq %rax, 0x28(%r15)
jne 0x55e47
addq $0x30, %r15
movq %r15, %r14
jmp 0x55e64
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4d3f0
movq %rax, %r14
addq $0x30, %rbx
movq %rax, %rdi
movq %rbx, %rsi
jmp 0x55e5f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4d3f0
movq %rax, %r14
addq $0x30, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x4e6c0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4d9b0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4d9b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f110
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4f110
movq %rax, %rbx
leaq 0x30(%r14), %r12
movq %r14, %rdi
callq 0x4ea10
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x51530
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x52140
cmpq 0x18(%rbx), %rax
je 0x561aa
movq %rax, %rdi
callq 0x4e740
movq %rax, %rbx
addq $0x30, %rbx
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/include/address.hh
// Function: Address::operator<(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 (%rdi), %rcx
movq (%rsi), %rdx
cmpq %rdx, %rcx
je 0x5622b
movb $0x1, %al
testq %rcx, %rcx
je 0x5622a
cmpq $-0x1, %rcx
je 0x56237
testq %rdx, %rdx
je 0x56237
cmpq $-0x1, %rdx
je 0x5622a
movl 0x60(%rcx), %eax
cmpl 0x60(%rdx), %eax
setl %al
retq
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
setb %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %r12
pushq $0x45
popq %r13
cmpl %r13d, %r12d
jg 0x573b5
leal (%r12,%r13), %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
movl %eax, %ebp
cltq
leaq 0x2f016(%rip), %rcx     # 0x86390
movslq (%rcx,%rax,4), %r14
leaq 0x532bb(%rip), %rax     # 0xaa640
movq (%rax,%r14,8), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4fb20
testb %al, %al
je 0x5739f
incl %ebp
movl %ebp, %r12d
jmp 0x57360
movq %r15, %rdi
movq %rbx, %rsi
callq 0x52100
testb %al, %al
je 0x573b8
decl %ebp
movl %ebp, %r13d
jmp 0x57360
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_O2/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 0x573e6
leaq 0x2ef77(%rip), %rcx     # 0x86350
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0xc
jmp 0x57423
pushq $0x46
popq %rax
addl $-0x25, %edi
cmpl $0x7, %edi
ja 0x5742f
leaq 0x2ef70(%rip), %rcx     # 0x86368
movslq (%rcx,%rdi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
pushq $0x1
jmp 0x57423
pushq $0x2a
jmp 0x57423
pushq $0x2c
jmp 0x5742a
pushq $0x29
jmp 0x57423
pushq $0x2b
jmp 0x5742a
pushq $0x10
jmp 0x5742a
pushq $0xe
jmp 0x5742a
pushq $0xd
jmp 0x5742a
pushq $0xb
popq %rax
xorl %ecx, %ecx
jmp 0x5742d
pushq $0xf
popq %rax
movb $0x1, %cl
movb %cl, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, (%rsp)
movq %rsi, %r14
andq $0x0, (%rdi)
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
andl $0x0, 0x10(%rdi)
movq 0x48(%rsi), %r12
subq 0x40(%rsi), %r12
shrq $0x5, %r12
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
shlq $0x5, %r12
addq $0x20, %r12
leaq 0x2f651(%rip), %rbp     # 0x86afd
xorl %r15d, %r15d
leaq -0x20(%r15), %rbx
movq %r12, %rax
addq %rbx, %rax
je 0x5755a
movq 0x40(%r14), %rdi
addq %r13, %rdi
movq %rbp, %rsi
callq 0x520f0
testb %al, %al
jne 0x57528
leaq 0x20(%r13), %r15
addq 0x40(%r14), %r13
movq %r13, %rdi
leaq 0x2eb4d(%rip), %rsi     # 0x86031
callq 0x520f0
movq %r15, %r13
movq %rbx, %r15
testb %al, %al
je 0x574af
movq (%rsp), %rax
movq 0xa0(%rax), %rax
movq 0x18(%rax), %rdi
movq 0x58(%r14), %rsi
subq %rbx, %rsi
addq $-0x20, %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movups (%rax), %xmm0
movq 0x8(%rsp), %rcx
movups %xmm0, (%rcx)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rcx)
jmp 0x5755a
movq 0x58(%r14), %rsi
subq %r15, %rsi
movq (%rsp), %rdi
callq 0x519f0
movq 0x8(%rsp), %rbx
movq %rax, (%rbx)
testq %rax, %rax
je 0x57569
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
callq *0x48(%rcx)
movq %rax, 0x8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
movq 0x58(%r14), %rdx
subq %r15, %rdx
leaq 0x2f18f(%rip), %rsi     # 0x86711
leaq 0x18(%rsp), %rdi
callq 0x4f1c0
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x578fb(%rip), %rsi     # 0xaeea0
movq 0x5768c(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x575cb
jmp 0x575d3
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movq %rdx, %r14
movq %rdi, %rbx
movl 0x58(%rsp), %r13d
movl 0x50(%rsp), %r12d
movl 0x48(%rsp), %eax
movl %eax, (%rsp)
movl 0x40(%rsp), %ebp
movq 0x57778(%rip), %rax     # 0xaedb0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x48(%rdi), %rax
movq %rax, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movb $0x0, 0x48(%rdi)
andl $0x0, 0x20(%rdi)
leaq 0x38(%rdi), %r15
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movl %ecx, 0x8(%rdi)
movq %r15, %rdi
movq %r8, %rsi
callq 0x4e400
movl 0x4(%rsp), %eax
movl %eax, 0x58(%rbx)
movl %ebp, 0x5c(%rbx)
movl (%rsp), %eax
movl %eax, 0x60(%rbx)
movl %r13d, 0x64(%rbx)
movl %r13d, 0x68(%rbx)
movb $0x20, 0x30(%rbx)
andl $0x100, %r12d           # imm = 0x100
movl %r12d, 0x24(%rbx)
cmpb $0x1, 0x120(%r14)
jne 0x576a7
orl $0x1, %r12d
movl %r12d, 0x24(%rbx)
orl $0x6, %r12d
movl %r12d, 0x24(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4e7c0
movq %rax, %rbx
movq %r15, %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x576d1(%rip), %rax     # 0xaedb0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x48(%rdi), %rax
movq %rax, 0x38(%rdi)
andq $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
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/space.cc
// Function: AddrSpace::saveBasicAttributes(std::ostream&) const
void AddrSpace::saveBasicAttributes(ostream &s) const

{
  a_v(s,"name",name);
  a_v_i(s,"index",index);
  a_v_b(s,"bigendian",isBigEndian());
  a_v_i(s,"delay",delay);
  if (delay != deadcodedelay)
    a_v_i(s,"deadcodedelay",deadcodedelay);
  a_v_i(s,"size",addressSize);
  if (wordsize > 1) a_v_i(s,"wordsize",wordsize);
  a_v_b(s,"physical",hasPhysical());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2e901(%rip), %rsi     # 0x86031
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
leaq 0x38(%r14), %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4dd90
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x2efc5(%rip), %rsi     # 0x86726
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movslq 0x60(%r14), %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x50e20
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x2ef9a(%rip), %rsi     # 0x8672c
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movl 0x24(%r14), %edx
andl $0x1, %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4da10
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x2ef78(%rip), %rsi     # 0x8673e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movslq 0x64(%r14), %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x50e20
leaq 0x8(%rsp), %rdi
callq 0x4e020
movl 0x64(%r14), %eax
cmpl 0x68(%r14), %eax
je 0x5782b
leaq 0x2ef35(%rip), %rsi     # 0x86736
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movslq 0x68(%r14), %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x50e20
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x34f3b(%rip), %rsi     # 0x8c76d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movl 0x58(%r14), %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x50e20
leaq 0x8(%rsp), %rdi
callq 0x4e020
cmpl $0x2, 0x5c(%r14)
jb 0x57894
leaq 0x2eeda(%rip), %rsi     # 0x86744
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movl 0x5c(%r14), %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x50e20
leaq 0x8(%rsp), %rdi
callq 0x4e020
leaq 0x2eeb2(%rip), %rsi     # 0x8674d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x515e0
movl 0x24(%r14), %edx
shrl $0x8, %edx
andl $0x1, %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4da10
leaq 0x8(%rsp), %rdi
callq 0x4e020
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x578ef
jmp 0x578fe
jmp 0x578ef
jmp 0x578fe
jmp 0x578ef
jmp 0x578fe
jmp 0x578ef
jmp 0x578fe
jmp 0x578ef
jmp 0x578fe
jmp 0x578ef
jmp 0x578fe
jmp 0x578ef
jmp 0x578fe
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4e020
jmp 0x57901
movq %rax, %rbx
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2f1cc(%rip), %rsi     # 0x86afd
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x515e0
addq $0x38, %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4dd90
leaq 0x8(%rsp), %rdi
callq 0x4e020
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x4fc10
leaq 0x2ede5(%rip), %rsi     # 0x86756
movq %rax, %rdi
callq 0x4f5b0
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4ef30
leaq 0x30c31(%rip), %rsi     # 0x885bc
movq %rbx, %rdi
callq 0x4f5b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0