LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x70(%rsp)
movb (%rax), %al
movb %al, 0x5f(%rsp)
movzbl 0x5f(%rsp), %eax
cmpl $0x25, %eax
jne 0xfec44
movq 0x70(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x70(%rsp)
movzbl (%rax), %eax
subl $0x20, %eax
movl %eax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movl 0x58(%rsp), %esi
callq 0xd8ac0
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
addq $0x8, %rsi
callq 0xd8460
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x70(%rsp)
movzbl (%rax), %ecx
subl $0x20, %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x10(%rax)
jmp 0xfed5d
movzbl 0x5f(%rsp), %eax
cmpl $0x24, %eax
jne 0xfeca9
movq 0x60(%rsp), %rdi
callq 0xd9e20
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
movq 0x70(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x70(%rsp)
movzbl (%rax), %eax
subl $0x20, %eax
movl %eax, 0x54(%rsp)
movq 0x60(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0xd8ac0
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x68(%rsp), %rax
movl $0x8, 0x10(%rax)
jmp 0xfed5b
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x89049(%rip), %rsi     # 0x187d21
leaq 0x30(%rsp), %rdi
callq 0xe00a0
jmp 0xfece4
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd1ae0
jmp 0xfecf5
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0xc918a(%rip), %rsi     # 0x1c7e90
movq 0xc8ec3(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0xfed71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0xfed3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd4550
leaq 0x2f(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x1b(%rsp)
jne 0xfed4f
jmp 0xfed59
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0xfed67
jmp 0xfed5d
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/translate.cc
// Function: PcodeEmit::restorePackedOp(Address const&, unsigned char const*, AddrSpaceManager const*)
const uint1 *PcodeEmit::restorePackedOp(const Address &addr,const uint1 *ptr,const AddrSpaceManager *manage)

{
  int4 opcode;
  VarnodeData outvar;
  VarnodeData invar[30];
  VarnodeData *outptr;

  ptr += 1;			// Consume the -op- tag
  opcode = (int4)(*ptr++ - 0x20);	// Opcode
  if (*ptr == void_tag) {
    ptr += 1;
    outptr = (VarnodeData *)0;
  }
  else {
    ptr = unpackVarnodeData(ptr,outvar,manage);
    outptr = &outvar;
  }
  int4 isize = 0;
  while(*ptr != end_tag) {
    ptr = unpackVarnodeData(ptr,invar[isize],manage);
    isize += 1;
  }
  ptr += 1;			// Consume the end tag
  dump(addr,(OpCode)opcode,outptr,invar,isize);
  return ptr;
}

// Assembly:
subq $0x338, %rsp            # imm = 0x338
movq %rdi, 0x330(%rsp)
movq %rsi, 0x328(%rsp)
movq %rdx, 0x320(%rsp)
movq %rcx, 0x318(%rsp)
movq 0x330(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x320(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x320(%rsp)
movq 0x320(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x320(%rsp)
movzbl (%rax), %eax
subl $0x20, %eax
movl %eax, 0x314(%rsp)
movq 0x320(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0xfee1b
movq 0x320(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x320(%rsp)
movq $0x0, 0x18(%rsp)
jmp 0xfee4d
movq 0x320(%rsp), %rdi
movq 0x318(%rsp), %rdx
leaq 0x2f8(%rsp), %rsi
callq 0xdc7a0
movq %rax, 0x320(%rsp)
leaq 0x2f8(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x320(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x60, %eax
je 0xfeea0
movq 0x320(%rsp), %rdi
movslq 0x14(%rsp), %rax
leaq 0x20(%rsp), %rsi
imulq $0x18, %rax, %rax
addq %rax, %rsi
movq 0x318(%rsp), %rdx
callq 0xdc7a0
movq %rax, 0x320(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xfee55
movq 0x8(%rsp), %rdi
movq 0x320(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x320(%rsp)
movq 0x328(%rsp), %rsi
movl 0x314(%rsp), %edx
movq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %r8
movl 0x14(%rsp), %r9d
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x320(%rsp), %rax
addq $0x338, %rsp            # imm = 0x338
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x38, %rdi
movq %rdi, 0x28(%rsp)
callq 0xdf4e0
movq 0x30(%rsp), %rdi
addq $0x50, %rdi
callq 0xe1dc0
jmp 0x106466
movq 0x30(%rsp), %rdi
addq $0x60, %rdi
callq 0xe1dc0
jmp 0x106476
movq 0x30(%rsp), %rdi
addq $0x70, %rdi
callq 0xe1dc0
jmp 0x106486
movq 0x30(%rsp), %rdi
addq $0x80, %rdi
movq %rdi, 0x20(%rsp)
callq 0xdacb0
movq 0x30(%rsp), %rax
movl $0x0, (%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x30(%rax)
cmpq $0x0, 0x48(%rsp)
je 0x10654d
movq 0x48(%rsp), %rdi
callq 0xd0500
movq %rax, 0x18(%rsp)
jmp 0x1064cd
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
movl %eax, 0x14(%rsp)
jmp 0x1064e1
movq 0x30(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x28(%rax)
movslq 0x28(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0xce140
movq %rax, 0x8(%rsp)
jmp 0x106513
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x106561
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x106566
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0xd3370
jmp 0x106566
movq 0x30(%rsp), %rax
movl $0x0, 0x28(%rax)
movq $0x0, 0x20(%rax)
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xd8db0
movq 0x40(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rdi)
addq $0x80, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xdc970
movq (%rsp), %rdi
addq $0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdda70
movq $0x0, 0x58(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x10661a
movq (%rsp), %rdi
addq $0x80, %rdi
movslq 0xc(%rsp), %rsi
callq 0xdda70
movq %rax, %rdi
addq $0x40, %rdi
movslq 0x18(%rsp), %rsi
callq 0xd7550
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1065dd
movq (%rsp), %rdi
addq $0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdda70
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x98(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movl %edx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x6c(%rsp), %eax
addl 0x64(%rsp), %eax
movl %eax, 0x64(%rsp)
cmpl $0x10, 0x64(%rsp)
jb 0x106737
movb $0x1, 0x2b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x816a6(%rip), %rsi     # 0x187d5a
leaq 0x40(%rsp), %rdi
callq 0xe00a0
jmp 0x1066c0
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xde3d0
jmp 0x1066d0
movq (%rsp), %rdi
movb $0x0, 0x2b(%rsp)
movq 0xc13d8(%rip), %rsi     # 0x1c7ab8
movq 0xc1791(%rip), %rdx     # 0x1c7e78
callq 0xe01f0
jmp 0x1067a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x106719
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd4550
leaq 0x3f(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x2b(%rsp)
jne 0x10672c
jmp 0x106735
movq (%rsp), %rdi
callq 0xd5400
jmp 0x10679d
movq 0x10(%rsp), %rax
addq $0x10, %rax
movl 0x64(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x68(%rsp), %eax
jge 0x106794
movl 0x1c(%rsp), %eax
shll $0x8, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
orl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x10675c
movl 0x1c(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movl %edx, 0x78(%rsp)
movl %ecx, 0x74(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x7c(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
addl 0x74(%rsp), %eax
movl %eax, 0x74(%rsp)
cmpl $0x10, 0x74(%rsp)
jb 0x1068af
movb $0x1, 0x3b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x8(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x10(%rsp), %rdx
leaq 0x81534(%rip), %rsi     # 0x187d5a
leaq 0x50(%rsp), %rdi
callq 0xe00a0
jmp 0x106832
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xde3d0
jmp 0x106843
movq 0x8(%rsp), %rdi
movb $0x0, 0x3b(%rsp)
movq 0xc1264(%rip), %rsi     # 0x1c7ab8
movq 0xc161d(%rip), %rdx     # 0x1c7e78
callq 0xe01f0
jmp 0x106986
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x10688d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd4550
leaq 0x4f(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x3b(%rsp)
jne 0x1068a0
jmp 0x1068aa
movq 0x8(%rsp), %rdi
callq 0xd5400
jmp 0x10697c
movq 0x18(%rsp), %rax
addq $0x10, %rax
movl 0x74(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movl 0x7c(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
addl 0x78(%rsp), %eax
subl $0x1, %eax
movl $0x8, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x106936
movl 0x28(%rsp), %eax
shll $0x8, %eax
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movslq 0x24(%rsp), %rcx
movzbl (%rax,%rcx), %eax
orl 0x28(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1068fe
movslq 0x2c(%rsp), %rax
movl $0x4, %ecx
subq %rax, %rcx
shlq $0x3, %rcx
movslq 0x7c(%rsp), %rax
addq %rax, %rcx
movl 0x28(%rsp), %eax
shll %cl, %eax
movl %eax, 0x28(%rsp)
movslq 0x78(%rsp), %rax
movl $0x20, %ecx
subq %rax, %rcx
movl 0x28(%rsp), %eax
shrl %cl, %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x30(%rsp)
movslq -0xc(%rsp), %rcx
shrq $0x2, %rcx
movl %ecx, -0x14(%rsp)
movq 0x20(%rax), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rsp)
movslq -0xc(%rsp), %rax
andq $0x3, %rax
movl %eax, -0x1c(%rsp)
movslq -0x10(%rsp), %rcx
movl $0x4, %eax
subq %rcx, %rax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %ecx
shll $0x3, %ecx
movl -0x18(%rsp), %eax
shll %cl, %eax
movl %eax, -0x18(%rsp)
movl -0x20(%rsp), %ecx
shll $0x3, %ecx
movl -0x18(%rsp), %eax
shrl %cl, %eax
movl %eax, -0x18(%rsp)
movslq -0x10(%rsp), %rax
subq $0x4, %rax
movslq -0x1c(%rsp), %rcx
addq %rcx, %rax
movl %eax, -0x24(%rsp)
cmpl $0x0, -0x24(%rsp)
jle 0x106a78
movq -0x30(%rsp), %rcx
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
cmpl 0x28(%rcx), %eax
jge 0x106a78
movq -0x30(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rsp)
movslq -0x24(%rsp), %rcx
movl $0x4, %eax
subq %rcx, %rax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %ecx
shll $0x3, %ecx
movl -0x28(%rsp), %eax
shrl %cl, %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %eax
orl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x30(%rsp)
movslq -0xc(%rsp), %rcx
shrq $0x5, %rcx
movl %ecx, -0x14(%rsp)
movq 0x20(%rax), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rsp)
movslq -0xc(%rsp), %rax
andq $0x1f, %rax
movl %eax, -0x1c(%rsp)
movslq -0x10(%rsp), %rcx
movl $0x20, %eax
subq %rcx, %rax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %ecx
movl -0x18(%rsp), %eax
shll %cl, %eax
movl %eax, -0x18(%rsp)
movl -0x20(%rsp), %ecx
movl -0x18(%rsp), %eax
shrl %cl, %eax
movl %eax, -0x18(%rsp)
movslq -0x10(%rsp), %rax
subq $0x20, %rax
movslq -0x1c(%rsp), %rcx
addq %rcx, %rax
movl %eax, -0x24(%rsp)
cmpl $0x0, -0x24(%rsp)
jle 0x106b5f
movq -0x30(%rsp), %rcx
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
cmpl 0x28(%rcx), %eax
jge 0x106b5f
movq -0x30(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rsp)
movslq -0x24(%rsp), %rcx
movl $0x20, %eax
subq %rcx, %rax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %ecx
movl -0x28(%rsp), %eax
shrl %cl, %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %eax
orl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movb %r8b, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq %r9, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x38, %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd36e0
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd7070
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
callq 0xd02e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x58(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x40(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movl 0x54(%rsp), %edx
movq 0x18(%rsp), %rcx
movl %edx, 0x10(%rcx)
movl 0x50(%rsp), %edx
movq 0x18(%rsp), %rcx
movl %edx, 0x14(%rcx)
movq 0x20(%rax), %rax
movslq 0x54(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
andl 0x50(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x18(%rax)
movb 0x4f(%rsp), %cl
movq 0x18(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x1c(%rax)
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
cmpq 0x48(%rsp), %rax
je 0x1070a6
cmpl $0x0, 0x24(%rsp)
jg 0x10708b
jmp 0x10714e
movl 0x24(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x107070
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0xd3060
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xdc230
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x1070f4
movq 0x28(%rsp), %rax
movl 0x64(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
callq 0xdae70
movl 0x4(%rsp), %ecx
addl %eax, %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x64(%rax)
jmp 0x107115
movq 0x28(%rsp), %rdi
addq $0x40, %rdi
movslq 0x44(%rsp), %rsi
callq 0xdafa0
movq (%rax), %rax
movl 0x64(%rax), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x64(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x28(%rsp), %rcx
movl 0x60(%rcx), %edx
movq 0x38(%rsp), %rcx
movl %edx, 0x60(%rcx)
movq 0x38(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x1c(%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rax
movl 0x64(%rax), %eax
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x1071f0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
addq $0x40, %rdi
movslq 0x24(%rsp), %rsi
callq 0xd3290
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x60(%rax), %eax
movq 0x18(%rsp), %rcx
addl 0x64(%rcx), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jle 0x1071e1
movl 0x14(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x1071e3
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x107192
movq 0x8(%rsp), %rax
movl 0x2c(%rsp), %ecx
movq 0x10(%rax), %rdx
subl 0x64(%rdx), %ecx
movq 0x10(%rax), %rax
movl %ecx, 0x60(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd5290
cmpq $0x0, %rax
jbe 0x109c45
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd3180
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd5290
movq 0x8(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xd9290
movsbl (%rax), %eax
movq 0xbe3ba(%rip), %rcx     # 0x1c7fd0
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x109c43
movq 0x10(%rsp), %rdi
movq 0xbe3a7(%rip), %rax     # 0x1c7fd0
movb (%rax), %al
movb %al, 0x7(%rsp)
callq 0xd5340
movq %rax, %rdi
movb 0x7(%rsp), %al
movsbl %al, %esi
callq 0xd46b0
jmp 0x109c45
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x168, %rsp            # imm = 0x168
movq %rdi, 0x160(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0xd31e0
movq %rax, 0x58(%rsp)
xorl %eax, %eax
cmpq 0x58(%rsp), %rax
jne 0x109f2b
jmp 0x109f7f
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0xe00a0
jmp 0x109f5a
leaq 0x37(%rsp), %rdi
callq 0xd8ec0
movq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd9510
jmp 0x109f75
leaq 0x38(%rsp), %rdi
callq 0xd4550
addq $0x168, %rsp            # imm = 0x168
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0xd8ec0
jmp 0x109fb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4550
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
cmpl $0x0, 0x6c(%rsp)
jne 0x10a8c9
jmp 0x10aa2d
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0e60
movq 0x8(%rsp), %rdi
movq 0x70(%rsp), %rsi
xorl %edx, %edx
callq 0xd6c60
jmp 0x10a8eb
leaq 0x38(%rsp), %rdi
callq 0xd6f70
leaq 0x50(%rsp), %rdi
callq 0xdf860
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd8dc0
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xdfc90
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xd02f0
testb $0x1, %al
jne 0x10a944
jmp 0x10aa23
leaq 0x38(%rsp), %rdi
callq 0xce840
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq $-0x1, %rdx
movq 0xbd66a(%rip), %rax     # 0x1c7fd0
movsbl (%rax), %esi
callq 0xe2e10
movq %rax, 0x10(%rsp)
cmpq $-0x1, 0x10(%rsp)
jne 0x10a9a3
movq $0x0, 0x10(%rsp)
jmp 0x10a9b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd5480
jmp 0x10aa35
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x78(%rsp), %rcx
movq $-0x1, %rdx
callq 0xdb600
movl %eax, 0x4(%rsp)
jmp 0x10a9d2
movl 0x4(%rsp), %eax
cmpl $0x0, %eax
jne 0x10a9f1
movq 0x80(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd3180
jmp 0x10a9ef
jmp 0x10aa12
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0x6c(%rsp), %ecx
decl %ecx
callq 0xe23f0
jmp 0x10aa10
jmp 0x10aa12
jmp 0x10aa14
leaq 0x38(%rsp), %rdi
callq 0xd6a80
jmp 0x10a91d
leaq 0x50(%rsp), %rdi
callq 0xd5480
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xe0be0
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rdi
callq 0xd5290
subq $0x1, %rax
movq %rax, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
callq 0xd5290
movq (%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xd9290
movsbl (%rax), %eax
movq 0xbd53d(%rip), %rcx     # 0x1c7fd0
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x10aaad
movq 0x70(%rsp), %rdi
callq 0xd5290
subq $0x2, %rax
movq %rax, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq 0xbd517(%rip), %rax     # 0x1c7fd0
movb (%rax), %al
movq 0x58(%rsp), %rdx
movsbl %al, %esi
callq 0xe2e10
movq %rax, 0x50(%rsp)
cmpq $-0x1, 0x50(%rsp)
jne 0x10aaf0
movq 0x70(%rsp), %rsi
movq 0x60(%rsp), %rdi
callq 0xce450
movq 0x68(%rsp), %rdi
callq 0xdb760
jmp 0x10ab6a
movq 0x58(%rsp), %rax
subq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x70(%rsp), %rsi
movq 0x50(%rsp), %rdx
addq $0x1, %rdx
movq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %rdi
callq 0xd8920
movq 0x60(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xda960
leaq 0x28(%rsp), %rdi
callq 0xd4550
movq 0x70(%rsp), %rsi
movq 0x50(%rsp), %rcx
addq $0x1, %rcx
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0xd8920
movq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xda960
leaq 0x8(%rsp), %rdi
callq 0xd4550
addq $0x78, %rsp
retq
nop
// File: 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:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
movl %edx, 0x1a4(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xdbe90
movq 0x1a8(%rsp), %rdi
callq 0xe1670
subq $0x1, %rax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x1a4(%rsp), %eax
jl 0x10ac26
movq 0xbd403(%rip), %rax     # 0x1c7fd0
movsbl (%rax), %esi
leaq 0x28(%rsp), %rdi
callq 0xda0c0
jmp 0x10abdc
movq 0x1a8(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xda3d0
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0xd7350
jmp 0x10abfd
jmp 0x10abff
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x10abb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd0160
jmp 0x10ac4d
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd8840
jmp 0x10ac36
leaq 0x28(%rsp), %rdi
callq 0xd0160
movq 0x8(%rsp), %rax
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: 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:
subq $0xf8, %rsp
movq %rdi, 0xe8(%rsp)
movl %esi, 0xe4(%rsp)
movq %rdx, 0xd8(%rsp)
movl 0xe4(%rsp), %eax
addl $0x1, %eax
cltq
movq %rax, 0x20(%rsp)
movq 0xe8(%rsp), %rdi
callq 0xe1670
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jb 0x10b126
movb $0x0, 0xf7(%rsp)
jmp 0x10b335
movq 0xe8(%rsp), %rsi
movl 0xe4(%rsp), %edx
incl %edx
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe06b0
movq 0x10(%rsp), %rsi
movq 0xd8(%rsp), %rdi
callq 0xda960
movq 0x10(%rsp), %rdi
callq 0xd4550
leaq 0xa0(%rsp), %rdi
callq 0xe0e60
leaq 0x88(%rsp), %rdi
callq 0xe0e60
leaq 0x67(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xe0c80
movq 0x18(%rsp), %rdx
leaq 0x7cc2e(%rip), %rsi     # 0x187dc8
leaq 0x68(%rsp), %rdi
callq 0xe00a0
jmp 0x10b1a6
movq 0xd8(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movl $0x1, %ecx
callq 0xe23f0
jmp 0x10b1c7
leaq 0x68(%rsp), %rdi
callq 0xd4550
leaq 0x67(%rsp), %rdi
callq 0xd8ec0
leaq 0xa0(%rsp), %rdi
callq 0xe1670
cmpq $0x1, %rax
je 0x10b23a
movb $0x0, 0xf7(%rsp)
movl $0x1, 0x50(%rsp)
jmp 0x10b2fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x10b22b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xd4550
leaq 0x67(%rsp), %rdi
callq 0xd8ec0
jmp 0x10b319
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x7cb7a(%rip), %rsi     # 0x187dcf
leaq 0x30(%rsp), %rdi
callq 0xe00a0
jmp 0x10b261
xorl %eax, %eax
movl %eax, %esi
leaq 0xa0(%rsp), %rdi
callq 0xe1770
movq %rax, %rdx
leaq 0x88(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x1, %ecx
callq 0xe23f0
jmp 0x10b28e
leaq 0x30(%rsp), %rdi
callq 0xd4550
leaq 0x2f(%rsp), %rdi
callq 0xd8ec0
leaq 0x88(%rsp), %rdi
callq 0xe1670
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movb %al, 0xf7(%rsp)
movl $0x1, 0x50(%rsp)
jmp 0x10b2fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x10b2f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd4550
leaq 0x2f(%rsp), %rdi
callq 0xd8ec0
jmp 0x10b319
leaq 0x88(%rsp), %rdi
callq 0xd5480
leaq 0xa0(%rsp), %rdi
callq 0xd5480
jmp 0x10b335
leaq 0x88(%rsp), %rdi
callq 0xd5480
leaq 0xa0(%rsp), %rdi
callq 0xd5480
jmp 0x10b346
movb 0xf7(%rsp), %al
andb $0x1, %al
addq $0xf8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0xe0be0
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x18, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
callq 0xcf120
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
leaq 0x38(%rsp), %rsi
callq 0xdc8a0
movq 0x38(%rsp), %rdi
callq 0xdab40
cmpq $0x0, %rax
je 0x10cb09
movl $0x68, %edi
callq 0xd8380
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xdab40
movq %rax, 0x10(%rsp)
jmp 0x10cac9
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0xdfaf0
jmp 0x10cada
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x10cb16
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x68, %esi
callq 0xd8620
jmp 0x10cb1b
movq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x10cb6f
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x10cb6d
movq 0x18(%rsp), %rdi
movl $0x68, %esi
callq 0xd8620
jmp 0x10cb6f
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x10cc1d
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xdd5e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x10cbf2
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xdaef0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x10cbe3
movq 0x8(%rsp), %rdi
callq 0xcea00
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0xd8620
jmp 0x10cbe5
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x10cb86
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x10cc1b
movq (%rsp), %rdi
callq 0xd7770
movq (%rsp), %rdi
movl $0x18, %esi
callq 0xd8620
jmp 0x10cc1d
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl $0x18, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, 0x28(%rsp)
callq 0xcf120
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movslq 0x5c(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
callq 0xe0fe0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x10cdb6
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0xdcb70
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd90f0
movq 0x68(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0xce070
movq (%rax), %rax
movq (%rax), %rdi
callq 0xd1660
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0xce070
movq (%rax), %rax
movq (%rax), %rdi
callq 0xdcb70
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0xcf9f0
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0xce070
movq (%rax), %rax
movq (%rax), %rdi
callq 0xd9b80
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0xce070
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0x68(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0xce070
movq (%rax), %rax
movq $0x0, 0x8(%rax)
movq 0x68(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0xce070
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x10cda4
movq 0x18(%rsp), %rdi
callq 0xdb660
movq 0x18(%rsp), %rdi
movl $0x10, %esi
callq 0xd8620
jmp 0x10cda6
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x10cc67
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xdc8a0
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x10cdeb
movq (%rsp), %rdi
callq 0xe24d0
movq (%rsp), %rdi
movl $0x18, %esi
callq 0xd8620
movq 0x60(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x10ce48
movq (%rsp), %rdi
callq 0xdb660
movq (%rsp), %rdi
movl $0x10, %esi
callq 0xd8620
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x8(%rax)
jne 0x10cf44
movb $0x1, 0x3b(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, 0x20(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xe0c80
movq 0x28(%rsp), %rdx
leaq 0x7b031(%rip), %rsi     # 0x187eec
leaq 0x50(%rsp), %rdi
callq 0xe00a0
jmp 0x10cec7
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xd06e0
jmp 0x10ced8
movq 0x20(%rsp), %rdi
movb $0x0, 0x3b(%rsp)
movq 0xbaf7f(%rip), %rsi     # 0x1c7e68
movq 0xbab30(%rip), %rdx     # 0x1c7a20
callq 0xe01f0
jmp 0x10d08c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x10cf22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd4550
leaq 0x4f(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x3b(%rsp)
jne 0x10cf35
jmp 0x10cf3f
movq 0x20(%rsp), %rdi
callq 0xd5400
jmp 0x10d082
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xe1e30
testb $0x1, %al
jne 0x10cf58
jmp 0x10cfae
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x10cf7b
movq 0x18(%rsp), %rdi
movl $0x68, %esi
callq 0xd8620
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0xd2800
movq (%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0xe1ed0
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xddc10
jmp 0x10d02e
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl $0x1, %esi
callq 0xcf490
jmp 0x10cfcf
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xddc10
movq 0x30(%rsp), %rax
movq (%rax), %rdi
leaq 0x70(%rsp), %rsi
callq 0xdc8a0
jmp 0x10d02e
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x28, %esi
callq 0xd8620
jmp 0x10d082
movl $0x68, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rsi
callq 0xdfaf0
jmp 0x10d04f
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x88, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0x40(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movb %dl, %al
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $-0x1, 0x44(%rsp)
jne 0x10d5cb
movq 0x38(%rsp), %rdi
callq 0xdab40
movq %rax, 0x8(%rsp)
jmp 0x10d5de
movq 0x38(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0xd3b80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x10d628
movq 0x38(%rsp), %rdi
callq 0xdab40
cmpq $0x0, %rax
je 0x10d626
movq 0x38(%rsp), %rdi
callq 0xdab40
movq %rax, %rdi
callq 0xdd230
testb $0x1, %al
jne 0x10d624
movq 0x38(%rsp), %rdi
callq 0xdab40
movq %rax, 0x20(%rsp)
jmp 0x10d626
jmp 0x10d628
movq 0x38(%rsp), %rdi
callq 0xdf850
movl %eax, 0x10(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x10d690
cmpq $0x0, 0x20(%rsp)
je 0x10d652
jmp 0x10d690
movq 0x38(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xd3b80
movq %rax, %rdi
callq 0xdd230
testb $0x1, %al
jne 0x10d66e
jmp 0x10d670
jmp 0x10d683
movq 0x38(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xd3b80
movq %rax, 0x20(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x10d63e
cmpq $0x0, 0x20(%rsp)
je 0x10d6bc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0xd4930
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rdx
callq 0xcf5c0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x68, %edi
callq 0xd8380
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rsi
leaq 0x68(%rsp), %rdi
callq 0xd69a0
jmp 0x10df53
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq %rax, (%rsp)
jmp 0x10df66
movq (%rsp), %rdx
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0xd9880
jmp 0x10df78
xorl %esi, %esi
movl %esi, %edx
leaq 0x18(%rsp), %rdi
callq 0xd9880
jmp 0x10df88
movq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0xdf370
jmp 0x10dfa3
movq 0x10(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
movl $0x1, %esi
callq 0xd5300
movq 0x88(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0x60(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x40, %edi
callq 0xd8380
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq 0x38(%rsp), %rsi
movl 0x20(%rax), %edx
movl %edx, %ecx
incl %ecx
movl %ecx, 0x20(%rax)
callq 0xdf590
jmp 0x10e048
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x10e07b
movq 0x8(%rsp), %rdi
callq 0xd4550
movq 0x8(%rsp), %rdi
movl $0x20, %esi
callq 0xd8620
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x40, %esi
callq 0xd8620
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopl (%rax)