LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::defineOperand(OperandSymbol*, PatternExpression*)
void SleighCompile::defineOperand(OperandSymbol *sym,PatternExpression *patexp)

{				// Define operand in terms of PatternExpression
  try {
    sym->defineOperand(patexp);
    sym->setOffsetIrrelevant();	// If not a self-definition, the operand has no
				// pattern directly associated with it, so
				// the operand's offset is irrelevant
  }
  catch(SleighError &err) {
    reportError(err.explain,true);
    PatternExpression::release(patexp);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x4b332
orb $0x2, 0x58(%r15)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x30cec
movq %r15, %rdi
callq 0xf180
movq %r14, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x2d000
movq %rbx, %rdi
callq 0x3bab8
popq %rbx
popq %r14
popq %r15
jmp 0xf680
movq %rax, %r15
callq 0xf680
movq %r15, %rdi
callq 0xf730
movq %rax, %rdi
callq 0x13a37
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::defineInvisibleOperand(TripleSymbol*)
PatternEquation *SleighCompile::defineInvisibleOperand(TripleSymbol *sym)

{
  int4 index = curct->getNumOperands();
  OperandSymbol *opsym = new OperandSymbol(sym->getName(),index,curct);
  addSymbol(opsym);
  curct->addInvisibleOperand(opsym);
  PatternEquation *res = new OperandEquation(opsym->getIndex());
  SleighSymbol::symbol_type tp = sym->getType();
  try {
    if ((tp==SleighSymbol::value_symbol)||(tp==SleighSymbol::context_symbol)) {
      opsym->defineOperand(sym->getPatternExpression());
    }
    else {
      opsym->defineOperand(sym);
      //      reportWarning("Defining invisible operand "+sym->getName(),true);
    }
  }
  catch(SleighError &err) {
    reportError(err.explain,true);
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x2d0(%rdi), %r14
movq 0x20(%r14), %r13
subq 0x18(%r14), %r13
shrq $0x3, %r13
movl $0x60, %edi
callq 0xf370
movq %rax, %r15
leaq 0x8(%r12), %rsi
movq %rax, %rdi
movl %r13d, %edx
movq %r14, %rcx
callq 0x4b2aa
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d7f2
movq 0x2d0(%rbx), %rdi
movq %r15, %rsi
callq 0x4c814
movl $0x40, %edi
callq 0xf370
movq %rax, %r14
movl 0x3c(%r15), %ebp
leaq 0x5a106(%rip), %rax     # 0x8ae78
movq %rax, (%r14)
leaq 0x10(%r14), %rdi
callq 0x3b186
movl $0x0, 0x8(%r14)
leaq 0x5aa73(%rip), %rax     # 0x8b800
addq $0x10, %rax
movq %rax, (%r14)
movl %ebp, 0x38(%r14)
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
cmpl $0xf, %eax
je 0x30dac
cmpl $0x3, %eax
jne 0x30dc3
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x4b332
jmp 0x30dce
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b3e2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movl $0x40, %esi
movq %r14, %rdi
jmp 0x30df8
movq %rax, %r12
movl $0x60, %esi
movq %r15, %rdi
callq 0xf380
movq %r12, %rdi
callq 0xf730
movq %rax, %r12
cmpl $0x1, %edx
jne 0x30dfd
movq %r12, %rdi
callq 0xf180
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x2d000
callq 0xf680
jmp 0x30dce
movq %rax, %r12
callq 0xf680
jmp 0x30dfd
movq %rax, %rdi
callq 0x13a37
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::selfDefine(OperandSymbol*)
void SleighCompile::selfDefine(OperandSymbol *sym)

{				// Define operand as global symbol of same name
  TripleSymbol *glob = dynamic_cast<TripleSymbol *>(symtab.findSymbol(sym->getName(),1));
  if (glob == (TripleSymbol *)0) {
    reportError(sym->getName()+": No matching global symbol",true);
    return;
  }
  SleighSymbol::symbol_type tp = glob->getType();
  try {
    if ((tp==SleighSymbol::value_symbol)||(tp==SleighSymbol::context_symbol)) {
      sym->defineOperand(glob->getPatternExpression());
    }
    else
      sym->defineOperand(glob);
  }
  catch(SleighError &err) {
    reportError(err.explain,true);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x198(%rdi), %r15
leaq 0x8(%rsi), %r12
movq %r15, %rdi
movl $0x1, %esi
callq 0x47ac6
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x47d02
testq %rax, %rax
je 0x30ec3
leaq 0x5b34f(%rip), %rsi     # 0x8c1d0
leaq 0x59d20(%rip), %rdx     # 0x8aba8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xf410
testq %rax, %rax
je 0x30ec3
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x10(%rax)
cmpl $0xf, %eax
je 0x30ead
cmpl $0x3, %eax
jne 0x30f1e
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x4b332
jmp 0x30f29
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x15420
leaq 0x3176b(%rip), %rsi     # 0x62656
movq %r14, %rdi
callq 0xf780
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2d000
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x30f29
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf380
jmp 0x30f29
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b3e2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x30f37
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x30f51
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf380
movq %r14, %rdi
callq 0xf730
movq %rax, %r14
cmpl $0x1, %edx
jne 0x30f51
movq %r14, %rdi
callq 0xf180
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x2d000
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf680
movq %rax, %r14
callq 0xf680
jmp 0x30f51
movq %rax, %rdi
callq 0x13a37
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::setResultVarnode(ConstructTpl*, VarnodeTpl*)
ConstructTpl *SleighCompile::setResultVarnode(ConstructTpl *ct,VarnodeTpl *vn)

{				// Set constructors handle to indicate given varnode
  HandleTpl *res = new HandleTpl(vn);
  delete vn;
  ct->setResult(res);
  return ct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movl $0xe0, %edi
callq 0xf370
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2462e
movl $0x68, %esi
movq %r15, %rdi
callq 0xf380
movq %rbx, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xe0, %esi
movq %rbx, %rdi
callq 0xf380
movq %r14, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::setResultStarVarnode(ConstructTpl*, StarQuality*, VarnodeTpl*)
ConstructTpl *SleighCompile::setResultStarVarnode(ConstructTpl *ct,StarQuality *star,VarnodeTpl *vn)

{				// Set constructors handle to be the value pointed
				// at by -vn-
  HandleTpl *res = new HandleTpl(star->id,ConstTpl(ConstTpl::real,star->size),vn,
				   getUniqueSpace(),getUniqueAddr());
  delete star;
  delete vn;
  ct->setResult(res);
  return ct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movl $0xe0, %edi
callq 0xf370
movq %rax, %r14
movl 0x20(%r12), %edx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x23374
movq 0xc8(%r13), %r8
movl 0x124(%r13), %r9d
movl %r9d, %eax
shrl $0x4, %eax
cmpl $0xffffffe, %eax        # imm = 0xFFFFFFE
ja 0x3104d
leal 0x10(%r9), %eax
movl %eax, 0x124(%r13)
movq %rsp, %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x246ae
movl $0x28, %esi
movq %r12, %rdi
callq 0xf380
movl $0x68, %esi
movq %r15, %rdi
callq 0xf380
movq %r14, 0x20(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0xe0, %esi
movq %r14, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::contextMod(std::vector<ContextChange*, std::allocator<ContextChange*>>*, ContextSymbol*, PatternExpression*)
bool SleighCompile::contextMod(vector<ContextChange *> *vec,ContextSymbol *sym,PatternExpression *pe)

{ // A temporary change to a context variable (within the parsing of a single instruction)
  // Because we are in the middle of parsing, the "inst_next" value has not been computed yet
  // So we check to make sure the value expression doesn't use this symbol
  vector<const PatternValue *> vallist;
  pe->listValues(vallist);
  for(uint4 i=0;i<vallist.size();++i)
    if (dynamic_cast<const EndInstructionValue *>(vallist[i]) != (const EndInstructionValue *)0)
      return false;
  // Otherwise we generate a "temporary" change to context instruction  (ContextOp)
  ContextField *field = (ContextField *)sym->getPatternValue();
  ContextOp *op = new ContextOp(field->getStartBit(),field->getEndBit(),pe);
  vec->push_back(op);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, 0x18(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq (%rcx), %rax
movq %rcx, 0x20(%rsp)
movq %rcx, %rdi
callq *0x20(%rax)
movq (%rsp), %r12
movq 0x8(%rsp), %r15
subq %r12, %r15
je 0x3112e
sarq $0x3, %r15
movl $0x1, %r14d
xorl %eax, %eax
leaq 0x59b6a(%rip), %rbp     # 0x8ac68
leaq 0x59b7b(%rip), %rbx     # 0x8ac80
movq (%r12,%rax,8), %rdi
testq %rdi, %rdi
je 0x31123
xorl %r13d, %r13d
movq %rbp, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xf410
testq %rax, %rax
jne 0x3117a
movl %r14d, %eax
incl %r14d
cmpq %rax, %r15
ja 0x31105
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq %rax, %rbx
movl $0x20, %edi
callq 0xf370
movq %rax, %r15
movl 0xc(%rbx), %esi
movl 0x10(%rbx), %edx
movq %rax, %rdi
movq 0x20(%rsp), %rcx
callq 0x50378
leaq 0x30(%rsp), %rsi
movq %r15, (%rsi)
movq 0x18(%rsp), %rdi
callq 0x3507c
movq (%rsp), %r12
movb $0x1, %r13b
testq %r12, %r12
je 0x3118a
movq 0x10(%rsp), %rsi
subq %r12, %rsi
movq %r12, %rdi
callq 0xf380
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x311b4
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
callq 0xf380
jmp 0x311b7
jmp 0x311b4
jmp 0x311b4
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x311cd
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::contextSet(std::vector<ContextChange*, std::allocator<ContextChange*>>*, TripleSymbol*, ContextSymbol*)
void SleighCompile::contextSet(vector<ContextChange *> *vec,TripleSymbol *sym,
				ContextSymbol *cvar)

{ // A permanent (global) change to context.  During parsing of an instruction, this change
  // is put off until the full instruction has been parsed.  The existing value in the context
  // field is set permanently to that value starting at the address given by the address expression
  ContextField *field = (ContextField *)cvar->getPatternValue();
  ContextCommit *op = new ContextCommit(sym,field->getStartBit(),field->getEndBit(),cvar->getFlow());
  vec->push_back(op);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq (%rcx), %rax
movq %rcx, %rdi
callq *0x60(%rax)
movq %rax, %r13
movl $0x20, %edi
callq 0xf370
movq %rax, %r14
movl 0xc(%r13), %edx
movl 0x10(%r13), %ecx
movzbl 0x48(%r15), %r8d
movq %rax, %rdi
movq %r12, %rsi
callq 0x5099a
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x3507c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::createMacro(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
MacroSymbol *SleighCompile::createMacro(string *name,vector<string> *params)

{				// create a macro symbol (with parameter names)
  curct = (Constructor *)0;	// Not currently defining a Constructor
  curmacro = new MacroSymbol(*name,macrotable.size());
  delete name;
  addSymbol(curmacro);
  symtab.addScope();		// New scope for the body of the macro definition
  pcode.resetLabelCount();	// Macros have their own labels
  for(int4 i=0;i<params->size();++i) {
    OperandSymbol *oper = new OperandSymbol((*params)[i],i,(Constructor *)0);
    addSymbol(oper);
    curmacro->addOperand(oper);
  }
  delete params;
  return curmacro;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, 0x2d0(%rdi)
movl $0x58, %edi
callq 0xf370
movq %rax, %r12
movq 0x258(%rbx), %rbp
movq 0x260(%rbx), %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x20362
subq %rbp, %r13
shrq $0x3, %r13
leaq 0x59c19(%rip), %rax     # 0x8aec0
movq %rax, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r12)
xorl %eax, %eax
movq %rax, 0x50(%r12)
movl %r13d, 0x30(%r12)
movq %rax, 0x38(%r12)
movq %r12, 0x2d8(%rbx)
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x312e3
movq (%rax), %rsi
incq %rsi
callq 0xf380
movl $0x20, %esi
movq %r15, %rdi
callq 0xf380
movq 0x2d8(%rbx), %rsi
movq %rbx, %rdi
callq 0x2d7f2
leaq 0x198(%rbx), %rdi
callq 0x47a4a
movl $0x0, 0x200(%rbx)
movq (%r14), %r12
cmpq %r12, 0x8(%r14)
je 0x31377
xorl %ebp, %ebp
xorl %r15d, %r15d
movl $0x60, %edi
callq 0xf370
movq %rax, %r13
addq %rbp, %r12
movq %rax, %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x4b2aa
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2d7f2
movq 0x2d8(%rbx), %rdi
movq %r13, %rsi
callq 0x3441c
incq %r15
movq (%r14), %r12
movq 0x8(%r14), %rax
subq %r12, %rax
sarq $0x5, %rax
addq $0x20, %rbp
cmpq %r15, %rax
ja 0x31323
movq %r14, %rdi
callq 0x138c4
movl $0x18, %esi
movq %r14, %rdi
callq 0xf380
movq 0x2d8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r12, %rdi
jmp 0x313ba
movq %rax, %rbx
movl $0x60, %esi
movq %r13, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::compareMacroParams(MacroSymbol*, std::vector<ExprTree*, std::allocator<ExprTree*>> const&)
void SleighCompile::compareMacroParams(MacroSymbol *sym,const vector<ExprTree *> &param)

{ // Match up any qualities of the macro's OperandSymbols with
  // any OperandSymbol passed into the macro
  for(uint4 i=0;i<param.size();++i) {
    VarnodeTpl *outvn = param[i]->getOut();
    if (outvn == (VarnodeTpl *)0) continue;
    // Check if an OperandSymbol was passed into this macro
    if (outvn->getOffset().getType() != ConstTpl::handle) continue;
    int4 hand = outvn->getOffset().getHandleIndex();

    // The matching operands
    OperandSymbol *macroop = sym->getOperand(i);
    OperandSymbol *parentop;
    if (curct == (Constructor *)0)
      parentop = curmacro->getOperand(hand);
    else
      parentop = curct->getOperand(hand);

    // This is the only property we check right now
    if (macroop->isCodeAddress())
      parentop->setCodeAddress();
  }
}

// Assembly:
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
subq %rax, %rcx
je 0x31438
sarq $0x3, %rcx
movq 0x2d0(%rdi), %r8
movq 0x2d8(%rdi), %rdx
leaq 0x18(%r8), %rdi
addq $0x40, %rdx
testq %r8, %r8
cmovneq %rdi, %rdx
xorl %edi, %edi
movq (%rax,%rdi,8), %r8
movq 0x8(%r8), %r8
testq %r8, %r8
je 0x3142d
cmpl $0x1, 0x20(%r8)
jne 0x3142d
movslq %edi, %r9
movq 0x40(%rsi), %r10
movq (%r10,%r9,8), %r9
testb $0x1, 0x58(%r9)
je 0x3142d
movq (%rdx), %r9
movslq 0x28(%r8), %r8
movq (%r9,%r8,8), %r8
orl $0x1, 0x58(%r8)
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x313f7
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::createMacroUse(MacroSymbol*, std::vector<ExprTree*, std::allocator<ExprTree*>>*)
vector<OpTpl *> *SleighCompile::createMacroUse(MacroSymbol *sym,vector<ExprTree *> *param)

{ // Create macro build directive, given symbol and parameters
  if (sym->getNumOperands() != param->size()) {
    string errmsg = "Invocation of macro \"" + sym->getName();
    if (param->size() > sym->getNumOperands())
      errmsg += "\" passes too many parameters";
    else
      errmsg += "\" passes too few parameters";
    reportError(errmsg,true);
    return new vector<OpTpl *>;
  }
  compareMacroParams(sym,*param);
  OpTpl *op = new OpTpl(MACROBUILD);
  VarnodeTpl *idvn = new VarnodeTpl(ConstTpl(getConstantSpace()),
				      ConstTpl(ConstTpl::real,sym->getIndex()),
				      ConstTpl(ConstTpl::real,4));
  op->addInput(idvn);
  return ExprTree::appendParams(op,param);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq 0x48(%rsi), %rax
subq 0x40(%rsi), %rax
movq %rdi, %r15
shrq $0x3, %rax
cltq
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x31517
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x313c8
movl $0x28, %edi
callq 0xf370
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r13)
movl $0x40, 0x8(%r13)
movq %rax, (%r13)
movl $0x68, %edi
callq 0xf370
movq %rax, %r14
movq 0x98(%r15), %rsi
movq %rsp, %rdi
callq 0x233a4
movslq 0x30(%r12), %rdx
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x23374
leaq 0x20(%rsp), %rdi
movl $0x4, %edx
xorl %esi, %esi
callq 0x23374
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
callq 0x24330
movq %r13, %rdi
movq %r14, %rsi
callq 0x20118
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1dcaa
movq %rax, %rbx
jmp 0x315ad
leaq 0x8(%r12), %rdx
leaq 0x3114f(%rip), %rsi     # 0x62672
movq %rsp, %r14
movq %r14, %rdi
callq 0x1170e
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movq 0x48(%r12), %rcx
subq 0x40(%r12), %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
leaq 0x31134(%rip), %rax     # 0x62688
leaq 0x3114a(%rip), %rsi     # 0x626a5
cmovaq %rax, %rsi
movq %r14, %rdi
callq 0xf780
movq %rsp, %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x2d000
movl $0x18, %edi
callq 0xf370
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x315ad
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf380
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x315c2
jmp 0x315c2
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
jmp 0x315e8
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x315ed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::nextNamedSection(SectionVector*, ConstructTpl*, SectionSymbol*)
SectionVector *SleighCompile::nextNamedSection(SectionVector *vec,ConstructTpl *section,SectionSymbol *sym)

{ // Add additional named p-code sections
  sym->incrementDefineCount();
  symtab.popScope();		// Pop the scope of the last named section
  SymbolScope *curscope = symtab.getCurrentScope(); // This should now be the Constructor scope
  SymbolScope *parscope = curscope->getParent();
  if (parscope != symtab.getGlobalScope())
    throw LowlevelError("nextNamedSection called when not in section scope"); // Unrecoverable
  symtab.addScope();		// Add new scope under the Constructor scope (not the last section scope)
  vec->append(section,curscope); // Associate finished section
  vec->setNextIndex(sym->getTemplateId()); // Set index for the NEXT section (not been fully parsed yet)
  return vec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
incl 0x34(%rcx)
leaq 0x198(%rdi), %r12
movq %r12, %rdi
callq 0x47ab4
movq 0x1b0(%r13), %rax
movq 0x1c8(%r13), %r13
movq (%r13), %rcx
cmpq (%rax), %rcx
jne 0x31797
movq %r12, %rdi
callq 0x47a4a
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x29c42
movl 0x30(%r14), %eax
movl %eax, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0xf1b0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x30f44(%rip), %rsi     # 0x626f8
leaq 0x30f6e(%rip), %rdx     # 0x62729
leaq 0x8(%rsp), %rdi
callq 0x117f6
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11796
xorl %ebp, %ebp
leaq 0x57392(%rip), %rsi     # 0x88b70
leaq -0x2000b(%rip), %rdx    # 0x117da
movq %rbx, %rdi
callq 0xf6d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x31807
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf380
testb %bpl, %bpl
jne 0x31811
jmp 0x31819
movq %rax, %r14
movq %rbx, %rdi
callq 0xf290
movq %r14, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::finalNamedSection(SectionVector*, ConstructTpl*)
SectionVector *SleighCompile::finalNamedSection(SectionVector *vec,ConstructTpl *section)

{ // Fill-in final named section to match the previous SectionSymbol
  vec->append(section,symtab.getCurrentScope());
  symtab.popScope();		// Pop the section scope
  return vec;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c8(%rdi), %rax
addq $0x198, %r14            # imm = 0x198
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x29c42
movq %r14, %rdi
callq 0x47ab4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::createCrossBuild(VarnodeTpl*, SectionSymbol*)
vector<OpTpl *> *SleighCompile::createCrossBuild(VarnodeTpl *addr,SectionSymbol *sym)

{ // Create the crossbuild directive as a pcode template
  unique_allocatemask = 1;
  vector<OpTpl *> *res = new vector<OpTpl *>();
  VarnodeTpl *sectionid = new VarnodeTpl(ConstTpl(getConstantSpace()),
                                         ConstTpl(ConstTpl::real,sym->getTemplateId()),
                                         ConstTpl(ConstTpl::real,4));
  // This is simply a single pcodeop (template), where the opcode indicates the crossbuild directive
  OpTpl *op = new OpTpl( CROSSBUILD );
  op->addInput(addr);		// The first input is the VarnodeTpl representing the address
  op->addInput(sectionid);	// The second input is the indexed representing the named pcode section to build
  res->push_back(op);
  sym->incrementRefCount();	// Keep track of the references to the section symbol
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movl $0x1, 0x1d4(%rdi)
movl $0x18, %edi
callq 0xf370
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl $0x68, %edi
callq 0xf370
movq %rax, %rbx
movq 0x98(%r13), %rsi
leaq 0x8(%rsp), %rdi
callq 0x233a4
movslq 0x30(%r14), %rdx
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x23374
leaq 0x28(%rsp), %rdi
movl $0x4, %edx
xorl %esi, %esi
callq 0x23374
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x24330
movl $0x28, %edi
callq 0xf370
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r13)
movl $0x42, 0x8(%r13)
movq %rax, (%r13)
leaq 0x8(%rsp), %rbp
movq %r13, (%rbp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x20118
movq %r13, %rdi
movq %rbx, %rsi
callq 0x20118
movq %r15, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2044c
incl 0x38(%r14)
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3195a
jmp 0x3195a
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0xf380
movq %r14, %rdi
callq 0xf730
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::createConstructor(SubtableSymbol*)
Constructor *SleighCompile::createConstructor(SubtableSymbol *sym)

{
  if (sym == (SubtableSymbol *)0)
    sym = WithBlock::getCurrentSubtable(withstack);
  if (sym == (SubtableSymbol *)0)
    sym = root;
  curmacro = (MacroSymbol *)0;	// Not currently defining a macro
  curct = new Constructor(sym);
  curct->setLineno(lineno.back());
  sym->addConstructor(curct);
  symtab.addScope();		// Make a new symbol scope for our constructor
  pcode.resetLabelCount();
  return curct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x319a2
leaq 0x2b8(%rbx), %rax
movq %rax, %rcx
movq (%rcx), %rcx
cmpq %rax, %rcx
je 0x3199f
movq 0x10(%rcx), %r14
testq %r14, %r14
je 0x3198c
jmp 0x319a2
xorl %r14d, %r14d
testq %r14, %r14
jne 0x319ae
movq 0x190(%rbx), %r14
movq $0x0, 0x2d8(%rbx)
movl $0x98, %edi
callq 0xf370
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4c6ba
movq %r15, 0x2d0(%rbx)
movq 0x320(%rbx), %rax
movl -0x4(%rax), %eax
movl %eax, 0x90(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x34446
leaq 0x198(%rbx), %rdi
callq 0x47a4a
movl $0x0, 0x200(%rbx)
movq 0x2d0(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x98, %esi
movq %r15, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::expandMacros(ConstructTpl*, std::vector<ConstructTpl*, std::allocator<ConstructTpl*>> const&)
bool SleighCompile::expandMacros(ConstructTpl *ctpl,const vector<ConstructTpl *> &macrotable)

{
  vector<OpTpl *> newvec;
  vector<OpTpl *>::const_iterator iter;
  OpTpl *op;
  
  for(iter=ctpl->getOpvec().begin();iter!=ctpl->getOpvec().end();++iter) {
    op = *iter;
    if (op->getOpcode() == MACROBUILD) {
      MacroBuilder builder(this,newvec,ctpl->numLabels());
      int4 index = op->getIn(0)->getOffset().getReal();
      if (index >= macrotable.size())
	return false;
      builder.setMacroOp(op);
      ConstructTpl *macro_tpl = macrotable[index];
      builder.build(macro_tpl,-1);
      ctpl->setNumLabels( ctpl->numLabels() + macro_tpl->numLabels() );
      delete op;		// Throw away the place holder op
      if (builder.hasError())
	return false;
    }
    else
      newvec.push_back(op);
  }
  ctpl->setOpvec(newvec);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsi), %r12
cmpq 0x10(%rsi), %r12
je 0x31b77
movq %rdx, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r13
movq (%r12), %rsi
movq %rsi, 0x18(%rsp)
cmpl $0x40, 0x8(%rsi)
jne 0x31b42
movl 0x4(%rbx), %eax
movl %eax, 0x2c(%rsp)
movl %eax, 0x28(%rsp)
leaq 0x59207(%rip), %rax     # 0x8aca8
movq %rax, 0x20(%rsp)
movq %rsp, %rax
movq %rax, 0x48(%rsp)
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rax
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %r15, 0x38(%rsp)
movb $0x0, 0x40(%rsp)
movq 0x10(%rsi), %rax
movq (%rax), %rax
movslq 0x30(%rax), %rbp
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
cmpq %rax, %rbp
jae 0x31b8b
movq %r13, %rdi
callq 0x2d12c
movq (%r14), %rax
movq (%rax,%rbp,8), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x25660
movl 0x4(%rbp), %eax
addl %eax, 0x4(%rbx)
movq 0x18(%rsp), %rbp
testq %rbp, %rbp
je 0x31b21
movq %rbp, %rdi
callq 0x24a4a
movl $0x28, %esi
movq %rbp, %rdi
callq 0xf380
movb 0x40(%rsp), %bpl
movq %r13, %rdi
callq 0x34482
testb %bpl, %bpl
je 0x31b69
jmp 0x31b95
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x31b59
movq %rsi, (%rax)
addq $0x8, 0x8(%rsp)
jmp 0x31b69
movq %rsp, %rdi
movq %rax, %rsi
leaq 0x18(%rsp), %rdx
callq 0x2044c
addq $0x8, %r12
cmpq 0x10(%rbx), %r12
jne 0x31a7c
addq $0x8, %rbx
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x20142
jmp 0x31b97
leaq 0x20(%rsp), %rdi
callq 0x34482
xorl %ebp, %ebp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x31bad
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xf380
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31bc0
movq %rax, %rbx
jmp 0x31bd4
jmp 0x31bc7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x34482
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x31bea
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueVn(VarnodeTpl*, int)
void SleighCompile::shiftUniqueVn(VarnodeTpl *vn,int4 sa)

{ // If the varnode is in the unique space, shift its offset up by -sa- bits
  if (vn->getSpace().isUniqueSpace() && (vn->getOffset().getType() == ConstTpl::real)) {
    uintb val = vn->getOffset().getReal();
    val <<= sa;
    vn->setOffset(val);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x233c4
testb %al, %al
je 0x325ca
cmpl $0x0, 0x20(%rbx)
jne 0x325ca
movq 0x30(%rbx), %rdx
addq $0x20, %rbx
movl %ebp, %ecx
shlq %cl, %rdx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x23374
movups (%r14), %xmm0
movups 0xc(%r14), %xmm1
movups %xmm1, 0xc(%rbx)
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueOp(OpTpl*, int)
void SleighCompile::shiftUniqueOp(OpTpl *op,int4 sa)

{ // Shift the offset up by -sa- bits for any varnode used by this -op- in the unique space
  VarnodeTpl *outvn = op->getOut();
  if (outvn != (VarnodeTpl *)0)
    shiftUniqueVn(outvn,sa);
  for(int4 i=0;i<op->numInput();++i)
    shiftUniqueVn(op->getIn(i),sa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x325ed
movl %ebx, %esi
callq 0x32584
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x32628
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x32584
incq %r15
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jl 0x32603
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueHandle(HandleTpl*, int)
void SleighCompile::shiftUniqueHandle(HandleTpl *hand,int4 sa)

{ // Shift the offset up by -sa- bits, for either the dynamic or static varnode aspects that are in the unique space
  if (hand->getSpace().isUniqueSpace() && (hand->getPtrSpace().getType() == ConstTpl::real)
      && (hand->getPtrOffset().getType() == ConstTpl::real)) {
    uintb val = hand->getPtrOffset().getReal();
    val <<= sa;
    hand->setPtrOffset(val);
  }
  else if (hand->getPtrSpace().isUniqueSpace() && (hand->getPtrOffset().getType() == ConstTpl::real)) {
    uintb val = hand->getPtrOffset().getReal();
    val <<= sa;
    hand->setPtrOffset(val);
  }
  
  if (hand->getTempSpace().isUniqueSpace() && (hand->getTempOffset().getType() == ConstTpl::real)) {
    uintb val = hand->getTempOffset().getReal();
    val <<= sa;
    hand->setTempOffset(val);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x233c4
testb %al, %al
je 0x32652
cmpl $0x0, 0x40(%rbx)
jne 0x32652
cmpl $0x0, 0x60(%rbx)
je 0x32665
leaq 0x40(%rbx), %rdi
callq 0x233c4
testb %al, %al
je 0x32693
cmpl $0x0, 0x60(%rbx)
jne 0x32693
leaq 0x60(%rbx), %r15
movq 0x70(%rbx), %rdx
movl %ebp, %ecx
shlq %cl, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x23374
movups (%r14), %xmm0
movups 0xc(%r14), %xmm1
movups %xmm1, 0xc(%r15)
movups %xmm0, (%r15)
leaq 0xa0(%rbx), %rdi
callq 0x233c4
testb %al, %al
je 0x326de
cmpl $0x0, 0xc0(%rbx)
jne 0x326de
movq 0xd0(%rbx), %rdx
addq $0xc0, %rbx
movl %ebp, %ecx
shlq %cl, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x23374
movups (%r14), %xmm0
movups 0xc(%r14), %xmm1
movups %xmm1, 0xc(%rbx)
movups %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::shiftUniqueConstruct(ConstructTpl*, int)
void SleighCompile::shiftUniqueConstruct(ConstructTpl *tpl,int4 sa)

{ // Shift the offset up by -sa- bits, for any varnode in the unique space associated with this template
  HandleTpl *result = tpl->getResult();
  if (result != (HandleTpl *)0)
    shiftUniqueHandle(result,sa);
  const vector<OpTpl *> &vec( tpl->getOpvec() );
  for(int4 i=0;i<vec.size();++i)
    shiftUniqueOp(vec[i],sa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x32704
movl %ebx, %esi
callq 0x3262e
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x32733
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x325d4
incq %r15
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x32711
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::buildConstructor(Constructor*, PatternEquation*, std::vector<ContextChange*, std::allocator<ContextChange*>>*, SectionVector*)
void SleighCompile::buildConstructor(Constructor *big,PatternEquation *pateq,vector<ContextChange *> *contvec,SectionVector *vec)

{ // Take all the different parse pieces for a Constructor and build the Constructor object
  bool noerrors = true;
  if (vec != (SectionVector *)0) { // If the sections were implemented
    noerrors = finalizeSections(big,vec);
    if (noerrors) {		// Attach the sections to the Constructor
      big->setMainSection(vec->getMainSection());
      int4 max = vec->getMaxId();
      for(int4 i=0;i<max;++i) {
	ConstructTpl *section = vec->getNamedSection(i);
	if (section != (ConstructTpl *)0)
	  big->setNamedSection(section,i);
      }
    }
    delete vec;
  }
  if (noerrors) {
    pateq = WithBlock::collectAndPrependPattern(withstack, pateq);
    contvec = WithBlock::collectAndPrependContext(withstack, contvec);
    big->addEquation(pateq);
    big->removeTrailingSpace();
    if (contvec != (vector<ContextChange *> *)0) {
      big->addContext(*contvec);
      delete contvec;
    }
  }
  symtab.popScope();		// In all cases pop scope
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
testq %r8, %r8
je 0x3289d
movq %r8, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r8, %rdx
callq 0x31bf2
testb %al, %al
je 0x32902
movq 0x8(%r15), %rax
movq %rax, 0x60(%r14)
movq 0x18(%r15), %rdi
movq 0x20(%r15), %r12
subq %rdi, %r12
shrq $0x4, %r12
testl %r12d, %r12d
jle 0x3287f
movq %r13, 0x8(%rsp)
movq %rbp, 0x10(%rsp)
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x18(%r15), %rax
movq (%rax,%r13), %rsi
testq %rsi, %rsi
je 0x32865
movq %r14, %rdi
movl %ebp, %edx
callq 0x4ca72
incq %rbp
addq $0x10, %r13
cmpq %rbp, %r12
jne 0x3284e
movq 0x18(%r15), %rdi
movq 0x10(%rsp), %rbp
movq 0x8(%rsp), %r13
testq %rdi, %rdi
je 0x32890
movq 0x28(%r15), %rsi
subq %rdi, %rsi
callq 0xf380
movl $0x30, %esi
movq %r15, %rdi
callq 0xf380
leaq 0x2b8(%rbx), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x29f04
movq %rax, %r13
movq %r15, %rdi
movq %rbp, %rsi
callq 0x29f70
movq %rax, %r15
movq %r14, %rdi
movq %r13, %rsi
callq 0x4ca6a
movq %r14, %rdi
callq 0x4cd32
testq %r15, %r15
je 0x32924
addq $0x48, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x34d1c
movq (%r15), %rdi
testq %rdi, %rdi
je 0x328fb
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0xf380
movl $0x18, %esi
jmp 0x3291c
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x32917
movq 0x28(%r15), %rsi
subq %rdi, %rsi
callq 0xf380
movl $0x30, %esi
movq %r15, %rdi
callq 0xf380
addq $0x198, %rbx            # imm = 0x198
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x47ab4
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::buildMacro(MacroSymbol*, ConstructTpl*)
void SleighCompile::buildMacro(MacroSymbol *sym,ConstructTpl *rtl)

{
  string errstring = checkSymbols(symtab.getCurrentScope());
  if (errstring.size() != 0) {
    reportError(" in definition of macro "+sym->getName(),false);
    cerr << errstring;
    return;
  }
  if (!expandMacros(rtl,macrotable)) {
    reportError("Could not expand submacro in definition of macro "+sym->getName(),true);
    return;
  }
  PcodeCompile::propagateSize(rtl); // Propagate size information (as much as possible)
  sym->setConstruct(rtl);
  symtab.popScope();		// Pop local variables used to define macro
  macrotable.push_back(rtl);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x20(%rsp)
movq 0x1c8(%rdi), %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x2ee9c
cmpq $0x0, 0x8(%r12)
je 0x329f2
addq $0x8, %r14
leaq 0x2fe87(%rip), %rsi     # 0x62809
movq %rsp, %rdi
movq %r14, %rdx
callq 0x1170e
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2d000
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x329b5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf380
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x5a622(%rip), %rdi     # 0x8cfe8
callq 0xf420
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x329e6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf380
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x258(%rbx), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x31a42
testb %al, %al
je 0x32a40
movq %r15, %rdi
callq 0x1e500
leaq 0x198(%rbx), %rdi
movq %r15, 0x38(%r14)
callq 0x47ab4
movq 0x260(%rbx), %rsi
cmpq 0x268(%rbx), %rsi
je 0x32a8a
movq %r15, (%rsi)
addq $0x8, 0x260(%rbx)
jmp 0x329cb
addq $0x8, %r14
leaq 0x2fda5(%rip), %rsi     # 0x627f0
movq %rsp, %rdi
movq %r14, %rdx
callq 0x1170e
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2d000
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x329cb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf380
jmp 0x329cb
leaq 0x20(%rsp), %rdx
movq %r12, %rdi
callq 0x3723e
jmp 0x329cb
jmp 0x32aa0
jmp 0x32ac2
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32ac5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf380
jmp 0x32ac5
jmp 0x32ac2
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32ae0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: findSlaSpecs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static void findSlaSpecs(vector<string> &res, const string &dir, const string &suffix)

{
  FileManage::matchListDir(res, suffix, true, dir, false);
  
  vector<string> dirs;
  FileManage::directoryList(dirs, dir);
  vector<string>::const_iterator iter;
  for(iter = dirs.begin();iter!=dirs.end();++iter) {
    const string &nextdir( *iter );
    findSlaSpecs(res, nextdir,suffix);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rsi
movl $0x1, %edx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x14502
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r15, %rsi
xorl %edx, %edx
callq 0x14782
movq (%rsp), %r15
cmpq 0x8(%rsp), %r15
je 0x33d03
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x33ca4
addq $0x20, %r15
jmp 0x33ce8
movq %rsp, %rdi
callq 0x138c4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x33d17
movq %rax, %rbx
movq %rsp, %rdi
callq 0x138c4
movq %rbx, %rdi
callq 0xf730
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: initCompiler(SleighCompile&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&, bool, bool, bool, bool, bool, bool)
static void initCompiler(SleighCompile &compiler, map<string,string> &defines, bool enableUnnecessaryPcodeWarning,
			 bool disableLenientConflict, bool enableAllCollisionWarning,
			 bool enableAllNopWarning,bool enableDeadTempWarning,bool enforceLocalKeyWord)

{
  map<string,string>::iterator iter = defines.begin();
  for (iter = defines.begin(); iter != defines.end(); iter++) {
    compiler.setPreprocValue((*iter).first, (*iter).second);
  }
  if (enableUnnecessaryPcodeWarning)
    compiler.setUnnecessaryPcodeWarning(true);
  if (disableLenientConflict)
    compiler.setLenientConflict(false);
  if (enableAllCollisionWarning)
    compiler.setLocalCollisionWarning( true );
  if (enableAllNopWarning)
    compiler.setAllNopWarning( true );
  if (enableDeadTempWarning)
    compiler.setDeadTempWarning(true);
  if (enforceLocalKeyWord)
    compiler.setEnforceLocalKeyWord(true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movq 0x18(%rsi), %rbp
addq $0x8, %r13
cmpq %r13, %rbp
je 0x33d8e
leaq 0x210(%rbx), %r14
leaq 0x20(%rbp), %rsi
leaq 0x40(%rbp), %r15
movq %r14, %rdi
callq 0x342c8
movq %rax, %rdi
movq %r15, %rsi
callq 0xf1f0
movq %rbp, %rdi
callq 0xf270
movq %rax, %rbp
cmpq %r13, %rax
jne 0x33d63
testb %r12b, %r12b
je 0x33d9a
movb $0x1, 0x334(%rbx)
cmpb $0x0, 0xc(%rsp)
je 0x33da8
movb $0x0, 0x336(%rbx)
cmpb $0x0, 0x10(%rsp)
je 0x33db6
movb $0x1, 0x337(%rbx)
movb 0x50(%rsp), %al
cmpb $0x0, 0x14(%rsp)
je 0x33dc8
movb $0x1, 0x338(%rbx)
movb 0x58(%rsp), %cl
testb %al, %al
je 0x33dd7
movb $0x1, 0x335(%rbx)
testb %cl, %cl
je 0x33de2
movb $0x1, 0x204(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/base.cpp
// Function: (anonymous namespace)::update_screen_size(int)
void update_screen_size(const int sig)
{
	signal(SIGWINCH, SIG_IGN);
	endwin();
	refresh();
	signal(SIGWINCH, update_screen_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %esi
movl $0x1c, %edi
callq 0x4450
callq 0x46a0
callq 0x40b0
leaq -0x24(%rip), %rsi       # 0x67b8
movl $0x1c, %edi
popq %rbp
jmp 0x4450
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::deinit_ncurses()
void Base::deinit_ncurses()
{
	int i;
	if(colmode == CM_FULL)
	{
		// restore original colours: (this gives a nice shutdown "animation", too)
		for(i = 0; i < MAX_PREDEF_COLOUR-BASE_COLOURS; ++i)
			init_color(i+BASE_COLOURS, term_colours[3*i], term_colours[3*i+1],
				term_colours[3*i+2]);
		delete[] term_colours;
	}
	for(i = 0; i < MAX_WIN; ++i)
		delwin(windows[i]);
	echo();
	endwin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x11167(%rip)     # 0x1795c
jne 0x6843
movl $0x4, %r14d
movw $0x10, %bx
movq 0x11158(%rip), %rax     # 0x17960
movswl -0x4(%rax,%r14), %esi
movswl -0x2(%rax,%r14), %edx
movswl (%rax,%r14), %ecx
movswl %bx, %ebx
movl %ebx, %edi
callq 0x4570
addq $0x6, %r14
incl %ebx
cmpq $0x184, %r14            # imm = 0x184
jne 0x6801
movq 0x11127(%rip), %rdi     # 0x17960
testq %rdi, %rdi
je 0x6843
callq 0x44c0
xorl %ebx, %ebx
leaq 0x11124(%rip), %r14     # 0x17970
movq (%rbx,%r14), %rdi
callq 0x43c0
addq $0x8, %rbx
cmpq $0x20, %rbx
jne 0x684c
callq 0x43f0
popq %rbx
popq %r14
popq %rbp
jmp 0x46a0
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::print_str(char const*, unsigned char, char, char, e_Win, bool)
void Base::print_str(const char *cs, const unsigned char cpair, const char x,
	const char y, const e_Win targetwin, const bool cteol)
{
	wmove(windows[targetwin], y, x);
	change_colour(windows[targetwin], cpair);
	waddstr(windows[targetwin], cs);
	if(cteol)
		wclrtoeol(windows[targetwin]);
	wrefresh(windows[targetwin]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %esi, %r14d
movq %rdi, %r15
movl %r8d, %r12d
leaq 0x110e2(%rip), %r13     # 0x17970
movq (%r13,%r12,8), %rdi
movl %ecx, %esi
callq 0x4230
movq (%r13,%r12,8), %rdi
movl %r14d, %esi
callq 0x68ee
movq (%r13,%r12,8), %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4680
testl %ebx, %ebx
je 0x68c7
movq (%r13,%r12,8), %rdi
callq 0x4500
movq (%r13,%r12,8), %rdi
callq 0x4420
movzbl 0x110b8(%rip), %edi     # 0x17990
xorl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x697f
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/base.cpp
// Function: (anonymous namespace)::change_colour(_win_st*, unsigned char)
void change_colour(WINDOW* const w, unsigned char cpair)
{
	if(colmode != CM_FEW)
	{
		if(cpair >= 8 && cpair <= 15) // make second 8 base colours "light"
			wattrset(w, A_BOLD|COLOR_PAIR(cpair));
		else
			wattrset(w, COLOR_PAIR(cpair));
	}
	else
	{
		// Reduce the colours to the base 16:
		if(cpair >= BASE_COLOURS)
		{
			if(cpair < C_BG_HEAL)
				cpair = col_remap[cpair - BASE_COLOURS]; // (and goto set_colour)
			else // background is not black
			{
				// check the cases that require light foreground:
				if(cpair == C_BROWN_ON_TRAP || cpair == C_YELLOW_ON_TRAP
					|| cpair == C_GREEN_ON_POIS || cpair == C_RED_ON_HIT
					|| cpair == C_BLUE_ON_HEAL)
					wattrset(w, (A_BOLD
						| (COLOR_PAIR(cpair - C_BG_HEAL + BASE_COLOURS))));
				else
					wattrset(w, COLOR_PAIR(cpair - C_BG_HEAL + BASE_COLOURS));
				return;
			}
		}
		// set_colour:
		if(cpair >= BASE_COLOURS/2)
			wattrset(w, (A_BOLD | (COLOR_PAIR(cpair))));
		else
			wattrset(w, COLOR_PAIR(cpair));
	} // only few colours
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, 0x11063(%rip)     # 0x1795c
jne 0x6919
cmpb $0x10, %sil
jb 0x692f
cmpb $0x42, %sil
ja 0x6942
addl $-0x10, %esi
leaq 0x99cf(%rip), %rax      # 0x102e0
movb (%rsi,%rax), %cl
movzbl %cl, %esi
jmp 0x6931
movl %esi, %ecx
andb $-0x8, %cl
shll $0x8, %esi
leal 0x200000(%rsi), %eax
cmpb $0x8, %cl
cmovnel %esi, %eax
jmp 0x6969
movl %esi, %ecx
shll $0x8, %esi
leal 0x200000(%rsi), %eax
cmpb $0x8, %cl
cmovbl %esi, %eax
jmp 0x6969
movzbl %sil, %eax
addl $-0x47, %eax
cmpl $0x1d, %eax
ja 0x6971
movl $0x20000621, %ecx       # imm = 0x20000621
btl %eax, %ecx
jae 0x6971
shll $0x8, %esi
addl $0xcd00, %esi           # imm = 0xCD00
movzwl %si, %eax
orl $0x200000, %eax         # imm = 0x200000
movl %eax, %esi
popq %rbp
jmp 0x41c0
shll $0x8, %esi
addl $0xcd00, %esi           # imm = 0xCD00
movzwl %si, %eax
jmp 0x6969
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::incr_print_end(e_Win, bool)
void Base::incr_print_end(const e_Win targetwin, const bool cteol)
{
	if(cteol)
		wclrtoeol(windows[targetwin]);
	wrefresh(windows[targetwin]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x10f3a(%rip), %r14     # 0x17970
testl %esi, %esi
je 0x6a43
movq (%r14,%rbx,8), %rdi
callq 0x4500
movq (%r14,%rbx,8), %rdi
callq 0x4420
movzbl 0x10f3d(%rip), %edi     # 0x17990
xorl $0x1, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x697f