LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextDatabase::restoreTracked(Element const*, AddrSpaceManager const*, std::vector<TrackedContext, std::allocator<TrackedContext>>&)
void ContextDatabase::restoreTracked(const Element *el,const AddrSpaceManager *manage,
				     TrackedSet &vec)

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

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

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xd3640
movq 0x60(%rsp), %rdi
callq 0xde930
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xd4960
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0xd7a70
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd72b0
testb $0x1, %al
jne 0xeadef
jmp 0xeae56
leaq 0x40(%rsp), %rdi
callq 0xddc90
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd36e0
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xdc960
movq 0x50(%rsp), %rdi
callq 0xd0310
movq %rax, %rdi
movq 0x30(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xd1990
leaq 0x40(%rsp), %rdi
callq 0xd0700
jmp 0xeadcb
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextDatabase::setVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Address const&, unsigned int)
void ContextDatabase::setVariable(const string &nm,const Address &addr,
			       uintm value)
{
  const ContextBitRange &bitrange( getVariable(nm) );
  int4 num = bitrange.getWord();
  uintm mask = bitrange.getMask()<<bitrange.getShift();

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

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x78(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0xcf7a0
movl %eax, 0x5c(%rsp)
movq 0x60(%rsp), %rdi
callq 0xd3af0
movl %eax, 0x1c(%rsp)
movq 0x60(%rsp), %rdi
callq 0xdf3e0
movl %eax, %ecx
movl 0x1c(%rsp), %eax
shll %cl, %eax
movl %eax, 0x58(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xd3f20
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x70(%rsp), %rdx
movl 0x5c(%rsp), %ecx
movl 0x58(%rsp), %r8d
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0xeafb0
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xce5b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xeb02e
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x30(%rsp), %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0xdc850
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
movl 0x6c(%rsp), %edx
callq 0xe17e0
jmp 0xeb005
jmp 0xeb007
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xeafb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xdd240
jmp 0xeb040
leaq 0x40(%rsp), %rdi
callq 0xdd240
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movl %ecx, 0x60(%rsp)
movl %r8d, 0x5c(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd3f20
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x68(%rsp), %rdx
movl 0x64(%rsp), %ecx
movl 0x60(%rsp), %r8d
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0xeb107
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xce5b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xeb1ae
movl 0x30(%rsp), %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0xdc850
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movslq 0x64(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x24(%rsp)
movl 0x60(%rsp), %eax
xorl $-0x1, %eax
andl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x5c(%rsp), %eax
orl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %rax
movslq 0x64(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xeb10f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xdd240
jmp 0xeb1bd
leaq 0x40(%rsp), %rdi
callq 0xdd240
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movl %r8d, 0x58(%rsp)
movl %r9d, 0x54(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xd3f20
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rcx
movl 0x5c(%rsp), %r8d
movl 0x58(%rsp), %r9d
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xeb233
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xce5b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xeb2cd
movl 0x28(%rsp), %eax
movl %eax, %esi
leaq 0x38(%rsp), %rdi
callq 0xdc850
movq (%rax), %rax
movslq 0x5c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl 0x58(%rsp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
orl 0x54(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x28(%rsp), %eax
movl %eax, %esi
leaq 0x38(%rsp), %rdi
callq 0xdc850
movl 0xc(%rsp), %edx
movq (%rax), %rax
movslq 0x5c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xeb23b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xdd240
jmp 0xeb2dc
leaq 0x38(%rsp), %rdi
callq 0xdd240
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movl %r8d, 0x74(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x88(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, 0x68(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd3f20
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rdi
callq 0xcf7a0
movl %eax, 0x3c(%rsp)
jmp 0xeb36c
movq 0x68(%rsp), %rdi
callq 0xd3af0
movl %eax, 0x1c(%rsp)
jmp 0xeb37c
movq 0x68(%rsp), %rdi
callq 0xdf3e0
movl %eax, 0x18(%rsp)
jmp 0xeb38c
movl 0x3c(%rsp), %r8d
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %r9d
movl 0x18(%rsp), %eax
movb %al, %cl
shll %cl, %r9d
movq 0x30(%rsp), %rcx
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq 0x50(%rsp), %rsi
callq *%rax
jmp 0xeb3be
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xce5b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xeb43c
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x40(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xdc850
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
movl 0x74(%rsp), %edx
callq 0xe17e0
jmp 0xeb413
jmp 0xeb415
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0xeb3c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xdd240
jmp 0xeb44e
leaq 0x50(%rsp), %rdi
callq 0xdd240
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xe0be0
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x40(%rsp), %rcx
movl 0x10(%rcx), %ecx
addq %rcx, %rax
subq $0x1, %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0xdbd60
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xeb5fc
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xd8c50
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rsp), %rcx
cmpq (%rcx), %rax
je 0xeb4fb
jmp 0xeb5ec
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x40(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0xeb514
jmp 0xeb5ec
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
addq %rcx, %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0xeb542
jmp 0xeb5ec
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xddec0
testb $0x1, %al
jne 0xeb563
jmp 0xeb590
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0xeb58e
movq 0x20(%rsp), %rcx
movq 0x40(%rsp), %rax
subq 0x8(%rax), %rcx
shlq $0x3, %rcx
movq 0x8(%rsp), %rax
shrq %cl, %rax
movq %rax, 0x8(%rsp)
jmp 0xeb5c9
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
je 0xeb5c7
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
subq 0x8(%rax), %rcx
shlq $0x3, %rcx
movq 0x8(%rsp), %rax
shrq %cl, %rax
movq %rax, 0x8(%rsp)
jmp 0xeb5c9
movq 0x40(%rsp), %rax
movl 0x10(%rax), %edi
callq 0xcfa60
andq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xeb605
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xeb4ad
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0xeb756
movslq 0x3c(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xce140
movq %rax, 0x30(%rsp)
movslq 0x3c(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xce140
movq 0x10(%rsp), %rcx
movq %rax, 0x28(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x10(%rcx), %eax
jle 0xeb6f7
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0xeb6f5
movq 0x30(%rsp), %rax
movslq 0x20(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movq 0x28(%rsp), %rax
movslq 0x20(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xeb6bc
jmp 0xeb6ff
movl 0x3c(%rsp), %eax
movl %eax, 0x24(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0xeb754
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movslq 0x1c(%rsp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x30(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x8(%rax), %rax
movslq 0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xeb707
jmp 0xeb756
movq 0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0xeb79c
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xeb77e
movq 0x8(%rsp), %rdi
callq 0xdb380
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xeb79a
movq (%rsp), %rdi
callq 0xdb380
jmp 0xeb79c
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x3c(%rsp), %ecx
movl %ecx, 0x10(%rax)
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x10(%rax)
je 0xeb81b
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xeb7fb
movq 0x10(%rsp), %rdi
callq 0xdb380
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xeb819
movq 0x8(%rsp), %rdi
callq 0xdb380
jmp 0xeb81b
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq 0x28(%rsp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
je 0xeb8ff
movq 0x18(%rsp), %rax
movslq 0x10(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xce140
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movslq 0x10(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xce140
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0xeb8fd
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x24(%rsp), %rdx
movl (%rcx,%rdx,4), %esi
movq (%rax), %rcx
movslq 0x24(%rsp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x8(%rax), %rax
movslq 0x24(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xeb8b2
jmp 0xeb8ff
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xdea20
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x58(%rsp), %rsi
callq 0xd56a0
movq 0x8(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
addq $0x10, %rdi
callq 0xdbc60
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd92f0
testb $0x1, %al
jne 0xec3ef
jmp 0xec484
movb $0x1, 0x13(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
movq 0x58(%rsp), %rdx
leaq 0x9ae9a(%rip), %rsi     # 0x1872a8
leaq 0x20(%rsp), %rdi
callq 0xd7370
jmp 0xec41a
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd1ae0
jmp 0xec42a
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
movq 0xdba56(%rip), %rsi     # 0x1c7e90
movq 0xdb78f(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0xec4a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0xec470
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x13(%rsp)
jne 0xec479
jmp 0xec482
movq (%rsp), %rdi
callq 0xd5400
jmp 0xec497
leaq 0x50(%rsp), %rdi
callq 0xd4ce0
addq $0x20, %rax
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd7380
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x58(%rsp), %rsi
callq 0xdcc80
movq 0x8(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
addq $0x10, %rdi
callq 0xd8700
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xcf850
testb $0x1, %al
jne 0xec51f
jmp 0xec5b4
movb $0x1, 0x13(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
movq 0x58(%rsp), %rdx
leaq 0x9ad6a(%rip), %rsi     # 0x1872a8
leaq 0x20(%rsp), %rdi
callq 0xd7370
jmp 0xec54a
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd1ae0
jmp 0xec55a
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
movq 0xdb926(%rip), %rsi     # 0x1c7e90
movq 0xdb65f(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0xec5d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0xec5a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd4550
testb $0x1, 0x13(%rsp)
jne 0xec5a9
jmp 0xec5b2
movq (%rsp), %rdi
callq 0xd5400
jmp 0xec5c7
leaq 0x50(%rsp), %rdi
callq 0xdf500
addq $0x20, %rax
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xe1dc0
leaq 0x20(%rsp), %rdi
callq 0xe1dc0
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
movq 0x58(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x44(%rsp), %r8
callq 0xda670
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x44(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xec672
leaq 0x30(%rsp), %rdi
callq 0xd9cf0
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0xd9cf0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0xec680
movq 0x50(%rsp), %rax
movq $0x0, (%rax)
jmp 0xec695
leaq 0x30(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
movl 0x44(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xec6c5
leaq 0x20(%rsp), %rdi
callq 0xd9cf0
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
callq 0xd9cf0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
je 0xec6e4
movq 0x58(%rsp), %rdi
callq 0xd9cf0
movq %rax, %rdi
callq 0xdd9c0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
jmp 0xec6fd
leaq 0x20(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
subq $0x1, %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movl %r9d, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x40, %rdi
movq 0x50(%rsp), %rsi
callq 0xdf120
leaq 0x38(%rsp), %rdi
callq 0xd6e40
leaq 0x30(%rsp), %rdi
callq 0xd6e40
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x50(%rsp), %rsi
callq 0xdb290
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0xce5a0
testb $0x1, %al
jne 0xec7c1
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x48(%rsp), %rsi
callq 0xdf120
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x48(%rsp), %rsi
callq 0xdb290
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xec7dd
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0xcf8e0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xec7df
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xdd030
testb $0x1, %al
jne 0xec7f4
jmp 0xec849
leaq 0x38(%rsp), %rdi
callq 0xdfe40
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xdfe40
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd0fc0
movl 0x40(%rsp), %edx
movq 0x8(%rsp), %rax
movslq 0x44(%rsp), %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
leaq 0x38(%rsp), %rdi
callq 0xd0860
jmp 0xec7df
addq $0x68, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movl %r8d, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x40, %rdi
movq 0x40(%rsp), %rsi
callq 0xdf120
leaq 0x30(%rsp), %rdi
callq 0xd6e40
leaq 0x28(%rsp), %rdi
callq 0xd6e40
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x40(%rsp), %rsi
callq 0xdb290
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0x40, %rdi
callq 0xcf8e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xce820
testb $0x1, %al
jne 0xec8e9
jmp 0xec8ee
jmp 0xec9af
leaq 0x30(%rsp), %rdi
callq 0xdfe40
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd0fc0
leaq 0x30(%rsp), %rdi
callq 0xdfe40
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movl 0x38(%rsp), %edx
movq 0x20(%rsp), %rax
movslq 0x3c(%rsp), %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
leaq 0x30(%rsp), %rdi
callq 0xd0860
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xdd030
testb $0x1, %al
jne 0xec956
jmp 0xec9af
leaq 0x30(%rsp), %rdi
callq 0xdfe40
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xdfe40
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movslq 0x3c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
andl 0x38(%rsp), %eax
cmpl $0x0, %eax
je 0xec994
jmp 0xec9af
movq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd0fc0
leaq 0x30(%rsp), %rdi
callq 0xd0860
jmp 0xec941
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x40, %rdi
callq 0xe2b40
testb $0x1, %al
jne 0xeca37
jmp 0xeca53
movq 0x20(%rsp), %rdi
addq $0x88, %rdi
callq 0xdb620
testb $0x1, %al
jne 0xeca4e
jmp 0xeca53
jmp 0xecbcb
movq 0x68(%rsp), %rdi
leaq 0x9a869(%rip), %rsi     # 0x1872c8
callq 0xd8300
leaq 0x60(%rsp), %rdi
callq 0xd1040
leaq 0x58(%rsp), %rdi
callq 0xd1040
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
callq 0xdd780
movq 0x20(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
addq $0x40, %rdi
callq 0xdf140
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xce710
testb $0x1, %al
jne 0xecac7
jmp 0xecb0e
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd4220
movq %rax, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd4220
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rax), %rcx
callq 0xdc940
leaq 0x60(%rsp), %rdi
callq 0xcf410
jmp 0xecab2
leaq 0x40(%rsp), %rdi
callq 0xd2d70
leaq 0x38(%rsp), %rdi
callq 0xd2d70
movq 0x20(%rsp), %rdi
addq $0x88, %rdi
callq 0xdd660
movq 0x20(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
addq $0x88, %rdi
callq 0xd8440
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd8710
testb $0x1, %al
jne 0xecb77
jmp 0xecbba
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0xda0e0
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xda0e0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
addq $0x10, %rdx
callq 0xdb890
leaq 0x40(%rsp), %rdi
callq 0xd22c0
jmp 0xecb62
movq 0x68(%rsp), %rdi
leaq 0x9a714(%rip), %rsi     # 0x1872da
callq 0xd8300
addq $0x78, %rsp
retq
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd9cf0
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xed2cc
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
ja 0xed2cc
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xed304
movq 0x38(%rsp), %rdi
callq 0xd9cf0
movq 0x20(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq (%rcx), %rdi
movq 0x38(%rsp), %rsi
movq %rcx, %rdx
addq $0x18, %rdx
addq $0x20, %rcx
movq (%rdi), %rax
callq *0x58(%rax)
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rax
movl 0x2c(%rsp), %ecx
movl %ecx, 0xc(%rsp)
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0xed357
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xed30c
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x8(%rax)
jne 0xed390
jmp 0xed419
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
movl 0x20(%rsp), %ecx
movl 0x1c(%rsp), %r8d
callq 0xcebb0
movq 0x28(%rsp), %rdi
callq 0xd9cf0
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xed419
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
ja 0xed419
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jb 0xed419
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl %r8d, 0x48(%rsp)
movl %r9d, 0x44(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
testb $0x1, 0x8(%rax)
jne 0xed456
jmp 0xed595
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movl 0x4c(%rsp), %ecx
movl 0x48(%rsp), %r8d
movl 0x44(%rsp), %r9d
callq 0xcfb10
movq 0x58(%rsp), %rdi
callq 0xd9cf0
movq 0x38(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xed4e7
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
ja 0xed4e7
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jb 0xed4e7
movq 0x38(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
ja 0xed53e
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jb 0xed53e
movq 0x38(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jb 0xed595
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0xe03b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
ja 0xed595
movq 0x38(%rsp), %rax
movq $0x0, 0x10(%rax)
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rcx
movq %rcx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movslq (%rcx), %rdx
movl (%rax,%rdx,4), %eax
movl %eax, -0x18(%rsp)
movl 0x10(%rcx), %eax
movl 0xc(%rcx), %ecx
shll %cl, %eax
movq -0x20(%rsp), %rcx
xorl $-0x1, %eax
andl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x14(%rsp), %eax
andl 0x10(%rcx), %eax
movl 0xc(%rcx), %ecx
shll %cl, %eax
movq -0x20(%rsp), %rcx
orl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %edx
movq -0x10(%rsp), %rax
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
retq
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd7e20
testb $0x1, %al
jne 0xedc32
jmp 0xedc50
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
movl $0x3, (%rcx)
addq $0x30, %rax
movq %rax, 0x60(%rsp)
jmp 0xedd6c
leaq 0x30(%rsp), %rdi
callq 0xd1040
leaq 0x28(%rsp), %rdi
callq 0xd1040
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xdd080
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0xdb820
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xce710
testb $0x1, %al
jne 0xedca9
jmp 0xedd3c
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xda820
leaq 0x30(%rsp), %rdi
callq 0xd4220
movq %rax, %rsi
movq 0x48(%rsp), %rdi
callq 0xdafc0
movq 0x8(%rsp), %rdi
callq 0xd2850
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xde360
testb $0x1, %al
jne 0xedcf8
jmp 0xedd05
movq 0x38(%rsp), %rax
movl $0x2, (%rax)
jmp 0xedd27
leaq 0x28(%rsp), %rdi
callq 0xd4220
movq %rax, %rsi
movq 0x40(%rsp), %rdi
callq 0xdafc0
movq 0x38(%rsp), %rax
movl $0x0, (%rax)
leaq 0x30(%rsp), %rdi
callq 0xd4220
addq $0x10, %rax
movq %rax, 0x60(%rsp)
jmp 0xedd6c
movq 0x38(%rsp), %rax
movl $0x1, (%rax)
leaq 0x28(%rsp), %rdi
callq 0xd4220
movq %rax, %rsi
movq 0x40(%rsp), %rdi
callq 0xdafc0
movq 0x8(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd6e40
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xdabe0
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0xd4980
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xdd030
testb $0x1, %al
jne 0xedde1
jmp 0xede57
leaq 0x28(%rsp), %rdi
callq 0xe1340
leaq 0x28(%rsp), %rdi
callq 0xdfe40
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0xdc0d0
testb $0x1, %al
jne 0xede08
jmp 0xede1d
leaq 0x28(%rsp), %rdi
callq 0xdfe40
addq $0x10, %rax
movq %rax, 0x40(%rsp)
jmp 0xede86
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xcf0e0
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xdfe40
movq %rax, %rsi
addq $0x10, %rsi
movq 0x10(%rsp), %rdi
callq 0xd4180
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xede86
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xcf0e0
movq (%rsp), %rsi
movq %rax, 0x8(%rsp)
addq $0x30, %rsi
movq 0x8(%rsp), %rdi
callq 0xd4180
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x48(%rsp), %rsi
callq 0xd08e0
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xd08e0
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xcecf0
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rsi
callq 0xcecf0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd3e30
addq $0x10, %rax
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xe0910
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xe2a50
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe2a50
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xd1610
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0xd1040
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdd080
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0xdb820
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xde360
testb $0x1, %al
jne 0xef251
jmp 0xef260
movq (%rsp), %rax
addq $0x30, %rax
movq %rax, 0x30(%rsp)
jmp 0xef27d
leaq 0x18(%rsp), %rdi
callq 0xda820
leaq 0x18(%rsp), %rdi
callq 0xd4220
addq $0x10, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
je 0xef5ad
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xef52e
movb $0x1, 0x27(%rsp)
jmp 0xef5e3
movq 0x8(%rsp), %rax
movq $-0x1, %rcx
cmpq %rcx, (%rax)
jne 0xef549
movb $0x0, 0x27(%rsp)
jmp 0xef5e3
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xef55e
movb $0x0, 0x27(%rsp)
jmp 0xef5e3
movq 0x10(%rsp), %rax
movq $-0x1, %rcx
cmpq %rcx, (%rax)
jne 0xef576
movb $0x1, 0x27(%rsp)
jmp 0xef5e3
jmp 0xef578
jmp 0xef57a
jmp 0xef57c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xd89c0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xd89c0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xef5e3
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
je 0xef5de
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
setb %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xef5e3
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movl $0x45, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jg 0xf4fe9
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rcx
leaq 0x92499(%rip), %rax     # 0x187410
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movslq 0x8(%rsp), %rcx
leaq 0xdd9f6(%rip), %rax     # 0x1d2980
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
callq 0xd9d50
testb $0x1, %al
jne 0xf4f9e
jmp 0xf4fab
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xf4fe4
movslq 0x8(%rsp), %rcx
leaq 0xdd9c9(%rip), %rax     # 0x1d2980
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
callq 0xe3110
testb $0x1, %al
jne 0xf4fcb
jmp 0xf4fd8
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xf4fe2
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xf4ff1
jmp 0xf4fe4
jmp 0xf4f49
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
movl %edi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl -0x8(%rsp), %eax
addl $-0xb, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x21, %eax
ja 0xf5107
movq -0x18(%rsp), %rax
leaq 0x92354(%rip), %rcx     # 0x187380
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rsp), %rax
movb $0x0, (%rax)
movl $0xc, -0x4(%rsp)
jmp 0xf5111
movq -0x10(%rsp), %rax
movb $0x0, (%rax)
movl $0xb, -0x4(%rsp)
jmp 0xf5111
movq -0x10(%rsp), %rax
movb $0x1, (%rax)
movl $0xe, -0x4(%rsp)
jmp 0xf5111
movq -0x10(%rsp), %rax
movb $0x1, (%rax)
movl $0xd, -0x4(%rsp)
jmp 0xf5111
movq -0x10(%rsp), %rax
movb $0x1, (%rax)
movl $0x10, -0x4(%rsp)
jmp 0xf5111
movq -0x10(%rsp), %rax
movb $0x1, (%rax)
movl $0xf, -0x4(%rsp)
jmp 0xf5111
movq -0x10(%rsp), %rax
movb $0x0, (%rax)
movl $0x1, -0x4(%rsp)
jmp 0xf5111
movq -0x10(%rsp), %rax
movb $0x0, (%rax)
movl $0x2a, -0x4(%rsp)
jmp 0xf5111
movq -0x10(%rsp), %rax
movb $0x0, (%rax)
movl $0x29, -0x4(%rsp)
jmp 0xf5111
movq -0x10(%rsp), %rax
movb $0x1, (%rax)
movl $0x2c, -0x4(%rsp)
jmp 0xf5111
movq -0x10(%rsp), %rax
movb $0x1, (%rax)
movl $0x2b, -0x4(%rsp)
jmp 0xf5111
jmp 0xf5109
movl $0x46, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)