LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createLoad(StarQuality*, ExprTree*)
ExprTree *PcodeCompile::createLoad(StarQuality *qual,ExprTree *ptr)

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rbp
callq 0x4ec70
movq %rax, %r15
pushq $0x28
popq %rdi
callq 0x4f5d0
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl $0x2, 0x8(%rax)
andq $0x0, (%rax)
movq %rax, (%rsp)
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r12
movq 0x10(%rbp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4ef60
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
xorl %esi, %esi
callq 0x4fa20
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rcx
movq %r12, %rdi
movq %r14, %rdx
callq 0x51230
movq %r13, %rdi
movq %r12, %rsi
callq 0x51a50
movq 0x8(%rbx), %rsi
movq %r13, %rdi
callq 0x51a50
movq %r15, (%r13)
movq (%rbx), %rdi
movq %rsp, %rsi
callq 0x50780
movl 0x20(%r14), %edx
testq %rdx, %rdx
je 0x5fb70
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x4fa20
movq (%rbx), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x4d520
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x51460
movq %r12, 0x8(%rbx)
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x4f670
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5fbab
jmp 0x5fbab
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r12, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createStore(StarQuality*, ExprTree*, ExprTree*)
vector<OpTpl *> *PcodeCompile::createStore(StarQuality *qual,
					      ExprTree *ptr,ExprTree *val)
{
  vector<OpTpl *> *res = ptr->ops;
  ptr->ops = (vector<OpTpl *> *)0;
  res->insert(res->end(),val->ops->begin(),val->ops->end());
  val->ops->clear();
  OpTpl *op = new OpTpl(CPUI_STORE);
  // The first varnode input to the store is a constant reference to the AddrSpace being loaded
  // from.  Internally, we really store the pointer to the AddrSpace as the reference, but this
  // isn't platform independent. So officially, we assume that the constant reference will be the
  // AddrSpace index.  We can safely assume this always has size 4.
  VarnodeTpl *spcvn = new VarnodeTpl(ConstTpl(constantspace),
				     qual->id,
				     ConstTpl(ConstTpl::real,8));
  op->addInput(spcvn);
  op->addInput(ptr->outvn);
  op->addInput(val->outvn);
  res->push_back(op);
  force_size(val->outvn,ConstTpl(ConstTpl::real,qual->size),*res);
  ptr->outvn = (VarnodeTpl *)0;
  val->outvn = (VarnodeTpl *)0;
  delete ptr;
  delete val;
  delete qual;
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movq (%rdx), %rbx
andq $0x0, (%rdx)
movq 0x8(%rbx), %rsi
movq (%rcx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rbx, %rdi
callq 0x4d5e0
movq (%r15), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x5fc0b
movq %rcx, 0x8(%rax)
pushq $0x28
popq %rdi
callq 0x4f5d0
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl $0x3, 0x8(%rax)
andq $0x0, (%rax)
movq %rax, 0x10(%rsp)
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %rbp
movq 0x10(%r14), %rsi
leaq 0x18(%rsp), %rdi
callq 0x4ef60
leaq 0x38(%rsp), %rdi
pushq $0x8
popq %rdx
xorl %esi, %esi
callq 0x4fa20
movq 0x8(%rsp), %r14
leaq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rcx
movq %rbp, %rdi
movq %r14, %rdx
callq 0x51230
movq %r13, %rdi
movq %rbp, %rsi
callq 0x51a50
movq 0x8(%r12), %rsi
movq %r13, %rdi
callq 0x51a50
movq 0x8(%r15), %rsi
movq %r13, %rdi
callq 0x51a50
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x50780
movq %r14, %rbp
movq 0x8(%r15), %r14
movl 0x20(%rbp), %edx
leaq 0x18(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x4fa20
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x4d520
andq $0x0, 0x8(%r12)
andq $0x0, 0x8(%r15)
movq %r12, %rdi
callq 0x501f0
pushq $0x10
popq %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x4f670
movq %r15, %rdi
callq 0x501f0
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f670
pushq $0x28
popq %rsi
movq %rbp, %rdi
callq 0x4f670
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5fd20
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %rbp, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createUserOp(UserOpSymbol*, std::vector<ExprTree*, std::allocator<ExprTree*>>*)
ExprTree *PcodeCompile::createUserOp(UserOpSymbol *sym,vector<ExprTree *> *param)

{ // Create userdefined pcode op, given symbol and parameters
  VarnodeTpl *outvn = buildTemporary();
  ExprTree *res = new ExprTree();
  res->ops = createUserOpNoOut(sym,param);
  res->ops->back()->setOutput(outvn);
  res->outvn = new VarnodeTpl(*outvn);
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x4ec70
movq %rax, %r13
pushq $0x10
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
andq $0x0, 0x8(%rax)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4eb00
movq %rax, (%rbx)
movq 0x8(%rax), %rax
movq -0x8(%rax), %rax
movq %r13, (%rax)
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
callq 0x51460
movq %r14, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r14, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createUserOpNoOut(UserOpSymbol*, std::vector<ExprTree*, std::allocator<ExprTree*>>*)
vector<OpTpl *> *PcodeCompile::createUserOpNoOut(UserOpSymbol *sym,vector<ExprTree *> *param)

{
  OpTpl *op = new OpTpl(CPUI_CALLOTHER);
  VarnodeTpl *vn = new VarnodeTpl(ConstTpl(constantspace),
				    ConstTpl(ConstTpl::real,sym->getIndex()),
				    ConstTpl(ConstTpl::real,4));
  op->addInput(vn);
  return ExprTree::appendParams(op,param);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
pushq $0x28
popq %rdi
callq 0x4f5d0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl $0x9, 0x8(%rax)
andq $0x0, (%rax)
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
movq 0x10(%r13), %rsi
leaq 0x40(%rsp), %rdi
callq 0x4ef60
movl 0x30(%r12), %edx
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x4fa20
movq %rsp, %rdi
pushq $0x4
popq %rdx
xorl %esi, %esi
callq 0x4fa20
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x51230
movq %r15, %rdi
movq %rbx, %rsi
callq 0x51a50
movq %r15, %rdi
movq %r14, %rsi
callq 0x50580
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5fe66
jmp 0x5fe66
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x4f670
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createVariadic(OpCode, std::vector<ExprTree*, std::allocator<ExprTree*>>*)
ExprTree *PcodeCompile::createVariadic(OpCode opc,vector<ExprTree *> *param)

{
  VarnodeTpl *outvn = buildTemporary();
  ExprTree *res = new ExprTree();
  OpTpl *op = new OpTpl(opc);
  res->ops = ExprTree::appendParams(op,param);
  res->ops->back()->setOutput(outvn);
  res->outvn = new VarnodeTpl(*outvn);
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
callq 0x4ec70
movq %rax, %r14
pushq $0x10
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
andq $0x0, 0x8(%rax)
pushq $0x28
popq %rdi
callq 0x4f5d0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl %ebp, 0x8(%rax)
andq $0x0, (%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x50580
movq %rax, (%rbx)
movq 0x8(%rax), %rax
movq -0x8(%rax), %rax
movq %r14, (%rax)
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x51460
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r15, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::appendOp(OpCode, ExprTree*, unsigned long, int)
void PcodeCompile::appendOp(OpCode opc,ExprTree *res,uintb constval,int4 constsz)

{ // Take output of res expression, combine with constant,
  // using opc operation, return the resulting expression
  OpTpl *op = new OpTpl(opc);
  VarnodeTpl *constvn = new VarnodeTpl(ConstTpl(constantspace),
					 ConstTpl(ConstTpl::real,constval),
					 ConstTpl(ConstTpl::real,constsz));
  VarnodeTpl *outvn = buildTemporary();
  op->addInput(res->outvn);
  op->addInput(constvn);
  op->setOutput(outvn);
  res->ops->push_back(op);
  res->outvn = new VarnodeTpl(*outvn);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r12
pushq $0x28
popq %rdi
callq 0x4f5d0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movl %r14d, 0x8(%rax)
andq $0x0, (%rax)
movq %rax, (%rsp)
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r14
movq 0x10(%r12), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4ef60
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x4fa20
movslq %ebp, %rdx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x4fa20
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
callq 0x51230
movq %r12, %rdi
callq 0x4ec70
movq %rax, %r12
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x51a50
movq %r15, %rdi
movq %r14, %rsi
callq 0x51a50
movq %r12, (%r15)
movq (%rbx), %rdi
movq %rsp, %rsi
callq 0x50780
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0x51460
movq %r14, 0x8(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x60000
jmp 0x60000
jmp 0x60000
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r14, %rdi
callq 0x4f670
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::addressOf(VarnodeTpl*, unsigned int)
VarnodeTpl *PcodeCompile::addressOf(VarnodeTpl *var,uint4 size)

{				// Produce constant varnode that is the offset
				// portion of varnode -var-
  if (size==0) {		// If no size specified
    if (var->getSpace().getType() == ConstTpl::spaceid) {
      AddrSpace *spc = var->getSpace().getSpace();	// Look to the particular space
      size = spc->getAddrSize(); // to see if it has a standard address size
    }
  }
  VarnodeTpl *res;
  if ((var->getOffset().getType() == ConstTpl::real)&&(var->getSpace().getType() == ConstTpl::spaceid)) {
    AddrSpace *spc = var->getSpace().getSpace();
    uintb off = AddrSpace::byteToAddress(var->getOffset().getReal(),spc->getWordSize());
    res = new VarnodeTpl(ConstTpl(constantspace),
			  ConstTpl(ConstTpl::real,off),
			  ConstTpl(ConstTpl::real,size));
  }
  else
    res = new VarnodeTpl(ConstTpl(constantspace),var->getOffset(),ConstTpl(ConstTpl::real,size));
  delete var;
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
jne 0x607ab
xorl %ebp, %ebp
cmpl $0x6, (%r14)
jne 0x607ab
movq 0x8(%r14), %rax
movl 0x58(%rax), %ebp
cmpl $0x0, 0x20(%r14)
jne 0x6081b
cmpl $0x6, (%r14)
jne 0x6081b
movq 0x8(%r14), %rax
movq 0x30(%r14), %r12
movl 0x5c(%rax), %r13d
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
movq 0x10(%r15), %rsi
leaq 0x28(%rsp), %rdi
callq 0x4ef60
movq %r12, %rax
xorl %edx, %edx
divq %r13
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x4fa20
movl %ebp, %edx
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x4fa20
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
callq 0x51230
jmp 0x60858
pushq $0x68
popq %rdi
callq 0x4f5d0
movq %rax, %rbx
movq 0x10(%r15), %rsi
leaq 0x28(%rsp), %rdi
callq 0x4ef60
movl %ebp, %edx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x4fa20
leaq 0x20(%r14), %rdx
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x51230
pushq $0x68
popq %rsi
movq %r14, %rdi
callq 0x4f670
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6087d
jmp 0x6087d
jmp 0x6087d
jmp 0x6087d
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x4f670
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstTpl::operator==(ConstTpl const&) const
bool ConstTpl::operator==(const ConstTpl &op2) const

{
  if (type != op2.type) return false;
  switch(type) {
  case real:
    return (value_real == op2.value_real);
  case handle:
    if (value.handle_index != op2.value.handle_index) return false;
    if (select != op2.select) return false;
    break;
  case spaceid:
    return (value.spaceid == op2.value.spaceid);
  default:			// Nothing additional to compare
    break;
  }
  return true;
}

// Assembly:
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x61021
cmpl $0x6, %eax
je 0x61024
cmpl $0x1, %eax
je 0x6100e
testl %eax, %eax
jne 0x6101e
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x6102c
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x61021
movl 0x18(%rdi), %eax
cmpl 0x18(%rsi), %eax
jne 0x61021
movb $0x1, %al
retq
xorl %eax, %eax
retq
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstTpl::operator<(ConstTpl const&) const
bool ConstTpl::operator<(const ConstTpl &op2) const

{
  if (type != op2.type) return (type < op2.type);
  switch(type) {
  case real:
    return (value_real < op2.value_real);
  case handle:
    if (value.handle_index != op2.value.handle_index)
      return (value.handle_index < op2.value.handle_index);
    if (select != op2.select) return (select < op2.select);
    break;
  case spaceid:
    return (value.spaceid < op2.value.spaceid);
  default:			// Nothing additional to compare
    break;
  }
  return false;
}

// Assembly:
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x6105c
cmpl $0x6, %eax
je 0x61060
cmpl $0x1, %eax
je 0x6104e
testl %eax, %eax
jne 0x6106c
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x61068
movl 0x8(%rsi), %eax
cmpl %eax, 0x8(%rdi)
jne 0x6105c
movl 0x18(%rdi), %eax
cmpl 0x18(%rsi), %eax
setl %al
retq
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
setb %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstTpl::fixSpace(ParserWalker const&) const
AddrSpace *ConstTpl::fixSpace(const ParserWalker &walker) const

{				// Get the value of the ConstTpl in context
				// when we know it is a space
  switch(type) {
  case j_curspace:
    return walker.getCurSpace();
  case handle:
    {
      const FixedHandle &hand(walker.getFixedHandle(value.handle_index));
      switch(select) {
      case v_space:
	if (hand.offset_space == (AddrSpace *)0)
	  return hand.space;
	return hand.temp_space;
      default:
	break;
      }
      break;
    }
  case spaceid:
    return value.spaceid;
  case j_flowref:
    return walker.getRefAddr().getSpace();
  default:
    break;
  }
  throw LowlevelError("ConstTpl is not a spaceid as expected");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x7, %eax
ja 0x611fb
leaq 0x25f5a(%rip), %rcx     # 0x870f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, 0x18(%rdi)
jne 0x611fb
movq 0x10(%rsi), %rax
movq 0x40(%rax), %rax
movslq 0x8(%rdi), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x30(%rax), %rdi
leaq 0x8(%rax), %rcx
cmpq $0x0, 0x18(%rax)
cmoveq %rcx, %rdi
jmp 0x611ef
addq $0x8, %rdi
jmp 0x611ef
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
jne 0x611e2
movq (%rsi), %rdi
addq $0x70, %rdi
jmp 0x611ef
movq (%rsi), %rdi
addq $0x50, %rdi
movq (%rdi), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x25f77(%rip), %rsi     # 0x87184
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x4dc6b(%rip), %rsi     # 0xaeea0
movq 0x4d9fc(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x6125b
jmp 0x61263
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstTpl::fillinSpace(FixedHandle&, ParserWalker const&) const
void ConstTpl::fillinSpace(FixedHandle &hand,const ParserWalker &walker) const

{ // Fill in the space portion of a FixedHandle, base on this ConstTpl
  switch(type) {
  case j_curspace:
    hand.space = walker.getCurSpace();
    return;
  case handle:
    {
      const FixedHandle &otherhand(walker.getFixedHandle(value.handle_index));
      switch(select) {
      case v_space:
	hand.space = otherhand.space;
	return;
      default:
	break;
      }
      break;
    }
  case spaceid:
    hand.space = value.spaceid;
    return;
  default:
    break;
  }
  throw LowlevelError("ConstTpl is not a spaceid as expected");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x6128e
cmpl $0x6, %eax
je 0x612a4
cmpl $0x4, %eax
jne 0x612b7
movq (%rdx), %rdi
addq $0x50, %rdi
jmp 0x612a8
cmpl $0x0, 0x18(%rdi)
jne 0x612b7
movq 0x10(%rdx), %rax
movq 0x40(%rax), %rax
movslq 0x8(%rdi), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x8, %rdi
movq (%rdi), %rax
movq %rax, (%rsi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x25ebb(%rip), %rsi     # 0x87184
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x4dbaf(%rip), %rsi     # 0xaeea0
movq 0x4d940(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x61317
jmp 0x6131f
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstTpl::fillinOffset(FixedHandle&, ParserWalker const&) const
void ConstTpl::fillinOffset(FixedHandle &hand,const ParserWalker &walker) const

{ // Fillin the offset portion of a FixedHandle, based on this ConstTpl
  // If the offset value is dynamic, indicate this in the handle
  // we don't just fill in the temporary variable offset
  // we assume hand.space is already filled in
  if (type == handle) {
    const FixedHandle &otherhand(walker.getFixedHandle(value.handle_index));
    hand.offset_space = otherhand.offset_space;
    hand.offset_offset = otherhand.offset_offset;
    hand.offset_size = otherhand.offset_size;
    hand.temp_space = otherhand.temp_space;
    hand.temp_offset = otherhand.temp_offset;
  }
  else {
    hand.offset_space = (AddrSpace *)0;
    hand.offset_offset = hand.space->wrapOffset(fix(walker));
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x1, (%rdi)
jne 0x6136b
movslq 0x8(%rdi), %rax
movq 0x10(%rdx), %rcx
movq 0x40(%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%rbx)
movl 0x28(%rax), %ecx
movl %ecx, 0x20(%rbx)
movq 0x30(%rax), %rcx
movq %rcx, 0x28(%rbx)
movq 0x38(%rax), %rax
pushq $0x30
popq %rcx
jmp 0x6139c
andq $0x0, 0x10(%rbx)
movq (%rbx), %r14
movq %rdx, %rsi
callq 0x4ea00
movq 0x28(%r14), %rsi
pushq $0x18
popq %rcx
cmpq %rax, %rsi
jae 0x6139c
incq %rsi
cqto
idivq %rsi
movq %rdx, %rax
sarq $0x3f, %rax
andq %rsi, %rax
addq %rdx, %rax
movq %rax, (%rbx,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstTpl::transfer(std::vector<HandleTpl*, std::allocator<HandleTpl*>> const&)
void ConstTpl::transfer(const vector<HandleTpl *> &params)

{				// Replace old handles with new handles
  if (type != handle) return;
  HandleTpl *newhandle = params[value.handle_index];

  switch(select) {
  case v_space:
    *this = newhandle->getSpace();
    break;
  case v_offset:
    *this = newhandle->getPtrOffset();
    break;
  case v_offset_plus:
    {
      uintb tmp = value_real;
      *this = newhandle->getPtrOffset();
      if (type == real) {
	value_real += (tmp&0xffff);
      }
      else if ((type == handle)&&(select == v_offset)) {
	select = v_offset_plus;
	value_real = tmp;
      }
      else
	throw LowlevelError("Cannot truncate macro input in this way");
      break;
    }
  case v_size:
    *this = newhandle->getSize();
    break;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x1, (%rdi)
jne 0x61439
movl 0x18(%rdi), %eax
cmpq $0x3, %rax
ja 0x61439
movslq 0x8(%rdi), %rcx
movq (%rsi), %rdx
movq (%rdx,%rcx,8), %rcx
leaq 0x25d44(%rip), %rdx     # 0x87118
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movups (%rcx), %xmm0
movups 0xc(%rcx), %xmm1
jmp 0x6141f
movups 0x20(%rcx), %xmm0
movups 0x2c(%rcx), %xmm1
jmp 0x6141f
movq 0x10(%rdi), %rax
movups 0x60(%rcx), %xmm0
movups 0x6c(%rcx), %xmm1
movups %xmm0, (%rdi)
movups %xmm1, 0xc(%rdi)
movl (%rdi), %ecx
cmpl $0x1, %ecx
je 0x61428
testl %ecx, %ecx
jne 0x61442
movzwl %ax, %eax
addq 0x10(%rdi), %rax
jmp 0x61435
movups 0x60(%rcx), %xmm0
movups 0x6c(%rcx), %xmm1
movups %xmm1, 0xc(%rdi)
movups %xmm0, (%rdi)
jmp 0x61439
cmpl $0x1, 0x18(%rdi)
jne 0x61442
movl $0x3, 0x18(%rdi)
movq %rax, 0x10(%rdi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x25d56(%rip), %rsi     # 0x871aa
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x4da24(%rip), %rsi     # 0xaeea0
movq 0x4d7b5(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x614a2
jmp 0x614aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstTpl::readHandleSelector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ConstTpl::v_field ConstTpl::readHandleSelector(const string &name)

{
  if (name == "space")
    return v_space;
  if (name == "offset")
    return v_offset;
  if (name == "size")
    return v_size;
  if (name == "offset_plus")
    return v_offset_plus;
  throw LowlevelError("Bad handle selector");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x2561d(%rip), %rsi     # 0x86afd
callq 0x520f0
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x61531
leaq 0x2580a(%rip), %rsi     # 0x86cfe
movq %rbx, %rdi
callq 0x520f0
testb %al, %al
je 0x61504
pushq $0x1
jmp 0x61530
leaq 0x2b262(%rip), %rsi     # 0x8c76d
movq %rbx, %rdi
callq 0x520f0
testb %al, %al
je 0x6151b
pushq $0x2
jmp 0x61530
leaq 0x25cb0(%rip), %rsi     # 0x871d2
movq %rbx, %rdi
callq 0x520f0
testb %al, %al
je 0x6153a
pushq $0x3
popq %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4e180
movq %rax, %rbx
leaq 0x25c92(%rip), %rsi     # 0x871de
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x515e0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ddf0
xorl %ebp, %ebp
movq 0x4d92c(%rip), %rsi     # 0xaeea0
movq 0x4d6bd(%rip), %rdx     # 0xaec38
movq %rbx, %rdi
callq 0x51630
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4e020
testb %bpl, %bpl
jne 0x6159a
jmp 0x615a2
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ea60
movq %r14, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: VarnodeTpl::VarnodeTpl(int, bool)
VarnodeTpl::VarnodeTpl(int4 hand,bool zerosize) :
  space(ConstTpl::handle,hand,ConstTpl::v_space), offset(ConstTpl::handle,hand,ConstTpl::v_offset), size(ConstTpl::handle,hand,ConstTpl::v_size)
{				// Varnode built from a handle
				// if zerosize is true, set the size constant to zero
  if (zerosize)
    size = ConstTpl(ConstTpl::real,0);
  unnamed_flag = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
pushq $0x1
popq %r12
movl %r12d, %esi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x51cf0
leaq 0x20(%rbx), %rdi
movl %r12d, %esi
movl %r15d, %edx
movl %r12d, %ecx
callq 0x51cf0
leaq 0x40(%rbx), %r14
pushq $0x2
popq %rcx
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x51cf0
testl %ebp, %ebp
je 0x61cc7
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4fa20
movups (%r15), %xmm0
movups 0xc(%r15), %xmm1
movups %xmm1, 0xc(%r14)
movups %xmm0, (%r14)
movb $0x0, 0x60(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: VarnodeTpl::isDynamic(ParserWalker const&) const
bool VarnodeTpl::isDynamic(const ParserWalker &walker) const

{
  if (offset.getType()!=ConstTpl::handle) return false;
				// Technically we should probably check all three
				// ConstTpls for dynamic handles, but in all cases
				// if there is any dynamic piece then the offset is
  const FixedHandle &hand(walker.getFixedHandle(offset.getHandleIndex()));
  return (hand.offset_space != (AddrSpace *)0);
}

// Assembly:
cmpl $0x1, 0x20(%rdi)
jne 0x61dbb
movslq 0x28(%rdi), %rax
movq 0x10(%rsi), %rcx
movq 0x40(%rcx), %rcx
movq (%rcx,%rax,8), %rax
cmpq $0x0, 0x18(%rax)
setne %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: VarnodeTpl::transfer(std::vector<HandleTpl*, std::allocator<HandleTpl*>> const&)
int4 VarnodeTpl::transfer(const vector<HandleTpl *> &params)

{
  bool doesOffsetPlus = false;
  int4 handleIndex;
  int4 plus;
  if ((offset.getType() == ConstTpl::handle)&&(offset.getSelect()==ConstTpl::v_offset_plus)) {
    handleIndex = offset.getHandleIndex();
    plus = (int4)offset.getReal();
    doesOffsetPlus = true;
  }
  space.transfer(params);
  offset.transfer(params);
  size.transfer(params);
  if (doesOffsetPlus) {
    if (isLocalTemp())
      return plus;		// A positive number indicates truncation of a local temp
    if (params[handleIndex]->getSize().isZero())
      return plus;		//    or a zerosize object
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rdi), %r12
movl 0x38(%rdi), %ebp
movslq 0x28(%rdi), %rax
movq %rax, (%rsp)
movl 0x20(%rdi), %r13d
movl 0x30(%rdi), %ebx
callq 0x51e90
movq %r12, %rdi
movq %r14, %rsi
callq 0x51e90
leaq 0x40(%r15), %rdi
movq %r14, %rsi
callq 0x51e90
cmpl $0x1, %r13d
jne 0x61e34
cmpl $0x3, %ebp
jne 0x61e34
cmpl $0x6, (%r15)
jne 0x61e1c
movq 0x8(%r15), %rax
cmpl $0x3, 0x8(%rax)
je 0x61e37
movq (%r14), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x20(%rax)
jne 0x61e34
cmpq $0x0, 0x30(%rax)
je 0x61e37
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: VarnodeTpl::adjustTruncation(int, bool)
bool VarnodeTpl::adjustTruncation(int4 sz,bool isbigendian)

{ // We know this->offset is an offset_plus, check that the truncation is in bounds (given -sz-)
  // adjust plus for endianness if necessary
  // return true if truncation is in bounds
  if (size.getType() != ConstTpl::real)
    return false;
  int4 numbytes = (int4) size.getReal();
  int4 byteoffset = (int4) offset.getReal();
  if (numbytes + byteoffset > sz) return false;

  // Encode the original truncation amount with the plus value
  uintb val = byteoffset;
  val <<= 16;
  if (isbigendian) {
    val |= (uintb)(sz - (numbytes+byteoffset));
  }
  else {
    val |= (uintb) byteoffset;
  }
  

  offset = ConstTpl(ConstTpl::handle,offset.getHandleIndex(),ConstTpl::v_offset_plus,val);
  return true;
}

// Assembly:
cmpl $0x0, 0x40(%rdi)
je 0x61e8b
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x50(%rdi), %ecx
addl %eax, %ecx
subl %ecx, %esi
jge 0x61ea6
xorl %eax, %eax
jmp 0x61ee4
cltq
movq %rax, %rcx
shlq $0x10, %rcx
movslq %esi, %r8
testb %dl, %dl
cmoveq %rax, %r8
orq %rcx, %r8
movl 0x28(%rbx), %edx
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
pushq $0x3
popq %rcx
movq %r14, %rdi
callq 0x50f90
movups (%r14), %xmm0
movups 0xc(%r14), %xmm1
movups %xmm1, 0x2c(%rbx)
movups %xmm0, 0x20(%rbx)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: VarnodeTpl::saveXml(std::ostream&) const
void VarnodeTpl::saveXml(ostream &s) const

{
  s << "<varnode_tpl>";
  space.saveXml(s);
  offset.saveXml(s);
  size.saveXml(s);
  s << "</varnode_tpl>\n";
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x25427(%rip), %rsi     # 0x87324
movq %rbx, %rdi
callq 0x4f5b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x504d0
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x504d0
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x504d0
leaq 0x25400(%rip), %rsi     # 0x87332
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4f5b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: VarnodeTpl::restoreXml(Element const*, AddrSpaceManager const*)
void VarnodeTpl::restoreXml(const Element *el,const AddrSpaceManager *manage)

{
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  space.restoreXml(*iter,manage);
  ++iter;
  offset.restoreXml(*iter,manage);
  ++iter;
  size.restoreXml(*iter,manage);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x78(%rsi), %r15
movq (%r15), %rsi
callq 0x4ee80
leaq 0x20(%r14), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x4ee80
addq $0x40, %r14
movq 0x10(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4ee80
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: VarnodeTpl::operator<(VarnodeTpl const&) const
bool VarnodeTpl::operator<(const VarnodeTpl &op2) const

{
  if (!(space==op2.space)) return (space<op2.space);
  if (!(offset==op2.offset)) return (offset<op2.offset);
  if (!(size==op2.size)) return (size<op2.size);
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4f1e0
testb %al, %al
je 0x61fd5
leaq 0x20(%r14), %r15
leaq 0x20(%rbx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4f1e0
testb %al, %al
je 0x61fdd
addq $0x40, %r14
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4f1e0
testb %al, %al
je 0x61fd5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x61fe3
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x51ac0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: HandleTpl::HandleTpl(VarnodeTpl const*)
HandleTpl::HandleTpl(const VarnodeTpl *vn)

{				// Build handle which indicates given varnode
  space = vn->getSpace();
  size = vn->getSize();
  ptrspace = ConstTpl(ConstTpl::real,0);
  ptroffset = vn->getOffset();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
andl $0x0, (%rdi)
andq $0x0, 0x10(%rdi)
andl $0x0, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
andl $0x0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
andl $0x0, 0x60(%rdi)
andq $0x0, 0x70(%rdi)
andl $0x0, 0x80(%rdi)
andq $0x0, 0x90(%rdi)
andl $0x0, 0xa0(%rdi)
andq $0x0, 0xb0(%rdi)
andl $0x0, 0xc0(%rdi)
movq %rsi, %r14
andq $0x0, 0xd0(%rdi)
movups (%rsi), %xmm0
movups 0xc(%rsi), %xmm1
movups %xmm1, 0xc(%rdi)
movups %xmm0, (%rdi)
movups 0x40(%rsi), %xmm0
movups 0x4c(%rsi), %xmm1
movups %xmm0, 0x20(%rdi)
movups %xmm1, 0x2c(%rdi)
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4fa20
movups (%r15), %xmm0
movups 0xc(%r15), %xmm1
movups %xmm1, 0x4c(%rbx)
movups %xmm0, 0x40(%rbx)
movups 0x20(%r14), %xmm0
movups 0x2c(%r14), %xmm1
movups %xmm1, 0x6c(%rbx)
movups %xmm0, 0x60(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: HandleTpl::fix(FixedHandle&, ParserWalker const&) const
void HandleTpl::fix(FixedHandle &hand,const ParserWalker &walker) const

{
  if (ptrspace.getType() == ConstTpl::real) {
    // The export is unstarred, but this doesn't mean the varnode
    // being exported isn't dynamic
    space.fillinSpace(hand,walker);
    hand.size = size.fix(walker);
    ptroffset.fillinOffset(hand,walker);
  }
  else {
    hand.space = space.fixSpace(walker);
    hand.size = size.fix(walker);
    hand.offset_offset = ptroffset.fix(walker);
    hand.offset_space = ptrspace.fixSpace(walker);
    if (hand.offset_space->getType()==IPTR_CONSTANT) {
				// Handle could have been dynamic but wasn't
      hand.offset_space = (AddrSpace *)0;
      hand.offset_offset = AddrSpace::addressToByte(hand.offset_offset,hand.space->getWordSize());
      hand.offset_offset = hand.space->wrapOffset(hand.offset_offset);
    }
    else {
      hand.offset_size = ptrsize.fix(walker);
      hand.temp_space = temp_space.fixSpace(walker);
      hand.temp_offset = temp_offset.fix(walker);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x0, 0x40(%rdi)
je 0x62214
leaq 0x40(%r15), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x4e940
movq %rax, (%rbx)
leaq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x4ea00
movl %eax, 0x8(%rbx)
leaq 0x60(%r15), %rdi
movq %r14, %rsi
callq 0x4ea00
movq %rax, 0x18(%rbx)
movq %r12, %rdi
movq %r14, %rsi
callq 0x4e940
movq %rax, 0x10(%rbx)
cmpl $0x0, 0x8(%rax)
je 0x6224e
leaq 0x80(%r15), %rdi
movq %r14, %rsi
callq 0x4ea00
movl %eax, 0x20(%rbx)
leaq 0xa0(%r15), %rdi
movq %r14, %rsi
callq 0x4e940
movq %rax, 0x28(%rbx)
addq $0xc0, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ea00
movq %rax, 0x30(%rbx)
jmp 0x62280
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x50560
leaq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x4ea00
movl %eax, 0x8(%rbx)
addq $0x60, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x51e30
andq $0x0, 0x10(%rbx)
movq (%rbx), %rcx
movl 0x5c(%rcx), %eax
imulq 0x18(%rbx), %rax
movq 0x28(%rcx), %rcx
cmpq %rax, %rcx
jae 0x6227c
incq %rcx
cqto
idivq %rcx
movq %rdx, %rax
sarq $0x3f, %rax
andq %rcx, %rax
addq %rdx, %rax
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: HandleTpl::saveXml(std::ostream&) const
void HandleTpl::saveXml(ostream &s) const

{
  s << "<handle_tpl>";
  space.saveXml(s);
  size.saveXml(s);
  ptrspace.saveXml(s);
  ptroffset.saveXml(s);
  ptrsize.saveXml(s);
  temp_space.saveXml(s);
  temp_offset.saveXml(s);
  s << "</handle_tpl>\n";
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x25005(%rip), %rsi     # 0x87342
movq %rbx, %rdi
callq 0x4f5b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x504d0
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x504d0
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x504d0
leaq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x504d0
leaq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x504d0
leaq 0xa0(%r14), %rdi
movq %rbx, %rsi
callq 0x504d0
addq $0xc0, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x504d0
leaq 0x24fa4(%rip), %rsi     # 0x8734f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4f5b0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: HandleTpl::restoreXml(Element const*, AddrSpaceManager const*)
void HandleTpl::restoreXml(const Element *el,const AddrSpaceManager *manage)

{
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  space.restoreXml(*iter,manage);
  ++iter;
  size.restoreXml(*iter,manage);
  ++iter;
  ptrspace.restoreXml(*iter,manage);
  ++iter;
  ptroffset.restoreXml(*iter,manage);
  ++iter;
  ptrsize.restoreXml(*iter,manage);
  ++iter;
  temp_space.restoreXml(*iter,manage);
  ++iter;
  temp_offset.restoreXml(*iter,manage);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x78(%rsi), %r15
movq (%r15), %rsi
callq 0x4ee80
leaq 0x20(%r14), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x4ee80
leaq 0x40(%r14), %rdi
movq 0x10(%r15), %rsi
movq %rbx, %rdx
callq 0x4ee80
leaq 0x60(%r14), %rdi
movq 0x18(%r15), %rsi
movq %rbx, %rdx
callq 0x4ee80
leaq 0x80(%r14), %rdi
movq 0x20(%r15), %rsi
movq %rbx, %rdx
callq 0x4ee80
leaq 0xa0(%r14), %rdi
movq 0x28(%r15), %rsi
movq %rbx, %rdx
callq 0x4ee80
addq $0xc0, %r14
movq 0x30(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4ee80
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: OpTpl::~OpTpl()
OpTpl::~OpTpl(void)

{				// An OpTpl owns its varnode_tpls
  if (output != (VarnodeTpl *)0)
    delete output;
  vector<VarnodeTpl *>::iterator iter;
  for(iter=input.begin();iter!=input.end();++iter)
    delete *iter;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x6245d
pushq $0x68
popq %rsi
callq 0x4f670
leaq 0x10(%rbx), %r14
movq 0x10(%rbx), %r12
pushq $0x68
popq %r15
cmpq 0x18(%rbx), %r12
je 0x62481
movq (%r12), %rdi
movq %r15, %rsi
callq 0x4f670
addq $0x8, %r12
jmp 0x62469
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4ea90
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: OpTpl::isZeroSize() const
bool OpTpl::isZeroSize(void) const

{				// Return if any input or output has zero size
  vector<VarnodeTpl *>::const_iterator iter;

  if (output != (VarnodeTpl *)0)
    if (output->isZeroSize()) return true;
  for(iter=input.begin();iter!=input.end();++iter)
    if ((*iter)->isZeroSize()) return true;
  return false;
}

// Assembly:
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x624ab
cmpl $0x0, 0x40(%rcx)
jne 0x624ab
movb $0x1, %al
cmpq $0x0, 0x50(%rcx)
je 0x624cf
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
cmpq %rdx, %rcx
setne %al
je 0x624cf
movq (%rcx), %rsi
addq $0x8, %rcx
cmpl $0x0, 0x40(%rsi)
jne 0x624b3
cmpq $0x0, 0x50(%rsi)
jne 0x624b3
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: OpTpl::removeInput(int)
void OpTpl::removeInput(int4 index)

{ // Remove the indicated input
  delete input[index];
  for(int4 i=index;i<input.size()-1;++i)
    input[i] = input[i+1];
  input.pop_back();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
movq 0x10(%rdi), %rax
movq (%rax,%r14,8), %rdi
pushq $0x68
popq %rsi
callq 0x4f670
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
decq %rdx
cmpq %r14, %rdx
jbe 0x62512
movq 0x8(%rax,%r14,8), %rcx
movq %rcx, (%rax,%r14,8)
incq %r14
jmp 0x624ea
addq $-0x8, %rcx
movq %rcx, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: OpTpl::changeHandleIndex(std::vector<int, std::allocator<int>> const&)
void OpTpl::changeHandleIndex(const vector<int4> &handmap)

{
  if (output != (VarnodeTpl *)0)
    output->changeHandleIndex(handmap);
  vector<VarnodeTpl *>::const_iterator iter;

  for(iter=input.begin();iter!=input.end();++iter)
    (*iter)->changeHandleIndex(handmap);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x6253d
movq %rbx, %rsi
callq 0x50fc0
movq 0x10(%r14), %r15
cmpq 0x18(%r14), %r15
je 0x62558
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x50fc0
addq $0x8, %r15
jmp 0x62541
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: OpTpl::saveXml(std::ostream&) const
void OpTpl::saveXml(ostream &s) const

{
  s << "<op_tpl code=\"" << get_opname(opc) << "\">";
  if (output == (VarnodeTpl *)0)
    s << "<null/>\n";
  else
    output->saveXml(s);
  for(int4 i=0;i<input.size();++i)
    input[i]->saveXml(s);
  s << "</op_tpl>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x24dee(%rip), %rsi     # 0x8735e
movq %rbx, %rdi
callq 0x4f5b0
movq %rax, %r15
movl 0x8(%r14), %edi
callq 0x4ee40
movq %r15, %rdi
movq %rax, %rsi
callq 0x4f5b0
leaq 0x24dd7(%rip), %rsi     # 0x8736d
movq %rax, %rdi
callq 0x4f5b0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x625b0
movq %rbx, %rsi
callq 0x4e420
jmp 0x625bf
leaq 0x24db9(%rip), %rsi     # 0x87370
movq %rbx, %rdi
callq 0x4f5b0
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x625e7
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x4e420
incq %r15
jmp 0x625c2
leaq 0x24d8b(%rip), %rsi     # 0x87379
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4f5b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: OpTpl::restoreXml(Element const*, AddrSpaceManager const*)
void OpTpl::restoreXml(const Element *el,const AddrSpaceManager *manage)

{
  opc = get_opcode(el->getAttributeValue("code"));
  const List &list(el->getChildren());
  List::const_iterator iter;
  iter = list.begin();
  if ((*iter)->getName() == "null")
    output = (VarnodeTpl *)0;
  else {
    output = new VarnodeTpl();
    output->restoreXml(*iter,manage);
  }
  ++iter;
  while(iter != list.end()) {
    VarnodeTpl *vn = new VarnodeTpl();
    vn->restoreXml(*iter,manage);
    input.push_back(vn);
    ++iter;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x246c7(%rip), %rsi     # 0x86ce1
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x515e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x50230
movq %rax, %rdi
callq 0x51410
movl %eax, 0x8(%r15)
leaq 0x8(%rsp), %rdi
callq 0x4e020
movq 0x78(%r14), %rbp
movq (%rbp), %rdi
leaq 0x24d28(%rip), %rsi     # 0x87384
callq 0x520f0
testb %al, %al
je 0x6266b
andq $0x0, (%r15)
jmp 0x626a3
pushq $0x68
popq %rdi
callq 0x4f5d0
andl $0x0, (%rax)
andq $0x0, 0x10(%rax)
andl $0x0, 0x20(%rax)
andq $0x0, 0x30(%rax)
andl $0x0, 0x40(%rax)
andq $0x0, 0x50(%rax)
movb $0x0, 0x60(%rax)
movq %rax, (%r15)
movq (%rbp), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x517f0
addq $0x10, %r15
addq $0x8, %rbp
pushq $0x68
popq %r12
leaq 0x8(%rsp), %r13
cmpq 0x80(%r14), %rbp
je 0x62708
movq %r12, %rdi
callq 0x4f5d0
andl $0x0, (%rax)
andq $0x0, 0x10(%rax)
andl $0x0, 0x20(%rax)
andq $0x0, 0x30(%rax)
andl $0x0, 0x40(%rax)
andq $0x0, 0x50(%rax)
movb $0x0, 0x60(%rax)
movq %rax, 0x8(%rsp)
movq (%rbp), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x517f0
movq %r15, %rdi
movq %r13, %rsi
callq 0x51cd0
addq $0x8, %rbp
jmp 0x626b4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4e020
movq %rbx, %rdi
callq 0x518c0
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::~ConstructTpl()
ConstructTpl::~ConstructTpl(void)

{				// Constructor owns its ops and handles
  vector<OpTpl *>::iterator oiter;
  for(oiter=vec.begin();oiter!=vec.end();++oiter)
    delete *oiter;
  if (result != (HandleTpl *)0)
    delete result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %r13
pushq $0x28
popq %r15
cmpq 0x10(%r14), %r13
je 0x6276c
movq (%r13), %r12
testq %r12, %r12
je 0x6275b
movq %r12, %rdi
callq 0x4d290
movq %r12, %rdi
movq %r15, %rsi
callq 0x4f670
addq $0x8, %r13
jmp 0x62744
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x6277f
movl $0xe0, %esi
callq 0x4f670
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x51010
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::addOp(OpTpl*)
bool ConstructTpl::addOp(OpTpl *ot)

{
  if (ot->getOpcode() == DELAY_SLOT) {
    if (delayslot != 0)
      return false;		// Cannot have multiple delay slots
    delayslot = ot->getIn(0)->getOffset().getReal();
  }
  else if (ot->getOpcode() == LABELBUILD)
    numlabels += 1;		// Count labels
  vec.push_back(ot);
  return true;
}

// Assembly:
pushq %rax
movq %rsi, (%rsp)
movl 0x8(%rsi), %eax
cmpl $0x41, %eax
je 0x627ab
cmpl $0x3d, %eax
jne 0x627bc
cmpl $0x0, (%rdi)
je 0x627b0
xorl %eax, %eax
jmp 0x627ca
incl 0x4(%rdi)
jmp 0x627bc
movq 0x10(%rsi), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq %rsp, %rsi
callq 0x50780
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstructTpl::addOpList(std::vector<OpTpl*, std::allocator<OpTpl*>> const&)
bool ConstructTpl::addOpList(const vector<OpTpl *> &oplist)

{
  for(int4 i=0;i<oplist.size();++i)
    if (!addOp(oplist[i]))
      return false;
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ecx, %ecx
movq %rcx, %r15
movq (%rbx), %rax
movq 0x8(%rbx), %r12
subq %rax, %r12
sarq $0x3, %r12
cmpq %rcx, %r12
jbe 0x62806
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x4e3e0
leaq 0x1(%r15), %rcx
testb %al, %al
jne 0x627dc
cmpq %r15, %r12
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq