LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/pcodecompile.cc
// Function: PcodeCompile::placeLabel(LabelSymbol*)
vector<OpTpl *> *PcodeCompile::placeLabel(LabelSymbol *labsym)

{ // Create placeholder OpTpl for a label
  if (labsym->isPlaced()) {
    string errmsg = "Label " + labsym->getName();
    errmsg += " is placed more than once";
    reportError(errmsg);
  }
  labsym->setPlaced();
  vector<OpTpl *> *res = new vector<OpTpl *>;
  OpTpl *op = new OpTpl(LABELBUILD);
  VarnodeTpl *idvn = new VarnodeTpl(ConstTpl(constantspace),
				      ConstTpl(ConstTpl::real,labsym->getIndex()),
				      ConstTpl(ConstTpl::real,4));
  op->addInput(idvn);
  res->push_back(op);
  return res;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xd8(%rsp), %rdi
callq 0xdb790
testb $0x1, %al
jne 0x10e0fa
jmp 0x10e183
movq 0xd8(%rsp), %rdi
callq 0xd1f90
movq %rax, %rdx
leaq 0x79e0c(%rip), %rsi     # 0x187f1d
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xd7370
movq 0x20(%rsp), %rdi
leaq 0x79df5(%rip), %rsi     # 0x187f24
callq 0xd7d80
jmp 0x10e136
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq 0xb8(%rsp), %rsi
callq *%rax
jmp 0x10e14e
leaq 0xb8(%rsp), %rdi
callq 0xd4550
jmp 0x10e183
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0xd4550
jmp 0x10e2ef
movq 0xd8(%rsp), %rdi
callq 0xe1e20
movl $0x18, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
callq 0xcf120
movq 0x10(%rsp), %rax
movq %rax, 0xa0(%rsp)
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movl $0x41, %esi
callq 0xcf490
jmp 0x10e1d5
movq 0x18(%rsp), %rax
movq %rax, 0x98(%rsp)
movl $0x68, %edi
callq 0xd8380
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rsi
leaq 0x70(%rsp), %rdi
callq 0xd69a0
jmp 0x10e209
movq 0xd8(%rsp), %rdi
callq 0xe01e0
movl %eax, 0x4(%rsp)
jmp 0x10e21c
movl 0x4(%rsp), %eax
movl %eax, %eax
movl %eax, %edx
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0xd9880
jmp 0x10e232
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0xd9880
jmp 0x10e245
movq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0xdf370
jmp 0x10e260
movq 0x8(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0xe1280
movq 0xa0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xdc8a0
movq 0xa0(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
movl $0x28, %esi
callq 0xd8620
jmp 0x10e2ef
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0xb0(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movl %edx, 0xa4(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0xd5da0
movq %rax, 0x90(%rsp)
cmpl $0x0, 0xa4(%rsp)
je 0x10e633
movq 0x90(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0xa4(%rsp), %eax
movl %eax, %edx
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
callq 0xd9880
movq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xe29d0
movl $0x58, %edi
callq 0xd8380
movq %rax, 0x38(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x90(%rsp), %rdi
callq 0xe3000
movq %rax, 0x48(%rsp)
jmp 0x10e663
movq 0x48(%rsp), %rdi
callq 0xd2a20
movq %rax, 0x30(%rsp)
jmp 0x10e674
movq 0x90(%rsp), %rdi
callq 0xdbaf0
movq %rax, 0x28(%rsp)
jmp 0x10e688
movq 0x28(%rsp), %rdi
callq 0xdd890
movq %rax, 0x20(%rsp)
jmp 0x10e699
movq 0x90(%rsp), %rdi
callq 0xd4930
movq %rax, 0x18(%rsp)
jmp 0x10e6ad
movq 0x18(%rsp), %rdi
callq 0xdd890
movq %rax, 0x10(%rsp)
jmp 0x10e6be
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rdx
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rax
movl %eax, %r8d
callq 0xd9790
jmp 0x10e6e1
movq 0x58(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x10e72d
movq 0x8(%rsp), %rdi
callq 0xd4550
movq 0x8(%rsp), %rdi
movl $0x20, %esi
callq 0xd8620
addq $0xb8, %rsp
retq
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
movl $0x58, %esi
callq 0xd8620
movq 0x68(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0xd5da0
movq %rax, 0x28(%rsp)
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %esi
callq 0xcf490
jmp 0x10e7a1
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xddc10
movq 0x30(%rsp), %rax
movq (%rax), %rdi
leaq 0x20(%rsp), %rsi
callq 0xdc8a0
movl $0x68, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
callq 0xdfaf0
jmp 0x10e7ff
movq (%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x28, %esi
callq 0xd8620
jmp 0x10e851
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rdi
callq 0xd5da0
movq %rax, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq (%rax), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdcb70
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xd90f0
movq 0x68(%rsp), %rax
movq (%rax), %rdi
callq 0xd1660
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
callq 0xdcb70
movq 0x10(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0xcf9f0
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
callq 0xd9b80
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movl 0x7c(%rsp), %esi
callq 0xcf490
jmp 0x10e924
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0x68(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x30(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xddc10
movq 0x70(%rsp), %rax
movq (%rax), %rdi
leaq 0x30(%rsp), %rsi
callq 0xdc8a0
movl $0x68, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rsi
callq 0xdfaf0
jmp 0x10e9a3
movq 0x8(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x10e9d7
movq (%rsp), %rdi
callq 0xdb660
movq (%rsp), %rdi
movl $0x10, %esi
callq 0xd8620
movq 0x70(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x28, %esi
callq 0xd8620
jmp 0x10ea20
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdcb70
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xd90f0
movq 0x60(%rsp), %rax
movq (%rax), %rdi
callq 0xd1660
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rdi
callq 0xdcb70
movq 0x10(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0xcf9f0
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rdi
callq 0xd9b80
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movl 0x74(%rsp), %esi
callq 0xcf490
jmp 0x10eae7
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0x30(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0x60(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x30(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xddc10
movq 0x68(%rsp), %rax
movq (%rax), %rdi
leaq 0x30(%rsp), %rsi
callq 0xdc8a0
movl $0x68, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rsi
callq 0xdfaf0
jmp 0x10eb66
movq 0x8(%rsp), %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x10eb9a
movq (%rsp), %rdi
callq 0xdb660
movq (%rsp), %rdi
movl $0x10, %esi
callq 0xd8620
movq 0x68(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x28, %esi
callq 0xd8620
jmp 0x10ebe3
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %esi
callq 0xcf490
jmp 0x10ec27
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xddc10
movq 0x28(%rsp), %rax
movq (%rax), %rdi
leaq 0x20(%rsp), %rsi
callq 0xdc8a0
movl $0x68, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rsi
callq 0xdfaf0
jmp 0x10ec85
movq (%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x28, %esi
callq 0xd8620
jmp 0x10ecd7
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %esi
callq 0xcf490
jmp 0x10ed22
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0x30(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq $0x0, (%rax)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x10ed8b
movq (%rsp), %rdi
callq 0xdb660
movq (%rsp), %rdi
movl $0x10, %esi
callq 0xd8620
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xdc8a0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x28, %esi
callq 0xd8620
movq 0x20(%rsp), %rdi
callq 0xe0be0
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq $0x0, (%rax)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdcb70
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xd90f0
movq 0x68(%rsp), %rax
movq (%rax), %rdi
callq 0xd1660
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
callq 0xdcb70
movq 0x10(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0xcf9f0
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
callq 0xd9b80
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movl 0x7c(%rsp), %esi
callq 0xcf490
jmp 0x10ee98
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0x70(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0x68(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xdc8a0
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x10ef1a
movq 0x8(%rsp), %rdi
callq 0xdb660
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0xd8620
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x10ef40
movq (%rsp), %rdi
callq 0xdb660
movq (%rsp), %rdi
movl $0x10, %esi
callq 0xd8620
movq 0x60(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x28, %esi
callq 0xd8620
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x68, %edi
callq 0xd8380
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rsi
leaq 0x88(%rsp), %rdi
callq 0xd69a0
jmp 0x10efd5
movq 0xb0(%rsp), %rdx
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xd9880
jmp 0x10efeb
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0xd9880
jmp 0x10effe
movq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x58(%rsp), %rdx
leaq 0x38(%rsp), %rcx
callq 0xdf370
jmp 0x10f01c
movq 0x20(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl $0x18, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
callq 0xcf120
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl 0xbc(%rsp), %esi
callq 0xcf490
jmp 0x10f06d
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0xe1280
movq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xdc8a0
movq 0x30(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
movl $0x68, %esi
callq 0xd8620
jmp 0x10f0e7
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
movl $0x28, %esi
callq 0xd8620
movq 0x80(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd5da0
movq %rax, 0x38(%rsp)
movl $0x10, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0xd10a0
jmp 0x10f6e3
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xd5690
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0xd2800
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0xddc10
movl $0x68, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0xdfaf0
jmp 0x10f747
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x10, %esi
callq 0xd8620
jmp 0x10f79b
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movl $0x9, %esi
callq 0xcf490
jmp 0x10f7fd
movq 0x18(%rsp), %rax
movq %rax, 0x98(%rsp)
movl $0x68, %edi
callq 0xd8380
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rsi
leaq 0x60(%rsp), %rdi
callq 0xd69a0
jmp 0x10f831
movq 0xa8(%rsp), %rdi
callq 0xd6ea0
movl %eax, 0x4(%rsp)
jmp 0x10f844
movl 0x4(%rsp), %eax
movl %eax, %eax
movl %eax, %edx
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0xd9880
jmp 0x10f85a
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0xd9880
jmp 0x10f86d
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0xdf370
jmp 0x10f888
movq 0x8(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x98(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xe1280
movq 0x98(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xdc200
addq $0xb8, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
movl $0x28, %esi
callq 0xd8620
jmp 0x10f90f
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0x90(%rsp), %rdi
callq 0xe0be0
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0xd5da0
movq %rax, 0x38(%rsp)
movl $0x10, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0xd10a0
jmp 0x10f95d
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl 0x4c(%rsp), %esi
callq 0xcf490
jmp 0x10f987
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xdc200
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0xd2800
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0xddc10
movl $0x68, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rsi
callq 0xdfaf0
jmp 0x10f9e5
movq (%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x10, %esi
callq 0xd8620
jmp 0x10fa56
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x28, %esi
callq 0xd8620
jmp 0x10fa56
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0x28(%rsp), %rdi
callq 0xe0be0
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movl %esi, 0xcc(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movl %r8d, 0xb4(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x28, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movl 0xcc(%rsp), %esi
callq 0xcf490
jmp 0x10fabe
movq 0x20(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl $0x68, %edi
callq 0xd8380
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x10(%rax), %rsi
leaq 0x70(%rsp), %rdi
callq 0xd69a0
jmp 0x10faf2
movq 0xb8(%rsp), %rdx
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0xd9880
jmp 0x10fb08
movslq 0xb4(%rsp), %rdx
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0xd9880
jmp 0x10fb1e
movq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0xdf370
jmp 0x10fb39
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x90(%rsp)
callq 0xd5da0
movq %rax, 0x28(%rsp)
movq 0xa8(%rsp), %rdi
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xe1280
movq 0xa8(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0xe1280
movq 0xa8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xddc10
movq 0xc0(%rsp), %rax
movq (%rax), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xdc8a0
movl $0x68, %edi
callq 0xd8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0xdfaf0
jmp 0x10fbce
movq 0x8(%rsp), %rcx
movq 0xc0(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0xd8, %rsp
retq
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
movl $0x28, %esi
callq 0xd8620
jmp 0x10fc54
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
movl $0x68, %esi
callq 0xd8620
jmp 0x10fc54
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
movl $0x68, %esi
callq 0xd8620
movq 0xa0(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movl %ecx, (%rax)
movq -0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstTpl::ConstTpl(ConstTpl::const_type, int, ConstTpl::v_field)
ConstTpl::ConstTpl(const_type tp,int4 ht,v_field vf)

{				// Constructor for handle constant
  type = handle;
  value.handle_index = ht;
  select = vf;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movl $0x1, (%rax)
movl -0x10(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl -0x14(%rsp), %ecx
movl %ecx, 0x18(%rax)
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstTpl::ConstTpl(ConstTpl::const_type, int, ConstTpl::v_field, unsigned long)
ConstTpl::ConstTpl(const_type tp,int4 ht,v_field vf,uintb plus)

{
  type = handle;
  value.handle_index = ht;
  select = vf;
  value_real = plus;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movq %r8, -0x20(%rsp)
movq -0x8(%rsp), %rax
movl $0x1, (%rax)
movl -0x10(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl -0x14(%rsp), %ecx
movl %ecx, 0x18(%rax)
movq -0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
je 0x114c99
movb $0x0, -0x1(%rsp)
jmp 0x114d35
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rsp)
testl %eax, %eax
je 0x114cc0
jmp 0x114caa
movl -0x24(%rsp), %eax
subl $0x1, %eax
je 0x114cdd
jmp 0x114cb5
movl -0x24(%rsp), %eax
subl $0x6, %eax
je 0x114d11
jmp 0x114d2e
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x114d35
movq -0x20(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x114cf6
movb $0x0, -0x1(%rsp)
jmp 0x114d35
movq -0x20(%rsp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x18(%rcx), %eax
je 0x114d0f
movb $0x0, -0x1(%rsp)
jmp 0x114d35
jmp 0x114d30
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x114d35
jmp 0x114d30
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
je 0x114d7b
movq -0x20(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x114e49
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rsp)
testl %eax, %eax
je 0x114da9
jmp 0x114d8c
movl -0x24(%rsp), %eax
subl $0x1, %eax
je 0x114dc9
jmp 0x114d97
movl -0x24(%rsp), %eax
subl $0x6, %eax
je 0x114e25
jmp 0x114e42
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
setb %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x114e49
movq -0x20(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x114df6
movq -0x20(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x114e49
movq -0x20(%rsp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x18(%rcx), %eax
je 0x114e23
movq -0x20(%rsp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x18(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x114e49
jmp 0x114e44
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
setb %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x114e49
jmp 0x114e44
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x18(%rsp)
subl $0x7, %eax
ja 0x115211
movq 0x18(%rsp), %rax
leaq 0x72fac(%rip), %rcx     # 0x188114
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%rsp), %rdi
callq 0xdadc0
movq %rax, 0x70(%rsp)
jmp 0x1152c1
movq 0x10(%rsp), %rax
movq 0x60(%rsp), %rdi
movl 0x8(%rax), %esi
callq 0xdb860
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x58(%rsp)
movl 0x18(%rax), %eax
testl %eax, %eax
jne 0x1151de
jmp 0x1151ad
movq 0x58(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1151cb
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x1152c1
movq 0x58(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x1152c1
jmp 0x1151e0
jmp 0x115213
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x1152c1
movq 0x60(%rsp), %rdi
callq 0xd1300
movq %rax, %rdi
callq 0xd9cf0
movq %rax, 0x70(%rsp)
jmp 0x1152c1
jmp 0x115213
movb $0x1, 0x23(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x72f5f(%rip), %rsi     # 0x1881a0
leaq 0x38(%rsp), %rdi
callq 0xe00a0
jmp 0x11524d
movq (%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd1ae0
jmp 0x11525d
movq (%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0xb2c23(%rip), %rsi     # 0x1c7e90
movq 0xb295c(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x1152d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1152a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4550
leaq 0x37(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x23(%rsp)
jne 0x1152b6
jmp 0x1152bf
movq (%rsp), %rdi
callq 0xd5400
jmp 0x1152cb
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xe0be0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
subl $0x1, %eax
je 0x11533a
jmp 0x11530a
movl 0x1c(%rsp), %eax
subl $0x4, %eax
je 0x115320
jmp 0x115315
movl 0x1c(%rsp), %eax
subl $0x6, %eax
je 0x11537b
jmp 0x115391
movq 0x60(%rsp), %rdi
callq 0xdadc0
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
jmp 0x115441
movq 0x10(%rsp), %rax
movq 0x60(%rsp), %rdi
movl 0x8(%rax), %esi
callq 0xdb860
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x58(%rsp)
movl 0x18(%rax), %eax
testl %eax, %eax
jne 0x115377
jmp 0x115362
movq 0x58(%rsp), %rax
movq (%rax), %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
jmp 0x115441
jmp 0x115379
jmp 0x115393
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
jmp 0x115441
jmp 0x115393
movb $0x1, 0x23(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x72ddf(%rip), %rsi     # 0x1881a0
leaq 0x38(%rsp), %rdi
callq 0xe00a0
jmp 0x1153cd
movq (%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd1ae0
jmp 0x1153dd
movq (%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0xb2aa3(%rip), %rsi     # 0x1c7e90
movq 0xb27dc(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x115450
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x115423
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd4550
leaq 0x37(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x23(%rsp)
jne 0x115436
jmp 0x11543f
movq (%rsp), %rdi
callq 0xd5400
jmp 0x115446
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xe0be0
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, (%rax)
jne 0x1154e3
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rdi
movl 0x8(%rax), %esi
callq 0xdb860
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movl 0x20(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x115525
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0xd5220
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xcfa10
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/semantics.cc
// Function: ConstTpl::printHandleSelector(std::ostream&, ConstTpl::v_field)
void ConstTpl::printHandleSelector(ostream &s,v_field val)

{
  switch(val) {
  case v_space:
    s << "space";
    break;
  case v_offset:
    s << "offset";
    break;
  case v_size:
    s << "size";
    break;
  case v_offset_plus:
    s << "offset_plus";
    break;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x115809
movq (%rsp), %rax
leaq 0x7298e(%rip), %rcx     # 0x188144
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
leaq 0x7234e(%rip), %rsi     # 0x187b19
callq 0xd8300
jmp 0x115809
movq 0x10(%rsp), %rdi
leaq 0x7253c(%rip), %rsi     # 0x187d1a
callq 0xd8300
jmp 0x115809
movq 0x10(%rsp), %rdi
leaq 0x781bc(%rip), %rsi     # 0x18d9ad
callq 0xd8300
jmp 0x115809
movq 0x10(%rsp), %rdi
leaq 0x729ea(%rip), %rsi     # 0x1881ee
callq 0xd8300
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x722f4(%rip), %rsi     # 0x187b19
callq 0xe30f0
testb $0x1, %al
jne 0x115830
jmp 0x11583d
movl $0x0, 0x54(%rsp)
jmp 0x115957
movq 0x48(%rsp), %rdi
leaq 0x724d1(%rip), %rsi     # 0x187d1a
callq 0xe30f0
testb $0x1, %al
jne 0x115854
jmp 0x115861
movl $0x1, 0x54(%rsp)
jmp 0x115957
movq 0x48(%rsp), %rdi
leaq 0x78140(%rip), %rsi     # 0x18d9ad
callq 0xe30f0
testb $0x1, %al
jne 0x115878
jmp 0x115885
movl $0x2, 0x54(%rsp)
jmp 0x115957
movq 0x48(%rsp), %rdi
leaq 0x7295d(%rip), %rsi     # 0x1881ee
callq 0xe30f0
testb $0x1, %al
jne 0x11589c
jmp 0x1158a9
movl $0x3, 0x54(%rsp)
jmp 0x115957
movb $0x1, 0x13(%rsp)
movl $0x20, %edi
callq 0xd2b40
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe0c80
movq 0x8(%rsp), %rdx
leaq 0x72923(%rip), %rsi     # 0x1881fa
leaq 0x28(%rsp), %rdi
callq 0xe00a0
jmp 0x1158e3
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd1ae0
jmp 0x1158f3
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
movq 0xb258d(%rip), %rsi     # 0x1c7e90
movq 0xb22c6(%rip), %rdx     # 0x1c7bd0
callq 0xe01f0
jmp 0x11596a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x115939
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd4550
leaq 0x27(%rsp), %rdi
callq 0xd8ec0
testb $0x1, 0x13(%rsp)
jne 0x11594c
jmp 0x115955
movq (%rsp), %rdi
callq 0xd5400
jmp 0x115960
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xe0be0
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
andb $0x1, %al
movb %al, 0x2b(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movl 0x2c(%rsp), %edx
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xe1d00
movq (%rsp), %rdi
addq $0x20, %rdi
movl 0x2c(%rsp), %edx
movl $0x1, %ecx
movl %ecx, %esi
callq 0xe1d00
movq (%rsp), %rdi
addq $0x40, %rdi
movl 0x2c(%rsp), %edx
movl $0x1, %esi
movl $0x2, %ecx
callq 0xe1d00
testb $0x1, 0x2b(%rsp)
je 0x11691e
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd9880
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x50(%rax)
movl 0x20(%rsp), %ecx
movl %ecx, 0x58(%rax)
movq (%rsp), %rax
movb $0x0, 0x60(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movb $0x0, 0x1f(%rsp)
addq $0x20, %rdi
callq 0xde5d0
cmpl $0x1, %eax
jne 0x116b37
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0xdfbd0
cmpl $0x3, %eax
jne 0x116b37
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0xd1b90
movq 0x8(%rsp), %rdi
movl %eax, 0x18(%rsp)
addq $0x20, %rdi
callq 0xdd890
movl %eax, 0x14(%rsp)
movb $0x1, 0x1f(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xe2520
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x20(%rsp), %rsi
callq 0xe2520
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x20(%rsp), %rsi
callq 0xe2520
testb $0x1, 0x1f(%rsp)
je 0x116bbe
movq 0x8(%rsp), %rdi
callq 0xd5bf0
testb $0x1, %al
jne 0x116b83
jmp 0x116b8d
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x116bc6
movq 0x20(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0xdfa00
movq (%rax), %rdi
callq 0xce240
movq %rax, %rdi
callq 0xd04c0
testb $0x1, %al
jne 0x116bb2
jmp 0x116bbc
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x116bc6
jmp 0x116bbe
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
andb $0x1, %al
movb %al, 0x43(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x40, %rdi
callq 0xde5d0
cmpl $0x0, %eax
je 0x116c57
movb $0x0, 0x57(%rsp)
jmp 0x116d32
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0xdd890
movq 0x8(%rsp), %rdi
movl %eax, 0x3c(%rsp)
addq $0x20, %rdi
callq 0xdd890
movl %eax, 0x38(%rsp)
movl 0x3c(%rsp), %eax
addl 0x38(%rsp), %eax
cmpl 0x44(%rsp), %eax
jle 0x116c93
movb $0x0, 0x57(%rsp)
jmp 0x116d32
movslq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
shlq $0x10, %rax
movq %rax, 0x30(%rsp)
testb $0x1, 0x43(%rsp)
je 0x116cce
movl 0x44(%rsp), %eax
movl 0x3c(%rsp), %ecx
addl 0x38(%rsp), %ecx
subl %ecx, %eax
cltq
orq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x116cdd
movslq 0x38(%rsp), %rax
orq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0xd1b90
movl %eax, %edx
movq 0x30(%rsp), %r8
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x3, %ecx
callq 0xdea80
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x30(%rax)
movl 0x28(%rsp), %ecx
movl %ecx, 0x38(%rax)
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x715dd(%rip), %rsi     # 0x188340
callq 0xd8300
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xdbee0
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rsi
callq 0xdbee0
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x8(%rsp), %rsi
callq 0xdbee0
movq 0x8(%rsp), %rdi
leaq 0x715a8(%rip), %rsi     # 0x18834e
callq 0xd8300
addq $0x18, %rsp
retq