LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::newOutput(bool, ExprTree*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, unsigned int)
vector<OpTpl *> *PcodeCompile::newOutput(bool usesLocalKey,ExprTree *rhs,string *varname,uint4 size)

{
  VarnodeSymbol *sym;
  VarnodeTpl *tmpvn = buildTemporary();
  if (size != 0)
    tmpvn->setSize(ConstTpl(ConstTpl::real,size)); // Size was explicitly specified
  else if ((rhs->getSize().getType()==ConstTpl::real)&&(rhs->getSize().getReal()!=0))
    tmpvn->setSize(rhs->getSize());	// Inherit size from unnamed expression result
				// Only inherit if the size is real, otherwise we
				// cannot build the VarnodeSymbol with a placeholder constant
  rhs->setOutput(tmpvn);
  sym = new VarnodeSymbol(*varname,tmpvn->getSpace().getSpace(),tmpvn->getOffset().getReal(),tmpvn->getSize().getReal()); // Create new symbol regardless
  addSymbol(sym);
  if ((!usesLocalKey) && enforceLocalKey)
	  reportError("Must use 'local' keyword to define symbol: "+*varname);
  delete varname;
  return ExprTree::toVector(rhs);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
callq 0x401e0
movq %rax, %r12
testl %r13d, %r13d
je 0x529e5
movl %r13d, %edx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x40b20
movups (%r13), %xmm0
movups 0xc(%r13), %xmm1
movups %xmm1, 0x4c(%r12)
movups %xmm0, 0x40(%r12)
jmp 0x529f3
movq 0x8(%rbx), %rax
cmpl $0x0, 0x40(%rax)
je 0x52ad0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3fe90
movl $0x58, %edi
callq 0x40810
movq %rax, %r13
movq 0x8(%r12), %rdx
movq 0x30(%r12), %rcx
movl 0x50(%r12), %r8d
movq %rax, %rdi
movq %r14, %rsi
callq 0x40b00
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0x8(%rax)
testb %bpl, %bpl
jne 0x52a7b
cmpb $0x1, 0x24(%r15)
jne 0x52a7b
leaq 0x2d4fe(%rip), %rsi     # 0x7ff42
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0x40510
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x20(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52a7b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x52a92
movq (%rax), %rsi
incq %rsi
callq 0x40880
movl $0x20, %esi
movq %r14, %rdi
callq 0x40880
movq (%rbx), %r14
movq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x40f60
movl $0x10, %esi
movq %rbx, %rdi
callq 0x40880
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x50(%rax)
je 0x529f3
addq $0x40, %rax
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
jmp 0x529d7
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52b16
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x52b11
movq %rax, %rbx
movl $0x58, %esi
movq %r13, %rdi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::newLocalDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, unsigned int)
void PcodeCompile::newLocalDefinition(string *varname,uint4 size)

{ // Create a new temporary symbol (without generating any pcode)
  VarnodeSymbol *sym;
  VarnodeTpl *tmpvn = buildTemporary();
  if (size != 0)
    tmpvn->setSize(ConstTpl(ConstTpl::real,size)); // Size was explicitly specified
  sym = new VarnodeSymbol(*varname,tmpvn->getSpace().getSpace(),tmpvn->getOffset().getReal(),tmpvn->getSize().getReal());
  addSymbol(sym);
  delete varname;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x401e0
movq %rax, %r15
testl %ebp, %ebp
je 0x52b62
movl %ebp, %edx
movq %rsp, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x40b20
movups (%r12), %xmm0
movups 0xc(%r12), %xmm1
movups %xmm1, 0x4c(%r15)
movups %xmm0, 0x40(%r15)
movl $0x58, %edi
callq 0x40810
movq %rax, %r12
movq 0x8(%r15), %rdx
movq 0x30(%r15), %rcx
movl 0x50(%r15), %r8d
movq %rax, %rdi
movq %rbx, %rsi
callq 0x40b00
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x8(%rax)
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x52ba9
movq (%rax), %rsi
incq %rsi
callq 0x40880
movl $0x20, %esi
movq %rbx, %rdi
callq 0x40880
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r12, %rdi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOp(OpCode, ExprTree*)
ExprTree *PcodeCompile::createOp(OpCode opc,ExprTree *vn)

{				// Create new expression with output -outvn-
				// built by performing -opc- on input vn.
				// Free input expression
  VarnodeTpl *outvn = buildTemporary();
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn->outvn);
  op->setOutput(outvn);
  vn->ops->push_back(op);
  vn->outvn = new VarnodeTpl(*outvn);
  return vn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
callq 0x401e0
movq %rax, %r14
movl $0x28, %edi
callq 0x40810
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r15)
movl %ebp, 0x8(%r15)
movq %rax, (%r15)
movq %r15, (%rsp)
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x42020
movq %r14, (%r15)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x52c3b
movq %r15, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x52c43
movq %rsp, %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40810
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x41c00
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 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOp(OpCode, ExprTree*, ExprTree*)
ExprTree *PcodeCompile::createOp(OpCode opc,ExprTree *vn1,
				    ExprTree *vn2)

{				// Create new expression with output -outvn-
				// built by performing -opc- on inputs vn1 and vn2.
				// Free input expressions
  VarnodeTpl *outvn = buildTemporary();
  vn1->ops->insert(vn1->ops->end(),vn2->ops->begin(),vn2->ops->end());
  vn2->ops->clear();
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn1->outvn);
  op->addInput(vn2->outvn);
  vn2->outvn = (VarnodeTpl *)0;
  op->setOutput(outvn);
  vn1->ops->push_back(op);
  vn1->outvn = new VarnodeTpl(*outvn);
  delete vn2;
  return vn1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
callq 0x401e0
movq %rax, %r15
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
movq (%r14), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x3f850
movq (%r14), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x52cc7
movq %rcx, 0x8(%rax)
movl $0x28, %edi
callq 0x40810
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %r13d, %r13d
movq %r13, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %r13, (%rax)
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x42020
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x42020
movq %r13, 0x8(%r14)
movq %r15, (%r12)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x52d23
movq %r12, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x52d2b
movq %rsp, %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40810
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x41c00
movq %r12, 0x8(%rbx)
movq %r14, %rdi
callq 0x40f60
movl $0x10, %esi
movq %r14, %rdi
callq 0x40880
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r12, %rdi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOpOut(VarnodeTpl*, OpCode, ExprTree*, ExprTree*)
ExprTree *PcodeCompile::createOpOut(VarnodeTpl *outvn,OpCode opc,
				       ExprTree *vn1,ExprTree *vn2)
{ // Create an op with explicit output and two inputs
  vn1->ops->insert(vn1->ops->end(),vn2->ops->begin(),vn2->ops->end());
  vn2->ops->clear();
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn1->outvn);
  op->addInput(vn2->outvn);
  vn2->outvn = (VarnodeTpl *)0;
  op->setOutput(outvn);
  vn1->ops->push_back(op);
  vn1->outvn = new VarnodeTpl(*outvn);
  delete vn2;
  return vn1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq (%rcx), %rdi
movq 0x8(%rdi), %rsi
movq (%r8), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x3f850
movq (%r14), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x52dc2
movq %rcx, 0x8(%rax)
movl $0x28, %edi
callq 0x40810
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %r13d, %r13d
movq %r13, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %r13, (%rax)
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x42020
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x42020
movq %r13, 0x8(%r14)
movq %r15, (%r12)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x52e1e
movq %r12, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x52e26
movq %rsp, %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40810
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x41c00
movq %r12, 0x8(%rbx)
movq %r14, %rdi
callq 0x40f60
movl $0x10, %esi
movq %r14, %rdi
callq 0x40880
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r12, %rdi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOpOutUnary(VarnodeTpl*, OpCode, ExprTree*)
ExprTree *PcodeCompile::createOpOutUnary(VarnodeTpl *outvn,OpCode opc,ExprTree *vn)

{ // Create an op with explicit output and 1 input
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn->outvn);
  op->setOutput(outvn);
  vn->ops->push_back(op);
  vn->outvn = new VarnodeTpl(*outvn);
  return vn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movl $0x28, %edi
callq 0x40810
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r15)
movl %ebp, 0x8(%r15)
movq %rax, (%r15)
movq %r15, (%rsp)
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x42020
movq %r14, (%r15)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x52edc
movq %r15, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x52ee4
movq %rsp, %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40810
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x41c00
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 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOpNoOut(OpCode, ExprTree*)
vector<OpTpl *> *PcodeCompile::createOpNoOut(OpCode opc,ExprTree *vn)

{				// Create new expression by creating op with given -opc-
				// and single input vn.   Free the input expression
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn->outvn);
  vn->outvn = (VarnodeTpl *)0;	// There is no longer an output to this expression
  vector<OpTpl *> *res = vn->ops;
  vn->ops = (vector<OpTpl *> *)0;
  delete vn;
  res->push_back(op);
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movl $0x28, %edi
callq 0x40810
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movl %ebp, 0x8(%rbx)
movq %rax, (%rbx)
movq %rbx, (%rsp)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x42020
movq (%r15), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq %r15, %rdi
callq 0x40f60
movl $0x10, %esi
movq %r15, %rdi
callq 0x40880
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x52f95
movq %rbx, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x52fa0
movq %rsp, %rdx
movq %r14, %rdi
callq 0x3f150
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOpNoOut(OpCode, ExprTree*, ExprTree*)
vector<OpTpl *> *PcodeCompile::createOpNoOut(OpCode opc,ExprTree *vn1,ExprTree *vn2)

{				// Create new expression by creating op with given -opc-
				// and inputs vn1 and vn2. Free the input expressions
  vector<OpTpl *> *res = vn1->ops;
  vn1->ops = (vector<OpTpl *> *)0;
  res->insert(res->end(),vn2->ops->begin(),vn2->ops->end());
  vn2->ops->clear();
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn1->outvn);
  vn1->outvn = (VarnodeTpl *)0;
  op->addInput(vn2->outvn);
  vn2->outvn = (VarnodeTpl *)0;
  res->push_back(op);
  delete vn1;
  delete vn2;
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq (%rdx), %rbx
movq $0x0, (%rdx)
movq 0x8(%rbx), %rsi
movq (%rcx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rbx, %rdi
callq 0x3f850
movq (%r14), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x52ff1
movq %rcx, 0x8(%rax)
movl $0x28, %edi
callq 0x40810
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %r13d, %r13d
movq %r13, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %r13, (%rax)
movq %rax, (%rsp)
movq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x42020
movq %r13, 0x8(%r15)
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x42020
movq %r13, 0x8(%r14)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5304a
movq %r12, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x53055
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x3f150
movq %r15, %rdi
callq 0x40f60
movl $0x10, %esi
movq %r15, %rdi
callq 0x40880
movq %r14, %rdi
callq 0x40f60
movl $0x10, %esi
movq %r14, %rdi
callq 0x40880
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::createOpConst(OpCode, unsigned long)
vector<OpTpl *> *PcodeCompile::createOpConst(OpCode opc,uintb val)

{
  VarnodeTpl *vn = new VarnodeTpl(ConstTpl(constantspace),
				    ConstTpl(ConstTpl::real,val),
				    ConstTpl(ConstTpl::real,4));
  vector<OpTpl *> *res = new vector<OpTpl *>;
  OpTpl *op = new OpTpl(opc);
  op->addInput(vn);
  res->push_back(op);
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x68, %edi
callq 0x40810
movq %rax, %rbx
movq 0x10(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x403a0
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x40b20
leaq 0x28(%rsp), %rdi
movl $0x4, %edx
xorl %esi, %esi
callq 0x40b20
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x41ab0
movl $0x18, %edi
callq 0x40810
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
movl $0x28, %edi
callq 0x40810
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r15, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %r15, (%rax)
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x42020
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3f150
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5315d
jmp 0x5315d
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x40880
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::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 0x401e0
movq %rax, %r15
movl $0x28, %edi
callq 0x40810
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r13)
movl $0x2, 0x8(%r13)
movq %rax, (%r13)
movq %r13, (%rsp)
movl $0x68, %edi
callq 0x40810
movq %rax, %r12
movq 0x10(%rbp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x403a0
leaq 0x28(%rsp), %rdi
movl $0x8, %edx
xorl %esi, %esi
callq 0x40b20
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rcx
movq %r12, %rdi
movq %r14, %rdx
callq 0x41ab0
movq %r13, %rdi
movq %r12, %rsi
callq 0x42020
movq 0x8(%rbx), %rsi
movq %r13, %rdi
callq 0x42020
movq %r15, (%r13)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x53232
movq %r13, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x5323a
movq %rsp, %rdx
callq 0x3f150
movl 0x20(%r14), %edx
testq %rdx, %rdx
je 0x53260
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x40b20
movq (%rbx), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3f380
movl $0x68, %edi
callq 0x40810
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x41c00
movq %r12, 0x8(%rbx)
movl $0x28, %esi
movq %r14, %rdi
callq 0x40880
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5329f
jmp 0x5329f
movq %rax, %rbx
movl $0x68, %esi
movq %r12, %rdi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
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 0x53304
movq %rcx, 0x8(%rax)
movl $0x28, %edi
callq 0x40810
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r13)
movl $0x3, 0x8(%r13)
movq %rax, (%r13)
movq %r13, 0x10(%rsp)
movl $0x68, %edi
callq 0x40810
movq %rax, %rbp
movq 0x10(%r14), %rsi
leaq 0x18(%rsp), %rdi
callq 0x403a0
leaq 0x38(%rsp), %rdi
movl $0x8, %edx
xorl %esi, %esi
callq 0x40b20
leaq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rcx
movq %rbp, %rdi
movq 0x8(%rsp), %rdx
callq 0x41ab0
movq %r13, %rdi
movq %rbp, %rsi
callq 0x42020
movq 0x8(%r12), %rsi
movq %r13, %rdi
callq 0x42020
movq 0x8(%r15), %rsi
movq %r13, %rdi
callq 0x42020
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x533aa
movq %r13, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x533b7
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x3f150
movq 0x8(%r15), %r14
movq 0x8(%rsp), %rbp
movl 0x20(%rbp), %edx
leaq 0x18(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x40b20
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x3f380
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %rax, 0x8(%r15)
movq %r12, %rdi
callq 0x40f60
movl $0x10, %esi
movq %r12, %rdi
callq 0x40880
movq %r15, %rdi
callq 0x40f60
movl $0x10, %esi
movq %r15, %rdi
callq 0x40880
movl $0x28, %esi
movq %rbp, %rdi
callq 0x40880
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53436
movq %rax, %rbx
movl $0x68, %esi
movq %rbp, %rdi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x401e0
movq %rax, %r13
movl $0x10, %edi
callq 0x40810
movq %rax, %rbx
movq $0x0, 0x8(%rax)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x400f0
movq %rax, (%rbx)
movq 0x8(%rax), %rax
movq -0x8(%rax), %rax
movq %r13, (%rax)
movl $0x68, %edi
callq 0x40810
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
callq 0x41c00
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 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40810
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 0x40810
movq %rax, %rbx
movq 0x10(%r13), %rsi
leaq 0x40(%rsp), %rdi
callq 0x403a0
movl 0x30(%r12), %edx
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x40b20
movq %rsp, %rdi
movl $0x4, %edx
xorl %esi, %esi
callq 0x40b20
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x41ab0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x42020
movq %r15, %rdi
movq %r14, %rsi
callq 0x411e0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5358d
jmp 0x5358d
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x40880
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::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 %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %ebp
callq 0x401e0
movq %rax, %r14
movl $0x10, %edi
callq 0x40810
movq %rax, %rbx
xorl %r12d, %r12d
movq %r12, 0x8(%rax)
movl $0x28, %edi
callq 0x40810
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r12, 0x20(%rax)
movl %ebp, 0x8(%rax)
movq %r12, (%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x411e0
movq %rax, (%rbx)
movq 0x8(%rax), %rax
movq -0x8(%rax), %rax
movq %r14, (%rax)
movl $0x68, %edi
callq 0x40810
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x41c00
movq %r15, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r15, %rdi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x28, %edi
callq 0x40810
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r15)
movl %r14d, 0x8(%r15)
movq %rax, (%r15)
movq %r15, (%rsp)
movl $0x68, %edi
callq 0x40810
movq %rax, %r14
movq 0x10(%r12), %rsi
leaq 0x48(%rsp), %rdi
callq 0x403a0
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x40b20
movslq %ebp, %rdx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x40b20
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
callq 0x41ab0
movq %r12, %rdi
callq 0x401e0
movq %rax, %r12
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x42020
movq %r15, %rdi
movq %r14, %rsi
callq 0x42020
movq %r12, (%r15)
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x53713
movq %r15, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x5371b
movq %rsp, %rdx
callq 0x3f150
movl $0x68, %edi
callq 0x40810
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0x41c00
movq %r14, 0x8(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5374c
jmp 0x5374c
jmp 0x5374c
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: 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 0x54011
xorl %ebp, %ebp
cmpl $0x6, (%r14)
jne 0x54011
movq 0x8(%r14), %rax
movl 0x58(%rax), %ebp
cmpl $0x0, 0x20(%r14)
jne 0x54083
cmpl $0x6, (%r14)
jne 0x54083
movq 0x8(%r14), %rax
movq 0x30(%r14), %r12
movl 0x5c(%rax), %r13d
movl $0x68, %edi
callq 0x40810
movq %rax, %rbx
movq 0x10(%r15), %rsi
leaq 0x28(%rsp), %rdi
callq 0x403a0
movq %r12, %rax
xorl %edx, %edx
divq %r13
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x40b20
movl %ebp, %edx
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x40b20
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
callq 0x41ab0
jmp 0x540c2
movl $0x68, %edi
callq 0x40810
movq %rax, %rbx
movq 0x10(%r15), %rsi
leaq 0x28(%rsp), %rdi
callq 0x403a0
movl %ebp, %edx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x40b20
leaq 0x20(%r14), %rdx
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x41ab0
movl $0x68, %esi
movq %r14, %rdi
callq 0x40880
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x540e9
jmp 0x540e9
jmp 0x540e9
jmp 0x540e9
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x40880
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x547ad
cmpl $0x6, %eax
je 0x547b0
cmpl $0x1, %eax
je 0x5479a
testl %eax, %eax
jne 0x547aa
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x547b8
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x547ad
movl 0x18(%rdi), %eax
cmpl 0x18(%rsi), %eax
jne 0x547ad
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_O3/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 0x547e8
cmpl $0x6, %eax
je 0x547ec
cmpl $0x1, %eax
je 0x547da
testl %eax, %eax
jne 0x547f8
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x547f4
movl 0x8(%rsi), %eax
cmpl %eax, 0x8(%rdi)
jne 0x547e8
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_O3/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 0x5498b
leaq 0x2b7ec(%rip), %rcx     # 0x80118
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, 0x18(%rdi)
jne 0x5498b
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 0x5497d
addq $0x8, %rdi
jmp 0x5497d
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
jne 0x54970
movq (%rsi), %rdi
addq $0x70, %rdi
jmp 0x5497d
movq (%rsi), %rdi
addq $0x50, %rdi
movq (%rdi), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b7fc(%rip), %rsi     # 0x801a4
leaq 0x2b81a(%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 0x4e4d6(%rip), %rsi     # 0xa2ea8
movq 0x4e25f(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x549fb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x54a05
jmp 0x54a0d
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/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 0x54a3a
cmpl $0x6, %eax
je 0x54a50
cmpl $0x4, %eax
jne 0x54a65
movq (%rdx), %rdi
addq $0x50, %rdi
jmp 0x54a54
cmpl $0x0, 0x18(%rdi)
jne 0x54a65
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 0x2b722(%rip), %rsi     # 0x801a4
leaq 0x2b740(%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 0x4e3fc(%rip), %rsi     # 0xa2ea8
movq 0x4e185(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x54ad5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x54adf
jmp 0x54ae7
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/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 0x54b35
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 0x54b6b
movq $0x0, 0x10(%rbx)
movq (%rbx), %r14
movq %rdx, %rsi
callq 0x40030
movq 0x28(%r14), %rsi
movl $0x18, %ecx
cmpq %rax, %rsi
jae 0x54b6b
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_O3/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 0x54c0b
movl 0x18(%rdi), %eax
cmpq $0x3, %rax
ja 0x54c0b
movslq 0x8(%rdi), %rcx
movq (%rsi), %rdx
movq (%rdx,%rcx,8), %rcx
leaq 0x2b592(%rip), %rdx     # 0x80138
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movups (%rcx), %xmm0
movups 0xc(%rcx), %xmm1
jmp 0x54bf1
movups 0x20(%rcx), %xmm0
movups 0x2c(%rcx), %xmm1
jmp 0x54bf1
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 0x54bfa
testl %ecx, %ecx
jne 0x54c16
movzwl %ax, %eax
addq 0x10(%rdi), %rax
jmp 0x54c07
movups 0x60(%rcx), %xmm0
movups 0x6c(%rcx), %xmm1
movups %xmm1, 0xc(%rdi)
movups %xmm0, (%rdi)
jmp 0x54c0b
cmpl $0x1, 0x18(%rdi)
jne 0x54c16
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 0x2b597(%rip), %rsi     # 0x801ca
leaq 0x2b5b7(%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 0x4e24b(%rip), %rsi     # 0xa2ea8
movq 0x4dfd4(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x54c86
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x54c90
jmp 0x54c98
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/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 0x2ae0d(%rip), %rsi     # 0x7fb1d
callq 0x3f590
testl %eax, %eax
je 0x54db7
leaq 0x2affa(%rip), %rsi     # 0x7fd1e
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x54dbb
leaq 0x30a62(%rip), %rsi     # 0x8579d
movq %rbx, %rdi
callq 0x3f590
testl %eax, %eax
je 0x54dc2
leaq 0x2b4a4(%rip), %rsi     # 0x801f2
movq %rbx, %rdi
callq 0x3f590
movl %eax, %ecx
movl $0x3, %eax
testl %ecx, %ecx
je 0x54dc7
movl $0x20, %edi
callq 0x3fb00
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b480(%rip), %rsi     # 0x801fe
leaq 0x2b48c(%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 0x4e100(%rip), %rsi     # 0xa2ea8
movq 0x4de89(%rip), %rdx     # 0xa2c38
movq %rbx, %rdi
callq 0x41d70
xorl %eax, %eax
jmp 0x54dc7
movl $0x1, %eax
jmp 0x54dc7
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 0x54dec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
testb %bpl, %bpl
jne 0x54df6
jmp 0x54dfe
movq %rax, %r14
movq %rbx, %rdi
callq 0x40090
movq %r14, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/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 0x421f0
leaq 0x20(%rbx), %rdi
movl $0x1, %esi
movl %r15d, %edx
movl $0x1, %ecx
callq 0x421f0
leaq 0x40(%rbx), %r14
movq %r14, %rdi
movl $0x1, %esi
movl %r15d, %edx
movl $0x2, %ecx
callq 0x421f0
testl %ebp, %ebp
je 0x55707
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40b20
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_O3/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 0x42310
movq %r12, %rdi
movq %r14, %rsi
callq 0x42310
leaq 0x40(%r15), %rdi
movq %r14, %rsi
callq 0x42310
cmpl $0x1, %r13d
jne 0x55872
cmpl $0x3, %ebp
jne 0x55872
cmpl $0x6, (%r15)
jne 0x5585a
movq 0x8(%r15), %rax
cmpl $0x3, 0x8(%rax)
je 0x55877
movq (%r14), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x20(%rax)
jne 0x55872
cmpq $0x0, 0x30(%rax)
je 0x55877
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_O3/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 0x558cb
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 0x558e6
xorl %eax, %eax
jmp 0x55928
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
movq %r14, %rdi
movl $0x1, %esi
movl $0x3, %ecx
callq 0x418a0
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_O3/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 0x2aa03(%rip), %rsi     # 0x80344
movl $0xd, %edx
movq %rbx, %rdi
callq 0x40b90
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41150
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x41150
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41150
leaq 0x2a9d7(%rip), %rsi     # 0x80352
movl $0xf, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40b90
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40310
leaq 0x20(%r14), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x40310
addq $0x40, %r14
movq 0x10(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x40310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40530
testb %al, %al
je 0x55a23
leaq 0x20(%r14), %r15
leaq 0x20(%rbx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x40530
testb %al, %al
je 0x55a2b
addq $0x40, %r14
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40530
testb %al, %al
je 0x55a23
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x55a31
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42080
nop