LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserWalker::setOutOfBandState(Constructor*, int, ConstructState*, ParserWalker const&)
void ParserWalker::setOutOfBandState(Constructor *ct,int4 index,ConstructState *tempstate,const ParserWalker &otherwalker)

{ // Initialize walker for future calls into getInstructionBytes assuming -ct- is the current position in the walk
  const ConstructState *pt = otherwalker.point;
  int4 curdepth = otherwalker.depth;
  while(pt->ct != ct) {
    if (curdepth <= 0) return;
    curdepth -= 1;
    pt = pt->parent;
  }
  OperandSymbol *sym = ct->getOperand(index);
  int4 i = sym->getOffsetBase();
  // if i<0, i.e. the offset of the operand is constructor relative
  // its possible that the branch corresponding to the operand
  // has not been constructed yet. Context expressions are
  // evaluated BEFORE the constructors branches are created.
  // So we have to construct the offset explicitly.
  if (i<0)
    tempstate->offset = pt->offset + sym->getRelativeOffset();
  else
    tempstate->offset = pt->resolve[index]->offset;

  tempstate->ct = ct;
  tempstate->length = pt->length;
  point = tempstate;
  depth = 0;
  breadcrumb[0] = 0;
}

// Assembly:
movq 0x10(%r8), %rax
cmpq %rsi, (%rax)
je 0x500df
movl 0x18(%r8), %r8d
incl %r8d
decl %r8d
testl %r8d, %r8d
jle 0x5011d
movq 0x58(%rax), %rax
cmpq %rsi, (%rax)
jne 0x500ce
movslq %edx, %rdx
movq 0x18(%rsi), %r8
movq (%r8,%rdx,8), %r8
cmpl $0x0, 0x34(%r8)
js 0x500fe
movq 0x40(%rax), %r8
movq (%r8,%rdx,8), %rdx
movl 0x64(%rdx), %edx
jmp 0x50105
movl 0x30(%r8), %edx
addl 0x64(%rax), %edx
movl %edx, 0x64(%rcx)
movq %rsi, (%rcx)
movl 0x60(%rax), %eax
movl %eax, 0x60(%rcx)
movq %rcx, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserWalkerChange::calcCurrentLength(int, int)
void ParserWalkerChange::calcCurrentLength(int4 length,int4 numopers)

{				// Calculate the length of the current constructor
				// state assuming all its operands are constructed
  length += point->offset;	// Convert relative length to absolute length
  for(int4 i=0;i<numopers;++i) {
    ConstructState *subpoint = point->resolve[i];
    int4 sublength = subpoint->length + subpoint->offset;
				// Since subpoint->offset is an absolute offset
				// (relative to beginning of instruction) sublength
    if (sublength > length)	// is absolute and must be compared to absolute length
      length = sublength;
  }
  point->length = length - point->offset; // Convert back to relative length
}

// Assembly:
movq 0x10(%rdi), %rax
movl 0x64(%rax), %ecx
addl %ecx, %esi
testl %edx, %edx
jle 0x50154
movq 0x40(%rax), %rdi
movl %edx, %edx
xorl %r8d, %r8d
movq (%rdi,%r8,8), %r10
movl 0x64(%r10), %r9d
addl 0x60(%r10), %r9d
cmpl %esi, %r9d
cmovlel %esi, %r9d
incq %r8
movl %r9d, %esi
cmpq %r8, %rdx
jne 0x50134
jmp 0x50157
movl %esi, %r9d
subl %ecx, %r9d
movl %r9d, 0x60(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/filemanage.cc
// Function: FileManage::addDir2Path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void FileManage::addDir2Path(const string &path)

{
  if (path.size()>0) {
    pathlist.push_back(path);
    if (path[path.size()-1] != separator)
      pathlist.back() += separator;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rsi)
je 0x50708
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3fbc0
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq 0x528d0(%rip), %rax     # 0xa2fd0
movb (%rax), %al
cmpb %al, -0x1(%rcx,%rdx)
jne 0x50710
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rdi
addq $-0x20, %rdi
movsbl %al, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40480
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/filemanage.cc
// Function: FileManage::findFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void FileManage::findFile(string &res,const string &name) const

{				// Search through paths to find file with given name
  vector<string>::const_iterator iter;

  if (name[0] == separator) {
    res = name;
    ifstream s(res.c_str());
    if (s) {
      s.close();
      return;
    }
  }
  else {
    for(iter=pathlist.begin();iter!=pathlist.end();++iter) {
      res = *iter + name;
      ifstream s(res.c_str());
      if (s) {
	s.close();
	return;
      }
    }
  }
  res.clear();			// Can't find it, return empty string
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rax
movb (%rax), %al
movq 0x52885(%rip), %rcx     # 0xa2fd0
cmpb (%rcx), %al
jne 0x50789
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fc60
movq (%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x420f0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
je 0x5080d
movq %rsp, %rdi
callq 0x3f4d0
jmp 0x507fd
movq %rdi, %r15
movq (%rdi), %r12
cmpq 0x8(%rdi), %r12
je 0x507fd
leaq 0x10(%rsp), %rbp
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x42380
movq %rbx, %rdi
movq %r13, %rsi
callq 0x40da0
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x507cc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
movq (%rbx), %rsi
movq %r13, %rdi
movl $0x8, %edx
callq 0x420f0
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
je 0x50817
movq %r13, %rdi
callq 0x3f4d0
addq $0x20, %r12
cmpq 0x8(%r15), %r12
jne 0x5079d
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
jmp 0x50827
movq %rsp, %rdi
callq 0x3f3c0
jmp 0x5081f
movq %rsp, %rdi
callq 0x3f3c0
movq %rsp, %rdi
callq 0x3f4d0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5083b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3f4d0
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/filemanage.cc
// Function: FileManage::addCurrentDir()
void FileManage::addCurrentDir(void)

{				// Add current working directory to path
  char dirname[256];
  char *buf;

  buf = getcwd(dirname,256);
  if ((char *)0 == buf) return;
  string filename(buf);
  addDir2Path(filename);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x3fbd0
testq %rax, %rax
je 0x508bd
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, %rdi
callq 0x3f9e0
movq %r14, %rdx
addq %rax, %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3f8a0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x40a50
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x508bd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x508e5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/filemanage.cc
// Function: FileManage::scanDirectoryRecursive(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void FileManage::scanDirectoryRecursive(vector<string> &res,const string &matchname,const string &rootpath,int maxdepth)

{
  if (maxdepth == 0) return;
  vector<string> subdir;
  directoryList(subdir,rootpath);
  vector<string>::const_iterator iter;
  for(iter = subdir.begin();iter!=subdir.end();++iter) {
    const string &curpath( *iter );
    string::size_type pos = curpath.rfind(separator);
    if (pos == string::npos)
      pos = 0;
    else
      pos = pos + 1;
    if (curpath.compare(pos,string::npos,matchname)==0)
      res.push_back(curpath);
    else
      scanDirectoryRecursive(res,matchname,curpath,maxdepth-1); // Recurse
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
testl %ecx, %ecx
je 0x50e48
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rdx, %rsi
xorl %edx, %edx
callq 0x40460
movq (%rsp), %r12
cmpq 0x8(%rsp), %r12
je 0x50e40
decl %ebx
movq 0x521e6(%rip), %r13     # 0xa2fd0
movsbl (%r13), %esi
movq %r12, %rdi
movq $-0x1, %rdx
callq 0x42430
leaq 0x1(%rax), %rsi
movq %r12, %rdi
movq $-0x1, %rdx
movq %r14, %rcx
callq 0x40f40
testl %eax, %eax
je 0x50e2a
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x422c0
jmp 0x50e35
movq %r15, %rdi
movq %r12, %rsi
callq 0x3fbc0
addq $0x20, %r12
cmpq 0x8(%rsp), %r12
jne 0x50dea
movq %rsp, %rdi
callq 0x40090
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x50e58
movq %rax, %rbx
movq %rsp, %rdi
callq 0x40090
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/filemanage.cc
// Function: FileManage::splitPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void FileManage::splitPath(const string &full,string &path,string &base)

{ // Split path string -full- into its -base-name and -path- (relative or absolute)
  // If there is no path, i.e. only a basename in full, then -path- will return as an empty string
  // otherwise -path- will be non-empty and end in a separator character
  string::size_type end = full.size()-1;
  if (full[full.size()-1] == separator) // Take into account terminating separator
    end = full.size()-2;
  string::size_type pos = full.rfind(separator,end);
  if (pos == string::npos) {	// Didn't find any separator
    base = full;
    path.clear();
  }
  else {
    string::size_type sz = (end - pos);
    base = full.substr(pos+1,sz);
    path = full.substr(0,pos+1);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq -0x1(%rcx), %r13
movq 0x5213b(%rip), %rdx     # 0xa2fd0
movsbl (%rdx), %esi
leaq -0x2(%rcx), %rdx
cmpb %sil, -0x1(%rax,%rcx)
cmoveq %rdx, %r13
movq %r13, %rdx
callq 0x42430
cmpq $-0x1, %rax
je 0x50f30
movq %rax, %r15
subq %rax, %r13
incq %r15
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x408c0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x40da0
movq (%rbp), %rdi
leaq 0x18(%rsp), %r13
cmpq %r13, %rdi
je 0x50ef8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x408c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40da0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x50f49
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x50f49
movq %r12, %rdi
movq %r14, %rsi
callq 0x3fc60
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/filemanage.cc
// Function: FileManage::buildPath(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, int)
string FileManage::buildPath(const vector<string> &pathels,int level)

{ // Build an absolute path using elements from -pathels-, in reverse order
  // Build up to and including pathels[level]
  ostringstream s;

  for(int i=pathels.size()-1;i>=level;--i) {
    s << separator;
    s << pathels[i];
  }
  return s.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x41110
movq 0x8(%r14), %r13
subq (%r14), %r13
shrq $0x5, %r13
decl %r13d
movq 0x5203b(%rip), %rbx     # 0xa2fd0
leaq 0x7(%rsp), %r12
cmpl %ebp, %r13d
jl 0x50fd5
movb (%rbx), %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x40b80
movslq %r13d, %rax
movq (%r14), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
decl %r13d
movq %r15, %rdi
callq 0x40b80
jmp 0x50f9a
leaq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x418b0
movq 0x51d92(%rip), %rsi     # 0xa2d80
leaq 0x10(%rsp), %rdi
callq 0x3fc30
leaq 0x80(%rsp), %rdi
callq 0x3f730
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5101c
movq %rax, %rbx
movq 0x51d5a(%rip), %rsi     # 0xa2d80
leaq 0x10(%rsp), %rdi
callq 0x3fc30
leaq 0x80(%rsp), %rdi
callq 0x3f730
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/filemanage.cc
// Function: FileManage::testInstallPath(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool FileManage::testInstallPath(const vector<string> &pathels,int level,string &root)

{
  if (level + 1 >= pathels.size()) return false;
  root = buildPath(pathels,level+1);
  vector<string> testpaths1;
  vector<string> testpaths2;
  scanDirectoryRecursive(testpaths1,"server",root,1);
  if (testpaths1.size() != 1) return false;
  scanDirectoryRecursive(testpaths2,"server.conf",testpaths1[0],1);
  return (testpaths2.size() == 1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movl %esi, %edx
incl %edx
movslq %edx, %rax
movq 0x8(%rdi), %rcx
subq (%rdi), %rcx
sarq $0x5, %rcx
cmpq %rax, %rcx
jbe 0x51444
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x41e30
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40da0
movq (%r14), %rdi
leaq 0x10(%rsp), %r14
cmpq %r14, %rdi
je 0x5137e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
xorl %eax, %eax
movq %rax, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq %rax, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x2ea28(%rip), %rsi     # 0x7fdcc
leaq 0x2ea27(%rip), %rdx     # 0x7fdd2
callq 0x3f8a0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x422c0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x513db
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
movq 0x28(%rsp), %rax
subq 0x20(%rsp), %rax
cmpq $0x20, %rax
jne 0x51448
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x2e9db(%rip), %rsi     # 0x7fdd3
leaq 0x2e9df(%rip), %rdx     # 0x7fdde
callq 0x3f8a0
movq 0x20(%rsp), %rdx
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
movl $0x1, %ecx
callq 0x422c0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x51431
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
movq 0x48(%rsp), %rax
subq 0x40(%rsp), %rax
cmpq $0x20, %rax
sete %bl
jmp 0x5144a
xorl %ebx, %ebx
jmp 0x5145e
xorl %ebx, %ebx
leaq 0x40(%rsp), %rdi
callq 0x40090
leaq 0x20(%rsp), %rdi
callq 0x40090
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
jmp 0x5146c
jmp 0x51487
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x5148a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x5148a
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x40090
leaq 0x20(%rsp), %rdi
callq 0x40090
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: ExprTree::ExprTree(OpTpl*)
ExprTree::ExprTree(OpTpl *op)

{
  ops = new vector<OpTpl *>;
  ops->push_back(op);
  if (op->getOut() != (VarnodeTpl *)0)
    outvn = new VarnodeTpl(*op->getOut());
  else
    outvn = (VarnodeTpl *)0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movl $0x18, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%rbx)
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x51d79
movq %r14, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x51d86
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x3f150
movq 0x8(%rsp), %r15
cmpq $0x0, (%r15)
je 0x51dab
movl $0x68, %edi
callq 0x40800
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x41bf0
jmp 0x51dae
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: ExprTree::~ExprTree()
ExprTree::~ExprTree(void)

{
  if (outvn != (VarnodeTpl *)0)
    delete outvn;
  if (ops != (vector<OpTpl *> *)0) {
    for(int4 i=0;i<ops->size();++i)
      delete (*ops)[i];
    delete ops;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x51def
movl $0x68, %esi
callq 0x40870
cmpq $0x0, (%rbx)
je 0x51e5e
movq (%rbx), %r14
movq (%r14), %rdi
cmpq %rdi, 0x8(%r14)
je 0x51e3b
xorl %r15d, %r15d
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x51e22
movq %r14, %rdi
callq 0x3f1f0
movl $0x28, %esi
movq %r14, %rdi
callq 0x40870
incq %r15
movq (%rbx), %r14
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r15, %rax
ja 0x51e04
testq %rdi, %rdi
je 0x51e4c
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x40870
movl $0x18, %esi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40870
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: ExprTree::appendParams(OpTpl*, std::vector<ExprTree*, std::allocator<ExprTree*>>*)
vector<OpTpl *> *ExprTree::appendParams(OpTpl *op,vector<ExprTree *> *param)

{				// Create op expression with entire list of expression
				// inputs
  vector<OpTpl *> *res = new vector<OpTpl *>;
  
  for(int4 i=0;i<param->size();++i) {
    res->insert(res->end(),(*param)[i]->ops->begin(),(*param)[i]->ops->end());
    (*param)[i]->ops->clear();
    op->addInput((*param)[i]->outvn);
    (*param)[i]->outvn = (VarnodeTpl *)0;
    delete (*param)[i];
  }
  res->push_back(op);
  delete param;
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
movl $0x18, %edi
callq 0x40800
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x51f27
xorl %r12d, %r12d
movq 0x8(%r14), %rsi
movq (%rax,%r12,8), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %r14, %rdi
callq 0x3f850
movq (%rbx), %rax
movq (%rax,%r12,8), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdx
cmpq %rdx, 0x8(%rcx)
je 0x51ecf
movq %rdx, 0x8(%rcx)
movq (%rsp), %rdi
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %rsi
callq 0x42010
movq (%rbx), %rax
movq (%rax,%r12,8), %rcx
movq $0x0, 0x8(%rcx)
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x51f0d
movq %r15, %rdi
callq 0x40f50
movl $0x10, %esi
movq %r15, %rdi
callq 0x40870
incq %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x51e9e
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x51f3f
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x51f4a
movq %rsp, %rdx
movq %r14, %rdi
callq 0x3f150
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x51f5e
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x40870
movl $0x18, %esi
movq %rbx, %rdi
callq 0x40870
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: ExprTree::toVector(ExprTree*)
vector<OpTpl *> *ExprTree::toVector(ExprTree *expr)

{				// Grab the op vector and delete the output expression
  vector<OpTpl *> *res = expr->ops;
  expr->ops = (vector<OpTpl *> *)0;
  delete expr;
  return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq $0x0, (%rdi)
callq 0x40f50
movl $0x10, %esi
movq %rbx, %rdi
callq 0x40870
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: ExprTree::setOutput(VarnodeTpl*)
void ExprTree::setOutput(VarnodeTpl *newout)

{				// Force the output of the expression to be new out
				// If the original output is named, this requires
				// an extra COPY op
  OpTpl *op;
  if (outvn == (VarnodeTpl *)0)
    throw SleighError("Expression has no output");
  if (outvn->isUnnamed()) {
    delete outvn;
    op = ops->back();
    op->clearOutput();
    op->setOutput(newout);
  }
  else {
    op = new OpTpl(CPUI_COPY);
    op->addInput(outvn);
    op->setOutput(newout);
    ops->push_back(op);
  }
  outvn = new VarnodeTpl(*newout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x5208b
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x60(%r15)
jne 0x5200a
movl $0x68, %esi
movq %r15, %rdi
callq 0x40870
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq -0x8(%rax), %r15
movq %r15, (%rsp)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x51ffa
movl $0x68, %esi
callq 0x40870
movq $0x0, (%r15)
movq (%rsp), %rax
movq %r14, (%rax)
jmp 0x52064
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movl $0x1, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, (%rsp)
movq %rax, %rdi
movq %r15, %rsi
callq 0x42010
movq (%rsp), %rax
movq %r14, (%rax)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x5205c
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x52064
movq %rsp, %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40800
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x41bf0
movq %r15, 0x8(%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 0x2de48(%rip), %rsi     # 0x7fef0
leaq 0x2de59(%rip), %rdx     # 0x7ff08
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x50dbe(%rip), %rsi     # 0xa2e90
movq 0x50b5f(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x52103
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x52103
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x52122
movq %rbx, %rdi
callq 0x40080
jmp 0x52122
movq %rax, %r14
movl $0x68, %esi
movq %r15, %rdi
callq 0x40870
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::matchSize(int, OpTpl*, bool, std::vector<OpTpl*, std::allocator<OpTpl*>> const&)
void PcodeCompile::matchSize(int4 j,OpTpl *op,bool inputonly,const vector<OpTpl *> &ops)

{				// Find something to fill in zero size varnode
				// j is the slot we are trying to fill (-1=output)
				// Don't check output for non-zero if inputonly is true
  VarnodeTpl *match = (VarnodeTpl *)0;
  VarnodeTpl *vt;
  int4 i,inputsize;

  vt = (j==-1) ? op->getOut() : op->getIn(j);
  if (!inputonly) {
    if (op->getOut() != (VarnodeTpl *)0)
      if (!op->getOut()->isZeroSize())
	match = op->getOut();
  }
  inputsize = op->numInput();
  for(i=0;i<inputsize;++i) {
    if (match != (VarnodeTpl *)0) break;
    if (op->getIn(i)->isZeroSize()) continue;
    match = op->getIn(i);
  }
  if (match != (VarnodeTpl *)0)
    force_size(vt,match->getSize(),ops);
}

// Assembly:
movq %rsi, %rax
movq %rsi, %r8
cmpl $-0x1, %edi
je 0x523a2
movslq %edi, %r8
shlq $0x3, %r8
addq 0x10(%rax), %r8
testb %dl, %dl
jne 0x523c3
movq (%rax), %rdx
testq %rdx, %rdx
je 0x523c3
movq 0x50(%rdx), %rsi
testq %rsi, %rsi
cmovneq %rdx, %rsi
cmpl $0x0, 0x40(%rdx)
cmovneq %rdx, %rsi
jmp 0x523c5
xorl %esi, %esi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rax
subq %rdx, %rax
shrq $0x3, %rax
testq %rsi, %rsi
setne %dil
testl %eax, %eax
jle 0x5241b
testq %rsi, %rsi
jne 0x5241b
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl $0x1, %r9d
movq -0x8(%rdx,%r9,8), %rdi
movq 0x50(%rdi), %rsi
testq %rsi, %rsi
cmovneq %rdi, %rsi
cmpl $0x0, 0x40(%rdi)
cmovneq %rdi, %rsi
testq %rsi, %rsi
setne %dil
cmpq %rax, %r9
jae 0x5241b
incq %r9
testq %rsi, %rsi
je 0x523ef
testb %dil, %dil
je 0x5242f
movq (%r8), %rdi
addq $0x40, %rsi
movq %rcx, %rdx
jmp 0x3f380
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::buildTemporary()
VarnodeTpl *PcodeCompile::buildTemporary(void)

{				// Build temporary variable (with zerosize)
  VarnodeTpl *res = new VarnodeTpl(ConstTpl(uniqspace),
				   ConstTpl(ConstTpl::real,allocateTemp()),
				   ConstTpl(ConstTpl::real,0));
  res->setUnnamed(true);
  return res;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movl $0x68, %edi
callq 0x40800
movq %rax, %rbx
movq 0x18(%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x40390
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x40b10
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40b10
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x41aa0
movb $0x1, 0x60(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x528d2
jmp 0x528d2
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x40870
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::defineLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
LabelSymbol *PcodeCompile::defineLabel(string *name)

{ // Create a label symbol
  LabelSymbol *labsym = new LabelSymbol(*name,local_labelcount++);
  delete name;
  addSymbol(labsym);		// Add symbol to local scope
  return labsym;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x40, %edi
callq 0x40800
movq %rax, %rbx
movl 0x20(%r14), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x20(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x40550
movq 0x505fc(%rip), %rax     # 0xa2f20
addq $0x10, %rax
movq %rax, (%rbx)
movl %r12d, 0x30(%rbx)
movl $0x0, 0x38(%rbx)
movb $0x0, 0x34(%rbx)
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x52951
movq (%rax), %rsi
incq %rsi
callq 0x40870
movl $0x20, %esi
movq %r15, %rdi
callq 0x40870
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x40, %esi
movq %rbx, %rdi
callq 0x40870
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::placeLabel(LabelSymbol*)
vector<OpTpl *> *PcodeCompile::placeLabel(LabelSymbol *labsym)

{ // Create placeholder OpTpl for a label
  if (labsym->isPlaced()) {
    string errmsg = "Label " + labsym->getName();
    errmsg += " is placed more than once";
    reportError(errmsg);
  }
  labsym->setPlaced();
  vector<OpTpl *> *res = new vector<OpTpl *>;
  OpTpl *op = new OpTpl(LABELBUILD);
  VarnodeTpl *idvn = new VarnodeTpl(ConstTpl(constantspace),
				      ConstTpl(ConstTpl::real,labsym->getIndex()),
				      ConstTpl(ConstTpl::real,4));
  op->addInput(idvn);
  res->push_back(op);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r12
cmpb $0x1, 0x34(%rsi)
jne 0x529fa
leaq 0x8(%r14), %rdx
leaq 0x2d56d(%rip), %rsi     # 0x7ff21
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x40500
leaq 0x2d560(%rip), %rsi     # 0x7ff28
movq %rbx, %rdi
callq 0x422f0
movq (%r12), %rax
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq *0x20(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x529fa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
movb $0x1, 0x34(%r14)
movl $0x18, %edi
callq 0x40800
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r15, 0x20(%rax)
movl $0x41, 0x8(%rax)
movq %r15, (%rax)
movq %rax, (%rsp)
movl $0x68, %edi
callq 0x40800
movq %rax, %r15
movq 0x10(%r12), %rsi
leaq 0x8(%rsp), %rdi
callq 0x40390
movl 0x30(%r14), %edx
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x40b10
leaq 0x28(%rsp), %rdi
movl $0x4, %edx
xorl %esi, %esi
callq 0x40b10
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %r15, %rdi
callq 0x41aa0
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x42010
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x52ab4
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x52abf
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x3f150
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x52aed
jmp 0x52aed
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52afd
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x52af8
movq %rax, %rbx
movl $0x68, %esi
movq %r15, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::newOutput(bool, ExprTree*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, unsigned int)
vector<OpTpl *> *PcodeCompile::newOutput(bool usesLocalKey,ExprTree *rhs,string *varname,uint4 size)

{
  VarnodeSymbol *sym;
  VarnodeTpl *tmpvn = buildTemporary();
  if (size != 0)
    tmpvn->setSize(ConstTpl(ConstTpl::real,size)); // Size was explicitly specified
  else if ((rhs->getSize().getType()==ConstTpl::real)&&(rhs->getSize().getReal()!=0))
    tmpvn->setSize(rhs->getSize());	// Inherit size from unnamed expression result
				// Only inherit if the size is real, otherwise we
				// cannot build the VarnodeSymbol with a placeholder constant
  rhs->setOutput(tmpvn);
  sym = new VarnodeSymbol(*varname,tmpvn->getSpace().getSpace(),tmpvn->getOffset().getReal(),tmpvn->getSize().getReal()); // Create new symbol regardless
  addSymbol(sym);
  if ((!usesLocalKey) && enforceLocalKey)
	  reportError("Must use 'local' keyword to define symbol: "+*varname);
  delete varname;
  return ExprTree::toVector(rhs);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
callq 0x401d0
movq %rax, %r12
testl %r13d, %r13d
je 0x52b59
movl %r13d, %edx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x40b10
movups (%r13), %xmm0
movups 0xc(%r13), %xmm1
movups %xmm1, 0x4c(%r12)
movups %xmm0, 0x40(%r12)
jmp 0x52b67
movq 0x8(%rbx), %rax
cmpl $0x0, 0x40(%rax)
je 0x52c44
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3fe90
movl $0x58, %edi
callq 0x40800
movq %rax, %r13
movq 0x8(%r12), %rdx
movq 0x30(%r12), %rcx
movl 0x50(%r12), %r8d
movq %rax, %rdi
movq %r14, %rsi
callq 0x40af0
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0x8(%rax)
testb %bpl, %bpl
jne 0x52bef
cmpb $0x1, 0x24(%r15)
jne 0x52bef
leaq 0x2d38a(%rip), %rsi     # 0x7ff42
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0x40500
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x20(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52bef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x52c06
movq (%rax), %rsi
incq %rsi
callq 0x40870
movl $0x20, %esi
movq %r14, %rdi
callq 0x40870
movq (%rbx), %r14
movq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x40f50
movl $0x10, %esi
movq %rbx, %rdi
callq 0x40870
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x50(%rax)
je 0x52b67
addq $0x40, %rax
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
jmp 0x52b4b
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52c8a
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x52c85
movq %rax, %rbx
movl $0x58, %esi
movq %r13, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::newLocalDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, unsigned int)
void PcodeCompile::newLocalDefinition(string *varname,uint4 size)

{ // Create a new temporary symbol (without generating any pcode)
  VarnodeSymbol *sym;
  VarnodeTpl *tmpvn = buildTemporary();
  if (size != 0)
    tmpvn->setSize(ConstTpl(ConstTpl::real,size)); // Size was explicitly specified
  sym = new VarnodeSymbol(*varname,tmpvn->getSpace().getSpace(),tmpvn->getOffset().getReal(),tmpvn->getSize().getReal());
  addSymbol(sym);
  delete varname;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x401d0
movq %rax, %r15
testl %ebp, %ebp
je 0x52cd6
movl %ebp, %edx
movq %rsp, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x40b10
movups (%r12), %xmm0
movups 0xc(%r12), %xmm1
movups %xmm1, 0x4c(%r15)
movups %xmm0, 0x40(%r15)
movl $0x58, %edi
callq 0x40800
movq %rax, %r12
movq 0x8(%r15), %rdx
movq 0x30(%r15), %rcx
movl 0x50(%r15), %r8d
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40af0
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x52d1d
movq (%rax), %rsi
incq %rsi
callq 0x40870
movl $0x20, %esi
movq %rbx, %rdi
callq 0x40870
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r12, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOp(OpCode, ExprTree*)
ExprTree *PcodeCompile::createOp(OpCode opc,ExprTree *vn)

{				// Create new expression with output -outvn-
				// built by performing -opc- on input vn.
				// Free input expression
  VarnodeTpl *outvn = buildTemporary();
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn->outvn);
  op->setOutput(outvn);
  vn->ops->push_back(op);
  vn->outvn = new VarnodeTpl(*outvn);
  return vn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
callq 0x401d0
movq %rax, %r14
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x42010
movq (%rsp), %rax
movq %r14, (%rax)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x52db3
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x52dbb
movq %rsp, %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40800
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x41bf0
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r15, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOp(OpCode, ExprTree*, ExprTree*)
ExprTree *PcodeCompile::createOp(OpCode opc,ExprTree *vn1,
				    ExprTree *vn2)

{				// Create new expression with output -outvn-
				// built by performing -opc- on inputs vn1 and vn2.
				// Free input expressions
  VarnodeTpl *outvn = buildTemporary();
  vn1->ops->insert(vn1->ops->end(),vn2->ops->begin(),vn2->ops->end());
  vn2->ops->clear();
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn1->outvn);
  op->addInput(vn2->outvn);
  vn2->outvn = (VarnodeTpl *)0;
  op->setOutput(outvn);
  vn1->ops->push_back(op);
  vn1->outvn = new VarnodeTpl(*outvn);
  delete vn2;
  return vn1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
callq 0x401d0
movq %rax, %r15
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
movq (%r14), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x3f850
movq (%r14), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x52e40
movq %rcx, 0x8(%rax)
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %r12d, %r12d
movq %r12, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %r12, (%rax)
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x42010
movq 0x8(%rsp), %rdi
movq 0x8(%r14), %rsi
callq 0x42010
movq %r12, 0x8(%r14)
movq 0x8(%rsp), %rax
movq %r15, (%rax)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x52ea5
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x52eaf
leaq 0x8(%rsp), %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40800
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x41bf0
movq %r12, 0x8(%rbx)
movq %r14, %rdi
callq 0x40f50
movl $0x10, %esi
movq %r14, %rdi
callq 0x40870
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r12, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOpOut(VarnodeTpl*, OpCode, ExprTree*, ExprTree*)
ExprTree *PcodeCompile::createOpOut(VarnodeTpl *outvn,OpCode opc,
				       ExprTree *vn1,ExprTree *vn2)
{ // Create an op with explicit output and two inputs
  vn1->ops->insert(vn1->ops->end(),vn2->ops->begin(),vn2->ops->end());
  vn2->ops->clear();
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn1->outvn);
  op->addInput(vn2->outvn);
  vn2->outvn = (VarnodeTpl *)0;
  op->setOutput(outvn);
  vn1->ops->push_back(op);
  vn1->outvn = new VarnodeTpl(*outvn);
  delete vn2;
  return vn1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq (%rcx), %rdi
movq 0x8(%rdi), %rsi
movq (%r8), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x3f850
movq (%r14), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x52f45
movq %rcx, 0x8(%rax)
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %r12d, %r12d
movq %r12, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %r12, (%rax)
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x42010
movq 0x8(%rsp), %rdi
movq 0x8(%r14), %rsi
callq 0x42010
movq %r12, 0x8(%r14)
movq 0x8(%rsp), %rax
movq %r15, (%rax)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x52faa
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x52fb4
leaq 0x8(%rsp), %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40800
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x41bf0
movq %r12, 0x8(%rbx)
movq %r14, %rdi
callq 0x40f50
movl $0x10, %esi
movq %r14, %rdi
callq 0x40870
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r12, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOpOutUnary(VarnodeTpl*, OpCode, ExprTree*)
ExprTree *PcodeCompile::createOpOutUnary(VarnodeTpl *outvn,OpCode opc,ExprTree *vn)

{ // Create an op with explicit output and 1 input
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn->outvn);
  op->setOutput(outvn);
  vn->ops->push_back(op);
  vn->outvn = new VarnodeTpl(*outvn);
  return vn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x42010
movq (%rsp), %rax
movq %r14, (%rax)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x5306c
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x53074
movq %rsp, %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40800
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x41bf0
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r15, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOpNoOut(OpCode, ExprTree*)
vector<OpTpl *> *PcodeCompile::createOpNoOut(OpCode opc,ExprTree *vn)

{				// Create new expression by creating op with given -opc-
				// and single input vn.   Free the input expression
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn->outvn);
  vn->outvn = (VarnodeTpl *)0;	// There is no longer an output to this expression
  vector<OpTpl *> *res = vn->ops;
  vn->ops = (vector<OpTpl *> *)0;
  delete vn;
  res->push_back(op);
  return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movl %ebx, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, (%rsp)
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x42010
movq (%r14), %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %r14, %rdi
callq 0x40f50
movl $0x10, %esi
movq %r14, %rdi
callq 0x40870
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x53123
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x5312e
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x3f150
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOpNoOut(OpCode, ExprTree*, ExprTree*)
vector<OpTpl *> *PcodeCompile::createOpNoOut(OpCode opc,ExprTree *vn1,ExprTree *vn2)

{				// Create new expression by creating op with given -opc-
				// and inputs vn1 and vn2. Free the input expressions
  vector<OpTpl *> *res = vn1->ops;
  vn1->ops = (vector<OpTpl *> *)0;
  res->insert(res->end(),vn2->ops->begin(),vn2->ops->end());
  vn2->ops->clear();
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn1->outvn);
  vn1->outvn = (VarnodeTpl *)0;
  op->addInput(vn2->outvn);
  vn2->outvn = (VarnodeTpl *)0;
  res->push_back(op);
  delete vn1;
  delete vn2;
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq (%rdx), %rbx
movq $0x0, (%rdx)
movq 0x8(%rbx), %rsi
movq (%rcx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rbx, %rdi
callq 0x3f850
movq (%r14), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x5317e
movq %rcx, 0x8(%rax)
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %r12d, %r12d
movq %r12, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %r12, (%rax)
movq %rax, 0x8(%rsp)
movq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x42010
movq %r12, 0x8(%r15)
movq 0x8(%rsp), %rdi
movq 0x8(%r14), %rsi
callq 0x42010
movq %r12, 0x8(%r14)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x531dc
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x531e9
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3f150
movq %r15, %rdi
callq 0x40f50
movl $0x10, %esi
movq %r15, %rdi
callq 0x40870
movq %r14, %rdi
callq 0x40f50
movl $0x10, %esi
movq %r14, %rdi
callq 0x40870
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOpConst(OpCode, unsigned long)
vector<OpTpl *> *PcodeCompile::createOpConst(OpCode opc,uintb val)

{
  VarnodeTpl *vn = new VarnodeTpl(ConstTpl(constantspace),
				    ConstTpl(ConstTpl::real,val),
				    ConstTpl(ConstTpl::real,4));
  vector<OpTpl *> *res = new vector<OpTpl *>;
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn);
  res->push_back(op);
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x68, %edi
callq 0x40800
movq %rax, %rbx
movq 0x10(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x40390
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x40b10
leaq 0x28(%rsp), %rdi
movl $0x4, %edx
xorl %esi, %esi
callq 0x40b10
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x41aa0
movl $0x18, %edi
callq 0x40800
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r15, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %r15, (%rax)
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x42010
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x532e6
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x532f3
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x3f150
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53305
jmp 0x53305
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x40870
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createLoad(StarQuality*, ExprTree*)
ExprTree *PcodeCompile::createLoad(StarQuality *qual,ExprTree *ptr)

{				// Create new load expression, free ptr expression
  VarnodeTpl *outvn = buildTemporary();
  OpTpl *op = new OpTpl(CPUI_LOAD);
  // The first varnode input to the load is a constant reference to the AddrSpace being loaded
  // from.  Internally, we really store the pointer to the AddrSpace as the reference, but this
  // isn't platform independent. So officially, we assume that the constant reference will be the
  // AddrSpace index.  We can safely assume this always has size 4.
  VarnodeTpl *spcvn = new VarnodeTpl(ConstTpl(constantspace),
				     qual->id,
				     ConstTpl(ConstTpl::real,8));
  op->addInput(spcvn);
  op->addInput(ptr->outvn);
  op->setOutput(outvn);
  ptr->ops->push_back(op);
  if (qual->size > 0)
    force_size(outvn,ConstTpl(ConstTpl::real,qual->size),*ptr->ops);
  ptr->outvn = new VarnodeTpl(*outvn);
  delete qual;
  return ptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
callq 0x401d0
movq %rax, %r15
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movl $0x2, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movl $0x68, %edi
callq 0x40800
movq %rax, %r12
movq 0x10(%r13), %rsi
leaq 0x10(%rsp), %rdi
callq 0x40390
leaq 0x30(%rsp), %rdi
movl $0x8, %edx
xorl %esi, %esi
callq 0x40b10
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rcx
movq %r12, %rdi
movq %r14, %rdx
callq 0x41aa0
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x42010
movq 0x8(%rsp), %rdi
movq 0x8(%rbx), %rsi
callq 0x42010
movq 0x8(%rsp), %rax
movq %r15, (%rax)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x533e2
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x533ec
leaq 0x8(%rsp), %rdx
callq 0x3f150
movl 0x20(%r14), %edx
testq %rdx, %rdx
je 0x53412
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x40b10
movq (%rbx), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3f380
movl $0x68, %edi
callq 0x40800
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x41bf0
movq %r12, 0x8(%rbx)
movl $0x28, %esi
movq %r14, %rdi
callq 0x40870
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x53450
jmp 0x53450
movq %rax, %rbx
movl $0x68, %esi
movq %r12, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00