LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x18(%r8), %eax
addq $0x10, %r8
movq (%r8), %r8
cmpq %rsi, (%r8)
je 0x5cf34
testl %eax, %eax
jle 0x5cf6f
decl %eax
addq $0x58, %r8
jmp 0x5cf20
movslq %edx, %rax
movq 0x18(%rsi), %rdx
movq (%rdx,%rax,8), %rdx
cmpl $0x0, 0x34(%rdx)
js 0x5cf52
movq 0x40(%r8), %rdx
movq (%rdx,%rax,8), %rax
movl 0x64(%rax), %eax
jmp 0x5cf59
movl 0x30(%rdx), %eax
addl 0x64(%r8), %eax
movl %eax, 0x64(%rcx)
movq %rsi, (%rcx)
movl 0x60(%r8), %eax
movl %eax, 0x60(%rcx)
movq %rcx, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %edx
cmpq %rdi, %rdx
je 0x5cfa1
movq 0x40(%rax), %r8
movq (%r8,%rdi,8), %r8
movl 0x64(%r8), %r9d
addl 0x60(%r8), %r9d
cmpl %esi, %r9d
cmovgl %r9d, %esi
incq %rdi
jmp 0x5cf80
subl %ecx, %esi
movl %esi, 0x60(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5d704
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4e310
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq 0x518cc(%rip), %rax     # 0xaefc8
movb (%rax), %al
cmpb %al, -0x1(%rcx,%rdx)
jne 0x5d70c
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 0x4f090
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x51881(%rip), %rcx     # 0xaefc8
cmpb (%rcx), %al
jne 0x5d78a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e400
movq (%rbx), %rsi
movq %rsp, %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x51bb0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
je 0x5d7f1
movq %rsp, %rdi
callq 0x4d7e0
andq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
jmp 0x5d801
movq %rdi, %r15
movq (%rdi), %r12
movq %rsp, %r13
pushq $0x8
popq %rbp
cmpq 0x8(%r15), %r12
je 0x5d77d
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x51f80
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4fef0
movq %r13, %rdi
callq 0x4e020
movq (%rbx), %rsi
movq %r13, %rdi
movl %ebp, %edx
callq 0x51bb0
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
je 0x5d7e7
movq %r13, %rdi
callq 0x4d7e0
addq $0x20, %r12
jmp 0x5d796
movq %rsp, %rdi
callq 0x4d5f0
jmp 0x5d7f9
movq %rsp, %rdi
callq 0x4d5f0
movq %rsp, %rdi
callq 0x4d7e0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5d815
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4d7e0
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x4e330
testq %rax, %rax
je 0x5d873
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x515e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f940
leaq 0x10(%rsp), %rdi
callq 0x4e020
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/filemanage.cc
// Function: FileManage::directoryList(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&, bool)
void FileManage::directoryList(vector<string> &res,const string &dirname,bool allowdot)

{ // List full pathnames of all directories under the directory -dir-
  DIR *dir;
  struct dirent *entry;
  string dirfinal;

  dirfinal = dirname;
  if (dirfinal[dirfinal.size()-1] != separator)
    dirfinal += separator;

  dir = opendir(dirfinal.c_str());
  if (dir == (DIR *)0) return;
  entry = readdir(dir);
  while(entry != (struct dirent *)0) {
    if (entry->d_type == DT_DIR) {
      string fullname(entry->d_name);
      if ((fullname!=".")&&(fullname!="..")) {
	if (allowdot || (fullname[0] != '.'))
	  res.push_back( dirfinal + fullname );
      }
    }
    entry = readdir(dir);
  }
  closedir(dir);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebx
movq %rdi, 0x20(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
callq 0x4e400
movq (%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x514ee(%rip), %rax     # 0xaefc8
movb (%rax), %al
cmpb %al, -0x1(%rdi,%rcx)
je 0x5daf1
movsbl %al, %esi
movq %rsp, %rdi
callq 0x4f090
movq (%rsp), %rdi
callq 0x50ba0
testq %rax, %rax
je 0x5dba8
movq %rax, %r15
movq %rax, %rdi
callq 0x50d70
leaq 0x28(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq 0x29275(%rip), %rbp     # 0x86d90
leaq 0x2926d(%rip), %r14     # 0x86d8f
testq %rax, %rax
je 0x5dba0
cmpb $0x4, 0x12(%rax)
jne 0x5db96
addq $0x13, %rax
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x515e0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x4ee50
testb %al, %al
je 0x5db8e
movq %r12, %rdi
movq %r14, %rsi
callq 0x4ee50
testb %al, %al
je 0x5db8e
testb %bl, %bl
jne 0x5db6b
movq 0x28(%rsp), %rax
cmpb $0x2e, (%rax)
je 0x5db8e
movq %r13, %rdi
movq %rsp, %rsi
movq %r12, %rdx
callq 0x51f80
movq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0x4dc80
movq %r13, %rdi
callq 0x4e020
movq %r12, %rdi
callq 0x4e020
movq %r15, %rdi
callq 0x50d70
jmp 0x5db22
movq %r15, %rdi
callq 0x510c0
movq %rsp, %rdi
callq 0x4e020
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4e020
jmp 0x5dbd7
jmp 0x5dbd4
jmp 0x5dbe3
jmp 0x5dbe3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4e020
jmp 0x5dbe6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %ecx, %ecx
je 0x5dc94
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rdx, %rsi
xorl %edx, %edx
callq 0x4f040
movq (%rsp), %r12
decl %ebx
movq 0x5138f(%rip), %rbp     # 0xaefc8
pushq $-0x1
popq %r13
cmpq 0x8(%rsp), %r12
je 0x5dc8c
movsbl (%rbp), %esi
movq %r12, %rdi
movq %r13, %rdx
callq 0x520a0
leaq 0x1(%rax), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq %r14, %rcx
callq 0x501e0
testl %eax, %eax
je 0x5dc7b
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x51e40
jmp 0x5dc86
movq %r15, %rdi
movq %r12, %rsi
callq 0x4e310
addq $0x20, %r12
jmp 0x5dc3d
movq %rsp, %rdi
callq 0x4ea80
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5dca5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4ea80
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq -0x1(%rcx), %r13
movq 0x512e7(%rip), %rdx     # 0xaefc8
movsbl (%rdx), %esi
leaq -0x2(%rcx), %rdx
cmpb %sil, -0x1(%rax,%rcx)
cmoveq %rdx, %r13
movq %r13, %rdx
callq 0x520a0
cmpq $-0x1, %rax
je 0x5dd5b
movq %rax, %r12
subq %rax, %r13
incq %r12
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x4f700
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4fef0
movq %rbp, %rdi
callq 0x4e020
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x4f700
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4fef0
movq %r15, %rdi
callq 0x4e020
jmp 0x5dd71
movq %r15, %rdi
movq %r14, %rsi
callq 0x4e400
andq $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_O2/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 $0x178, %rsp            # imm = 0x178
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x504a0
movq 0x8(%r14), %r12
subq (%r14), %r12
shrq $0x5, %r12
decl %r12d
movq 0x5120f(%rip), %r13     # 0xaefc8
cmpl %ebp, %r12d
jl 0x5dde2
movsbl (%r13), %esi
movq %r15, %rdi
callq 0x4fc10
movslq %r12d, %rsi
shlq $0x5, %rsi
addq (%r14), %rsi
decl %r12d
movq %r15, %rdi
callq 0x4f1b0
jmp 0x5ddb9
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x50fb0
movq %rsp, %rdi
callq 0x4d7c0
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5de0e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4d7c0
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x68, %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 0x5e15a
movq %rdi, %rsi
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x51780
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4fef0
movq %r14, %rdi
callq 0x4e020
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
leaq 0x28cda(%rip), %rsi     # 0x86dac
leaq 0x48(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdx
callq 0x51e40
leaq 0x48(%rsp), %rdi
callq 0x4e020
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
cmpq $0x20, %rax
jne 0x5e15e
leaq 0x28c9c(%rip), %rsi     # 0x86db3
leaq 0x48(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
pushq $0x1
popq %rcx
callq 0x51e40
leaq 0x48(%rsp), %rdi
callq 0x4e020
movq 0x38(%rsp), %rax
subq 0x30(%rsp), %rax
cmpq $0x20, %rax
sete %bl
jmp 0x5e160
xorl %ebx, %ebx
jmp 0x5e174
xorl %ebx, %ebx
leaq 0x30(%rsp), %rdi
callq 0x4ea80
leaq 0x10(%rsp), %rdi
callq 0x4ea80
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x5e182
jmp 0x5e191
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4e020
jmp 0x5e194
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4ea80
leaq 0x10(%rsp), %rdi
callq 0x4ea80
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
pushq $0x18
popq %rdi
callq 0x4f5d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x50780
movq (%r14), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x5e830
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x51460
jmp 0x5e833
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r14, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5e874
pushq $0x68
popq %rsi
callq 0x4f670
movq (%rbx), %r15
testq %r15, %r15
je 0x5e8d8
xorl %r12d, %r12d
pushq $0x28
popq %r14
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x5e8ba
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x5e8a7
movq %r15, %rdi
callq 0x4d290
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f670
incq %r12
movq (%rbx), %r15
jmp 0x5e883
movq %r15, %rdi
callq 0x51010
pushq $0x18
popq %rsi
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4f670
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rdi, (%rsp)
pushq $0x18
popq %rdi
callq 0x4f5d0
movq %rax, %r14
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %ebp, %ebp
pushq $0x10
popq %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
jbe 0x5e999
movq 0x8(%r14), %rsi
movq (%rax,%rbp,8), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %r14, %rdi
callq 0x4d5e0
movq (%rbx), %rcx
movq (%rcx,%rbp,8), %rax
movq (%rax), %rdx
movq (%rdx), %rsi
cmpq %rsi, 0x8(%rdx)
je 0x5e95d
movq %rsi, 0x8(%rdx)
movq (%rcx,%rbp,8), %rax
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0x51a50
movq (%rbx), %rax
movq (%rax,%rbp,8), %rcx
andq $0x0, 0x8(%rcx)
movq (%rax,%rbp,8), %r13
testq %r13, %r13
je 0x5e986
movq %r13, %rdi
callq 0x501f0
movq %r13, %rdi
movq %r12, %rsi
callq 0x4f670
incq %rbp
jmp 0x5e915
movq %rsp, %rsi
movq %r14, %rdi
callq 0x50780
movq %rbx, %rdi
callq 0x50240
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x4f670
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_O2/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
andq $0x0, (%rdi)
callq 0x501f0
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x4f670
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x5eab2
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x60(%r15)
jne 0x5ea44
pushq $0x68
popq %rsi
movq %r15, %rdi
callq 0x4f670
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq -0x8(%rax), %r15
movq %r15, 0x10(%rsp)
movq %r15, %rdi
callq 0x51d80
movq %r14, (%r15)
jmp 0x5ea89
pushq $0x28
popq %rdi
callq 0x4f5d0
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl $0x1, 0x8(%rax)
andq $0x0, (%rax)
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movq %rax, %rdi
movq %r15, %rsi
callq 0x51a50
movq %r14, (%r12)
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x50780
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x51460
movq %r15, 0x8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x2840c(%rip), %rsi     # 0x86ed0
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x5039c(%rip), %rsi     # 0xaee88
movq 0x50145(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x5eb12
jmp 0x5eb2a
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
jmp 0x5eb2a
movq %rax, %r14
pushq $0x68
popq %rsi
movq %r15, %rdi
callq 0x4f670
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5ed64
movslq %edi, %r8
shlq $0x3, %r8
addq 0x10(%rax), %r8
testb %dl, %dl
jne 0x5ed85
movq (%rax), %rdx
testq %rdx, %rdx
je 0x5ed85
movq 0x50(%rdx), %rsi
testq %rsi, %rsi
cmovneq %rdx, %rsi
cmpl $0x0, 0x40(%rdx)
cmovneq %rdx, %rsi
jmp 0x5ed87
xorl %esi, %esi
movq (%r8), %rdi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rax
subq %rdx, %rax
shrq $0x3, %rax
cltq
xorl %r8d, %r8d
cmpq %rax, %r8
jge 0x5edc5
testq %rsi, %rsi
jne 0x5edc5
movq (%rdx,%r8,8), %r9
movq 0x50(%r9), %rsi
testq %rsi, %rsi
cmovneq %r9, %rsi
cmpl $0x0, 0x40(%r9)
cmovneq %r9, %rsi
incq %r8
jmp 0x5ed9e
testq %rsi, %rsi
je 0x5edd6
addq $0x40, %rsi
movq %rcx, %rdx
jmp 0x4d520
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::propagateSize(ConstructTpl*)
bool PcodeCompile::propagateSize(ConstructTpl *ct)

{				// Fill in size for varnodes with size 0
				// Return first OpTpl with a size 0 varnode
				// that cannot be filled in or NULL otherwise
  vector<OpTpl *> zerovec,zerovec2;
  vector<OpTpl *>::const_iterator iter;
  int4 lastsize;

  for(iter=ct->getOpvec().begin();iter!=ct->getOpvec().end();++iter)
    if ((*iter)->isZeroSize()) {
      fillinZero(*iter,ct->getOpvec());
      if ((*iter)->isZeroSize())
	zerovec.push_back(*iter);
    }
  lastsize = zerovec.size() + 1;
  while( zerovec.size() < lastsize ) {
    lastsize = zerovec.size();
    zerovec2.clear();
    for(iter=zerovec.begin();iter!=zerovec.end();++iter) {
      fillinZero(*iter,ct->getOpvec());
      if ((*iter)->isZeroSize())
	zerovec2.push_back( *iter );
    }
    zerovec = zerovec2;
  }
  if ( lastsize != 0 ) return false;
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %r15
andq $0x0, 0x10(%r15)
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rsp)
movaps %xmm0, (%r15)
movaps %xmm0, (%rsp)
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %r12
cmpq 0x10(%r14), %r12
je 0x5f0ae
movq (%r12), %rdi
callq 0x51980
testb %al, %al
je 0x5f0a8
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x4ed30
movq (%r12), %rdi
callq 0x51980
testb %al, %al
je 0x5f0a8
movq %r15, %rdi
movq %r12, %rsi
callq 0x50780
addq $0x8, %r12
jmp 0x5f071
leaq 0x20(%rsp), %r14
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x3, %rcx
incl %ecx
movq %rsp, %r15
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %rax
movq %rax, %r13
subq %r12, %r13
sarq $0x3, %r13
movslq %ecx, %rdx
cmpq %rdx, %r13
jae 0x5f133
movq (%rsp), %rcx
cmpq %rcx, 0x8(%rsp)
je 0x5f11e
movq %rcx, 0x8(%rsp)
jmp 0x5f11e
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x4ed30
movq (%r12), %rdi
callq 0x51980
testb %al, %al
je 0x5f115
movq %r15, %rdi
movq %r12, %rsi
callq 0x50780
addq $0x8, %r12
movq 0x28(%rsp), %rax
cmpq %rax, %r12
jne 0x5f0f1
movq %r14, %rdi
movq %r15, %rsi
callq 0x50c60
movl %r13d, %ecx
jmp 0x5f0c3
testl %ecx, %ecx
sete %bl
movq %rsp, %rdi
callq 0x51010
leaq 0x20(%rsp), %rdi
callq 0x51010
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5f15e
jmp 0x5f15e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x51010
leaq 0x20(%rsp), %rdi
callq 0x51010
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
movq 0x18(%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4ef60
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x4fa20
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4fa20
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x51230
movb $0x1, 0x60(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x5f1ee
jmp 0x5f1ee
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x4f670
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x40
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
movl 0x20(%r14), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x20(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x512f0
movq %r15, %rdi
callq 0x4e020
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x4f670
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x4f670
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %r12
cmpb $0x1, 0x34(%rsi)
jne 0x5f2c7
leaq 0x8(%r14), %rdx
leaq 0x27c6f(%rip), %rsi     # 0x86f01
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x4f1c0
leaq 0x27c62(%rip), %rsi     # 0x86f08
movq %rbx, %rdi
callq 0x51e80
movq (%r12), %rax
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq *0x20(%rax)
leaq 0x10(%rsp), %rdi
callq 0x4e020
movb $0x1, 0x34(%r14)
pushq $0x18
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
pushq $0x28
popq %rdi
callq 0x4f5d0
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl $0x41, 0x8(%rax)
andq $0x0, (%rax)
movq %rax, 0x8(%rsp)
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r15
movq 0x10(%r12), %rsi
leaq 0x10(%rsp), %rdi
callq 0x4ef60
movl 0x30(%r14), %edx
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x4fa20
leaq 0x30(%rsp), %rdi
pushq $0x4
popq %rdx
xorl %esi, %esi
callq 0x4fa20
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %r15, %rdi
callq 0x51230
movq %r13, %rdi
movq %r15, %rsi
callq 0x51a50
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x50780
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5f395
jmp 0x5f395
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4e020
jmp 0x5f3a3
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r15, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4ec70
movq %rax, %r12
testl %r13d, %r13d
je 0x5f3ff
movl %r13d, %edx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x4fa20
movups (%r13), %xmm0
movups 0xc(%r13), %xmm1
movups %xmm1, 0x4c(%r12)
movups %xmm0, 0x40(%r12)
jmp 0x5f40d
movq 0x8(%rbx), %rax
cmpl $0x0, 0x40(%rax)
je 0x5f4ac
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4e770
pushq $0x58
popq %rdi
callq 0x4f5d0
movq %rax, %r13
movq 0x8(%r12), %rdx
movq 0x30(%r12), %rcx
movl 0x50(%r12), %r8d
movq %rax, %rdi
movq %r14, %rsi
callq 0x4fa00
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0x8(%rax)
testb %bpl, %bpl
jne 0x5f482
cmpb $0x1, 0x24(%r15)
jne 0x5f482
leaq 0x27ac6(%rip), %rsi     # 0x86f22
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0x4f1c0
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x20(%rax)
leaq 0x8(%rsp), %rdi
callq 0x4e020
movq %r14, %rdi
callq 0x4e020
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x4d840
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x50(%rax)
je 0x5f40d
addq $0x40, %rax
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
jmp 0x5f3f1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4e020
jmp 0x5f4e4
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r13, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4ec70
movq %rax, %r15
testl %ebp, %ebp
je 0x5f530
movl %ebp, %edx
movq %rsp, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x4fa20
movups (%r12), %xmm0
movups 0xc(%r12), %xmm1
movups %xmm1, 0x4c(%r15)
movups %xmm0, 0x40(%r15)
pushq $0x58
popq %rdi
callq 0x4f5d0
movq %rax, %r12
movq 0x8(%r15), %rdx
movq 0x30(%r15), %rcx
movl 0x50(%r15), %r8d
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4fa00
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x4e020
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x4f670
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r12, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
callq 0x4ec70
movq %rax, %r14
pushq $0x28
popq %rdi
callq 0x4f5d0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl %ebp, 0x8(%rax)
andq $0x0, (%rax)
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x51a50
movq %r14, (%r15)
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x50780
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x51460
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r15, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
callq 0x4ec70
movq %rax, %r15
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
movq (%r14), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x4d5e0
movq (%r14), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x5f66f
movq %rcx, 0x8(%rax)
pushq $0x28
popq %rdi
callq 0x4f5d0
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl %ebp, 0x8(%rax)
andq $0x0, (%rax)
movq %rsp, %r13
movq %rax, (%r13)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x51a50
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x51a50
andq $0x0, 0x8(%r14)
movq %r15, (%r12)
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x50780
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x51460
movq %r12, 0x8(%rbx)
movq %r14, %rdi
callq 0x501f0
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x4f670
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r12, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
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 0x4d5e0
movq (%r14), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x5f752
movq %rcx, 0x8(%rax)
pushq $0x28
popq %rdi
callq 0x4f5d0
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl %ebp, 0x8(%rax)
andq $0x0, (%rax)
movq %rsp, %r13
movq %rax, (%r13)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x51a50
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x51a50
andq $0x0, 0x8(%r14)
movq %r15, (%r12)
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x50780
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x51460
movq %r12, 0x8(%rbx)
movq %r14, %rdi
callq 0x501f0
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x4f670
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r12, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
pushq $0x28
popq %rdi
callq 0x4f5d0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl %ebp, 0x8(%rax)
andq $0x0, (%rax)
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x51a50
movq %r14, (%r15)
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x50780
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x51460
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r15, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
pushq $0x28
popq %rdi
callq 0x4f5d0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl %ebp, 0x8(%rax)
andq $0x0, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x51a50
movq (%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
callq 0x501f0
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x4f670
movq %r15, %rdi
movq %r14, %rsi
callq 0x50780
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq (%rdx), %rbx
andq $0x0, (%rdx)
movq 0x8(%rbx), %rsi
movq (%rcx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rbx, %rdi
callq 0x4d5e0
movq (%r14), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x5f93c
movq %rcx, 0x8(%rax)
pushq $0x28
popq %rdi
callq 0x4f5d0
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl %ebp, 0x8(%rax)
andq $0x0, (%rax)
movq %rsp, %r13
movq %rax, (%r13)
movq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x51a50
andq $0x0, 0x8(%r15)
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x51a50
andq $0x0, 0x8(%r14)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x50780
movq %r15, %rdi
callq 0x501f0
pushq $0x10
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4f670
movq %r14, %rdi
callq 0x501f0
movq %r14, %rdi
movq %r12, %rsi
callq 0x4f670
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/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
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
movq 0x10(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4ef60
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x4fa20
leaq 0x28(%rsp), %rdi
pushq $0x4
popq %rdx
xorl %esi, %esi
callq 0x4fa20
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x51230
pushq $0x18
popq %rdi
callq 0x4f5d0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
pushq $0x28
popq %rdi
callq 0x4f5d0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl %ebp, 0x8(%rax)
andq $0x0, (%rax)
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x51a50
movq %r14, %rdi
movq %r15, %rsi
callq 0x50780
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5fa8b
jmp 0x5fa8b
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x4f670
movq %r14, %rdi
callq 0x518c0
nop