LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::resolveConstant(AddrSpace*, unsigned long, int, Address const&, unsigned long&) const
Address AddrSpaceManager::resolveConstant(AddrSpace *spc,uintb val,int4 sz,const Address &point,uintb &fullEncoding) const

{
  int4 ind = spc->getIndex();
  if (ind < resolvelist.size()) {
    AddressResolver *resolve = resolvelist[ind];
    if (resolve != (AddressResolver *)0)
      return resolve->resolve(val,sz,point,fullEncoding);
  }
  fullEncoding = val;
  val = AddrSpace::addressToByte(val,spc->getWordSize());
  val = spc->wrapOffset(val);
  return Address(spc,val);
}

// Assembly:
pushq %rbx
movq %rdx, %r10
movq %rdi, %rbx
movq 0x10(%rsp), %rax
movslq 0x60(%rdx), %rdx
movq 0x20(%rsi), %rdi
movq 0x28(%rsi), %rsi
subq %rdi, %rsi
sarq $0x3, %rsi
cmpq %rdx, %rsi
jbe 0x4d89f
movq (%rdi,%rdx,8), %rsi
testq %rsi, %rsi
je 0x4d89f
movq (%rsi), %r10
movq %rbx, %rdi
movq %rcx, %rdx
movl %r8d, %ecx
movq %r9, %r8
movq %rax, %r9
callq *0x10(%r10)
jmp 0x4d8cf
movq %rcx, (%rax)
movl 0x5c(%r10), %eax
imulq %rcx, %rax
movq 0x28(%r10), %rcx
cmpq %rax, %rcx
jae 0x4d8c8
incq %rcx
cqto
idivq %rcx
movq %rdx, %rax
sarq $0x3f, %rax
andq %rcx, %rax
addq %rdx, %rax
movq %r10, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::getNextSpaceInOrder(AddrSpace*) const
AddrSpace *AddrSpaceManager::getNextSpaceInOrder(AddrSpace *spc) const
{
  if (spc == (AddrSpace *)0) {
    return baselist[0];
  }
  if (spc == (AddrSpace *) ~((uintp)0)) {
    return (AddrSpace *)0;
  }
  int4 index = spc->getIndex() + 1;
  while (index < baselist.size()) {
    AddrSpace *res = baselist[index];
    if (res != (AddrSpace *)0)
      return res;
    index += 1;
  }
  return (AddrSpace *) ~((uintp)0);
}

// Assembly:
cmpq $-0x1, %rsi
je 0x4d8e7
testq %rsi, %rsi
jne 0x4d8ea
movq 0x8(%rdi), %rax
movq (%rax), %rax
retq
xorl %eax, %eax
retq
movslq 0x60(%rsi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
incq %rcx
cmpq %rcx, %rsi
jbe 0x4d912
movq (%rdx,%rcx,8), %rax
incq %rcx
testq %rax, %rax
je 0x4d900
retq
movq $-0x1, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::truncateSpace(TruncationTag const&)
void AddrSpaceManager::truncateSpace(const TruncationTag &tag)

{
  AddrSpace *spc = getSpaceByName(tag.getName());
  if (spc == (AddrSpace *)0)
    throw LowlevelError("Unknown space in <truncate_space> command: "+tag.getName());
  spc->truncateSpace(tag.getSize());
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x41ed0
addq $0x40, %rbx
cmpq %rbx, %rax
je 0x4ddb0
movq 0x40(%rax), %rdi
testq %rdi, %rdi
je 0x4ddb0
movl 0x20(%r14), %esi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x41440
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x31ee9(%rip), %rsi     # 0x7fcad
movq %rsp, %rdi
movq %r14, %rdx
callq 0x40510
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x550c2(%rip), %rsi     # 0xa2ea8
movq 0x54e4b(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4de13
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x4de1d
jmp 0x4de25
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: AddrSpaceManager::constructFloatExtensionAddress(Address const&, int, int)
Address AddrSpaceManager::constructFloatExtensionAddress(const Address &realaddr,int4 realsize,
							 int4 logicalsize)
{
  if (logicalsize == realsize)
    return realaddr;
  vector<VarnodeData> pieces;
  pieces.push_back(VarnodeData());
  pieces.back().space = realaddr.getSpace();
  pieces.back().offset = realaddr.getOffset();
  pieces.back().size = realsize;

  JoinRecord *join = findAddJoin(pieces,logicalsize);
  return join->getUnified().getAddr();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r12
movq %rdi, %rbx
cmpl %ecx, %r8d
jne 0x4de57
movq (%r12), %rax
movq %rax, (%rbx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbx)
jmp 0x4dec9
movl %r8d, %ebp
movl %ecx, %r15d
movq %rsi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x20(%rsp), %rdx
movq %rax, 0x10(%rdx)
movaps %xmm0, (%rdx)
xorl %esi, %esi
callq 0x41470
movq %rsp, %rsi
movq 0x8(%rsi), %rax
movq (%r12), %rcx
movq %rcx, -0x18(%rax)
movq 0x8(%r12), %rax
movq 0x8(%rsi), %rcx
movq %rax, -0x10(%rcx)
movl %r15d, -0x8(%rcx)
movq %r14, %rdi
movl %ebp, %edx
callq 0x410b0
movups 0x18(%rax), %xmm0
movups %xmm0, (%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4dec9
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4dedb
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4def4
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: PcodeEmit::unpackOffset(unsigned char const*, unsigned long&)
const uint1 *PcodeEmit::unpackOffset(const uint1 *ptr,uintb &off)

{
  uintb res = 0;
  int4 shift;
  for(shift=0;shift<67;shift+=6) {
    uint1 val = *ptr++;
    if (val == end_tag) {
      off = res;
      return ptr;
    }
    uintb bits = ((uintb)(val-0x20))<<shift;
    res |= bits;
  }
  throw LowlevelError("Bad packed offset");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
incq %rdi
movq $-0x6, %rcx
xorl %eax, %eax
movzbl -0x1(%rdi), %edx
cmpq $0x60, %rdx
je 0x4e6cf
addq $0x6, %rcx
addq $-0x20, %rdx
shlq %cl, %rdx
orq %rdx, %rax
incq %rdi
cmpq $0x3d, %rcx
jb 0x4e658
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3167d(%rip), %rsi     # 0x7fd13
leaq 0x31687(%rip), %rdx     # 0x7fd24
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x547e8(%rip), %rsi     # 0xa2ea8
movq 0x54571(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, (%rsi)
movq %rdi, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4e6fa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x4e704
jmp 0x4e70c
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: PcodeEmit::unpackVarnodeData(unsigned char const*, VarnodeData&, AddrSpaceManager const*)
const uint1 *PcodeEmit::unpackVarnodeData(const uint1 *ptr,VarnodeData &v,const AddrSpaceManager *manage)

{
  uint1 tag = *ptr++;
  if (tag == addrsz_tag) {
    int4 spcindex = (int4)(*ptr++ - 0x20);
    v.space = manage->getSpace(spcindex);
    ptr = unpackOffset(ptr,v.offset);
    v.size = (uint4)(*ptr++ - 0x20);
  }
  else if (tag == spaceid_tag) {
    v.space = manage->getConstantSpace();
    int4 spcindex = (int4)(*ptr++ - 0x20);
    v.offset = (uintb)(uintp)manage->getSpace( spcindex );
    v.size = sizeof(void *);
  }
  else
    throw LowlevelError("Bad packed VarnodeData");
  return ptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movzbl (%rdi), %eax
cmpl $0x24, %eax
je 0x4e75c
cmpl $0x25, %eax
jne 0x4e794
movzbl 0x1(%rdi), %eax
addq $0x2, %rdi
movq 0x8(%rdx), %rcx
movq -0x100(%rcx,%rax,8), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rsi
callq 0x40820
movq %rax, %rdi
movzbl (%rax), %eax
incq %rdi
addl $-0x20, %eax
jmp 0x4e783
movq 0x98(%rdx), %rax
movq %rax, (%rbx)
movzbl 0x1(%rdi), %eax
addq $0x2, %rdi
movq 0x8(%rdx), %rcx
movq -0x100(%rcx,%rax,8), %rax
movq %rax, 0x8(%rbx)
movl $0x8, %eax
movl %eax, 0x10(%rbx)
movq %rdi, %rax
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 0x31574(%rip), %rsi     # 0x7fd25
leaq 0x31583(%rip), %rdx     # 0x7fd3b
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x546cd(%rip), %rsi     # 0xa2ea8
movq 0x54456(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4e804
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x4e80e
jmp 0x4e816
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::ParserContext(ContextCache*)
ParserContext::ParserContext(ContextCache *ccache)

{
  parsestate = 0;
  contcache = ccache;
  if (ccache != (ContextCache *)0) {
    contextsize = ccache->getDatabase()->getContextSize();
    context = new uintm[ contextsize ];
  }
  else {
    contextsize = 0;
    context = (uintm *)0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x60(%rdi)
movq %rax, 0x70(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rdi)
movq %rax, 0x90(%rdi)
movl $0x0, (%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movq %rsi, 0x30(%rdi)
testq %rsi, %rsi
je 0x4fa5a
leaq 0x38(%rbx), %r12
leaq 0x80(%rbx), %r14
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, 0x28(%rbx)
movl %eax, %ecx
shlq $0x2, %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x3f060
jmp 0x4fa63
movl $0x0, 0x28(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x3fc10
movq (%r12), %rdi
testq %rdi, %rdi
je 0x4fa93
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x40880
movq %r15, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::initialize(int, int, AddrSpace*)
void ParserContext::initialize(int4 maxstate,int4 maxparam,AddrSpace *spc)

{
  const_space = spc;
  state.resize(maxstate);
  state[0].parent = (ConstructState *)0;
  for(int4 i=0;i<maxstate;++i)
    state[i].resolve.resize(maxparam);
  base_state = &state[0];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
movq %rcx, 0x8(%rdi)
leaq 0x80(%rdi), %r14
movslq %esi, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x41360
movq 0x80(%rbx), %rax
movq $0x0, 0x58(%rax)
testl %r12d, %r12d
jle 0x4fb07
movslq %r15d, %r15
movl %ebp, %eax
imulq $0x68, %rax, %r12
xorl %r13d, %r13d
movq (%r14), %rax
leaq (%rax,%r13), %rdi
addq $0x40, %rdi
movq %r15, %rsi
callq 0x40570
addq $0x68, %r13
cmpq %r13, %r12
jne 0x4fae8
movq (%r14), %rax
movq %rax, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::getInstructionBytes(int, int, unsigned int) const
uintm ParserContext::getInstructionBytes(int4 bytestart,int4 size,uint4 off) const

{				// Get bytes from the instruction stream into a intm
				// (assuming big endian format)
  off += bytestart;
  if (off >=16)
    throw BadDataError("Instruction is using more than 16 bytes"); 
  const uint1 *ptr = buf + off;
  uintm res = 0;
  for(int4 i=0;i<size;++i) {
    res <<= 8;
    res |= ptr[i];
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
addl %ecx, %esi
cmpl $0x10, %esi
jae 0x4fb65
testl %edx, %edx
jle 0x4fb58
movl %esi, %eax
leaq (%rdi,%rax), %rcx
addq $0x10, %rcx
movl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
shll $0x8, %edi
movzbl (%rcx,%rsi), %eax
orl %edi, %eax
incq %rsi
movl %eax, %edi
cmpq %rsi, %rdx
jne 0x4fb43
jmp 0x4fb5a
xorl %eax, %eax
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 0x301dc(%rip), %rsi     # 0x7fd5e
leaq 0x301fc(%rip), %rdx     # 0x7fd85
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x52fa4(%rip), %rsi     # 0xa2b50
movq 0x53085(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4fbd5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x4fbdf
jmp 0x4fbe7
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::getInstructionBits(int, int, unsigned int) const
uintm ParserContext::getInstructionBits(int4 startbit,int4 size,uint4 off) const

{
  off += (startbit/8);
  if (off >= 16)
    throw BadDataError("Instruction is using more than 16 bytes");
  const uint1 *ptr = buf + off;
  startbit = startbit % 8;
  int4 bytesize = (startbit+size-1)/8 + 1;
  uintm res = 0;
  for(int4 i=0;i<bytesize;++i) {
    res <<= 8;
    res |= ptr[i];
  }
  res <<= 8*(sizeof(uintm)-bytesize)+startbit; // Move starting bit to highest position
  res >>= 8*sizeof(uintm)-size;	// Shift to bottom of intm
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leal 0x7(%rsi), %eax
testl %esi, %esi
cmovnsl %esi, %eax
movl %eax, %r8d
sarl $0x3, %r8d
addl %ecx, %r8d
cmpl $0x10, %r8d
jae 0x4fc7f
andl $-0x8, %eax
subl %eax, %esi
leal (%rdx,%rsi), %r9d
decl %r9d
leal (%rdx,%rsi), %ecx
addl $0x6, %ecx
testl %r9d, %r9d
cmovnsl %r9d, %ecx
sarl $0x3, %ecx
xorl %eax, %eax
cmpl $-0x7, %r9d
jl 0x4fc61
movl %r8d, %eax
addq %rax, %rdi
addq $0x10, %rdi
leal 0x1(%rcx), %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
shll $0x8, %r10d
movzbl (%rdi,%r9), %eax
orl %r10d, %eax
incq %r9
movl %eax, %r10d
cmpq %r9, %r8
jne 0x4fc4a
shll $0x3, %ecx
subl %ecx, %esi
addb $0x18, %sil
movl %esi, %ecx
shll %cl, %eax
negb %dl
movl %edx, %ecx
shrl %cl, %eax
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 0x300c2(%rip), %rsi     # 0x7fd5e
leaq 0x300e2(%rip), %rdx     # 0x7fd85
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x52e8a(%rip), %rsi     # 0xa2b50
movq 0x52f6b(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4fcef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x4fcf9
jmp 0x4fd01
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::getContextBytes(int, int) const
uintm ParserContext::getContextBytes(int4 bytestart,int4 size) const

{				// Get bytes from context into a uintm
  int4 intstart = bytestart / sizeof(uintm);
  uintm res = context[ intstart ];
  int4 byteOffset = bytestart % sizeof(uintm);
  int4 unusedBytes = sizeof(uintm) - size;
  res <<= byteOffset*8;
  res >>= unusedBytes*8;
  int4 remaining = size - sizeof(uintm) + byteOffset;
  if ((remaining > 0)&&(++intstart < contextsize)) { // If we extend beyond boundary of a single uintm
    uintm res2 = context[ intstart ];
    unusedBytes = sizeof(uintm) - remaining;
    res2 >>= unusedBytes * 8;
    res |= res2;
  }
  return res;
}

// Assembly:
movl %esi, %r8d
sarl $0x2, %r8d
movq 0x20(%rdi), %r9
movslq %r8d, %rax
movl (%r9,%rax,4), %eax
andl $0x3, %esi
leal (,%rsi,8), %ecx
shll %cl, %eax
leal (,%rdx,8), %ecx
negb %cl
shrl %cl, %eax
leal (%rdx,%rsi), %ecx
addl $-0x4, %ecx
testl %ecx, %ecx
jle 0x4fd56
incl %r8d
cmpl 0x28(%rdi), %r8d
jge 0x4fd56
movslq %r8d, %rdx
movl (%r9,%rdx,4), %edx
shll $0x3, %ecx
negb %cl
shrl %cl, %edx
orl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::getContextBits(int, int) const
uintm ParserContext::getContextBits(int4 startbit,int4 size) const

{
  int4 intstart = startbit / (8*sizeof(uintm));
  uintm res = context[ intstart ]; // Get intm containing highest bit
  int4 bitOffset = startbit % (8*sizeof(uintm));
  int4 unusedBits = 8*sizeof(uintm) - size;
  res <<= bitOffset;	// Shift startbit to highest position
  res >>= unusedBits;
  int4 remaining = size - 8*sizeof(uintm) + bitOffset;
  if ((remaining > 0) && (++intstart < contextsize)) {
    uintm res2 = context[ intstart ];
    unusedBits = 8*sizeof(uintm) - remaining;
    res2 >>= unusedBits;
    res |= res2;
  }
  return res;
}

// Assembly:
movl %esi, %ecx
movl %esi, %r8d
sarl $0x5, %r8d
movq 0x20(%rdi), %r9
movslq %r8d, %rax
movl (%r9,%rax,4), %eax
andl $0x1f, %ecx
shll %cl, %eax
leal (%rdx,%rcx), %esi
addl $-0x20, %esi
movl %edx, %ecx
negb %cl
shrl %cl, %eax
testl %esi, %esi
jle 0x4fd9a
incl %r8d
cmpl 0x28(%rdi), %r8d
jge 0x4fd9a
movslq %r8d, %rcx
movl (%r9,%rcx,4), %edx
negb %sil
movl %esi, %ecx
shrl %cl, %edx
orl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/context.cc
// Function: ParserContext::addCommit(TripleSymbol*, int, unsigned int, bool, ConstructState*)
void ParserContext::addCommit(TripleSymbol *sym,int4 num,uintm mask,bool flow,ConstructState *point)

{
  contextcommit.push_back(ContextSet());
  ContextSet &set(contextcommit.back());

  set.sym = sym;
  set.point = point;		// This is the current state
  set.num = num;
  set.mask = mask;
  set.value = context[num] & mask;
  set.flow = flow;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r15
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r13
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x40(%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x4fde8
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
movq 0x40(%r12), %rax
addq $0x20, %rax
movq %rax, 0x40(%r12)
jmp 0x4fdfa
leaq 0x38(%r12), %rdi
movq %rsp, %rdx
callq 0x410f0
movq 0x40(%r12), %rax
movq %r13, -0x20(%rax)
movq %r15, -0x18(%rax)
movl %r14d, -0x10(%rax)
movl %ebp, -0xc(%rax)
movq 0x20(%r12), %rcx
movslq %r14d, %rdx
andl (%rcx,%rdx,4), %ebp
movl %ebp, -0x8(%rax)
movb %bl, -0x4(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/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 0x4ffa7
movl 0x18(%r8), %r8d
incl %r8d
decl %r8d
testl %r8d, %r8d
jle 0x4ffe5
movq 0x58(%rax), %rax
cmpq %rsi, (%rax)
jne 0x4ff96
movslq %edx, %rdx
movq 0x18(%rsi), %r8
movq (%r8,%rdx,8), %r8
cmpl $0x0, 0x34(%r8)
js 0x4ffc6
movq 0x40(%rax), %r8
movq (%r8,%rdx,8), %rdx
movl 0x64(%rdx), %edx
jmp 0x4ffcd
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_O3/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 0x5001c
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 0x4fffc
jmp 0x5001f
movl %esi, %r9d
subl %ecx, %r9d
movl %r9d, 0x60(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x505dc
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3fbc0
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq 0x529fc(%rip), %rax     # 0xa2fd0
movb (%rax), %al
cmpb %al, -0x1(%rcx,%rdx)
jne 0x505e4
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 0x40490
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x529b1(%rip), %rcx     # 0xa2fd0
cmpb (%rcx), %al
jne 0x5065d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fc60
movq (%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x42100
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
je 0x506e1
movq %rsp, %rdi
callq 0x3f4d0
jmp 0x506d1
movq %rdi, %r15
movq (%rdi), %r12
cmpq 0x8(%rdi), %r12
je 0x506d1
leaq 0x10(%rsp), %rbp
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x42390
movq %rbx, %rdi
movq %r13, %rsi
callq 0x40db0
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x506a0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
movq (%rbx), %rsi
movq %r13, %rdi
movl $0x8, %edx
callq 0x42100
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
je 0x506eb
movq %r13, %rdi
callq 0x3f4d0
addq $0x20, %r12
cmpq 0x8(%r15), %r12
jne 0x50671
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
jmp 0x506fb
movq %rsp, %rdi
callq 0x3f3c0
jmp 0x506f3
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 0x5070f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3f4d0
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x50791
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 0x40a60
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x50791
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x507b9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x50d1c
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 0x40470
movq (%rsp), %r12
cmpq 0x8(%rsp), %r12
je 0x50d14
decl %ebx
movq 0x52312(%rip), %r13     # 0xa2fd0
movsbl (%r13), %esi
movq %r12, %rdi
movq $-0x1, %rdx
callq 0x42440
leaq 0x1(%rax), %rsi
movq %r12, %rdi
movq $-0x1, %rdx
movq %r14, %rcx
callq 0x40f50
testl %eax, %eax
je 0x50cfe
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x422d0
jmp 0x50d09
movq %r15, %rdi
movq %r12, %rsi
callq 0x3fbc0
addq $0x20, %r12
cmpq 0x8(%rsp), %r12
jne 0x50cbe
movq %rsp, %rdi
callq 0x400a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x50d2c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x400a0
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x52267(%rip), %rdx     # 0xa2fd0
movsbl (%rdx), %esi
leaq -0x2(%rcx), %rdx
cmpb %sil, -0x1(%rax,%rcx)
cmoveq %rdx, %r13
movq %r13, %rdx
callq 0x42440
cmpq $-0x1, %rax
je 0x50e04
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 0x408d0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x40db0
movq (%rbp), %rdi
leaq 0x18(%rsp), %r13
cmpq %r13, %rdi
je 0x50dcc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x408d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40db0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x50e1d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
jmp 0x50e1d
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_O3/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 0x41120
movq 0x8(%r14), %r13
subq (%r14), %r13
shrq $0x5, %r13
decl %r13d
movq 0x52167(%rip), %rbx     # 0xa2fd0
leaq 0x7(%rsp), %r12
cmpl %ebp, %r13d
jl 0x50ea9
movb (%rbx), %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x40b90
movslq %r13d, %rax
movq (%r14), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
decl %r13d
movq %r15, %rdi
callq 0x40b90
jmp 0x50e6e
leaq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x418c0
movq 0x51ebe(%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 0x50ef0
movq %rax, %rbx
movq 0x51e86(%rip), %rsi     # 0xa2d80
leaq 0x10(%rsp), %rdi
callq 0x3fc30
leaq 0x80(%rsp), %rdi
callq 0x3f730
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x51318
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x41e40
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40db0
movq (%r14), %rdi
leaq 0x10(%rsp), %r14
cmpq %r14, %rdi
je 0x51252
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
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 0x2eb54(%rip), %rsi     # 0x7fdcc
leaq 0x2eb53(%rip), %rdx     # 0x7fdd2
callq 0x3f8a0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x422d0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x512af
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
movq 0x28(%rsp), %rax
subq 0x20(%rsp), %rax
cmpq $0x20, %rax
jne 0x5131c
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x2eb07(%rip), %rsi     # 0x7fdd3
leaq 0x2eb0b(%rip), %rdx     # 0x7fdde
callq 0x3f8a0
movq 0x20(%rsp), %rdx
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
movl $0x1, %ecx
callq 0x422d0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x51305
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
movq 0x48(%rsp), %rax
subq 0x40(%rsp), %rax
cmpq $0x20, %rax
sete %bl
jmp 0x5131e
xorl %ebx, %ebx
jmp 0x51332
xorl %ebx, %ebx
leaq 0x40(%rsp), %rdi
callq 0x400a0
leaq 0x20(%rsp), %rdi
callq 0x400a0
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
jmp 0x51340
jmp 0x5135b
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x5135e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x40880
jmp 0x5135e
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x400a0
leaq 0x20(%rsp), %rdi
callq 0x400a0
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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), %r15
movq %rsi, (%r15)
movl $0x18, %edi
callq 0x40810
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%rbx)
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3f150
movq (%r15), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x51c38
movl $0x68, %edi
callq 0x40810
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x41c00
movq %r14, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x51c79
movl $0x68, %esi
callq 0x40880
movq (%rbx), %r14
testq %r14, %r14
je 0x51ce7
movq (%r14), %rdi
cmpq %rdi, 0x8(%r14)
je 0x51cc4
xorl %r15d, %r15d
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x51c9e
movq %r14, %rdi
callq 0x3f1f0
movl $0x28, %esi
movq %r14, %rdi
callq 0x40880
incq %r15
movq (%rbx), %r14
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r15, %rax
ja 0x51c8d
testq %rdi, %rdi
je 0x51cd5
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x40880
movl $0x18, %esi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40880
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq %rdi, 0x8(%rsp)
movl $0x18, %edi
callq 0x40810
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x51dcd
xorl %r13d, %r13d
movq 0x8(%r14), %rsi
movq (%rax,%r13,8), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %r14, %rdi
callq 0x3f850
movq (%rbx), %rcx
movq (%rcx,%r13,8), %rax
movq (%rax), %rdx
movq (%rdx), %rsi
cmpq %rsi, 0x8(%rdx)
je 0x51d66
movq %rsi, 0x8(%rdx)
movq (%rcx,%r13,8), %rax
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0x42020
movq (%rbx), %rax
movq (%rax,%r13,8), %rcx
movq $0x0, 0x8(%rcx)
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x51d92
movq %r12, %rdi
callq 0x40f60
movl $0x10, %esi
movq %r12, %rdi
callq 0x40880
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x51d31
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x51dcf
movq %r15, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x51ddc
xorl %esi, %esi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x3f150
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x51df0
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x40880
movl $0x18, %esi
movq %rbx, %rdi
callq 0x40880
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/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 0x40f60
movl $0x10, %esi
movq %rbx, %rdi
callq 0x40880
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x30, %rsp
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x51f17
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x60(%r15)
jne 0x51e91
movl $0x68, %esi
movq %r15, %rdi
callq 0x40880
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq -0x8(%rax), %r15
movq %r15, 0x8(%rsp)
movq (%r15), %rdi
movl $0x68, %esi
callq 0x40880
movq %r14, (%r15)
jmp 0x51eee
movl $0x28, %edi
callq 0x40810
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r12)
movl $0x1, 0x8(%r12)
movq %rax, (%r12)
movq %r12, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x42020
movq %r14, (%r12)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x51ee4
movq %r12, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x51eee
leaq 0x8(%rsp), %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40810
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x41c00
movq %r15, 0x8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2dfbc(%rip), %rsi     # 0x7fef0
leaq 0x2dfcd(%rip), %rdx     # 0x7ff08
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x50f32(%rip), %rsi     # 0xa2e90
movq 0x50cd3(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x51f87
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x51f91
jmp 0x51fab
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
jmp 0x51fab
movq %rax, %r14
movl $0x68, %esi
movq %r15, %rdi
callq 0x40880
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x52228
movslq %edi, %r8
shlq $0x3, %r8
addq 0x10(%rax), %r8
testb %dl, %dl
jne 0x52249
movq (%rax), %rdx
testq %rdx, %rdx
je 0x52249
movq 0x50(%rdx), %rsi
testq %rsi, %rsi
cmovneq %rdx, %rsi
cmpl $0x0, 0x40(%rdx)
cmovneq %rdx, %rsi
jmp 0x5224b
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 0x522a1
testq %rsi, %rsi
jne 0x522a1
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 0x522a1
incq %r9
testq %rsi, %rsi
je 0x52275
testb %dil, %dil
je 0x522b5
movq (%r8), %rdi
addq $0x40, %rsi
movq %rcx, %rdx
jmp 0x3f380
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40810
movq %rax, %rbx
movq 0x18(%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x403a0
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x40b20
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40b20
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x41ab0
movb $0x1, 0x60(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x5276e
jmp 0x5276e
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x40880
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40810
movq %rax, %rbx
movl 0x20(%r14), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x20(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x40560
movq 0x50760(%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 0x527ed
movq (%rax), %rsi
incq %rsi
callq 0x40880
movl $0x20, %esi
movq %r15, %rdi
callq 0x40880
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 0x40880
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r12
cmpb $0x1, 0x34(%rsi)
jne 0x52898
leaq 0x8(%rbx), %rdx
leaq 0x2d6cf(%rip), %rsi     # 0x7ff21
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x40510
leaq 0x2d6c2(%rip), %rsi     # 0x7ff28
movq %r14, %rdi
callq 0x42300
movq (%r12), %rax
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq *0x20(%rax)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52898
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
movb $0x1, 0x34(%rbx)
movl $0x18, %edi
callq 0x40810
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
movl $0x28, %edi
callq 0x40810
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r15, 0x20(%rax)
movl $0x41, 0x8(%rax)
movq %r15, (%rax)
movq %rax, 0x8(%rsp)
movl $0x68, %edi
callq 0x40810
movq %rax, %r15
movq 0x10(%r12), %rsi
leaq 0x10(%rsp), %rdi
callq 0x403a0
movl 0x30(%rbx), %edx
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x40b20
leaq 0x30(%rsp), %rdi
movl $0x4, %edx
xorl %esi, %esi
callq 0x40b20
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %r15, %rdi
callq 0x41ab0
movq %r13, %rdi
movq %r15, %rsi
callq 0x42020
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3f150
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5297a
jmp 0x5297a
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5298a
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0x52985
movq %rax, %rbx
movl $0x68, %esi
movq %r15, %rdi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10