LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbp
movq (%rdx), %rbx
movq $0x0, (%rdx)
movq 0x8(%rbx), %rsi
movq (%rcx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rbx, %rdi
callq 0x3f850
movq (%r15), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x534b2
movq %rcx, 0x8(%rax)
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movl $0x3, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movl $0x68, %edi
callq 0x40800
movq %rax, %r13
movq 0x10(%rbp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x40390
leaq 0x38(%rsp), %rdi
movl $0x8, %edx
xorl %esi, %esi
callq 0x40b10
leaq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rcx
movq %r13, %rdi
movq %r14, %rdx
callq 0x41aa0
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x42010
movq 0x8(%rsp), %rdi
movq 0x8(%r12), %rsi
callq 0x42010
movq 0x8(%rsp), %rdi
movq 0x8(%r15), %rsi
callq 0x42010
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5355c
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x53569
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3f150
movq 0x8(%r15), %r13
movl 0x20(%r14), %edx
leaq 0x18(%rsp), %rbp
movq %r14, 0x10(%rsp)
xorl %r14d, %r14d
movq %rbp, %rdi
xorl %esi, %esi
callq 0x40b10
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x3f380
movq %r14, 0x8(%r12)
movq %r14, 0x8(%r15)
movq %r12, %rdi
callq 0x40f50
movl $0x10, %esi
movq %r12, %rdi
callq 0x40870
movq %r15, %rdi
callq 0x40f50
movl $0x10, %esi
movq %r15, %rdi
callq 0x40870
movl $0x28, %esi
movq 0x10(%rsp), %rdi
callq 0x40870
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x535ec
movq %rax, %rbx
movl $0x68, %esi
movq %r13, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::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 0x401d0
movq %rax, %r13
movl $0x10, %edi
callq 0x40800
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x400e0
movq %rax, (%rbx)
movq 0x8(%rax), %rax
movq -0x8(%rax), %rax
movq %r13, (%rax)
movl $0x68, %edi
callq 0x40800
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
callq 0x41bf0
movq %r14, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: 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
movl $0x28, %edi
callq 0x40800
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r15)
movl $0x9, 0x8(%r15)
movq %rax, (%r15)
movl $0x68, %edi
callq 0x40800
movq %rax, %rbx
movq 0x10(%r13), %rsi
leaq 0x40(%rsp), %rdi
callq 0x40390
movl 0x30(%r12), %edx
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x40b10
movq %rsp, %rdi
movl $0x4, %edx
xorl %esi, %esi
callq 0x40b10
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41aa0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x42010
movq %r15, %rdi
movq %r14, %rsi
callq 0x411d0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x53741
jmp 0x53741
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x40870
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::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 0x401d0
movq %rax, %r14
movl $0x10, %edi
callq 0x40800
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x411d0
movq %rax, (%rbx)
movq 0x8(%rax), %rax
movq -0x8(%rax), %rax
movq %r14, (%rax)
movl $0x68, %edi
callq 0x40800
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x41bf0
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r15, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::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 %r12
pushq %rbx
subq $0x70, %rsp
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl $0x28, %edi
callq 0x40800
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movl %r14d, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
movl $0x68, %edi
callq 0x40800
movq %rax, %r14
movq 0x10(%r15), %rsi
leaq 0x50(%rsp), %rdi
callq 0x40390
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x40b10
movslq %ebp, %rdx
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x40b10
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
callq 0x41aa0
movq %r15, %rdi
callq 0x401d0
movq %rax, %r15
movq 0x8(%rsp), %rdi
movq 0x8(%rbx), %rsi
callq 0x42010
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x42010
movq 0x8(%rsp), %rax
movq %r15, (%rax)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x538d2
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x538dc
leaq 0x8(%rsp), %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40800
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x41bf0
movq %r14, 0x8(%rbx)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5390b
jmp 0x5390b
jmp 0x5390b
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::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 0x541f5
xorl %ebp, %ebp
cmpl $0x6, (%r14)
jne 0x541f5
movq 0x8(%r14), %rax
movl 0x58(%rax), %ebp
cmpl $0x0, 0x20(%r14)
jne 0x54267
cmpl $0x6, (%r14)
jne 0x54267
movq 0x8(%r14), %rax
movq 0x30(%r14), %r12
movl 0x5c(%rax), %r13d
movl $0x68, %edi
callq 0x40800
movq %rax, %rbx
movq 0x10(%r15), %rsi
leaq 0x28(%rsp), %rdi
callq 0x40390
movq %r12, %rax
xorl %edx, %edx
divq %r13
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x40b10
movl %ebp, %edx
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x40b10
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
callq 0x41aa0
jmp 0x542a6
movl $0x68, %edi
callq 0x40800
movq %rax, %rbx
movq 0x10(%r15), %rsi
leaq 0x28(%rsp), %rdi
callq 0x40390
movl %ebp, %edx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x40b10
leaq 0x20(%r14), %rdx
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x41aa0
movl $0x68, %esi
movq %r14, %rdi
callq 0x40870
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x542cd
jmp 0x542cd
jmp 0x542cd
jmp 0x542cd
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x40870
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstTpl::ConstTpl(ConstTpl::const_type, unsigned long)
ConstTpl::ConstTpl(const_type tp,uintb val)

{				// Constructor for real constants
  type = tp;
  value_real = val;
  value.handle_index = 0;
  select = v_space;
}

// Assembly:
movl %esi, (%rdi)
movq %rdx, 0x10(%rdi)
xorl %eax, %eax
movl %eax, 0x8(%rdi)
movl %eax, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x549b9
cmpl $0x6, %eax
je 0x549bc
cmpl $0x1, %eax
je 0x549a6
testl %eax, %eax
jne 0x549b6
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x549c4
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x549b9
movl 0x18(%rdi), %eax
cmpl 0x18(%rsi), %eax
jne 0x549b9
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_O1/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 0x549f4
cmpl $0x6, %eax
je 0x549f8
cmpl $0x1, %eax
je 0x549e6
testl %eax, %eax
jne 0x54a04
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x54a00
movl 0x8(%rsi), %eax
cmpl %eax, 0x8(%rdi)
jne 0x549f4
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_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x7, %eax
ja 0x54b82
leaq 0x2b5ce(%rip), %rcx     # 0x80118
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
jne 0x54b7e
movq 0x10(%rsi), %rax
movq 0x40(%rax), %rax
movslq 0x8(%rdi), %rdx
movq (%rax,%rdx,8), %rax
leaq 0x30(%rax), %rdx
cmpq $0x0, 0x18(%rax)
leaq 0x8(%rax), %rax
cmoveq %rax, %rdx
movq (%rdx), %rax
testl %ecx, %ecx
je 0x54bfa
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b605(%rip), %rsi     # 0x801a4
leaq 0x2b623(%rip), %rdx     # 0x801c9
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x4e2df(%rip), %rsi     # 0xa2ea8
movq 0x4e068(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
addq $0x8, %rdi
jmp 0x54bf7
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
jne 0x54bea
movq (%rsi), %rdi
addq $0x70, %rdi
jmp 0x54bf7
movq (%rsi), %rdi
addq $0x50, %rdi
movq (%rdi), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x54c27
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x54c27
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x54c34
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x54c60
cmpl $0x6, %eax
je 0x54c76
cmpl $0x4, %eax
jne 0x54c8b
movq (%rdx), %rdi
addq $0x50, %rdi
jmp 0x54c7a
cmpl $0x0, 0x18(%rdi)
jne 0x54c8b
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 $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b4fc(%rip), %rsi     # 0x801a4
leaq 0x2b51a(%rip), %rdx     # 0x801c9
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x4e1d6(%rip), %rsi     # 0xa2ea8
movq 0x4df5f(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x54d03
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x54d03
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x54d10
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
// File: /workspace/github_cpp_makefile_star2_O1/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 0x54d5d
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
movl $0x30, %ecx
jmp 0x54d93
movq $0x0, 0x10(%rbx)
movq (%rbx), %r14
movq %rdx, %rsi
callq 0x40020
movq 0x28(%r14), %rsi
movl $0x18, %ecx
cmpq %rax, %rsi
jae 0x54d93
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, (%rdi)
jne 0x54e33
movl 0x18(%rdi), %eax
cmpq $0x3, %rax
ja 0x54e33
movslq 0x8(%rdi), %rcx
movq (%rsi), %rdx
movq (%rdx,%rcx,8), %rcx
leaq 0x2b36a(%rip), %rdx     # 0x80138
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movups (%rcx), %xmm0
movups 0xc(%rcx), %xmm1
jmp 0x54e19
movups 0x20(%rcx), %xmm0
movups 0x2c(%rcx), %xmm1
jmp 0x54e19
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 0x54e22
testl %ecx, %ecx
jne 0x54e3e
movzwl %ax, %eax
addq 0x10(%rdi), %rax
jmp 0x54e2f
movups 0x60(%rcx), %xmm0
movups 0x6c(%rcx), %xmm1
movups %xmm1, 0xc(%rdi)
movups %xmm0, (%rdi)
jmp 0x54e33
cmpl $0x1, 0x18(%rdi)
jne 0x54e3e
movl $0x3, 0x18(%rdi)
movq %rax, 0x10(%rdi)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b36f(%rip), %rsi     # 0x801ca
leaq 0x2b38f(%rip), %rdx     # 0x801f1
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x4e023(%rip), %rsi     # 0xa2ea8
movq 0x4ddac(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x54eb6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x54eb6
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x54ec3
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x2abe1(%rip), %rsi     # 0x7fb1d
callq 0x3f590
testl %eax, %eax
je 0x54fe3
leaq 0x2adce(%rip), %rsi     # 0x7fd1e
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x54fe7
leaq 0x30836(%rip), %rsi     # 0x8579d
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x54fee
leaq 0x2b278(%rip), %rsi     # 0x801f2
movq %rbx, %rdi
callq 0x3f590
movl %eax, %ecx
movl $0x3, %eax
testl %ecx, %ecx
je 0x54ff3
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b254(%rip), %rsi     # 0x801fe
leaq 0x2b260(%rip), %rdx     # 0x80211
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f890
xorl %ebp, %ebp
movq 0x4ded4(%rip), %rsi     # 0xa2ea8
movq 0x4dc5d(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d60
xorl %eax, %eax
jmp 0x54ff3
movl $0x1, %eax
jmp 0x54ff3
movl $0x2, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x55020
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
jmp 0x55020
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5502d
movq %rbx, %rdi
callq 0x40080
movq %r14, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x28, %rsp
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %esi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x421e0
leaq 0x20(%rbx), %rdi
movl $0x1, %esi
movl %r15d, %edx
movl $0x1, %ecx
callq 0x421e0
leaq 0x40(%rbx), %r14
movq %r14, %rdi
movl $0x1, %esi
movl %r15d, %edx
movl $0x2, %ecx
callq 0x421e0
testl %ebp, %ebp
je 0x55939
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40b10
movups (%r15), %xmm0
movups 0xc(%r15), %xmm1
movups %xmm1, 0xc(%r14)
movups %xmm0, (%r14)
movb $0x0, 0x60(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x55a2b
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_O1/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 0x20(%rdi), %ebp
movl 0x30(%rdi), %ebx
xorl $0x1, %ebp
movl 0x38(%rdi), %r13d
xorl $0x3, %r13d
movslq 0x28(%rdi), %rax
movq %rax, (%rsp)
callq 0x42300
movq %r12, %rdi
movq %r14, %rsi
callq 0x42300
leaq 0x40(%r15), %rdi
movq %r14, %rsi
callq 0x42300
xorl %edx, %edx
orl %ebp, %r13d
cmoveq (%rsp), %rdx
jne 0x55aa8
cmpl $0x6, (%r15)
jne 0x55a94
movq 0x8(%r15), %rcx
cmpl $0x3, 0x8(%rcx)
je 0x55aad
movq (%r14), %rcx
movq (%rcx,%rdx,8), %rcx
cmpl $0x0, 0x20(%rcx)
jne 0x55aa8
cmpq $0x0, 0x30(%rcx)
je 0x55aad
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
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_O1/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 0x55b01
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rcx
movl 0x50(%rdi), %eax
addl %ecx, %eax
subl %eax, %esi
setge %al
jl 0x55b5e
movslq %ecx, %rax
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
movq %r14, %rdi
movl $0x1, %esi
movl $0x3, %ecx
callq 0x41890
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_O1/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 0x2a7cd(%rip), %rsi     # 0x80344
movl $0xd, %edx
movq %rbx, %rdi
callq 0x40b80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41140
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x41140
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41140
leaq 0x2a7a1(%rip), %rsi     # 0x80352
movl $0xf, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40b80
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40300
leaq 0x20(%r14), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x40300
addq $0x40, %r14
movq 0x10(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x40300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40520
testb %al, %al
je 0x55c59
leaq 0x20(%r14), %r15
leaq 0x20(%rbx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x40520
testb %al, %al
je 0x55c61
addq $0x40, %r14
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40520
testb %al, %al
je 0x55c59
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x55c67
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42070
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, (%rdi)
movq %rax, 0x10(%rdi)
movl %eax, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movl %eax, 0x40(%rdi)
movq %rax, 0x50(%rdi)
movl %eax, 0x60(%rdi)
movq %rax, 0x70(%rdi)
movl %eax, 0x80(%rdi)
movq %rax, 0x90(%rdi)
movl %eax, 0xa0(%rdi)
movq %rax, 0xb0(%rdi)
movl %eax, 0xc0(%rdi)
movq %rax, 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 0x40b10
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_O1/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 0x55e8c
leaq 0x40(%r15), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x3ff90
movq %rax, (%rbx)
leaq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x40020
movl %eax, 0x8(%rbx)
leaq 0x60(%r15), %rdi
movq %r14, %rsi
callq 0x40020
movq %rax, 0x18(%rbx)
movq %r12, %rdi
movq %r14, %rsi
callq 0x3ff90
movq %rax, 0x10(%rbx)
cmpl $0x0, 0x8(%rax)
je 0x55ec6
leaq 0x80(%r15), %rdi
movq %r14, %rsi
callq 0x40020
movl %eax, 0x20(%rbx)
leaq 0xa0(%r15), %rdi
movq %r14, %rsi
callq 0x3ff90
movq %rax, 0x28(%rbx)
addq $0xc0, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x40020
movq %rax, 0x30(%rbx)
jmp 0x55eff
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x411b0
leaq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x40020
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 0x422b0
movq $0x0, 0x10(%rbx)
movq (%rbx), %rcx
movl 0x5c(%rcx), %eax
imulq 0x18(%rbx), %rax
movq %rax, 0x18(%rbx)
movq 0x28(%rcx), %rcx
cmpq %rax, %rcx
jae 0x55efb
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a3a5(%rip), %rsi     # 0x80362
movl $0xc, %edx
movq %rbx, %rdi
callq 0x40b80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41140
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x41140
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x41140
leaq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x41140
leaq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x41140
leaq 0xa0(%r14), %rdi
movq %rbx, %rsi
callq 0x41140
addq $0xc0, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41140
leaq 0x2a33f(%rip), %rsi     # 0x8036f
movl $0xe, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40b80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40300
leaq 0x20(%r14), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x40300
leaq 0x40(%r14), %rdi
movq 0x10(%r15), %rsi
movq %rbx, %rdx
callq 0x40300
leaq 0x60(%r14), %rdi
movq 0x18(%r15), %rsi
movq %rbx, %rdx
callq 0x40300
leaq 0x80(%r14), %rdi
movq 0x20(%r15), %rsi
movq %rbx, %rdx
callq 0x40300
leaq 0xa0(%r14), %rdi
movq 0x28(%r15), %rsi
movq %rbx, %rdx
callq 0x40300
addq $0xc0, %r14
movq 0x30(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x40300
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x560e5
movl $0x68, %esi
callq 0x40870
movq 0x10(%rbx), %r14
cmpq 0x18(%rbx), %r14
je 0x56107
movq (%r14), %rdi
testq %rdi, %rdi
je 0x56101
movl $0x68, %esi
callq 0x40870
addq $0x8, %r14
jmp 0x560e9
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x56123
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40870
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x56144
cmpl $0x0, 0x40(%rcx)
jne 0x56144
movb $0x1, %al
cmpq $0x0, 0x50(%rcx)
jne 0x56144
retq
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rcx
cmpq %rcx, %rdx
je 0x5617c
addq $0x8, %rdx
movq -0x8(%rdx), %rax
cmpl $0x0, 0x40(%rax)
sete %sil
cmpq $0x0, 0x50(%rax)
sete %al
andb %sil, %al
jne 0x56143
leaq 0x8(%rdx), %rsi
cmpq %rcx, %rdx
movq %rsi, %rdx
jne 0x56155
jmp 0x56143
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rdi, %rdi
je 0x561a1
movl $0x68, %esi
callq 0x40870
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
decq %rdx
cmpq %r14, %rdx
jbe 0x561e5
movq 0x8(%rax,%r14,8), %rcx
movq %rcx, (%rax,%r14,8)
leaq 0x1(%r14), %rdx
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
decq %rsi
movq %rdx, %r14
cmpq %rdx, %rsi
ja 0x561bb
addq $-0x8, %rcx
movq %rcx, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x56211
movq %rbx, %rsi
callq 0x418c0
movq 0x10(%r14), %r15
cmpq 0x18(%r14), %r15
je 0x5622c
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x418c0
addq $0x8, %r15
jmp 0x56215
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a13a(%rip), %rsi     # 0x8037e
movl $0xe, %edx
movq %rbx, %rdi
callq 0x40b80
movl 0x8(%r14), %edi
callq 0x402e0
testq %rax, %rax
je 0x5627a
movq %rax, %r15
movq %rax, %rdi
callq 0x3f9e0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x40b80
jmp 0x56291
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x41d20
leaq 0x2a0f5(%rip), %rsi     # 0x8038d
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%r14), %rdi
testq %rdi, %rdi
je 0x562b7
movq %rbx, %rsi
callq 0x3fc70
jmp 0x562cb
leaq 0x2a0d2(%rip), %rsi     # 0x80390
movl $0x8, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x10(%r14), %rax
cmpq %rax, 0x18(%r14)
je 0x562fb
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x3fc70
incq %r15
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x562d8
leaq 0x2a097(%rip), %rsi     # 0x80399
movl $0xa, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40b80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x299c6(%rip), %rsi     # 0x7fd01
leaq 0x299c3(%rip), %rdx     # 0x7fd05
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3f8a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x40f70
movq %rax, %rdi
callq 0x41ba0
movl %eax, 0x8(%r15)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5637d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
movq 0x78(%r14), %rbp
movq (%rbp), %rdi
leaq 0x2a018(%rip), %rsi     # 0x803a4
callq 0x3f590
testl %eax, %eax
je 0x563cd
movl $0x68, %edi
callq 0x40800
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x10(%rax)
movl %ecx, 0x20(%rax)
movq %rcx, 0x30(%rax)
movl %ecx, 0x40(%rax)
movq %rcx, 0x50(%rax)
movb $0x0, 0x60(%rax)
movq %rax, (%r15)
movq (%rbp), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x41e80
jmp 0x563d4
movq $0x0, (%r15)
addq $0x8, %rbp
cmpq 0x80(%r14), %rbp
je 0x56454
leaq 0x10(%r15), %r12
xorl %r13d, %r13d
movl $0x68, %edi
callq 0x40800
movl %r13d, (%rax)
movq %r13, 0x10(%rax)
movl %r13d, 0x20(%rax)
movq %r13, 0x30(%rax)
movl %r13d, 0x40(%rax)
movq %r13, 0x50(%rax)
movb $0x0, 0x60(%rax)
movq %rax, 0x8(%rsp)
movq (%rbp), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x41e80
movq 0x18(%r15), %rsi
cmpq 0x20(%r15), %rsi
je 0x5643a
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%r15)
jmp 0x56447
movq %r12, %rdi
leaq 0x8(%rsp), %rdx
callq 0x40b00
addq $0x8, %rbp
cmpq 0x80(%r14), %rbp
jne 0x563e8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5647d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r15
cmpq 0x10(%rdi), %r15
je 0x564bf
movq (%r15), %r14
testq %r14, %r14
je 0x564b5
movq %r14, %rdi
callq 0x3f1f0
movl $0x28, %esi
movq %r14, %rdi
callq 0x40870
addq $0x8, %r15
cmpq 0x10(%rbx), %r15
jne 0x56498
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x564d2
movl $0xe0, %esi
callq 0x40870
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x564ec
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x40870
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/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 0x5650d
cmpl $0x3d, %eax
jne 0x5651e
cmpl $0x0, (%rdi)
je 0x56512
xorl %eax, %eax
jmp 0x56543
incl 0x4(%rdi)
jmp 0x5651e
movq 0x10(%rsi), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movl %eax, (%rdi)
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
je 0x56532
movq %rsi, (%rax)
addq $0x8, 0x10(%rdi)
jmp 0x56541
addq $0x8, %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x3f150
movb $0x1, %al
popq %rcx
retq
nop