LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x47ea4
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x480e4
testq %rax, %rax
je 0x3114b
leaq 0x5b09b(%rip), %rsi     # 0x8c1d0
leaq 0x59a14(%rip), %rdx     # 0x8ab50
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xf410
movq %rax, %r15
jmp 0x3114e
xorl %r15d, %r15d
testq %r15, %r15
je 0x3117c
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
cmpl $0xf, %eax
je 0x31166
cmpl $0x3, %eax
jne 0x311d7
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x4b758
jmp 0x311e2
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 0x154be
leaq 0x31462(%rip), %rsi     # 0x62606
movq %r14, %rdi
callq 0xf780
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2d276
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x311e2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf380
jmp 0x311e2
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b80c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x311f0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3120a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf380
movq %r14, %rdi
callq 0xf730
movq %rax, %r14
cmpl $0x1, %edx
jne 0x3120a
movq %r14, %rdi
callq 0xf180
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x2d276
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf680
movq %rax, %r14
callq 0xf680
jmp 0x3120a
movq %rax, %rdi
callq 0x13ad1
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24754
testq %r15, %r15
je 0x31289
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2346c
movq 0xc8(%r13), %r8
movl 0x124(%r13), %r9d
movl %r9d, %eax
shrl $0x4, %eax
cmpl $0xffffffe, %eax        # imm = 0xFFFFFFE
ja 0x31309
leal 0x10(%r9), %eax
movl %eax, 0x124(%r13)
movq %rsp, %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x247d4
movl $0x28, %esi
movq %r12, %rdi
callq 0xf380
testq %r15, %r15
je 0x31339
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
// File: /workspace/github_cpp_makefile_star2_O1/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 %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq (%rcx), %rax
movq %rcx, %rdi
callq *0x20(%rax)
movq %r15, 0x28(%rsp)
movq %r14, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
movq (%rsp), %r14
movq 0x8(%rsp), %r12
subq %r14, %r12
sete %bl
je 0x313fa
sarq $0x3, %r12
movl $0x1, %r15d
xorl %eax, %eax
leaq 0x59846(%rip), %r13     # 0x8ac10
leaq 0x59857(%rip), %rbp     # 0x8ac28
movq (%r14,%rax,8), %rdi
testq %rdi, %rdi
je 0x313ec
movq %r13, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0xf410
testq %rax, %rax
jne 0x3143c
movl %r15d, %eax
incl %r15d
cmpq %rax, %r12
setbe %bl
ja 0x313d1
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq %rax, %r13
movl $0x20, %edi
callq 0xf370
movq %rax, %r12
movl 0xc(%r13), %esi
movl 0x10(%r13), %edx
movq %rax, %rdi
movq 0x20(%rsp), %rcx
callq 0x507c2
leaq 0x30(%rsp), %rsi
movq %r12, (%rsi)
movq 0x18(%rsp), %rdi
callq 0x35444
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x31452
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xf380
andb $0x1, %bl
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3147e
movq %rax, %rbx
movl $0x20, %esi
movq %r12, %rdi
callq 0xf380
jmp 0x31481
jmp 0x3147e
jmp 0x3147e
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x31497
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x50de6
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x35444
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_O1/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 0x202ec
subq %rbp, %r13
shrq $0x3, %r13
leaq 0x598f7(%rip), %rax     # 0x8ae68
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 0x315ad
movq (%rax), %rsi
incq %rsi
callq 0xf380
movl $0x20, %esi
movq %r15, %rdi
callq 0xf380
movq 0x2d8(%rbx), %rsi
movq %rbx, %rdi
callq 0x2da5a
leaq 0x198(%rbx), %rdi
callq 0x47e28
movl $0x0, 0x200(%rbx)
movq (%r14), %r12
cmpq %r12, 0x8(%r14)
je 0x31641
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 0x4b6c8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2da5a
movq 0x2d8(%rbx), %rdi
movq %r13, %rsi
callq 0x34800
incq %r15
movq (%r14), %r12
movq 0x8(%r14), %rax
subq %r12, %rax
sarq $0x5, %rax
addq $0x20, %rbp
cmpq %r15, %rax
ja 0x315ed
movq %r14, %rdi
callq 0x13962
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 0x31684
movq %rax, %rbx
movl $0x60, %esi
movq %r13, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31702
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 0x316f7
cmpl $0x1, 0x20(%r8)
jne 0x316f7
movslq %edi, %r9
movq 0x40(%rsi), %r10
movq (%r10,%r9,8), %r9
testb $0x1, 0x58(%r9)
je 0x316f7
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 0x316c1
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x317e1
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x31692
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 0x2349c
movslq 0x30(%r12), %rdx
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x2346c
leaq 0x20(%rsp), %rdi
movl $0x4, %edx
xorl %esi, %esi
callq 0x2346c
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
callq 0x2444e
movq %r13, %rdi
movq %r14, %rsi
callq 0x200b0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1dbdc
movq %rax, %rbx
jmp 0x31877
leaq 0x8(%r12), %rdx
leaq 0x30e35(%rip), %rsi     # 0x62622
movq %rsp, %r14
movq %r14, %rdi
callq 0x11754
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 0x30e1a(%rip), %rax     # 0x62638
leaq 0x30e30(%rip), %rsi     # 0x62655
cmovaq %rax, %rsi
movq %r14, %rdi
callq 0xf780
movq %rsp, %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x2d276
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 0x31877
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 0x3188c
jmp 0x3188c
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
jmp 0x318b2
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x318b7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x47e92
movq 0x1b0(%r13), %rax
movq 0x1c8(%r13), %r13
movq (%r13), %rcx
cmpq (%rax), %rcx
jne 0x31a73
movq %r12, %rdi
callq 0x47e28
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x29dae
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 0x30c18(%rip), %rsi     # 0x626a8
leaq 0x30c42(%rip), %rdx     # 0x626d9
leaq 0x8(%rsp), %rdi
callq 0x1183c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x117dc
xorl %ebp, %ebp
leaq 0x56f66(%rip), %rsi     # 0x88a20
leaq -0x202a1(%rip), %rdx    # 0x11820
movq %rbx, %rdi
callq 0xf6d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x31aeb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf380
jmp 0x31aeb
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x31af8
movq %rbx, %rdi
callq 0xf290
movq %r14, %rdi
callq 0xf730
// File: /workspace/github_cpp_makefile_star2_O1/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 0x29dae
movq %r14, %rdi
callq 0x47e92
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movl $0x1, 0x1d4(%rdi)
movl $0x18, %edi
callq 0xf370
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl $0x68, %edi
callq 0xf370
movq %rax, %r15
movq 0x98(%r13), %rsi
movq %rsp, %rdi
callq 0x2349c
movslq 0x30(%rbx), %rdx
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x2346c
leaq 0x20(%rsp), %rdi
movl $0x4, %edx
xorl %esi, %esi
callq 0x2346c
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r15, %rdi
callq 0x2444e
movl $0x28, %edi
callq 0xf370
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movl $0x42, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, (%rsp)
movq %rax, %rdi
movq %r12, %rsi
callq 0x200b0
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x200b0
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x31c1b
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x31c26
movq %rsp, %rdx
movq %r14, %rdi
callq 0x203d6
incl 0x38(%rbx)
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x31c3e
jmp 0x31c3e
movq %rax, %rbx
movl $0x68, %esi
movq %r15, %rdi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31c86
leaq 0x2b8(%rbx), %rax
movq %rax, %rcx
movq (%rcx), %rcx
cmpq %rax, %rcx
je 0x31c83
movq 0x10(%rcx), %r14
testq %r14, %r14
je 0x31c70
jmp 0x31c86
xorl %r14d, %r14d
testq %r14, %r14
jne 0x31c92
movq 0x190(%rbx), %r14
movq $0x0, 0x2d8(%rbx)
movl $0x98, %edi
callq 0xf370
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4cb0c
movq %r15, 0x2d0(%rbx)
movq 0x320(%rbx), %rax
movl -0x4(%rax), %eax
movl %eax, 0x90(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3482a
leaq 0x198(%rbx), %rdi
callq 0x47e28
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_O1/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 $0x78, %rsp
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsi), %r12
cmpq 0x10(%rsi), %r12
sete %bl
je 0x31e6b
movq %rdx, %r15
leaq 0x30(%rsp), %rbp
movq (%r12), %rsi
movq %rsi, 0x20(%rsp)
cmpl $0x40, 0x8(%rsi)
jne 0x31e33
movl 0x4(%r14), %eax
movl %eax, 0x3c(%rsp)
movl %eax, 0x38(%rsp)
leaq 0x58ec5(%rip), %rax     # 0x8ac50
movq %rax, 0x30(%rsp)
movq %rsp, %rax
movq %rax, 0x58(%rsp)
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rax
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x48(%rsp)
movb $0x0, 0x50(%rsp)
movq 0x10(%rsi), %rax
movq (%rax), %rax
movslq 0x30(%rax), %r13
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x3, %rax
cmpq %rax, %r13
jae 0x31ea4
movq %rbp, %rdi
callq 0x2d3a2
movq (%r15), %rax
movq (%rax,%r13,8), %r13
movq %rbp, %rdi
movq %r13, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x257b8
movl 0x4(%r13), %eax
addl %eax, 0x4(%r14)
movq 0x20(%rsp), %r13
testq %r13, %r13
je 0x31e1f
movq %r13, %rdi
callq 0x24b74
movl $0x28, %esi
movq %r13, %rdi
callq 0xf380
movb 0x50(%rsp), %r13b
movq %rbp, %rdi
callq 0x34866
testb %r13b, %r13b
je 0x31e5a
jmp 0x31e7a
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x31e4a
movq %rsi, (%rax)
addq $0x8, 0x8(%rsp)
jmp 0x31e5a
movq %rsp, %rdi
movq %rax, %rsi
leaq 0x20(%rsp), %rdx
callq 0x203d6
addq $0x8, %r12
cmpq 0x10(%r14), %r12
sete %bl
jne 0x31d65
addq $0x8, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x200da
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x31e90
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xf380
andb $0x1, %bl
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30(%rsp), %rdi
callq 0x34866
jmp 0x31e7a
jmp 0x31eb2
movq %rax, %rbx
jmp 0x31ec6
jmp 0x31eb9
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x34866
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x31edc
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
// File: /workspace/github_cpp_makefile_star2_O1/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 0x234bc
testb %al, %al
je 0x328d0
cmpl $0x0, 0x20(%rbx)
jne 0x328d0
movq 0x30(%rbx), %rdx
addq $0x20, %rbx
movl %ebp, %ecx
shlq %cl, %rdx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2346c
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_O1/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 0x328f3
movl %ebx, %esi
callq 0x3288a
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x3292e
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x3288a
incq %r15
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jl 0x32909
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x234bc
testb %al, %al
je 0x32958
cmpl $0x0, 0x40(%rbx)
jne 0x32958
cmpl $0x0, 0x60(%rbx)
je 0x3296b
leaq 0x40(%rbx), %rdi
callq 0x234bc
testb %al, %al
je 0x32999
cmpl $0x0, 0x60(%rbx)
jne 0x32999
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 0x2346c
movups (%r14), %xmm0
movups 0xc(%r14), %xmm1
movups %xmm1, 0xc(%r15)
movups %xmm0, (%r15)
leaq 0xa0(%rbx), %rdi
callq 0x234bc
testb %al, %al
je 0x329e4
cmpl $0x0, 0xc0(%rbx)
jne 0x329e4
movq 0xd0(%rbx), %rdx
addq $0xc0, %rbx
movl %ebp, %ecx
shlq %cl, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2346c
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_O1/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 0x32a0a
movl %ebx, %esi
callq 0x32934
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x32a39
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x328da
incq %r15
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x32a17
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
testq %r8, %r8
je 0x32bb0
movq %r8, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r8, %rdx
callq 0x31ee4
testb %al, %al
je 0x32c15
movb %al, 0x7(%rsp)
movq %r12, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x60(%r14)
movq 0x20(%r15), %r13
subq 0x18(%r15), %r13
shrq $0x4, %r13
testl %r13d, %r13d
jle 0x32b79
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x18(%r15), %rax
movq (%rax,%rbp), %rsi
testq %rsi, %rsi
je 0x32b6d
movq %r14, %rdi
movl %r12d, %edx
callq 0x4ceb4
incq %r12
addq $0x10, %rbp
cmpq %r12, %r13
jne 0x32b55
movq 0x18(%r15), %rdi
testq %rdi, %rdi
movq 0x10(%rsp), %r13
je 0x32b93
movq 0x28(%r15), %rsi
subq %rdi, %rsi
callq 0xf380
movl $0x30, %esi
movq %r15, %rdi
callq 0xf380
cmpb $0x0, 0x7(%rsp)
movq 0x8(%rsp), %r12
je 0x32c37
leaq 0x2b8(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a060
movq %rax, %r12
movq %r15, %rdi
movq %r13, %rsi
callq 0x2a0cc
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x4ceac
movq %r14, %rdi
callq 0x4d19a
testq %r15, %r15
je 0x32c37
addq $0x48, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x350f2
movq (%r15), %rdi
testq %rdi, %rdi
je 0x32c0e
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0xf380
movl $0x18, %esi
jmp 0x32c2f
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x32c2a
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 0x47e92
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
movq 0x1c8(%rdi), %rdx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x2f144
cmpq $0x0, 0x8(%r15)
je 0x32d00
addq $0x8, %r14
leaq 0x2fb2b(%rip), %rsi     # 0x627b9
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0x11754
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2d276
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32cc5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xf380
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x5a312(%rip), %rdi     # 0x8cfe8
callq 0xf420
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32cf6
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xf380
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rsi
leaq 0x258(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x31d26
testb %al, %al
je 0x32d5f
movq 0x8(%rsp), %rdi
callq 0x1e430
leaq 0x198(%rbx), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x38(%r14)
callq 0x47e92
movq 0x260(%rbx), %rsi
cmpq 0x268(%rbx), %rsi
je 0x32dad
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x260(%rbx)
jmp 0x32cdb
addq $0x8, %r14
leaq 0x2fa36(%rip), %rsi     # 0x627a0
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0x11754
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2d276
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32cdb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xf380
jmp 0x32cdb
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x375f6
jmp 0x32cdb
jmp 0x32dc3
jmp 0x32de5
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32de8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xf380
jmp 0x32de8
jmp 0x32de5
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32e03
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xf380
movq %rbx, %rdi
callq 0xf730
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1459a
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r15, %rsi
xorl %edx, %edx
callq 0x1481a
movq (%rsp), %r15
cmpq 0x8(%rsp), %r15
je 0x340b8
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x34059
addq $0x20, %r15
jmp 0x3409d
movq %rsp, %rdi
callq 0x13962
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x340cc
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13962
movq %rbx, %rdi
callq 0xf730
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34143
leaq 0x210(%rbx), %r14
leaq 0x20(%rbp), %rsi
leaq 0x40(%rbp), %r15
movq %r14, %rdi
callq 0x346ac
movq %rax, %rdi
movq %r15, %rsi
callq 0xf1f0
movq %rbp, %rdi
callq 0xf270
movq %rax, %rbp
cmpq %r13, %rax
jne 0x34118
testb %r12b, %r12b
je 0x3414f
movb $0x1, 0x334(%rbx)
cmpb $0x0, 0xc(%rsp)
je 0x3415d
movb $0x0, 0x336(%rbx)
cmpb $0x0, 0x10(%rsp)
je 0x3416b
movb $0x1, 0x337(%rbx)
movb 0x50(%rsp), %al
cmpb $0x0, 0x14(%rsp)
je 0x3417d
movb $0x1, 0x338(%rbx)
movb 0x58(%rsp), %cl
testb %al, %al
je 0x3418c
movb $0x1, 0x335(%rbx)
testb %cl, %cl
je 0x34197
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_O1/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 0x4460
callq 0x46b0
callq 0x40b0
leaq -0x24(%rip), %rsi       # 0x67fa
movl $0x1c, %edi
popq %rbp
jmp 0x4460
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x11125(%rip)     # 0x1795c
jne 0x6885
movl $0x4, %r14d
movw $0x10, %bx
movq 0x11116(%rip), %rax     # 0x17960
movswl -0x4(%rax,%r14), %esi
movswl -0x2(%rax,%r14), %edx
movswl (%rax,%r14), %ecx
movswl %bx, %ebx
movl %ebx, %edi
callq 0x4580
addq $0x6, %r14
incl %ebx
cmpq $0x184, %r14            # imm = 0x184
jne 0x6843
movq 0x110e5(%rip), %rdi     # 0x17960
testq %rdi, %rdi
je 0x6885
callq 0x44d0
xorl %ebx, %ebx
leaq 0x110e2(%rip), %r14     # 0x17970
movq (%rbx,%r14), %rdi
callq 0x43d0
addq $0x8, %rbx
cmpq $0x20, %rbx
jne 0x688e
callq 0x4400
popq %rbx
popq %r14
popq %rbp
jmp 0x46b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x110a0(%rip), %r13     # 0x17970
movq (%r13,%r12,8), %rdi
movl %ecx, %esi
callq 0x4230
movq (%r13,%r12,8), %rdi
movl %r14d, %esi
callq 0x6930
movq (%r13,%r12,8), %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4690
testl %ebx, %ebx
je 0x6909
movq (%r13,%r12,8), %rdi
callq 0x4510
movq (%r13,%r12,8), %rdi
callq 0x4430
movzbl 0x11076(%rip), %edi     # 0x17990
xorl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x69c1
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x11021(%rip)     # 0x1795c
jne 0x696e
cmpb $0x10, %sil
jb 0x6957
cmpb $0x42, %sil
ja 0x698a
addl $-0x10, %esi
leaq 0x998d(%rip), %rax      # 0x102e0
movb (%rsi,%rax), %sil
movzbl %sil, %ecx
movl %ecx, %edx
shll $0x8, %edx
leal 0x200000(%rdx), %eax
cmpb $0x8, %cl
cmovbl %edx, %eax
jmp 0x6982
movl %esi, %ecx
andb $-0x8, %cl
shll $0x8, %esi
leal 0x200000(%rsi), %eax
cmpb $0x8, %cl
cmovnel %esi, %eax
movl %eax, %esi
popq %rbp
jmp 0x41c0
movzbl %sil, %eax
addl $-0x47, %eax
cmpl $0x1d, %eax
ja 0x69b3
movl $0x20000621, %ecx       # imm = 0x20000621
btl %eax, %ecx
jae 0x69b3
shll $0x8, %esi
addl $0xcd00, %esi           # imm = 0xCD00
movzwl %si, %eax
orl $0x200000, %eax         # imm = 0x200000
jmp 0x6982
shll $0x8, %esi
addl $0xcd00, %esi           # imm = 0xCD00
movzwl %si, %eax
jmp 0x6982
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10ef8(%rip), %r14     # 0x17970
testl %esi, %esi
je 0x6a85
movq (%r14,%rbx,8), %rdi
callq 0x4510
movq (%r14,%rbx,8), %rdi
callq 0x4430
movzbl 0x10efb(%rip), %edi     # 0x17990
xorl $0x1, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x69c1
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::more_chat_ind()
void Base::more_chat_ind()
{
	wmove(windows[CHAT_WIN], scr_y - VIEWSIZE - 1, scr_x - 4);
	change_colour(windows[CHAT_WIN], BASE_BLUE);
	waddstr(windows[CHAT_WIN], "[+]");
	wrefresh(windows[CHAT_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10ecc(%rip), %rdi     # 0x17978
movzwl 0x10ea5(%rip), %esi     # 0x17958
addl $-0x18, %esi
movzwl 0x10e9d(%rip), %edx     # 0x1795a
addl $-0x4, %edx
callq 0x4230
movq 0x10eac(%rip), %rdi     # 0x17978
movl $0x4, %esi
callq 0x6930
movq 0x10e9b(%rip), %rdi     # 0x17978
leaq 0x9572(%rip), %rsi      # 0x10056
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4690
movq 0x10e83(%rip), %rdi     # 0x17978
callq 0x4430
movzbl 0x10e8f(%rip), %edi     # 0x17990
xorl $0x1, %edi
popq %rbp
jmp 0x69c1
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::less_chat_ind()
void Base::less_chat_ind()
{
	wmove(windows[CHAT_WIN], 0, scr_x - 4);
	change_colour(windows[CHAT_WIN], BASE_BLUE);
	waddstr(windows[CHAT_WIN], "[-]");
	wrefresh(windows[CHAT_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10e63(%rip), %rdi     # 0x17978
movzwl 0x10e3e(%rip), %edx     # 0x1795a
addl $-0x4, %edx
xorl %esi, %esi
callq 0x4230
movq 0x10e4b(%rip), %rdi     # 0x17978
movl $0x4, %esi
callq 0x6930
movq 0x10e3a(%rip), %rdi     # 0x17978
leaq 0x9515(%rip), %rsi      # 0x1005a
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4690
movq 0x10e22(%rip), %rdi     # 0x17978
callq 0x4430
movzbl 0x10e2e(%rip), %edi     # 0x17990
xorl $0x1, %edi
popq %rbp
jmp 0x69c1
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::print_view(char const*)
void Base::print_view(const char *source)
{
	// The view has a sequence of pairs (colour, symbol):
	char x, y;
	for(y = 0; y < VIEWSIZE; ++y)
	{
		wmove(windows[VIEW_WIN], y, 0);
		for(x = 0; x < VIEWSIZE; ++x)
		{
			change_colour(windows[VIEW_WIN], *source);
			waddch(windows[VIEW_WIN], *(++source));
			++source;
		}
	}
	wrefresh(windows[VIEW_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x10deb(%rip), %rdi     # 0x17988
movl %r14d, %esi
xorl %edx, %edx
callq 0x4230
xorl %r15d, %r15d
movq 0x10dd7(%rip), %rdi     # 0x17988
movzbl (%rbx,%r15), %esi
callq 0x6930
movq 0x10dc6(%rip), %rdi     # 0x17988
movsbl 0x1(%rbx,%r15), %esi
callq 0x45c0
addq $0x2, %r15
cmpb $0x2e, %r15b
jne 0x6baa
incl %r14d
addq %r15, %rbx
cmpl $0x17, %r14d
jne 0x6b96
movq 0x10d9e(%rip), %rdi     # 0x17988
callq 0x4430
movzbl 0x10d9a(%rip), %edi     # 0x17990
xorl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x69c1