LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: DecisionNode::consistentValues(std::vector<unsigned int, std::allocator<unsigned int>>&, DisjointPattern*)
void DecisionNode::consistentValues(vector<uint4> &bins,DisjointPattern *pat)

{				// Produce all possible values of -pat- by
				// iterating through all possible values of the
				// "don't care" bits within the value of -pat-
				// that intersects with this node (startbit,bitsize,context)
  uintm m = (bitsize==8*sizeof(uintm)) ? 0 : (((uintm)1)<<bitsize);
  m = m-1;
  uintm commonMask = m & pat->getMask(startbit,bitsize,contextdecision);
  uintm commonValue = commonMask & pat->getValue(startbit,bitsize,contextdecision);
  uintm dontCareMask = m^commonMask;

  for(uintm i=0;i<=dontCareMask;++i) { // Iterate over values that contain all don't care bits
    if ((i&dontCareMask)!=i) continue; // If all 1 bits in the value are don't cares
    bins.push_back( commonValue | i ); // add 1 bits into full value and store
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl 0x38(%rdi), %esi
movl 0x3c(%rdi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
shll %cl, %r12d
cmpl $0x20, %ecx
notl %r12d
cmovel %eax, %r12d
movzbl 0x34(%rdi), %eax
movq %rdx, %rdi
movl %ecx, %edx
movl %eax, %ecx
callq 0x421d0
movl %eax, %ebp
andl %r12d, %ebp
movl 0x38(%r15), %esi
movl 0x3c(%r15), %edx
movzbl 0x34(%r15), %ecx
movq %r14, %rdi
callq 0x40c10
movl %eax, %r14d
andl %ebp, %r14d
xorl %r12d, %ebp
xorl %r12d, %r12d
movl %ebp, %r13d
notl %r13d
leaq 0x4(%rsp), %r15
testl %r13d, %r12d
jne 0x6cb8b
movl %r12d, %eax
orl %r14d, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6cb80
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6cb8b
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3f740
incl %r12d
cmpl %ebp, %r12d
jbe 0x6cb5b
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/slghsymbol.cc
// Function: DecisionNode::resolve(ParserWalker&) const
Constructor *DecisionNode::resolve(ParserWalker &walker) const

{
  if (bitsize == 0) {		// The node is terminal
    vector<pair<DisjointPattern *,Constructor *> >::const_iterator iter;
    for(iter=list.begin();iter!=list.end();++iter)
      if ((*iter).first->isMatch(walker))
	return (*iter).second;
    ostringstream s;
    s << walker.getAddr().getShortcut();
    walker.getAddr().printRaw(s);
    s << ": Unable to resolve constructor";
    throw BadDataError(s.str());
  }
  uintm val;
  if (contextdecision)
    val = walker.getContextBits(startbit,bitsize);
  else
    val = walker.getInstructionBits(startbit,bitsize);
  return children[val]->resolve(walker);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %rbx
movq %rdi, %r14
movl 0x3c(%rdi), %edx
testl %edx, %edx
je 0x6cf4d
movl 0x38(%r14), %esi
movq (%rbx), %rdi
cmpb $0x1, 0x34(%r14)
jne 0x6cf31
callq 0x41880
jmp 0x6cf3d
movq 0x10(%rbx), %rax
movl 0x64(%rax), %ecx
callq 0x3f9b0
movl %eax, %eax
movq 0x18(%r14), %rcx
movq (%rcx,%rax,8), %r14
movl 0x3c(%r14), %edx
jmp 0x6cf18
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x6cf7e
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
testb %al, %al
jne 0x6cf6c
addq $0x10, %r15
jmp 0x6cf50
movq 0x8(%r15), %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x41120
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x6cf97
movq (%rbx), %rax
movq 0x50(%rax), %rax
movb 0x30(%rax), %al
movq %rsp, %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x40b90
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
jne 0x6cfbc
movq (%rbx), %rdi
addq $0x50, %rdi
leaq 0x20(%rsp), %rsi
callq 0x407f0
leaq 0x14737(%rip), %rsi     # 0x81708
leaq 0x20(%rsp), %rdi
movl $0x1f, %edx
callq 0x40b90
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x418c0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x35b3f(%rip), %rsi     # 0xa2b50
movq 0x35c20(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d03e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x6d048
jmp 0x6d055
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
jmp 0x6d055
movq %rax, %r14
movq 0x35d24(%rip), %rsi     # 0xa2d80
leaq 0x20(%rsp), %rdi
callq 0x3fc30
leaq 0x90(%rsp), %rdi
callq 0x3f730
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: calc_maskword(int, int, int&, int&, unsigned int&)
static void calc_maskword(int4 sbit,int4 ebit,int4 &num,int4 &shift,uintm &mask)

{
  num = sbit/(8*sizeof(uintm));
  if ( num != ebit/(8*sizeof(uintm)))
    throw SleighError("Context field not contained within one machine int");
  sbit -= num*8*sizeof(uintm);
  ebit -= num*8*sizeof(uintm);

  shift = 8*sizeof(uintm)-ebit-1;
  mask = (~((uintm)0))>>(sbit+shift);
  mask <<= shift;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rax
movl %edi, %ecx
sarl $0x5, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
movslq %esi, %rdx
shrq $0x5, %rdx
cmpq %rcx, %rdx
jne 0x6d10e
movl %edi, %ecx
andl $-0x20, %ecx
andl $0x1f, %edi
subl %esi, %ecx
leal 0x1f(%rcx), %edx
addl %edi, %ecx
addl $0x1f, %ecx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
shrl %cl, %esi
movl %edx, (%rax)
movl %esi, (%r8)
movb (%rax), %cl
shll %cl, %esi
movl %esi, (%r8)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x146ba(%rip), %rsi     # 0x817e5
leaq 0x146e5(%rip), %rdx     # 0x81817
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x35d3b(%rip), %rsi     # 0xa2e90
movq 0x35adc(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6d17e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x6d188
jmp 0x6d190
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/slghsymbol.cc
// Function: ContextOp::saveXml(std::ostream&) const
void ContextOp::saveXml(ostream &s) const

{
  s << "<context_op";
  s << " i=\"" << dec << num << "\"";
  s << " shift=\"" << shift << "\"";
  s << " mask=\"0x" << hex << mask << "\" >\n";
  patexp->saveXml(s);
  s << "</context_op>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1446a(%rip), %rsi     # 0x817ac
movl $0xb, %edx
movq %rbx, %rdi
callq 0x40b90
leaq 0x14462(%rip), %rsi     # 0x817b8
movl $0x4, %edx
movq %rbx, %rdi
callq 0x40b90
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x41db0
leaq 0x1425c(%rip), %r15     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b90
leaq 0x13469(%rip), %rsi     # 0x8080b
movl $0x8, %edx
movq %rbx, %rdi
callq 0x40b90
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x41db0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x40b90
leaq 0x143eb(%rip), %rsi     # 0x817bd
movl $0x9, %edx
movq %rbx, %rdi
callq 0x40b90
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movl 0x14(%r14), %esi
movq %rbx, %rdi
callq 0x3ffc0
leaq 0x143c0(%rip), %rsi     # 0x817c7
movl $0x4, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
leaq 0x143a4(%rip), %rsi     # 0x817cc
movl $0xe, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40b90
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextOp::clone() const
ContextChange *ContextOp::clone(void) const

{
  ContextOp *res = new ContextOp();
  (res->patexp = patexp)->layClaim();
  res->mask = mask;
  res->num = num;
  res->shift = shift;
  return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x40810
movq 0x3562d(%rip), %rcx     # 0xa2cb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
incl 0x8(%rcx)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movl 0x18(%rbx), %ecx
movl %ecx, 0x18(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextCommit::ContextCommit(TripleSymbol*, int, int, bool)
ContextCommit::ContextCommit(TripleSymbol *s,int4 sbit,int4 ebit,bool fl)

{
  sym = s;
  flow = fl;

  int4 shift;
  calc_maskword(sbit,ebit,num,shift,mask);
}

// Assembly:
pushq %rax
movl %edx, %eax
movq 0x35500(%rip), %rdx     # 0xa2bb0
addq $0x10, %rdx
movq %rdx, (%rdi)
movq %rsi, 0x8(%rdi)
movb %r8b, 0x18(%rdi)
leaq 0x10(%rdi), %rdx
leaq 0x14(%rdi), %r8
leaq 0x4(%rsp), %r9
movl %eax, %edi
movl %ecx, %esi
movq %r9, %rcx
callq 0x6d0bb
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slghsymbol.cc
// Function: ContextCommit::clone() const
ContextChange *ContextCommit::clone(void) const

{
  ContextCommit *res = new ContextCommit();
  res->sym = sym;
  res->flow = flow;
  res->mask = mask;
  res->num = num;
  return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x40810
movq 0x34ea7(%rip), %rcx     # 0xa2bb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movb 0x18(%rbx), %cl
movb %cl, 0x18(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/loadimage.cc
// Function: RawLoadImage::RawLoadImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
RawLoadImage::RawLoadImage(const string &f) : LoadImage(f)

{
  vma = 0;
  thefile = (ifstream *)0;
  spaceid = (AddrSpace *)0;
  filesize = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x32187(%rip), %rax     # 0xa2d58
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %r14, %rdi
callq 0x3fc60
movq 0x321d1(%rip), %rax     # 0xa2dd0
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x70c2d
movq (%r15), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/loadimage.cc
// Function: RawLoadImage::open()
void RawLoadImage::open(void)

{
  if (thefile != (ifstream *)0) throw LowlevelError("loadimage is already open");
  thefile = new ifstream(filename.c_str());
  if (!(*thefile)) {
    string errmsg = "Unable to open raw image file: "+filename;
    throw LowlevelError(errmsg);
  }
  thefile->seekg(0,ios::end);
  filesize = thefile->tellg();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x30(%rdi)
jne 0x70d1a
movq %rdi, %rbx
movl $0x208, %edi            # imm = 0x208
callq 0x40810
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq %rax, %rdi
movl $0x8, %edx
callq 0x42100
movq %r15, 0x30(%rbx)
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
jne 0x70d72
movq %r15, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x41130
movq 0x30(%rbx), %rdi
callq 0x41dc0
movq %rax, 0x38(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10ba0(%rip), %rsi     # 0x818d7
leaq 0x10bb2(%rip), %rdx     # 0x818f0
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x32147(%rip), %rsi     # 0xa2ea8
movq 0x31ed0(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
jmp 0x70dbb
addq $0x8, %rbx
leaq 0x10b74(%rip), %rsi     # 0x818f1
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x40510
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3f890
movq 0x320fc(%rip), %rsi     # 0xa2ea8
movq 0x31e85(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
jmp 0x70dcb
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x70e21
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x70e1c
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x70dfd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x70e07
jmp 0x70e21
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
jmp 0x70e21
movq %rax, %r14
movl $0x208, %esi            # imm = 0x208
movq %r15, %rdi
callq 0x40880
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: BreakTableCallBack::registerPcodeCallback(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BreakCallBack*)
void BreakTableCallBack::registerPcodeCallback(const string &name,BreakCallBack *func)

{
  func->setEmulate(emulate);
  vector<string> userops;
  trans->getUserOpNames(userops);
  for(int4 i=0;i<userops.size();++i) {
    if (userops[i] == name) {
      pcodecallback[(uintb)i] = func;
      return;
    }
  }
  throw LowlevelError("Bad userop name: "+name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq %rdx, 0x8(%rsp)
movq %rax, 0x8(%rdx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %rbx
subq %rbp, %rbx
je 0x71102
sarq $0x5, %rbx
movq (%rsp), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq $0x1, %rbx
adcq $0x0, %rbx
addq $0x8, %rbp
xorl %r14d, %r14d
cmpq %r13, (%rbp)
jne 0x710f6
testq %r13, %r13
je 0x7114c
movq -0x8(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x408c0
testl %eax, %eax
je 0x7114c
incq %r14
addq $0x20, %rbp
cmpq %r14, %rbx
jne 0x710d8
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x108e4(%rip), %rsi     # 0x819fa
leaq 0x28(%rsp), %rdi
movq (%rsp), %rdx
callq 0x40510
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x31d6b(%rip), %rsi     # 0xa2ea8
movq 0x31af4(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
addq $0x48, %r15
leaq 0x28(%rsp), %rsi
movq %r14, (%rsi)
movq %r15, %rdi
callq 0x41eb0
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x400a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x71183
movq %rax, %r14
jmp 0x711b8
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x711a6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x711b0
jmp 0x711b8
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
leaq 0x10(%rsp), %rdi
callq 0x400a0
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: BreakTableCallBack::setEmulate(Emulate*)
void BreakTableCallBack::setEmulate(Emulate *emu)

{ // Make sure all callbbacks are aware of new emulator
  emulate = emu;
  map<Address,BreakCallBack *>::iterator iter1;

  for(iter1=addresscallback.begin();iter1!=addresscallback.end();++iter1)
    (*iter1).second->setEmulate(emu);

  map<uintb,BreakCallBack *>::iterator iter2;


  for(iter2=pcodecallback.begin();iter2!=pcodecallback.end();++iter2)
    (*iter2).second->setEmulate(emu);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rdi)
movq 0x30(%rdi), %rax
leaq 0x20(%rdi), %r15
cmpq %r15, %rax
je 0x71212
movq 0x30(%rax), %rcx
movq %rbx, 0x8(%rcx)
movq %rax, %rdi
callq 0x40040
jmp 0x711fb
movq 0x60(%r14), %rax
addq $0x50, %r14
cmpq %r14, %rax
je 0x71231
movq 0x28(%rax), %rcx
movq %rbx, 0x8(%rcx)
movq %rax, %rdi
callq 0x40040
jmp 0x7121a
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: BreakTableCallBack::doAddressBreak(Address const&)
bool BreakTableCallBack::doAddressBreak(const Address &addr)

{
  map<Address,BreakCallBack *>::const_iterator iter;
  
  iter = addresscallback.find(addr);
  if (iter == addresscallback.end()) return false;
  return (*iter).second->addressCallback(addr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0x42040
addq $0x20, %r14
cmpq %r14, %rax
je 0x712bb
movq 0x30(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: PcodeEmitCache::createVarnode(VarnodeData const*)
VarnodeData *PcodeEmitCache::createVarnode(const VarnodeData *var)

{
  VarnodeData *res = new VarnodeData();
  *res = *var;
  varcache.push_back(res);
  return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0x40810
movq %rax, (%rsp)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x71324
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x71332
movq %rsp, %rbx
movq %rbx, %rdx
callq 0x3f0f0
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: PcodeEmitCache::dump(Address const&, OpCode, VarnodeData*, VarnodeData*, int)
void PcodeEmitCache::dump(const Address &addr,OpCode opc,VarnodeData *outvar,VarnodeData *vars,int4 isize)

{
  PcodeOpRaw *op = new PcodeOpRaw();
  op->setSeqNum(addr,uniq);
  opcache.push_back(op);
  op->setBehavior( inst[opc] );
  uniq += 1;
  if (outvar != (VarnodeData *)0) {
    VarnodeData *outvn = createVarnode(outvar);
    op->setOutput(outvn);
  }
  for(int4 i=0;i<isize;++i) {
    VarnodeData *invn = createVarnode(vars+i);
    op->addInput(invn);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
movl $0x40, %edi
callq 0x40810
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movq %rax, 0x8(%rsp)
movl 0x20(%r14), %ecx
movups (%r13), %xmm0
movups %xmm0, 0x8(%rax)
movq %rcx, 0x18(%rax)
movq 0x8(%r14), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x713a4
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x713b9
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0x41050
movq (%r13), %rax
movl 0x20(%r14), %ecx
movq 0x18(%r14), %rdx
movl %r12d, %esi
movq (%rdx), %rdx
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rax)
incl %ecx
movl %ecx, 0x20(%r14)
testq %r15, %r15
je 0x713e9
movq %r14, %rdi
movq %r15, %rsi
callq 0x40ce0
movq 0x8(%rsp), %rcx
movq %rax, 0x20(%rcx)
testl %ebp, %ebp
jle 0x71433
movl %ebp, %r12d
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40ce0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x30(%rdi), %rsi
cmpq 0x38(%rdi), %rsi
je 0x7141e
movq %rax, (%rsi)
addq $0x8, 0x30(%rdi)
jmp 0x7142a
addq $0x28, %rdi
movq %r15, %rdx
callq 0x3f0f0
addq $0x18, %rbx
decq %r12
jne 0x713f5
addq $0x18, %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/emulate.cc
// Function: EmulatePcodeCache::EmulatePcodeCache(Translate*, MemoryState*, BreakTable*)
EmulatePcodeCache::EmulatePcodeCache(Translate *t,MemoryState *s,BreakTable *b)
  : EmulateMemory(s)
{
  trans = t;
  OpBehavior::registerInstructions(inst,t);
  breaktable = b;
  breaktable->setEmulate(this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdi, %rbx
movb $0x1, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq 0x30e76(%rip), %rcx     # 0xa2ae8
addq $0x10, %rcx
movq %rcx, (%rdi)
leaq 0x30(%rdi), %r14
leaq 0x48(%rdi), %r15
leaq 0x60(%rdi), %r13
movq %rax, 0x80(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movq %rax, 0x70(%rdi)
movq %rsi, 0x28(%rdi)
movq %r13, %rdi
callq 0x42460
movq %r12, 0x78(%rbx)
movq (%r12), %rax
movq %r12, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq (%r13), %rdi
testq %rdi, %rdi
je 0x71ce2
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x40880
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x427ea
movq %r12, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::clearCache()
void EmulatePcodeCache::clearCache(void)

{
  for(int4 i=0;i<opcache.size();++i)
    delete opcache[i];
  for(int4 i=0;i<varcache.size();++i)
    delete varcache[i];
  opcache.clear();
  varcache.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rdx
cmpq %rax, %rdx
je 0x71d55
xorl %r15d, %r15d
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x71d2e
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x71d2e
movq 0x38(%r14), %rsi
subq %rdi, %rsi
callq 0x40880
movl $0x40, %esi
movq %r14, %rdi
callq 0x40880
incq %r15
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x71d10
movq 0x48(%rbx), %rcx
movq 0x50(%rbx), %rsi
cmpq %rcx, %rsi
je 0x71d95
xorl %r14d, %r14d
movq (%rcx,%r14,8), %rdi
movl $0x18, %esi
callq 0x40880
incq %r14
movq 0x48(%rbx), %rcx
movq 0x50(%rbx), %rsi
movq %rsi, %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %r14, %rax
ja 0x71d65
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rdx
cmpq %rax, %rdx
je 0x71d9e
movq %rax, 0x38(%rbx)
cmpq %rcx, %rsi
je 0x71da7
movq %rcx, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::~EmulatePcodeCache()
EmulatePcodeCache::~EmulatePcodeCache(void)

{
  clearCache();
  for(int4 i=0;i<inst.size();++i) {
    OpBehavior *t_op = inst[i];
    if (t_op != (OpBehavior *)0)
      delete t_op;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30d2c(%rip), %rax     # 0xa2ae8
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x3f770
movq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rcx
cmpq %rdi, %rcx
je 0x71e04
xorl %r14d, %r14d
movq (%rdi,%r14,8), %rax
testq %rax, %rax
je 0x71df2
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rcx
incq %r14
movq %rcx, %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r14, %rax
ja 0x71dd8
testq %rdi, %rdi
je 0x71e15
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x40880
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x71e2a
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x40880
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x71e46
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40880
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::establishOp()
void EmulatePcodeCache::establishOp(void)

{
  if (current_op < opcache.size()) {
    currentOp = opcache[current_op];
    currentBehave = currentOp->getBehavior();
    return;
  }
  currentOp = (PcodeOpRaw *)0;
  currentBehave = (OpBehavior *)0;
}

// Assembly:
movslq 0x94(%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x38(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x71eee
movq (%rcx,%rax,8), %rax
movq (%rax), %rcx
jmp 0x71ef2
xorl %eax, %eax
xorl %ecx, %ecx
movq %rax, 0x20(%rdi)
movq %rcx, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::fallthruOp()
void EmulatePcodeCache::fallthruOp(void)

{
  instruction_start = false;
  current_op += 1;
  if (current_op >= opcache.size()) {
    current_address = current_address + instruction_length;
    createInstruction(current_address);
  }
  establishOp();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x90(%rdi)
movslq 0x94(%rdi), %rax
incq %rax
movl %eax, 0x94(%rdi)
movq 0x30(%rdi), %rcx
movq 0x38(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
ja 0x71f8a
leaq 0x80(%rbx), %rsi
movslq 0x98(%rbx), %rax
movq 0x80(%rbx), %rcx
addq 0x88(%rbx), %rax
movq 0x28(%rcx), %rcx
cmpq %rax, %rcx
jae 0x71f65
incq %rcx
cqto
idivq %rcx
movq %rdx, %rax
sarq $0x3f, %rax
andq %rcx, %rax
addq %rdx, %rax
movq %rax, 0x88(%rbx)
movq %rbx, %rdi
callq 0x40520
movslq 0x94(%rbx), %rax
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x71f98
movq (%rcx,%rax,8), %rax
movq (%rax), %rcx
jmp 0x71f9c
xorl %eax, %eax
xorl %ecx, %ecx
movq %rax, 0x20(%rbx)
movq %rcx, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::executeBranch()
void EmulatePcodeCache::executeBranch(void)

{
  const Address &destaddr( currentOp->getInput(0)->getAddr() );
  if (destaddr.isConstant()) {
    uintm id = destaddr.getOffset();
    id = id + (uintm)current_op;
    current_op = id;
    if (current_op == opcache.size())
      fallthruOp();
    else if ((current_op < 0)||(current_op >= opcache.size()))
      throw LowlevelError("Bad intra-instruction branch");
  }
  else
    setExecuteAddress(destaddr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq 0x20(%rdi), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x8(%rcx)
je 0x71fe2
movq (%rdi), %rax
leaq 0x8(%rsp), %rsi
callq *0x90(%rax)
jmp 0x7201d
addl 0x94(%rdi), %eax
movl %eax, 0x94(%rdi)
movslq %eax, %rdx
movq 0x38(%rdi), %rcx
subq 0x30(%rdi), %rcx
sarq $0x3, %rcx
cmpq %rdx, %rcx
jne 0x72012
movq (%rdi), %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x78(%rax)
testl %eax, %eax
js 0x72028
movl %eax, %eax
cmpq %rax, %rcx
jbe 0x72028
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xface(%rip), %rsi      # 0x81b13
leaq 0xfae3(%rip), %rdx      # 0x81b2f
leaq 0x18(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x30e39(%rip), %rsi     # 0xa2ea8
movq 0x30bc2(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x72098
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x720a2
jmp 0x720aa
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/emulate.cc
// Function: EmulatePcodeCache::setExecuteAddress(Address const&)
void EmulatePcodeCache::setExecuteAddress(const Address &addr)

{
  current_address = addr;	// Copy -addr- BEFORE calling createInstruction
                                // as it calls clear and may delete -addr-
  createInstruction(current_address);
  establishOp();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x80(%rdi), %rax
movq (%rsi), %rcx
movq %rcx, 0x80(%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x88(%rdi)
movq %rax, %rsi
callq 0x40520
movslq 0x94(%rbx), %rax
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x721ba
movq (%rcx,%rax,8), %rax
movq (%rax), %rcx
jmp 0x721be
xorl %eax, %eax
xorl %ecx, %ecx
movq %rax, 0x20(%rbx)
movq %rcx, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/emulate.cc
// Function: EmulatePcodeCache::executeInstruction()
void EmulatePcodeCache::executeInstruction(void)

{
  if (instruction_start) {
    if (breaktable->doAddressBreak(current_address))
      return;
  }
  do {
    executeCurrentOp();
  } while(!instruction_start);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x90(%rdi)
jne 0x721ea
movq 0x78(%rbx), %rdi
leaq 0x80(%rbx), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x721fb
movq %rbx, %rdi
callq 0x3f1c0
cmpb $0x1, 0x90(%rbx)
jne 0x721ea
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryBank::constructValue(unsigned char const*, int, bool)
uintb MemoryBank::constructValue(const uint1 *ptr,int4 size,bool bigendian)

{
  uintb res = 0;

  if (bigendian) {
    for(int4 i=0;i<size;++i) {
      res <<= 8;
      res += (uintb) ptr[i];
    }
  }
  else {
    for(int4 i=size-1;i>=0;--i) {
      res <<= 8;
      res += (uintb) ptr[i];
    }
  }
  return res;
}

// Assembly:
testl %edx, %edx
je 0x72be7
testl %esi, %esi
jle 0x72c08
movl %esi, %ecx
xorl %edx, %edx
xorl %eax, %eax
shlq $0x8, %rax
movzbl (%rdi,%rdx), %esi
orq %rsi, %rax
incq %rdx
cmpq %rdx, %rcx
jne 0x72bd2
jmp 0x72c07
testl %esi, %esi
jle 0x72c08
movl %esi, %ecx
incq %rcx
xorl %eax, %eax
shlq $0x8, %rax
movzbl -0x2(%rdi,%rcx), %edx
orq %rdx, %rax
decq %rcx
cmpq $0x1, %rcx
ja 0x72bf2
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryBank::deconstructValue(unsigned char*, unsigned long, int, bool)
void MemoryBank::deconstructValue(uint1 *ptr,uintb val,int4 size,bool bigendian)

{
  if (bigendian) {
    for(int4 i=size-1;i>=0;--i) {
      ptr[i] = (uint1) (val & 0xff);
      val >>= 8;
    }
  }
  else {
    for(int4 i=0;i<size;++i) {
      ptr[i] = (uint1) (val & 0xff);
      val >>= 8;
    }
  }
}

// Assembly:
testl %ecx, %ecx
je 0x72c2d
testl %edx, %edx
jle 0x72c45
movl %edx, %eax
incq %rax
movb %sil, -0x2(%rdi,%rax)
shrq $0x8, %rsi
decq %rax
cmpq $0x1, %rax
ja 0x72c19
jmp 0x72c45
testl %edx, %edx
jle 0x72c45
movl %edx, %eax
xorl %ecx, %ecx
movb %sil, (%rdi,%rcx)
shrq $0x8, %rsi
incq %rcx
cmpq %rcx, %rax
jne 0x72c35
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryBank::setPage(unsigned long, unsigned char const*, int, int)
void MemoryBank::setPage(uintb addr,const uint1 *val,int4 skip,int4 size)
  
{  // Default implementation just iterates using insert
   // but could be optimized
  uintb ptraddr = addr + skip;
  uintb endaddr = ptraddr + size;
  uintb startalign = ptraddr & ~((uintb)(wordsize-1));
  uintb endalign = endaddr & ~((uintb)(wordsize-1));
  if ((endaddr & ((uintb)(wordsize-1))) != 0)
    endalign += wordsize;

  uintb curval;
  bool bswap = ((HOST_ENDIAN==1) != space->isBigEndian());
  uint1 *ptr;
  do {
    ptr = (uint1 *)&curval;
    int4 sz = wordsize;
    if (startalign < addr) {
      ptr += (addr-startalign);
      sz = wordsize - (addr-startalign);
    }
    if (startalign + wordsize > endaddr)
      sz -= (startalign + wordsize - endaddr);
    if (sz != wordsize) {
      curval = find(startalign); // Part of word is copied from underlying
      memcpy(ptr,val,sz);	 // Rest is taken from -val-
    }
    else
      curval = *((const uintb *)val); // -val- supplies entire word
    if (bswap)
      curval = byte_swap(curval,wordsize);
    insert(startalign,curval);
    val += sz;
    startalign += wordsize;
  } while(startalign != endalign);
}

// 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
movslq %ecx, %r12
addq %rsi, %r12
movslq %r8d, %rbp
addq %r12, %rbp
movslq 0x8(%rdi), %rax
leaq -0x1(%rax), %rdx
movq %rax, %rcx
negq %rcx
andq %rcx, %r12
andq %rbp, %rcx
andq %rbp, %rdx
cmovneq %rax, %rdx
addq %rcx, %rdx
movq %rdx, 0x20(%rsp)
movq 0x10(%rdi), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, 0x14(%rsp)
movq %rsi, 0x18(%rsp)
movq %r12, %rcx
subq %r14, %rcx
movl $0x0, %edi
cmovael %edi, %ecx
addl %eax, %ecx
cltq
leaq (%r12,%rax), %rdx
movq %rbp, %rsi
subq %rdx, %rsi
cmovael %edi, %esi
addl %ecx, %esi
movslq %esi, %r13
cmpl %eax, %esi
jne 0x72dc6
movq (%rbx), %rdx
movq %rdx, 0x8(%rsp)
jmp 0x72e09
movq %r14, %rax
subq %r12, %rax
movl $0x0, %ecx
cmovaeq %rax, %rcx
movq %rbp, %r14
leaq 0x8(%rsp,%rcx), %rbp
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
movq %r14, %rbp
movq 0x18(%rsp), %r14
movq %rbx, %rsi
movq %r13, %rdx
callq 0x40380
movq 0x8(%rsp), %rdx
testb $0x1, 0x14(%rsp)
je 0x72e24
movl 0x8(%r15), %esi
movq %rdx, %rdi
callq 0x3f6a0
movq %rax, %rdx
movq %rax, 0x8(%rsp)
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *(%rax)
addq %r13, %rbx
movslq 0x8(%r15), %rax
addq %rax, %r12
cmpq 0x20(%rsp), %r12
jne 0x72d94
addq $0x28, %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/memstate.cc
// Function: MemoryBank::getValue(unsigned long, int) const
uintb MemoryBank::getValue(uintb offset,int4 size) const

{
    uintb res;

    uintb alignmask = (uintb) (wordsize - 1);
    uintb ind = offset & (~alignmask);
    int4 skip = offset & alignmask;
    int4 size1 = wordsize - skip;
    int4 size2;
    int4 gap;
    uintb val1, val2;
    if (size > size1) { // We have spill over
        size2 = size - size1;
        val1 = find (ind);
        val2 = find (ind + wordsize);
        gap = wordsize - size2;
    } else {
        val1 = find (ind);
        val2 = 0;
        if (size == wordsize)
            return val1;
        gap = size1 - size;
        size1 = size;
        size2 = 0;
    }

    if (space->isBigEndian ()) {
        if (size2 == 0)
            res = val1 >> (8 * gap);
        else
            res = (val1 << (8 * size2)) | (val2 >> (8 * gap));
    } else {
        if (size2 == 0)
            res = val1 >> (skip * 8);
        else
            res = (val1 >> (skip * 8)) | (val2 << (size1 * 8));
    }
    res &= (uintb)calc_mask (size);
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r13
movl 0x8(%rdi), %r12d
leal -0x1(%r12), %eax
movl %r12d, %ecx
negl %ecx
movslq %ecx, %rbp
andq %rsi, %rbp
andl %eax, %r15d
subl %r15d, %r12d
movq (%rdi), %rax
movq %rbp, %rsi
callq *0x8(%rax)
movq %rax, %r14
movl %r12d, %ecx
movslq 0x8(%r13), %rax
subl %ebx, %ecx
jge 0x730a8
addq %rax, %rbp
movq (%r13), %rax
movq %r13, %rdi
movq %rbp, %rsi
callq *0x8(%rax)
movq 0x10(%r13), %rcx
testb $0x1, 0x24(%rcx)
jne 0x730bf
shll $0x3, %r15d
movl %r15d, %ecx
shrq %cl, %r14
shll $0x3, %r12d
movl %r12d, %ecx
shlq %cl, %rax
jmp 0x730d8
cmpl %ebx, %eax
je 0x730fb
movq 0x10(%r13), %rax
testb $0x1, 0x24(%rax)
jne 0x730dd
shll $0x3, %r15d
movl %r15d, %ecx
jmp 0x730e0
movl 0x8(%r13), %edx
movl %ebx, %ecx
subl %r12d, %ecx
subl %ecx, %edx
shll $0x3, %ecx
shlq %cl, %r14
shll $0x3, %edx
movl %edx, %ecx
shrq %cl, %rax
orq %rax, %r14
jmp 0x730e3
shll $0x3, %ecx
shrq %cl, %r14
cmpl $0x8, %ebx
movl $0x8, %eax
cmovll %ebx, %eax
cltq
movq 0x2fad9(%rip), %rcx     # 0xa2bd0
andq (%rcx,%rax,8), %r14
movq %r14, %rax
addq $0x8, %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/memstate.cc
// Function: MemoryImage::find(unsigned long) const
uintb MemoryImage::find(uintb addr) const

{ // Assume that -addr- is word aligned
  uintb res = 0;		// Make sure all bytes start as 0, as load may not fill all bytes
  AddrSpace *spc = getSpace();
  try {
    uint1 *ptr = (uint1 *)&res;
    ptr += (HOST_ENDIAN==1) ? (sizeof(uintb) - getWordSize()) : 0;
    loader->loadFill(ptr,getWordSize(),Address(spc,addr));
  } catch(DataUnavailError &err) {
    // Pages not mapped in the load image, are assumed to be zero
    res = 0;
  }
  if ((HOST_ENDIAN==1) != spc->isBigEndian())
    res = byte_swap(res,getWordSize());
  return res;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq $0x0, (%rax)
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %rdi
movl 0x8(%rbx), %edx
leaq 0x8(%rsp), %rcx
movq %r14, (%rcx)
movq %rsi, 0x8(%rcx)
movq (%rdi), %r8
movq %rax, %rsi
callq *0x10(%r8)
testb $0x1, 0x24(%r14)
movq (%rsp), %rax
je 0x73245
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x3f6a0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x73269
callq 0x3f910
movq $0x0, (%rsp)
callq 0x41aa0
jmp 0x7322f
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryImage::getPage(unsigned long, unsigned char*, int, int) const
void MemoryImage::getPage(uintb addr,uint1 *res,int4 skip,int4 size) const

{  // Assume that -addr- is page aligned
  AddrSpace *spc = getSpace();

  try {
    loader->loadFill(res,size,Address(spc,addr+skip));
  }
  catch(DataUnavailError &err) {
    // Pages not mapped in the load image, are assumed to be zero
    for(int4 i=0;i<size;++i)
      res[i] = 0;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movq %rdx, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rdi
movslq %ecx, %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
movq (%rdi), %rax
movq %rbx, %rsi
movl %r8d, %edx
callq *0x10(%rax)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x732cb
callq 0x3f910
testl %ebp, %ebp
jle 0x732c4
movl %ebp, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3fca0
callq 0x41aa0
jmp 0x732a0
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryPageOverlay::insert(unsigned long, unsigned long)
void MemoryPageOverlay::insert(uintb addr,uintb val)

{
  uintb pageaddr = addr & ~((uintb)(getPageSize()-1));
  map<uintb,uint1 *>::iterator iter;

  uint1 *pageptr;

  iter = page.find(pageaddr);
  if (iter != page.end())
    pageptr = (*iter).second;
  else {
    pageptr = new uint1[getPageSize()];
    page[pageaddr] = pageptr;
    if (underlie == (MemoryBank *)0) {
      for(int4 i=0;i<getPageSize();++i)
	pageptr[i] = 0;
    }
    else
      underlie->getPage(pageaddr,pageptr,0,getPageSize());
  }
  
  uintb pageoffset = addr & ((uintb)(getPageSize()-1));
  deconstructValue(pageptr + pageoffset,val,getWordSize(),getSpace()->isBigEndian());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0xc(%rdi), %r12d
movl %r12d, %eax
negl %eax
cltq
andq %rsi, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rdi), %rdx
testq %rdx, %rdx
je 0x7334a
leaq 0x28(%r14), %rsi
movq %rsi, %rcx
xorl %edi, %edi
cmpq %rax, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x73327
cmpq %rsi, %rcx
je 0x7334a
cmpq 0x20(%rcx), %rax
jae 0x733a4
movslq %r12d, %rdi
leaq 0x20(%r14), %r12
callq 0x3f060
movq %rax, %r13
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x403c0
movq %r13, (%rax)
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x7338c
movq 0x8(%rsp), %rsi
movl 0xc(%r14), %r8d
movq (%rdi), %rax
movq %r13, %rdx
xorl %ecx, %ecx
callq *0x10(%rax)
movl 0xc(%r14), %r12d
jmp 0x733a8
movslq 0xc(%r14), %r12
testq %r12, %r12
jle 0x733a8
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3fca0
jmp 0x733a8
movq 0x28(%rcx), %r13
decl %r12d
movslq %r12d, %rax
andq %r15, %rax
addq %r13, %rax
movl 0x8(%r14), %ecx
movq 0x10(%r14), %rdx
testb $0x1, 0x24(%rdx)
jne 0x733d9
testl %ecx, %ecx
jle 0x733f1
xorl %edx, %edx
movb %bl, (%rax,%rdx)
shrq $0x8, %rbx
incq %rdx
cmpq %rdx, %rcx
jne 0x733c8
jmp 0x733f1
testl %ecx, %ecx
jle 0x733f1
incq %rcx
movb %bl, -0x2(%rax,%rcx)
shrq $0x8, %rbx
decq %rcx
cmpq $0x1, %rcx
ja 0x733e0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryPageOverlay::setPage(unsigned long, unsigned char const*, int, int)
void MemoryPageOverlay::setPage(uintb addr,const uint1 *val,int4 skip,int4 size)

{
  map<uintb,uint1 *>::iterator iter;
  uint1 *pageptr;

  iter = page.find(addr);
  if (iter == page.end()) {
    pageptr = new uint1[getPageSize()];
    page[addr] = pageptr;
    if (size != getPageSize()) {
      if (underlie == (MemoryBank *)0) {
	for(int4 i=0;i<getPageSize();++i)
	  pageptr[i] = 0;
      }
      else
	underlie->getPage(addr,pageptr,0,getPageSize());
    }
  }
  else
    pageptr = (*iter).second;

  memcpy(pageptr+skip,val,size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %rbx
movq %rdi, %r12
movq %rsi, (%rsp)
movq 0x30(%rdi), %rcx
testq %rcx, %rcx
je 0x7356b
leaq 0x28(%r12), %rdx
movq %rdx, %rax
xorl %edi, %edi
cmpq %rsi, 0x20(%rcx)
setb %dil
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdi,8), %rcx
testq %rcx, %rcx
jne 0x73548
cmpq %rdx, %rax
je 0x7356b
cmpq %rsi, 0x20(%rax)
jbe 0x735b0
leaq 0x20(%r12), %r13
movslq 0xc(%r12), %rdi
callq 0x3f060
movq %rax, %r15
movq %rsp, %rsi
movq %r13, %rdi
callq 0x403c0
movq %r15, (%rax)
movl 0xc(%r12), %r8d
cmpl %ebp, %r8d
je 0x735c8
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x735b6
movq (%rsp), %rsi
movq (%rdi), %rax
movq %r15, %rdx
xorl %ecx, %ecx
callq *0x10(%rax)
jmp 0x735c8
movq 0x28(%rax), %r15
jmp 0x735c8
testl %r8d, %r8d
jle 0x735c8
movq %r15, %rdi
xorl %esi, %esi
movq %r8, %rdx
callq 0x3fca0
movslq %r14d, %rdi
addq %r15, %rdi
movslq %ebp, %rdx
movq %rbx, %rsi
callq 0x40380
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/memstate.cc
// Function: MemoryHashOverlay::MemoryHashOverlay(AddrSpace*, int, int, int, MemoryBank*)
MemoryHashOverlay::MemoryHashOverlay(AddrSpace *spc,int4 ws,int4 ps,int4 hashsize,MemoryBank *ul)
  : MemoryBank(spc,ws,ps), address(hashsize,0xBADBEEF), value(hashsize,0)
{
  underlie = ul;
  collideskip = 1023;

  uint4 tmp = ws - 1;
  alignshift = 0;
  while(tmp != 0) {
    alignshift += 1;
    tmp >>= 1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movl %edx, %ebp
movq %rdi, %rbx
movq %rsi, 0x10(%rdi)
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
movq 0x2f775(%rip), %rax     # 0xa2f80
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x30(%rdi), %r15
movslq %r8d, %r12
leaq 0x10(%rsp), %r13
movq $0xbadbeef, (%r13)      # imm = 0xBADBEEF
leaq 0xf(%rsp), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3f4a0
leaq 0x48(%rbx), %rdi
movq $0x0, (%r13)
leaq 0x10(%rsp), %rdx
leaq 0xf(%rsp), %rcx
movq %r12, %rsi
callq 0x3f4a0
movq %r14, 0x18(%rbx)
movq $0x3ff, 0x28(%rbx)      # imm = 0x3FF
decl %ebp
bsrl %ebp, %eax
xorl $-0x20, %eax
addl $0x21, %eax
testl %ebp, %ebp
cmovel %ebp, %eax
movl %eax, 0x20(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0x7389c
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x40880
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryState::setMemoryBank(MemoryBank*)
void MemoryState::setMemoryBank(MemoryBank *bank)

{
  AddrSpace *spc = bank->getSpace();
  int4 index = spc->getIndex();

  while(index >= memspace.size())
    memspace.push_back((MemoryBank *)0);

  memspace[index] = bank;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x10(%rsi), %rax
movslq 0x60(%rax), %r13
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x73904
movq %rdi, %r14
leaq 0x8(%rdi), %r15
leaq 0x8(%rsp), %r12
movq $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x404f0
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x738dc
movq %rbx, (%rax,%r13,8)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/memstate.cc
// Function: MemoryState::setValue(AddrSpace*, unsigned long, int, unsigned long)
void MemoryState::setValue(AddrSpace *spc,uintb off,int4 size,uintb cval)

{
  MemoryBank *mspace = getMemoryBank(spc);
  if (mspace == (MemoryBank *)0)
    throw LowlevelError("Setting value for unmapped memory space: "+spc->getName());
  mspace->setValue(off,size,cval);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movslq 0x60(%rsi), %rax
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
subq %rsi, %rdi
sarq $0x3, %rdi
cmpq %rax, %rdi
jbe 0x73977
movq (%rsi,%rax,8), %rdi
testq %rdi, %rdi
je 0x73977
movq %rdx, %rsi
movl %ecx, %edx
movq %r8, %rcx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x408a0
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
addq $0x38, %r14
leaq 0xe1f4(%rip), %rsi      # 0x81b83
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40510
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x2f4f7(%rip), %rsi     # 0xa2ea8
movq 0x2f280(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x739de
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x739e8
jmp 0x739f0
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/memstate.cc
// Function: MemoryState::getValue(AddrSpace*, unsigned long, int) const
uintb MemoryState::getValue(AddrSpace *spc,uintb off,int4 size) const

{
  if (spc->getType() == IPTR_CONSTANT) return off;
  MemoryBank *mspace = getMemoryBank(spc);
  if (mspace == (MemoryBank *)0)
    throw LowlevelError("Getting value from unmapped memory space: "+spc->getName());
  return mspace->getValue(off,size);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, 0x8(%rsi)
je 0x73a3c
movq %rsi, %r14
movslq 0x60(%rsi), %rax
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
subq %rsi, %rdi
sarq $0x3, %rdi
cmpq %rax, %rdi
jbe 0x73a48
movq (%rsi,%rax,8), %rdi
testq %rdi, %rdi
je 0x73a48
movq %rdx, %rsi
movl %ecx, %edx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x41780
movq %rdx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
addq $0x38, %r14
leaq 0xe14d(%rip), %rsi      # 0x81bad
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40510
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x2f426(%rip), %rsi     # 0xa2ea8
movq 0x2f1af(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x73aaf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x73ab9
jmp 0x73ac1
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
nop