LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::printBounds(std::ostream&) const
void RangeList::printBounds(ostream &s) const

{
  if (tree.empty())
    s << "all" << endl;
  else {
    set<Range>::const_iterator iter;
    for(iter=tree.begin();iter!=tree.end();++iter) {
      (*iter).printBounds(s);
      s << endl;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x43cc2
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x43cbc
leaq 0x20(%r15), %rdi
movq %rbx, %rsi
callq 0x41e30
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x40750
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3f0a0
movq %rax, %rdi
callq 0x3ffd0
movq %r15, %rdi
callq 0x40bd0
movq %rax, %r15
cmpq %r14, %rax
jne 0x43c79
popq %rbx
popq %r14
popq %r15
retq
leaq 0x419f3(%rip), %rsi     # 0x856bc
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b90
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x40750
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3f0a0
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3ffd0
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::saveXml(std::ostream&) const
void RangeList::saveXml(ostream &s) const

{
  set<Range>::const_iterator iter;

  s << "<rangelist>\n";
  for(iter=tree.begin();iter!=tree.end();++iter) {
    (*iter).saveXml(s);
  }
  s << "</rangelist>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3b34a(%rip), %rsi     # 0x7f05e
movl $0xc, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x43d4a
leaq 0x20(%r15), %rdi
movq %rbx, %rsi
callq 0x416f0
movq %r15, %rdi
callq 0x40bd0
movq %rax, %r15
cmpq %r14, %rax
jne 0x43d2e
leaq 0x3b31a(%rip), %rsi     # 0x7f06b
movl $0xd, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40b90
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: sign_extend(unsigned long, int, int)
uintb sign_extend(uintb in,int4 sizein,int4 sizeout)

{
  int4 signbit;
  uintb mask;

  signbit = sizein*8 - 1;
  in &= calc_mask(sizein);
  if (sizein >= sizeout) return in;
  if ((in>>signbit) != 0) {
    mask = calc_mask(sizeout);
    uintb tmp = mask << signbit; // Split shift into two pieces
    tmp = (tmp<<1) & mask;	// In case, everything is shifted out
    in |= tmp;
  }
  return in;
}

// Assembly:
movq %rdi, %rax
cmpl $0x8, %esi
movl $0x8, %ecx
cmovll %esi, %ecx
movslq %ecx, %rcx
movq 0x5edc3(%rip), %rdi     # 0xa2bd0
andq (%rdi,%rcx,8), %rax
cmpl %edx, %esi
jge 0x43e48
leal -0x1(,%rsi,8), %ecx
movq %rax, %rsi
shrq %cl, %rsi
testq %rsi, %rsi
je 0x43e48
cmpl $0x8, %edx
movl $0x8, %esi
cmovll %edx, %esi
movslq %esi, %rdx
movq (%rdi,%rdx,8), %rdx
movq %rdx, %rsi
shlq %cl, %rsi
addq %rsi, %rsi
andq %rdx, %rsi
orq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: byte_swap(long&, int)
void byte_swap(intb &val,int4 size)

{
  intb res = 0;
  while(size>0) {
    res <<= 8;
    res |= (val&0xff);
    val >>= 8;
    size -= 1;
  }
  val = res;
}

// Assembly:
testl %esi, %esi
jle 0x43ea5
movq (%rdi), %rcx
incl %esi
xorl %eax, %eax
shlq $0x8, %rax
movzbl %cl, %edx
orq %rdx, %rax
sarq $0x8, %rcx
decl %esi
cmpl $0x1, %esi
ja 0x43e8e
jmp 0x43ea7
xorl %eax, %eax
movq %rax, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: byte_swap(unsigned long, int)
uintb byte_swap(uintb val,int4 size)

{
  uintb res=0;
  while(size>0) {
    res <<= 8;
    res |= (val&0xff);
    val >>= 8;
    size -= 1;
  }
  return res;
}

// Assembly:
testl %esi, %esi
jle 0x43eca
incl %esi
xorl %eax, %eax
shlq $0x8, %rax
movzbl %dil, %ecx
orq %rcx, %rax
shrq $0x8, %rdi
decl %esi
cmpl $0x1, %esi
ja 0x43eb3
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: leastsigbit_set(unsigned long)
int4 leastsigbit_set(uintb val)

{
  if (val==0) return -1;
  int4 res = 0;
  int4 sz = 4*sizeof(uintb);
  uintb mask = ~((uintb)0);
  do {
    mask >>= sz;
    if ((mask&val)==0) {
      res += sz;
      val >>= sz;
    }
    sz >>= 1;
  } while(sz!=0);
  return res;
}

// Assembly:
testq %rdi, %rdi
je 0x43eff
movq $-0x1, %rsi
movl $0x20, %edx
xorl %eax, %eax
movl %edx, %ecx
shrq %cl, %rsi
movl %edx, %ecx
testq %rdi, %rsi
je 0x43eee
xorl %ecx, %ecx
shrq %cl, %rdi
addl %ecx, %eax
movl %edx, %ecx
shrl %ecx
cmpl $0x1, %edx
movl %ecx, %edx
ja 0x43ee0
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: mostsigbit_set(unsigned long)
int4 mostsigbit_set(uintb val)

{
  if (val==0) return -1;
  int4 res = 8*sizeof(uintb)-1;
  int4 sz = 4*sizeof(uintb);
  uintb mask = ~((uintb)0);
  do {
    mask <<= sz;
    if ((mask&val)==0) {
      res -= sz;
      val <<= sz;
    }
    sz >>= 1;
  } while(sz != 0);
  return res;
}

// Assembly:
testq %rdi, %rdi
je 0x43f3a
movq $-0x1, %rsi
movl $0x20, %edx
movl $0x3f, %eax
movl %edx, %ecx
shlq %cl, %rsi
movl %edx, %ecx
testq %rdi, %rsi
je 0x43f29
xorl %ecx, %ecx
shlq %cl, %rdi
subl %ecx, %eax
movl %edx, %ecx
shrl %ecx
cmpl $0x1, %edx
movl %ecx, %edx
ja 0x43f1b
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: count_leading_zeros(unsigned long)
int4 count_leading_zeros(uintb val)

{
  if (val == 0)
    return 8*sizeof(uintb);
  uintb mask = ~((uintb)0);
  int4 maskSize = 4*sizeof(uintb);
  mask &= (mask << maskSize);
  int4 bit = 0;

  do {
    if ((mask & val)==0) {
      bit += maskSize;
      maskSize >>= 1;
      mask |= (mask >> maskSize);
    }
    else {
      maskSize >>= 1;
      mask &= (mask << maskSize);
    }
  } while(maskSize != 0);
  return bit;
}

// Assembly:
testq %rdi, %rdi
je 0x43f7a
xorl %eax, %eax
movl $0x20, %ecx
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
testq %rdi, %rdx
je 0x43f68
sarl %ecx
movq %rdx, %rsi
shlq %cl, %rsi
andq %rsi, %rdx
jmp 0x43f75
addl %ecx, %eax
sarl %ecx
movq %rdx, %rsi
shrq %cl, %rsi
orq %rsi, %rdx
testl %ecx, %ecx
jne 0x43f56
retq
movl $0x40, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: coveringmask(unsigned long)
uintb coveringmask(uintb val)

{
  uintb res = val;
  int4 sz = 1;
  while(sz < 8*sizeof(uintb)) {
    res = res | (res>>sz);
    sz <<= 1;
  }
  return res;
}

// Assembly:
movq %rdi, %rax
movl $0x1, %ecx
movq %rax, %rdx
shrq %cl, %rax
orq %rdx, %rax
leal (%rcx,%rcx), %edx
cmpl $0x20, %ecx
movl %edx, %ecx
jb 0x43f88
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: bit_transitions(unsigned long, int)
int4 bit_transitions(uintb val,int4 sz)

{
  int4 res = 0;
  int4 last = val & 1;
  int4 cur;
  for(int4 i=1;i<8*sz;++i) {
    val >>= 1;
    cur = val & 1;
    if (cur != last) {
      res += 1;
      last = cur;
    }
    if (val==0) break;
  }
  return res;
}

// Assembly:
testl %esi, %esi
jle 0x43fe5
shll $0x3, %esi
movl %edi, %edx
andl $0x1, %edx
cmpl $0x3, %esi
movl $0x2, %ecx
cmovgel %esi, %ecx
addl $-0x2, %ecx
xorl %eax, %eax
movl %eax, %esi
movl %edx, %r8d
movq %rdi, %r9
shrq %rdi
movl %edi, %edx
andl $0x1, %edx
xorl %eax, %eax
cmpl %r8d, %edx
setne %al
addl %esi, %eax
subl $0x1, %ecx
setb %sil
cmpq $0x2, %r9
jb 0x43fe4
testb %sil, %sil
je 0x43fb8
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::FloatFormat(int)
FloatFormat::FloatFormat(int4 sz)

{
  size = sz;

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

// Assembly:
movl %esi, (%rdi)
cmpl $0x4, %esi
je 0x446a8
cmpl $0x8, %esi
jne 0x446cc
movabsq $0x3ff0000000b, %rax    # imm = 0x3FF0000000B
movq %rax, 0x14(%rdi)
movaps 0x3aa27(%rip), %xmm0    # 0x7f0c0
movups %xmm0, 0x4(%rdi)
movb $0x1, 0x20(%rdi)
movl $0xb, %ecx
jmp 0x446cf
movabsq $0x7f00000008, %rax     # imm = 0x7F00000008
movq %rax, 0x14(%rdi)
movaps 0x3aa13(%rip), %xmm0    # 0x7f0d0
movups %xmm0, 0x4(%rdi)
movb $0x1, 0x20(%rdi)
movl $0x8, %ecx
jmp 0x446cf
movl 0x14(%rdi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
movl %eax, 0x1c(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::getHostFloat(unsigned long, FloatFormat::floatclass*) const
double FloatFormat::getHostFloat(uintb encoding,floatclass *type) const

{
  bool sgn = extractSign(encoding);
  uintb frac = extractFractionalCode(encoding);
  int4 exp = extractExponentCode(encoding);
  bool normal = true;

  if (exp == 0) {
    if ( frac == 0 ) {		// Floating point zero
      *type = zero;
      // FIXME:  add on sign-bit  for +0 or -0 allowed by standard
      return sgn ? -0.0 : +0.0;
    }
    *type = denormalized;
    // Number is denormalized
    normal = false;
  }
  else if (exp == maxexponent) {
    if ( frac == 0 ) {		// Floating point infinity
      *type = infinity;
      // FIXME: add on sign-bit for +inf or -inf allowed by standard
      return sgn ? -INFINITY : +INFINITY;
    }
    *type = nan;
    // encoding is "Not a Number" NaN
    return sgn ? -NAN : +NAN; // Sign is usually ignored
  }
  else
    *type = normalized;

  // Get "true" exponent and fractional
  exp -= bias;
  if (normal && jbitimplied) {
    frac >>= 1;			// Make room for 1 jbit
    uintb highbit = 1;
    highbit <<= 8*sizeof(uintb)-1;
    frac |= highbit;		// Stick bit in at top
  }
  return createFloat(sgn,frac,exp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rax
movb 0x4(%rdi), %cl
movb 0x8(%rdi), %sil
movl $0x1, %r14d
shlq %cl, %r14
movq %rbx, %r8
movl %esi, %ecx
shrq %cl, %r8
xorl %ecx, %ecx
subb 0xc(%rdi), %cl
shlq %cl, %r8
movb 0x10(%rdi), %cl
movq %rbx, %rdi
shrq %cl, %rdi
movb 0x14(%rax), %cl
movq $-0x1, %rsi
shlq %cl, %rsi
notl %esi
andl %esi, %edi
je 0x448fb
cmpl %edi, 0x1c(%rax)
jne 0x4490b
xorl %eax, %eax
testq %r8, %r8
je 0x4495c
testq %rbx, %r14
sete %al
movl $0x3, (%rdx)
leaq 0x3a807(%rip), %rcx     # 0x7f100
jmp 0x4496f
testq %r8, %r8
je 0x44943
movl $0x4, (%rdx)
movl 0x18(%rax), %ecx
jmp 0x44922
movl $0x0, (%rdx)
movl 0x18(%rax), %ecx
cmpb $0x1, 0x20(%rax)
jne 0x44922
shrq %r8
btsq $0x3f, %r8
shrq %r8
cvtsi2sd %r8, %xmm0
subl %ecx, %edi
addl $-0x3e, %edi
callq 0x416e0
testq %rbx, %r14
je 0x44974
xorpd 0x3a79f(%rip), %xmm0    # 0x7f0e0
jmp 0x44974
movl $0x2, (%rdx)
xorpd %xmm0, %xmm0
testq %rbx, %r14
je 0x44974
movsd 0x3a7ce(%rip), %xmm0    # 0x7f128
jmp 0x44974
testq %rbx, %r14
sete %al
movl $0x1, (%rdx)
leaq 0x3a7a1(%rip), %rcx     # 0x7f110
movsd (%rcx,%rax,8), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::getEncoding(double) const
uintb FloatFormat::getEncoding(double host) const

{
  floatclass type;
  bool sgn;
  uintb signif;
  int4 exp;

  type = extractExpSig(host,&sgn,&signif,&exp);
  if (type == zero)
    return getZeroEncoding(sgn);
  else if (type == infinity)
    return getInfinityEncoding(sgn);
  else if (type == nan)
    return getNaNEncoding(sgn);

  // convert exponent and fractional to their encodings
  exp += bias;
  if (exp < 0)			// Exponent is too small to represent
    return getZeroEncoding(sgn);
  if (exp > maxexponent)	// Exponent is too big to represent
    return getInfinityEncoding(sgn);
  if (jbitimplied && (exp !=0))
    signif <<= 1;		// Cut off top bit (which should be 1)

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x3(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x41690
movl %eax, %eax
leaq 0x3a797(%rip), %rcx     # 0x7f138
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x4(%rsp), %esi
addl 0x18(%rbx), %esi
js 0x449e2
movslq 0x1c(%rbx), %rdx
cmpl %edx, %esi
jg 0x449fe
testl %esi, %esi
setne %cl
andb 0x20(%rbx), %cl
movq 0x8(%rsp), %rdx
shlq %cl, %rdx
movb 0xc(%rbx), %al
xorl %ecx, %ecx
subb %al, %cl
shrq %cl, %rdx
movb 0x8(%rbx), %cl
shlq %cl, %rdx
movb 0x4(%rbx), %al
movl %esi, %esi
jmp 0x44a3f
movb 0x4(%rbx), %cl
movl $0x1, %edx
shlq %cl, %rdx
xorl %eax, %eax
cmpb $0x0, 0x3(%rsp)
cmovneq %rdx, %rax
jmp 0x44a60
movslq 0x1c(%rbx), %rdx
movb 0x4(%rbx), %al
movb 0x10(%rbx), %cl
shlq %cl, %rdx
movl $0x1, %esi
movl %eax, %ecx
shlq %cl, %rsi
xorl %eax, %eax
cmpb $0x0, 0x3(%rsp)
cmovneq %rsi, %rax
jmp 0x44a5d
movb 0xc(%rbx), %al
xorl %ecx, %ecx
subb %al, %cl
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movb 0x8(%rbx), %cl
shlq %cl, %rdx
movb 0x4(%rbx), %al
movslq 0x1c(%rbx), %rsi
movb 0x10(%rbx), %cl
shlq %cl, %rsi
movl $0x1, %edi
movl %eax, %ecx
shlq %cl, %rdi
xorl %eax, %eax
cmpb $0x0, 0x3(%rsp)
cmovneq %rdi, %rax
orq %rsi, %rax
orq %rdx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::opEqual(unsigned long, unsigned long) const
uintb FloatFormat::opEqual(uintb a,uintb b) const

{
  floatclass type;
  double val1 = getHostFloat(a,&type);
  double val2 = getHostFloat(b,&type);
  uintb res = (val1 == val2) ? 1 : 0;
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rdx
callq 0x40a50
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x40a50
cmpeqsd (%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::opLess(unsigned long, unsigned long) const
uintb FloatFormat::opLess(uintb a,uintb b) const

{
  floatclass type;
  double val1 = getHostFloat(a,&type);
  double val2 = getHostFloat(b,&type);
  uintb res = (val1 < val2) ? 1 : 0;
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rdx
callq 0x40a50
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x40a50
xorl %eax, %eax
ucomisd (%rsp), %xmm0
seta %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::opInt2Float(unsigned long, int) const
uintb FloatFormat::opInt2Float(uintb a,int4 sizein) const

{
  intb ival = (intb)a;
  sign_extend(ival,8*sizein-1);
  double val = (double) ival;	// Convert integer to float
  return getEncoding(val);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
leal -0x1(,%rdx,8), %esi
movq %r14, %rdi
callq 0x40550
cvtsi2sdq (%r14), %xmm0
movq %rbx, %rdi
callq 0x3f980
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/float.cc
// Function: FloatFormat::opTrunc(unsigned long, int) const
uintb FloatFormat::opTrunc(uintb a,int4 sizeout) const

{
  floatclass type;
  double val = getHostFloat(a,&type);
  intb ival = (intb) val;	// Convert to integer
  uintb res = (uintb) ival;	// Convert to unsigned
  res &= calc_mask(sizeout);	// Truncate to proper size
  return res;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
leaq 0xc(%rsp), %rdx
callq 0x40a50
cvttsd2si %xmm0, %rax
cmpl $0x8, %ebx
movl $0x8, %ecx
cmovll %ebx, %ecx
movslq %ecx, %rcx
movq 0x5dd2d(%rip), %rdx     # 0xa2bd0
andq (%rdx,%rcx,8), %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: TrackedContext::saveXml(std::ostream&) const
void TrackedContext::saveXml(ostream &s) const

{
  s << "<set";
  loc.space->saveXmlAttributes(s,loc.offset,loc.size);
  a_v_u(s,"val",val);
  s << "/>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x397e1(%rip), %rsi     # 0x7f1ef
movl $0x4, %edx
movq %rbx, %rdi
callq 0x40b90
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movl 0x10(%r14), %ecx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x40(%rax)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x39770(%rip), %rsi     # 0x7f1b0
leaq 0x3976c(%rip), %rdx     # 0x7f1b3
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movq 0x18(%r14), %r14
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
movq %rax, %r15
leaq 0x3b62c(%rip), %rsi     # 0x810b2
movl $0x4, %edx
movq %rax, %rdi
callq 0x40b90
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3ffc0
leaq 0x3bb2b(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x45ae0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x3ad2e(%rip), %rsi     # 0x80815
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b90
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x45b1a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: TrackedContext::restoreXml(Element const*, AddrSpaceManager const*)
void TrackedContext::restoreXml(const Element *el,const AddrSpaceManager *manage)

{
  int4 size;
  Address addr = Address::restoreXml(el,manage,size);
  
  istringstream s(el->getAttributeValue("val"));
  s.unsetf(ios::dec | ios::hex | ios::oct);
  s >> val;

  loc.space = addr.getSpace();
  loc.offset = addr.getOffset();
  loc.size = size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rcx
callq 0x40910
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3965d(%rip), %rsi     # 0x7f1b0
leaq 0x39659(%rip), %rdx     # 0x7f1b3
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x40f80
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x41c90
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x45b9a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x40(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x58(%rsp,%rax)
leaq 0x18(%rbx), %rsi
callq 0x3fc90
movq 0x30(%rsp), %rax
movq %rax, (%rbx)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rbx)
movq 0x5d13d(%rip), %rsi     # 0xa2d10
leaq 0x40(%rsp), %rdi
callq 0x41450
leaq 0xb8(%rsp), %rdi
callq 0x3f730
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x5d10f(%rip), %rsi     # 0xa2d10
leaq 0x40(%rsp), %rdi
callq 0x41450
leaq 0xb8(%rsp), %rdi
callq 0x3f730
jmp 0x45c39
movq %rax, %rbx
jmp 0x45c39
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x45c39
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x45d24
movq %rax, 0x8(%rbx)
movq 0x78(%r15), %rbp
cmpq 0x80(%r15), %rbp
je 0x45d91
xorps %xmm0, %xmm0
movq %rsp, %r12
movq (%rbp), %r13
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x45d63
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
movq 0x8(%rbx), %rdi
addq $0x20, %rdi
movq %rdi, 0x8(%rbx)
jmp 0x45d72
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3fa10
movq 0x8(%rbx), %rdi
addq $-0x20, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x3f870
addq $0x8, %rbp
cmpq 0x80(%r15), %rbp
xorps %xmm0, %xmm0
jne 0x45d37
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rdi, %r12
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movl (%rax), %eax
movl 0x10(%r14), %r8d
movb 0xc(%r14), %cl
shll %cl, %r8d
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq (%r12), %r9
movq %r12, %rdi
movq %r15, %rdx
movl %eax, %ecx
callq *0x18(%r9)
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x45ea0
sarq $0x3, %rax
xorl %edx, %edx
movq (%rdi,%rdx,8), %rsi
movslq (%r14), %r8
movl 0x10(%r14), %r9d
movb 0xc(%r14), %cl
movl %r9d, %r10d
shll %cl, %r10d
notl %r10d
andl (%rsi,%r8,4), %r10d
andl %ebx, %r9d
shll %cl, %r9d
orl %r10d, %r9d
movl %r9d, (%rsi,%r8,4)
incq %rdx
movl %edx, %ecx
cmpq %rcx, %rax
ja 0x45e6b
jmp 0x45ea5
testq %rdi, %rdi
je 0x45eb2
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x45ed7
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x10(%rsi)
movq (%rdi), %rax
movl %r14d, %ecx
movl %ebp, %r8d
callq *0x18(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x45f7d
sarq $0x3, %rax
movslq %r14d, %rcx
notl %ebp
xorl %edx, %edx
movq (%rdi,%rdx,8), %rsi
movl (%rsi,%rcx,4), %r8d
andl %ebp, %r8d
orl %ebx, %r8d
movl %r8d, (%rsi,%rcx,4)
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0x45f5f
jmp 0x45f82
testq %rdi, %rdi
je 0x45f8f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x45fb1
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x10(%rsi)
movq (%rdi), %rax
movl %r14d, %r8d
movl %ebp, %r9d
callq *0x10(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x46025
sarq $0x3, %rax
movslq %r14d, %rcx
notl %ebp
xorl %edx, %edx
movq (%rdi,%rdx,8), %rsi
movl (%rsi,%rcx,4), %r8d
andl %ebp, %r8d
orl %ebx, %r8d
movl %r8d, (%rsi,%rcx,4)
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0x46007
jmp 0x4602a
testq %rdi, %rdi
je 0x46037
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x46059
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextDatabase::setVariableRegion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Address const&, Address const&, unsigned int)
void ContextDatabase::setVariableRegion(const string &nm,
				     const Address &begad,
				     const Address &endad,
				     uintm value)
{
  const ContextBitRange &bitrange( getVariable(nm) );

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movl (%rax), %r8d
movl 0x10(%rax), %r9d
movb 0xc(%rax), %cl
shll %cl, %r9d
movq (%r13), %rax
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq *0x10(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x46100
sarq $0x3, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %edx, %edx
movq (%rdi,%rdx,8), %rsi
movslq (%r14), %r8
movl 0x10(%r14), %r9d
movb 0xc(%r14), %cl
movl %r9d, %r10d
shll %cl, %r10d
notl %r10d
andl (%rsi,%r8,4), %r10d
andl %ebx, %r9d
shll %cl, %r9d
orl %r10d, %r9d
movl %r9d, (%rsi,%r8,4)
incq %rdx
cmpq %rdx, %rax
jne 0x460cd
jmp 0x46105
testq %rdi, %rdi
je 0x46112
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x46139
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 (%rax), %rdi
movq 0x8(%rax), %r8
subq %rdi, %r8
je 0x461b3
movq 0x8(%rbx), %rcx
movl 0x10(%rbx), %esi
leaq (%rcx,%rsi), %r9
leaq (%rcx,%rsi), %r10
decq %r10
sarq $0x5, %r8
movq (%rbx), %r11
cmpq $0x1, %r8
adcq $0x0, %r8
addq $0x18, %rdi
xorl %eax, %eax
movq -0x18(%rdi), %r14
cmpq %r11, %r14
jne 0x461a8
movq -0x10(%rdi), %rbx
cmpq %rbx, %rcx
jb 0x461a8
movl -0x8(%rdi), %r15d
leaq (%rbx,%r15), %rdx
decq %rdx
cmpq %r10, %rdx
jae 0x461b7
addq $0x20, %rdi
decq %r8
jne 0x46186
jmp 0x461f8
xorl %eax, %eax
jmp 0x461f8
movq (%rdi), %rax
testb $0x1, 0x24(%r14)
jne 0x461cd
cmpq %rbx, %rcx
je 0x461df
subl %ebx, %ecx
shll $0x3, %ecx
jmp 0x461dc
addq %r15, %rbx
cmpq %rbx, %r9
je 0x461df
subl %ecx, %edx
shll $0x3, %edx
movl %edx, %ecx
shrq %cl, %rax
cmpl $0x8, %esi
movl $0x8, %ecx
cmovll %esi, %ecx
movslq %ecx, %rcx
movq 0x5c9dc(%rip), %rdx     # 0xa2bd0
andq (%rdx,%rcx,8), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::FreeArray::reset(int)
void ContextInternal::FreeArray::reset(int4 sz)

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
je 0x4631a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4630c
callq 0x40f10
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4631a
callq 0x40f10
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movslq 0x10(%r14), %r13
movl %r13d, 0x10(%rbx)
testq %r13, %r13
je 0x4637d
leaq (,%r13,4), %rax
testl %r13d, %r13d
movq $-0x1, %r12
cmovnsq %rax, %r12
movq %r12, %rdi
callq 0x3f060
movq %rax, %r15
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x3f060
movq %rax, 0x8(%rbx)
testl %r13d, %r13d
jle 0x4637d
movq (%r14), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
movl %esi, (%r15,%rdx,4)
movl $0x0, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %r13
jne 0x46367
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x407c0
addq $0x18, %rbx
cmpq %rbx, %rax
je 0x46a09
addq $0x40, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x3885a(%rip), %rsi     # 0x7f277
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40510
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x5c469(%rip), %rsi     # 0xa2ea8
movq 0x5c1f2(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46a6c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x46a76
jmp 0x46a7e
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x41640
addq $0x18, %rbx
cmpq %rbx, %rax
je 0x46ab3
addq $0x40, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x387b0(%rip), %rsi     # 0x7f277
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40510
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x5c3bf(%rip), %rsi     # 0xa2ea8
movq 0x5c148(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46b16
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x46b20
jmp 0x46b28
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
xorl %ebp, %ebp
leaq 0x18(%rsp), %r12
movq %rbp, (%r12)
leaq 0x8(%rsp), %rcx
movq %rbp, (%rcx)
addq $0x40, %rdi
leaq 0x4(%rsp), %r13
movq %r12, %rdx
movq %r13, %r8
callq 0x40d40
movl (%r13), %edx
movq (%r15), %rcx
movl $0x0, %esi
cmpq %rcx, (%r12)
jne 0x46b85
movq 0x20(%rsp), %rsi
movq (%rax), %rax
testb $0x1, %dl
cmoveq %rsi, %rbp
movq %rbp, (%r14)
testb $0x2, %dl
jne 0x46ba8
cmpq %rcx, 0x8(%rsp)
jne 0x46ba8
movq 0x10(%rsp), %rcx
decq %rcx
jmp 0x46bac
movq 0x28(%rcx), %rcx
movq %rcx, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::getRegionForSet(std::vector<unsigned int*, std::allocator<unsigned int*>>&, Address const&, Address const&, int, unsigned int)
void ContextInternal::getRegionForSet(vector<uintm *> &res,const Address &addr1,const Address &addr2,
				      int4 num,uintm mask)
{
  database.split(addr1);
  partmap<Address,FreeArray>::iterator aiter,biter;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rdi), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x41a20
movq 0x50(%rbx), %r12
movq %rbx, 0x10(%rsp)
addq $0x48, %rbx
movq %rbx, %r15
testq %r12, %r12
je 0x46c2e
movq %rbx, %r15
leaq 0x20(%r12), %rsi
movq %r13, %rdi
movq %rbp, %rdx
callq 0x42270
testb %al, %al
cmoveq %r12, %r15
movzbl %al, %eax
movq 0x10(%r12,%rax,8), %r12
testq %r12, %r12
jne 0x46c0b
movq 0x18(%rsp), %rbp
cmpq $0x0, (%rbp)
je 0x46c73
movq %r13, %rdi
movq %rbp, %rsi
callq 0x41a20
movq 0x10(%rsp), %rax
movq 0x50(%rax), %r12
testq %r12, %r12
je 0x46c73
leaq 0x20(%r12), %rsi
movq %r13, %rdi
movq %rbp, %rdx
callq 0x42270
testb %al, %al
cmoveq %r12, %rbx
movzbl %al, %eax
movq 0x10(%r12,%rax,8), %r12
jmp 0x46c4e
cmpq %rbx, %r15
je 0x46cc7
movslq 0x8(%rsp), %r13
leaq 0x20(%rsp), %r12
movq 0x30(%r15), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%r15), %rbp
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x46ca3
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x46cae
movq %r14, %rdi
movq %r12, %rdx
callq 0x3f4f0
movl 0xc(%rsp), %eax
orl %eax, (%rbp,%r13,4)
movq %r15, %rdi
callq 0x40040
movq %rax, %r15
cmpq %rbx, %rax
jne 0x46c82
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::getRegionToChangePoint(std::vector<unsigned int*, std::allocator<unsigned int*>>&, Address const&, int, unsigned int)
void ContextInternal::getRegionToChangePoint(vector<uintm *> &res,const Address &addr,int4 num,uintm mask)

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x4(%rsp)
movl %ecx, 0x14(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
leaq 0x40(%rdi), %rbp
movq %rbp, %rdi
movq %rdx, %rsi
callq 0x41a20
movq 0x50(%r15), %rbx
testq %rbx, %rbx
je 0x46ddc
addq $0x48, %r15
movq %r15, %r12
leaq 0x20(%rbx), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x42270
testb %al, %al
cmoveq %rbx, %r12
movzbl %al, %eax
movq 0x10(%rbx,%rax,8), %rbx
testq %rbx, %rbx
jne 0x46d19
cmpq %r15, %r12
je 0x46ddc
movq 0x30(%r12), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x46d62
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x46d6f
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x3f4f0
movq 0x38(%r12), %rax
movslq 0x14(%rsp), %rbp
movl 0x4(%rsp), %ecx
orl %ecx, (%rax,%rbp,4)
movq %r12, %rdi
callq 0x40040
cmpq %r15, %rax
je 0x46ddc
movq %rax, %r12
leaq 0x8(%rsp), %r13
movq 0x30(%r12), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%r12), %rcx
movl 0x4(%rsp), %edx
testl %edx, (%rcx,%rbp,4)
jne 0x46ddc
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x46dc1
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x46dcc
movq %r14, %rdi
movq %r13, %rdx
callq 0x3f4f0
movq %r12, %rdi
callq 0x40040
movq %rax, %r12
cmpq %r15, %rax
jne 0x46d95
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x46e16
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3846c(%rip), %rsi     # 0x7f297
movl $0x11, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x58(%r14), %r15
leaq 0x48(%r14), %r12
cmpq %r12, %r15
je 0x46e68
leaq 0x20(%r15), %rdx
movq 0x30(%r15), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41350
movq %r15, %rdi
callq 0x40bd0
movq %rax, %r15
cmpq %r12, %rax
jne 0x46e45
movq 0xa0(%r14), %r15
addq $0x90, %r14
cmpq %r14, %r15
je 0x46e9b
leaq 0x20(%r15), %rsi
leaq 0x30(%r15), %rdx
movq %rbx, %rdi
callq 0x40fc0
movq %r15, %rdi
callq 0x40bd0
movq %rax, %r15
cmpq %r14, %rax
jne 0x46e7b
leaq 0x38407(%rip), %rsi     # 0x7f2a9
movl $0x12, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40b90
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/globalcontext.cc
// Function: ContextInternal::restoreXml(Element const*, AddrSpaceManager const*)
void ContextInternal::restoreXml(const Element *el,const AddrSpaceManager *manage)

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, (%rsp)
movq 0x78(%rsi), %r13
cmpq 0x80(%rsi), %r13
je 0x46fa4
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsp), %rax
leaq 0x88(%rax), %r12
leaq 0x18(%rsp), %rbp
movq (%r13), %r15
movq %r15, %rdi
leaq 0x382db(%rip), %rsi     # 0x7f1dc
callq 0x3f590
testl %eax, %eax
je 0x46f4a
movq %r15, %rdi
leaq 0x382a1(%rip), %rsi     # 0x7f1b5
callq 0x3f590
testl %eax, %eax
jne 0x46fb3
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x42120
movq %r12, %rdi
movq %rbp, %rsi
callq 0x3f5f0
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40a80
jmp 0x46f93
movq 0x48(%r15), %rax
subq 0x40(%r15), %rax
shrq $0x5, %rax
testl %eax, %eax
je 0x46f73
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x42120
movq $0x0, 0x8(%rsp)
jmp 0x46f7f
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
leaq 0x8(%rsp), %rcx
callq 0x3f520
addq $0x8, %r13
cmpq 0x80(%r14), %r13
jne 0x46ef3
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x382f5(%rip), %rsi     # 0x7f2bc
leaq 0x18(%rsp), %rdi
movq %r15, %rdx
callq 0x40510
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x5bebb(%rip), %rsi     # 0xa2ea8
movq 0x5bc44(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4701a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x47024
jmp 0x4702c
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x47250
movq %rax, 0x10(%r14)
movq (%r14), %rdi
leaq 0x18(%r14), %rdx
leaq 0x20(%r14), %rcx
movq (%rdi), %rax
callq *0x58(%rax)
movq %rax, 0x28(%r14)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testl %eax, %eax
jle 0x4724a
xorl %r15d, %r15d
movq 0x28(%r14), %rax
movl (%rax,%r15,4), %eax
movl %eax, (%rbx,%r15,4)
incq %r15
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cltq
cmpq %rax, %r15
jl 0x4722b
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsi), %rcx
cmpq %rcx, 0x18(%r14)
ja 0x47202
cmpq %rcx, 0x20(%r14)
jae 0x4721b
jmp 0x47202
// File: /workspace/github_cpp_makefile_star2_O3/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 0x472a2
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3f200
movq (%r14), %rax
cmpq 0x10(%rbx), %rax
jne 0x4729b
movq 0x8(%r14), %rax
cmpq %rax, 0x18(%rbx)
ja 0x4729b
cmpq %rax, 0x20(%rbx)
jb 0x4729b
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop