LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::readWriteInterference(VarnodeTpl const*, OpTpl const*, bool) const
bool ConsistencyChecker::readWriteInterference(const VarnodeTpl *vn,const OpTpl *op,bool checkread) const

{ // Does op potentially read vn
  // This is extremely conservative.  Basically any op where
  // we can't see exactly what might be written is considered
  // interference
  switch(op->getOpcode()) {
  case BUILD:
  case CROSSBUILD:
  case DELAY_SLOT:
  case MACROBUILD:
  case CPUI_LOAD:
  case CPUI_STORE:
  case CPUI_BRANCH:
  case CPUI_CBRANCH:
  case CPUI_BRANCHIND:
  case CPUI_CALL:
  case CPUI_CALLIND:
  case CPUI_CALLOTHER:
  case CPUI_RETURN:
  case LABELBUILD:		// Another value might jump in here
    return true;
  default:
    break;
  }

  if (checkread) {
    int4 numinputs = op->numInput();
    for(int4 i=0;i<numinputs;++i)
      if (possibleIntersection(vn,op->getIn(i)))
	return true;
  }

  // We always check for writes to -vn-
  const VarnodeTpl *vn2 = op->getOut();
  if (vn2 != (const VarnodeTpl *)0) {
	if (possibleIntersection(vn,vn2))
      return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3fd40
movl %eax, %ecx
movl %ecx, %eax
addl $-0x2, %eax
movl %ecx, -0x3c(%rbp)
subl $0x9, %eax
jb 0x5f0af
jmp 0x5f095
movl -0x3c(%rbp), %eax
addl $-0x3c, %eax
subl $0x2, %eax
jb 0x5f0af
jmp 0x5f0a2
movl -0x3c(%rbp), %eax
addl $-0x40, %eax
subl $0x2, %eax
ja 0x5f0b8
jmp 0x5f0af
movb $0x1, -0x1(%rbp)
jmp 0x5f149
jmp 0x5f0ba
testb $0x1, -0x21(%rbp)
je 0x5f116
movq -0x20(%rbp), %rdi
callq 0x3fcc0
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x5f114
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x3fce0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x5ee20
testb $0x1, %al
jne 0x5f101
jmp 0x5f107
movb $0x1, -0x1(%rbp)
jmp 0x5f149
jmp 0x5f109
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5f0d3
jmp 0x5f116
movq -0x20(%rbp), %rdi
callq 0x3f7a0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x5f145
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5ee20
testb $0x1, %al
jne 0x5f13d
jmp 0x5f143
movb $0x1, -0x1(%rbp)
jmp 0x5f149
jmp 0x5f145
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::examineVn(std::map<unsigned long, ConsistencyChecker::OptimizeRecord, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, ConsistencyChecker::OptimizeRecord>>>&, VarnodeTpl const*, unsigned int, int, int)
void ConsistencyChecker::examineVn(map<uintb,OptimizeRecord> &recs,
				   const VarnodeTpl *vn,uint4 i,int4 inslot,int4 secnum)
{ // If varnode is a temporary,  count whether it is read or written
  if (vn == (const VarnodeTpl *)0) return;
  if (!vn->getSpace().isUniqueSpace()) return;
  if (vn->getOffset().getType() != ConstTpl::real) return;

  map<uintb,OptimizeRecord>::iterator iter;
  iter = recs.insert( pair<uint4,OptimizeRecord>(vn->getOffset().getReal(),OptimizeRecord())).first;
  if (inslot>=0) {
    (*iter).second.readop = i;
    (*iter).second.readcount += 1;
    (*iter).second.inslot = inslot;
    (*iter).second.readsection = secnum;
  }
  else {
    (*iter).second.writeop = i;
    (*iter).second.writecount += 1;
    (*iter).second.writesection = secnum;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5f189
jmp 0x5f304
movq -0x10(%rbp), %rdi
callq 0x40220
movq %rax, %rdi
callq 0x4a000
testb $0x1, %al
jne 0x5f1a3
jmp 0x5f304
movq -0x10(%rbp), %rdi
callq 0x3fca0
movq %rax, %rdi
callq 0x3fc10
cmpl $0x0, %eax
je 0x5f1be
jmp 0x5f304
leaq -0x28(%rbp), %rdi
callq 0x6aa90
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3fca0
movq %rax, %rdi
callq 0x3fc20
movq %rax, -0x68(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x6aaf0
movq -0xb0(%rbp), %rdx
leaq -0x5c(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x6ab40
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x6aab0
movb %dl, -0x90(%rbp)
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x90(%rbp), %al
movb %al, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x5f2bc
movl -0x14(%rbp), %eax
movl %eax, -0xbc(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6ab90
movl -0xbc(%rbp), %ecx
movl %ecx, 0xc(%rax)
leaq -0x28(%rbp), %rdi
callq 0x6ab90
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0xb8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6ab90
movl -0xb8(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0xb4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6ab90
movl -0xb4(%rbp), %ecx
movl %ecx, 0x20(%rax)
jmp 0x5f304
movl -0x14(%rbp), %eax
movl %eax, -0xc4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6ab90
movl -0xc4(%rbp), %ecx
movl %ecx, 0x8(%rax)
leaq -0x28(%rbp), %rdi
callq 0x6ab90
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0xc0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6ab90
movl -0xc0(%rbp), %ecx
movl %ecx, 0x1c(%rax)
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::optimizeGather1(Constructor*, std::map<unsigned long, ConsistencyChecker::OptimizeRecord, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, ConsistencyChecker::OptimizeRecord>>>&, int) const
void ConsistencyChecker::optimizeGather1(Constructor *ct,map<uintb,OptimizeRecord> &recs,int4 secnum) const

{ // Look for reads and writes to temporaries, count how many times each temporary is read or written
  ConstructTpl *tpl;
  if (secnum < 0)
    tpl = ct->getTempl();
  else
    tpl = ct->getNamedTempl(secnum);
  if (tpl == (ConstructTpl *)0)
    return;
  const vector<OpTpl *> &ops( tpl->getOpvec() );
  for(uint4 i=0;i<ops.size();++i) {
    const OpTpl *op = ops[i];
    for(uint4 j=0;j<op->numInput();++j) {
      const VarnodeTpl *vnin = op->getIn(j);
      examineVn(recs,vnin,i,j,secnum);
    }
    const VarnodeTpl *vn = op->getOut();
    examineVn(recs,vn,i,-1,secnum);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x5f33c
movq -0x10(%rbp), %rdi
callq 0x52880
movq %rax, -0x28(%rbp)
jmp 0x5f34c
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xaa8d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5f358
jmp 0x5f426
movq -0x28(%rbp), %rdi
callq 0x3fd80
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3f7c0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x5f426
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x3fc80
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3fcc0
movl %eax, %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jae 0x5f3f2
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x3fce0
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x34(%rbp), %edx
movl -0x44(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x5f160
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5f3a8
movq -0x40(%rbp), %rdi
callq 0x3f7a0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl -0x34(%rbp), %edx
movl -0x1c(%rbp), %r8d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x5f160
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5f36c
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::checkUnusedTemps(Constructor*, std::map<unsigned long, ConsistencyChecker::OptimizeRecord, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, ConsistencyChecker::OptimizeRecord>>> const&)
void ConsistencyChecker::checkUnusedTemps(Constructor *ct,const map<uintb,OptimizeRecord> &recs)

{
  map<uintb,OptimizeRecord>::const_iterator iter;
  iter = recs.begin();
  while(iter != recs.end()) {
    const OptimizeRecord &currec( (*iter).second );
    if (currec.readcount == 0) {
      if (printdeadwarning)
	cerr << "Warning: temporary is written but not read in constructor starting at line " << dec << ct->getLineno() << endl;
      writenoread += 1;
    }
    else if (currec.writecount == 0) {
      cerr << "Error: temporary is read but not written in constructor starting at line " << dec << ct->getLineno() << endl;
      readnowrite += 1;
    }
    ++iter;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6adf0
movq -0x18(%rbp), %rdi
callq 0x6ae10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6ae70
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6ae40
testb $0x1, %al
jne 0x5fd9d
jmp 0x5fe8a
leaq -0x20(%rbp), %rdi
callq 0x6aea0
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x5fe1a
movq -0x40(%rbp), %rax
testb $0x1, 0xd(%rax)
je 0x5fe0b
movq 0xd221f(%rip), %rdi     # 0x131fe8
leaq 0x79481(%rip), %rsi     # 0xd9251
callq 0x11420
movq %rax, %rdi
leaq -0x3a76f(%rip), %rsi    # 0x25670
callq 0x11180
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a600
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x11880
movq %rax, %rdi
movq 0xd219a(%rip), %rsi     # 0x131fa0
callq 0x114a0
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x5fe7c
movq -0x38(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x5fe7a
movq 0xd21bd(%rip), %rdi     # 0x131fe8
leaq 0x7946b(%rip), %rsi     # 0xd929d
callq 0x11420
movq %rax, %rdi
leaq -0x3a7d1(%rip), %rsi    # 0x25670
callq 0x11180
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a600
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x11880
movq %rax, %rdi
movq 0xd2138(%rip), %rsi     # 0x131fa0
callq 0x114a0
movq -0x40(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x5fe7c
leaq -0x20(%rbp), %rdi
callq 0x6aec0
jmp 0x5fd7a
addq $0x50, %rsp
popq %rbp
retq
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::optimize(Constructor*)
void ConsistencyChecker::optimize(Constructor *ct)

{
  OptimizeRecord *currec;
  map<uintb,OptimizeRecord> recs;
  int4 numsections = ct->getNumSections();
  do {
    recs.clear();
    for(int4 i=-1;i<numsections;++i) {
      optimizeGather1(ct,recs,i);
      optimizeGather2(ct,recs,i);
    }
    currec = findValidRule(ct,recs);
    if (currec != (OptimizeRecord *)0)
      applyOptimization(ct,*currec);
  } while(currec != (OptimizeRecord *)0);
  checkUnusedTemps(ct,recs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6aef0
movq -0x10(%rbp), %rdi
callq 0x6a6b0
movl %eax, -0x64(%rbp)
jmp 0x5fec2
movl -0x64(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6af10
movl $0xffffffff, -0x60(%rbp) # imm = 0xFFFFFFFF
movl -0x60(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0x5ff30
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x60(%rbp), %ecx
leaq -0x48(%rbp), %rdx
callq 0x5f310
jmp 0x5fef6
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x60(%rbp), %ecx
leaq -0x48(%rbp), %rdx
callq 0x5f430
jmp 0x5ff0c
jmp 0x5ff0e
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x5fed8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6af30
jmp 0x5ff9d
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x5f740
movq %rax, -0x78(%rbp)
jmp 0x5ff47
movq -0x78(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5ff6b
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5faf0
jmp 0x5ff69
jmp 0x5ff6b
jmp 0x5ff6d
cmpq $0x0, -0x18(%rbp)
jne 0x5fec8
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x5fd40
jmp 0x5ff8b
leaq -0x48(%rbp), %rdi
callq 0x6af30
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x118b0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::test()
bool ConsistencyChecker::test(void)

{ // Main entry point for size consistency check
  setPostOrder(root_symbol);
  bool testresult = true;

  for(int4 i=0;i<postorder.size();++i) {
    SubtableSymbol *sym = postorder[i];
    if (!checkSubtable(sym))
      testresult = false;
  }
  return testresult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq 0x10(%rdi), %rsi
callq 0x5ea00
movb $0x1, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
callq 0x6af50
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x60033
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0x6af70
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x5e5d0
testb $0x1, %al
jne 0x60026
movb $0x0, -0x9(%rbp)
jmp 0x60028
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5ffd8
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::testTruncations(bool)
bool ConsistencyChecker::testTruncations(bool isbigendian)

{
  // Now that the sizemap is calculated, we can check/adjust the offset_plus templates
  bool testresult = true;
  for(int4 i=0;i<postorder.size();++i) {
    SubtableSymbol *sym = postorder[i];
    int4 numconstruct = sym->getNumConstructors();
    Constructor *ct;
    for(int4 j=0;j<numconstruct;++j) {
      ct = sym->getConstructor(j);

      int4 numsections = ct->getNumSections();
      for(int4 k=-1;k<numsections;++k) {
	ConstructTpl *tpl;
	if (k < 0)
	  tpl = ct->getTempl();
	else
	  tpl = ct->getNamedTempl(k);
	if (tpl == (ConstructTpl *)0)
	  continue;
	if (!checkSectionTruncations(ct,tpl,isbigendian))
	  testresult = false;
      }
    }
  }
  return testresult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, -0xa(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x18, %rdi
callq 0x6af50
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x6016a
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0x6af70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6a660
movl %eax, -0x1c(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6015a
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x6a680
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6a6b0
movl %eax, -0x30(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x6014a
cmpl $0x0, -0x34(%rbp)
jge 0x60103
movq -0x28(%rbp), %rdi
callq 0x52880
movq %rax, -0x40(%rbp)
jmp 0x60113
movq -0x28(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0xaa8d0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x6011c
jmp 0x6013f
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x5e460
testb $0x1, %al
jne 0x6013d
movb $0x0, -0xa(%rbp)
jmp 0x6013f
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x600e6
jmp 0x6014c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x600b7
jmp 0x6015c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x60067
movb -0xa(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: ConsistencyChecker::optimizeAll()
void ConsistencyChecker::optimizeAll(void)

{
  for(int4 i=0;i<postorder.size();++i) {
    SubtableSymbol *sym = postorder[i];
    int4 numconstruct = sym->getNumConstructors();
    Constructor *ct;
    for(int4 i=0;i<numconstruct;++i) {
      ct = sym->getConstructor(i);
      optimize(ct);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
callq 0x6af50
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x60227
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x6af70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6a660
movl %eax, -0x1c(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x60217
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x6a680
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x5fe90
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x601e7
jmp 0x60219
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6019b
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: MacroBuilder::free()
void MacroBuilder::free(void)

{
  vector<HandleTpl *>::iterator iter;

  for(iter=params.begin();iter!=params.end();++iter)
    delete *iter;

  params.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6afc0
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x6afe0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x6b050
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6b010
testb $0x1, %al
jne 0x6032a
jmp 0x6035b
leaq -0x10(%rbp), %rdi
callq 0x6b080
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x6034e
movq -0x30(%rbp), %rdi
movl $0xe0, %esi
callq 0x11450
jmp 0x60350
leaq -0x10(%rbp), %rdi
callq 0x6b0a0
jmp 0x60306
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x6b0c0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::reportError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void SleighCompile::reportError(const string &msg,bool includeline)

{
  cerr << "Error in " << filename.back() << ' ';
  if (includeline)
    cerr << "at line " << dec << lineno.back() << ": ";
  cerr << msg << endl;
  errors += 1;
  if (errors >50) {
    cerr << "Too many errors: Aborting" << endl;
    exit(2);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0xd1c12(%rip), %rdi     # 0x131fe8
leaq 0x79249(%rip), %rsi     # 0xd9626
callq 0x11420
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x300, %rdi            # imm = 0x300
callq 0x224a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x113e0
movq %rax, %rdi
movl $0x20, %esi
callq 0x11560
testb $0x1, -0x11(%rbp)
je 0x60465
movq 0xd1bcc(%rip), %rdi     # 0x131fe8
leaq 0x78d9c(%rip), %rsi     # 0xd91bf
callq 0x11420
movq %rax, %rdi
leaq -0x3adc2(%rip), %rsi    # 0x25670
callq 0x11180
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x318, %rdi            # imm = 0x318
callq 0x6a930
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x11880
movq %rax, %rdi
leaq 0x790dd(%rip), %rsi     # 0xd953d
callq 0x11420
movq -0x10(%rbp), %rsi
movq 0xd1b78(%rip), %rdi     # 0x131fe8
callq 0x113e0
movq %rax, %rdi
movq 0xd1b21(%rip), %rsi     # 0x131fa0
callq 0x114a0
movq -0x28(%rbp), %rax
movl 0x358(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x358(%rax)
cmpl $0x32, 0x358(%rax)
jle 0x604cc
movq 0xd1b41(%rip), %rdi     # 0x131fe8
leaq 0x79182(%rip), %rsi     # 0xd9630
callq 0x11420
movq %rax, %rdi
movq 0xd1ae3(%rip), %rsi     # 0x131fa0
callq 0x114a0
movl $0x2, %edi
callq 0x115b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: MacroBuilder::setMacroOp(OpTpl*)
void MacroBuilder::setMacroOp(OpTpl *macroop)

{				// Set up parameters for a particular macro invocation
  VarnodeTpl *vn;
  HandleTpl *hand;
  free();
  for(int4 i=1;i<macroop->numInput();++i) {
    vn = macroop->getIn(i);
    hand = new HandleTpl(vn);
    params.push_back(hand);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x602d0
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3fcc0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x6058b
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x3fce0
movq %rax, -0x18(%rbp)
movl $0xe0, %edi
callq 0x11440
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4c090
jmp 0x6054b
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
leaq -0x20(%rbp), %rsi
callq 0x6b0e0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x60504
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0xe0, %esi
callq 0x11450
jmp 0x60591
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x118b0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: MacroBuilder::setLabel(OpTpl*)
void MacroBuilder::setLabel(OpTpl *op)

{ // A label within a macro is local to the macro, but when
  // we expand the macro, we have to adjust the index of
  // the label, which is local to the macro, so that it fits
  // in with other labels local to the parent
  OpTpl *clone;
  VarnodeTpl *v_clone;

  clone = new OpTpl(op->getOpcode());
  v_clone = new VarnodeTpl( *op->getIn(0) ); // Clone the label index
  // Make adjustment to macro local value so that it is parent local
  uintb val = v_clone->getOffset().getReal() + getLabelBase();
  v_clone->setOffset(val);
  clone->addInput(v_clone);
  outvec.push_back(clone);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x28, %edi
callq 0x11440
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3fd40
movl %eax, -0x3c(%rbp)
jmp 0x60e24
movl -0x3c(%rbp), %esi
movq -0x48(%rbp), %rdi
callq 0x3fbb0
jmp 0x60e32
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x68, %edi
callq 0x11440
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3fce0
movq %rax, -0x58(%rbp)
jmp 0x60e59
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x4bb20
jmp 0x60e68
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3fca0
movq %rax, %rdi
callq 0x3fc20
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x52740
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4e7f0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3fa10
movq -0x50(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3f730
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0x11450
jmp 0x60f04
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x68, %esi
callq 0x11450
movq -0x28(%rbp), %rdi
callq 0x118b0
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::SleighCompile()
SleighCompile::SleighCompile(void)
  : SleighBase()
{
  pcode.setCompiler(this);
  contextlock = false;		// Context layout is not locked
  userop_count = 0;
  errors = 0;
  warnunnecessarypcode = false;
  warndeadtemps = false;
  lenientconflicterrors = true;
  warnalllocalcollisions = false;
  warnallnops = false;
  root = (SubtableSymbol *)0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x55760
movq -0x28(%rbp), %rdi
leaq 0xce7f9(%rip), %rax     # 0x12f850
movq %rax, (%rdi)
addq $0x1e0, %rdi            # imm = 0x1E0
movq %rdi, -0x20(%rbp)
callq 0x6b1d0
jmp 0x6106c
movq -0x28(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
movq %rdi, -0x80(%rbp)
callq 0x6b210
movq -0x28(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
movq %rdi, -0x78(%rbp)
callq 0x6b230
movq -0x28(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movq %rdi, -0x70(%rbp)
callq 0x6b250
movq -0x28(%rbp), %rdi
addq $0x270, %rdi            # imm = 0x270
movq %rdi, -0x68(%rbp)
callq 0x6b270
movq -0x28(%rbp), %rdi
addq $0x288, %rdi            # imm = 0x288
movq %rdi, -0x60(%rbp)
callq 0x6a4d0
movq -0x28(%rbp), %rdi
addq $0x2a0, %rdi            # imm = 0x2A0
movq %rdi, -0x58(%rbp)
callq 0x6b290
movq -0x28(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
movq %rdi, -0x50(%rbp)
callq 0x6b2b0
movq -0x28(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
movq %rdi, -0x48(%rbp)
callq 0x1ba90
movq -0x28(%rbp), %rdi
addq $0x300, %rdi            # imm = 0x300
movq %rdi, -0x40(%rbp)
callq 0x1ba90
movq -0x28(%rbp), %rdi
addq $0x318, %rdi            # imm = 0x318
movq %rdi, -0x38(%rbp)
callq 0x6a7f0
movq -0x28(%rbp), %rdi
addq $0x340, %rdi            # imm = 0x340
movq %rdi, -0x30(%rbp)
callq 0x1ba90
movq -0x28(%rbp), %rsi
movq %rsi, %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0x6b2d0
jmp 0x6115d
movq -0x28(%rbp), %rax
movb $0x0, 0x2e0(%rax)
movl $0x0, 0x330(%rax)
movl $0x0, 0x358(%rax)
movb $0x0, 0x334(%rax)
movb $0x0, 0x335(%rax)
movb $0x1, 0x336(%rax)
movb $0x0, 0x337(%rax)
movb $0x0, 0x338(%rax)
movq $0x0, 0x190(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x61239
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x1bc40
movq -0x38(%rbp), %rdi
callq 0x6a9d0
movq -0x40(%rbp), %rdi
callq 0x1bc40
movq -0x48(%rbp), %rdi
callq 0x1bc40
movq -0x50(%rbp), %rdi
callq 0x6b2f0
movq -0x58(%rbp), %rdi
callq 0x6b310
movq -0x60(%rbp), %rdi
callq 0x6aa30
movq -0x68(%rbp), %rdi
callq 0x6b370
movq -0x70(%rbp), %rdi
callq 0x6b3d0
movq -0x78(%rbp), %rdi
callq 0x6b430
movq -0x80(%rbp), %rdi
callq 0x6b490
movq -0x20(%rbp), %rdi
callq 0x6b4b0
movq -0x28(%rbp), %rdi
callq 0x52a10
movq -0x10(%rbp), %rdi
callq 0x118b0
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::buildDecisionTrees()
void SleighCompile::buildDecisionTrees(void)

{
  DecisionProperties props;
  root->buildDecisionTree(props);

  for(int4 i=0;i<tables.size();++i)
    tables[i]->buildDecisionTree(props);

  const vector<string> &ierrors( props.getIdentErrors() );
  for(int4 i=0;i<ierrors.size();++i) {
    errors += 1;
    cerr << ierrors[i];
  }

  if (!lenientconflicterrors) {
    const vector<string> &cerrors( props.getConflictErrors() );
    for(int4 i=0;i<cerrors.size();++i) {
      errors += 1;
      cerr << cerrors[i];
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x6b5b0
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rsi
movq 0x190(%rax), %rdi
callq 0xaef10
jmp 0x6208a
movl $0x0, -0x48(%rbp)
movq -0x78(%rbp), %rdi
movslq -0x48(%rbp), %rax
movq %rax, -0x80(%rbp)
addq $0x288, %rdi            # imm = 0x288
callq 0x6af50
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x620fe
movq -0x78(%rbp), %rdi
addq $0x288, %rdi            # imm = 0x288
movslq -0x48(%rbp), %rsi
callq 0x6af70
movq (%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0xaef10
jmp 0x620d7
jmp 0x620d9
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x62091
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6b610
jmp 0x6222b
leaq -0x38(%rbp), %rdi
callq 0x6b5e0
movq %rax, -0x88(%rbp)
jmp 0x62110
movq -0x88(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movslq -0x54(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x50(%rbp), %rdi
callq 0x15090
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x62182
movq -0x78(%rbp), %rax
movl 0x358(%rax), %ecx
incl %ecx
movl %ecx, 0x358(%rax)
movq -0x50(%rbp), %rdi
movslq -0x54(%rbp), %rsi
callq 0x150b0
movq %rax, %rsi
movq 0xcfe7a(%rip), %rdi     # 0x131fe8
callq 0x113e0
jmp 0x62175
jmp 0x62177
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x62122
movq -0x78(%rbp), %rax
testb $0x1, 0x336(%rax)
jne 0x62219
leaq -0x38(%rbp), %rdi
callq 0x6b5f0
movq %rax, -0x98(%rbp)
jmp 0x621a5
movq -0x98(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
movslq -0x64(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x60(%rbp), %rdi
callq 0x15090
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jae 0x62217
movq -0x78(%rbp), %rax
movl 0x358(%rax), %ecx
incl %ecx
movl %ecx, 0x358(%rax)
movq -0x60(%rbp), %rdi
movslq -0x64(%rbp), %rsi
callq 0x150b0
movq %rax, %rsi
movq 0xcfde5(%rip), %rdi     # 0x131fe8
callq 0x113e0
jmp 0x6220a
jmp 0x6220c
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x621b7
jmp 0x62219
leaq -0x38(%rbp), %rdi
callq 0x6b610
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x118b0
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::buildPatterns()
void SleighCompile::buildPatterns(void)

{
  if (root == 0) {
    reportError("No patterns to match.",false);
    return;
  }
  root->buildPattern(cerr);	// This should recursively hit everything
  if (root->isError()) errors += 1;
  for(int4 i=0;i<tables.size();++i) {
    if (tables[i]->isError())
      errors += 1;
    if (tables[i]->getPattern() == (TokenPattern *)0)
      reportWarning("Unreferenced table: "+tables[i]->getName(),false);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, 0x190(%rax)
jne 0x622dd
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x118c0
movq -0x70(%rbp), %rdx
leaq 0x771b0(%rip), %rsi     # 0xd9429
leaq -0x28(%rbp), %rdi
callq 0x14430
jmp 0x62284
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x603b0
jmp 0x62295
leaq -0x28(%rbp), %rdi
callq 0x11300
leaq -0x29(%rbp), %rdi
callq 0x114d0
jmp 0x62419
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x622cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x11300
leaq -0x29(%rbp), %rdi
callq 0x114d0
jmp 0x62422
movq -0x68(%rbp), %rax
movq 0x190(%rax), %rdi
movq 0xcfcf9(%rip), %rsi     # 0x131fe8
callq 0xad7b0
movq -0x68(%rbp), %rax
movq 0x190(%rax), %rdi
callq 0x6b640
testb $0x1, %al
jne 0x6230a
jmp 0x6231d
movq -0x68(%rbp), %rax
movl 0x358(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x358(%rax)
movl $0x0, -0x40(%rbp)
movq -0x68(%rbp), %rdi
movslq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x288, %rdi            # imm = 0x288
callq 0x6af50
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x62419
movq -0x68(%rbp), %rdi
addq $0x288, %rdi            # imm = 0x288
movslq -0x40(%rbp), %rsi
callq 0x6af70
movq (%rax), %rdi
callq 0x6b640
testb $0x1, %al
jne 0x6236e
jmp 0x62381
movq -0x68(%rbp), %rax
movl 0x358(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x358(%rax)
movq -0x68(%rbp), %rdi
addq $0x288, %rdi            # imm = 0x288
movslq -0x40(%rbp), %rsi
callq 0x6af70
movq (%rax), %rdi
callq 0x6b660
cmpq $0x0, %rax
jne 0x62409
movq -0x68(%rbp), %rdi
addq $0x288, %rdi            # imm = 0x288
movslq -0x40(%rbp), %rsi
callq 0x6af70
movq (%rax), %rdi
callq 0x401a0
movq %rax, %rdx
leaq 0x77076(%rip), %rsi     # 0xd943f
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x147f0
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
xorl %edx, %edx
callq 0x62430
jmp 0x623e7
leaq -0x60(%rbp), %rdi
callq 0x11300
jmp 0x62409
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x11300
jmp 0x62422
jmp 0x6240b
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x62324
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x118b0
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::reportWarning(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void SleighCompile::reportWarning(const string &msg,bool includeline)

{
  cerr << "Warning in " << filename.back() << ' ';
  if (includeline)
    cerr << "at line " << dec << lineno.back() << ": ";
  cerr << msg << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0xcfb92(%rip), %rdi     # 0x131fe8
leaq 0x771ed(%rip), %rsi     # 0xd964a
callq 0x11420
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x300, %rdi            # imm = 0x300
callq 0x224a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x113e0
movq %rax, %rdi
movl $0x20, %esi
callq 0x11560
testb $0x1, -0x11(%rbp)
je 0x624e5
movq 0xcfb4c(%rip), %rdi     # 0x131fe8
leaq 0x76d1c(%rip), %rsi     # 0xd91bf
callq 0x11420
movq %rax, %rdi
leaq -0x3ce42(%rip), %rsi    # 0x25670
callq 0x11180
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x318, %rdi            # imm = 0x318
callq 0x6a930
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x11880
movq %rax, %rdi
leaq 0x7705d(%rip), %rsi     # 0xd953d
callq 0x11420
movq -0x10(%rbp), %rsi
movq 0xcfaf8(%rip), %rdi     # 0x131fe8
callq 0x113e0
movq %rax, %rdi
movq 0xcfaa1(%rip), %rsi     # 0x131fa0
callq 0x114a0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::findCollision(std::map<unsigned long, int, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, int>>>&, std::vector<unsigned long, std::allocator<unsigned long>> const&, int)
int4 SleighCompile::findCollision(map<uintb,int4> &local2Operand,const vector<uintb> &locals,int operand)

{
  for(int4 i=0;i<locals.size();++i) {
    pair<map<uintb,int4>::iterator,bool> res;
    res = local2Operand.insert(pair<uintb,int4>(locals[i],operand));
    if (!res.second) {
      int4 oldIndex = (*res.first).second;
      if (oldIndex != operand)
	return oldIndex;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x320d0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x62906
leaq -0x30(%rbp), %rdi
callq 0x6b700
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x32110
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x1c(%rbp), %rdx
callq 0x6b770
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x6b730
movb %dl, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movb -0x58(%rbp), %al
movb %al, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6b7a0
testb $0x1, -0x28(%rbp)
jne 0x628f6
leaq -0x30(%rbp), %rdi
callq 0x6b7d0
movl 0x8(%rax), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x628f4
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6290d
jmp 0x628f6
jmp 0x628f8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6284d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::checkLocalCollisions()
void SleighCompile::checkLocalCollisions(void)

{
  int4 collisionCount = 0;
  SubtableSymbol *sym = root; // Start with the instruction table
  int4 i = -1;
  for(;;) {
    int4 numconst = sym->getNumConstructors();
    for(int4 j=0;j<numconst;++j) {
      if (!checkLocalExports(sym->getConstructor(j)))
	collisionCount += 1;
    }
    i+=1;
    if (i>=tables.size()) break;
    sym = tables[i];
  }
  if (collisionCount > 0) {
    cerr << "WARNING: " << dec << collisionCount << " constructors with local collisions between operands" << endl;
    if (!warnalllocalcollisions)
      cerr << "Use -c switch to list each individually" << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0xc(%rbp)
movq 0x190(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rdi
callq 0x6a660
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x62cda
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x6a680
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x62920
testb $0x1, %al
jne 0x62ccd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x62ccf
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x62ca0
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x288, %rdi            # imm = 0x288
callq 0x6af50
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jb 0x62d09
jmp 0x62d29
movq -0x30(%rbp), %rdi
addq $0x288, %rdi            # imm = 0x288
movslq -0x1c(%rbp), %rsi
callq 0x6af70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x62c8d
cmpl $0x0, -0xc(%rbp)
jle 0x62dab
movq 0xcf2b2(%rip), %rdi     # 0x131fe8
leaq 0x767f9(%rip), %rsi     # 0xd9536
callq 0x11420
movq %rax, %rdi
leaq -0x3d6dc(%rip), %rsi    # 0x25670
callq 0x11180
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x11880
movq %rax, %rdi
leaq 0x767da(%rip), %rsi     # 0xd9540
callq 0x11420
movq %rax, %rdi
movq 0xcf22b(%rip), %rsi     # 0x131fa0
callq 0x114a0
movq -0x30(%rbp), %rax
testb $0x1, 0x337(%rax)
jne 0x62da9
movq 0xcf25a(%rip), %rdi     # 0x131fe8
leaq 0x767e0(%rip), %rsi     # 0xd9575
callq 0x11420
movq %rax, %rdi
movq 0xcf1fc(%rip), %rsi     # 0x131fa0
callq 0x114a0
jmp 0x62dab
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::checkNops()
void SleighCompile::checkNops(void)

{
  if (noplist.size() > 0) {
    if (warnallnops) {
      for(int4 i=0;i<noplist.size();++i)
	cerr << noplist[i] << endl;
    }
    cerr << dec << (int4)noplist.size() << " NOP constructors found" << endl;
    if (!warnallnops)
      cerr << "Use -n switch to list each individually" << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x340, %rdi            # imm = 0x340
callq 0x15090
cmpq $0x0, %rax
jbe 0x62ee2
movq -0x18(%rbp), %rax
testb $0x1, 0x338(%rax)
je 0x62e61
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x340, %rdi            # imm = 0x340
callq 0x15090
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x62e5f
movq -0x18(%rbp), %rdi
addq $0x340, %rdi            # imm = 0x340
movslq -0xc(%rbp), %rsi
callq 0x1bb40
movq %rax, %rsi
movq 0xcf1a8(%rip), %rdi     # 0x131fe8
callq 0x113e0
movq %rax, %rdi
movq 0xcf151(%rip), %rsi     # 0x131fa0
callq 0x114a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x62dfe
jmp 0x62e61
movq 0xcf180(%rip), %rdi     # 0x131fe8
leaq -0x3d7ff(%rip), %rsi    # 0x25670
callq 0x11180
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x340, %rdi            # imm = 0x340
callq 0x15090
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x11880
movq %rax, %rdi
leaq 0x76700(%rip), %rsi     # 0xd959d
callq 0x11420
movq %rax, %rdi
movq 0xcf0f4(%rip), %rsi     # 0x131fa0
callq 0x114a0
movq -0x18(%rbp), %rax
testb $0x1, 0x338(%rax)
jne 0x62ee0
movq 0xcf123(%rip), %rdi     # 0x131fe8
leaq 0x766e9(%rip), %rsi     # 0xd95b5
callq 0x11420
movq %rax, %rdi
movq 0xcf0c5(%rip), %rsi     # 0x131fa0
callq 0x114a0
jmp 0x62ee2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::checkSymbols[abi:cxx11](SymbolScope*)
string SleighCompile::checkSymbols(SymbolScope *scope)

{ // Make sure label symbols are used properly
  ostringstream s;
  SymbolTree::const_iterator iter;
  for(iter=scope->begin();iter!=scope->end();++iter) {
    LabelSymbol *sym = (LabelSymbol *)*iter;
    if (sym->getType() != SleighSymbol::label_symbol) continue;
    if (sym->getRefCount() == 0)
      s << "   Label <" << sym->getName() << "> was placed but not used\n";
    else if (!sym->isPlaced())
      s << "   Label <" << sym->getName() << "> was referenced but never placed\n";
  }
  return s.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x116c0
leaq -0x198(%rbp), %rdi
callq 0x47f10
movq -0x18(%rbp), %rdi
callq 0x57720
movq %rax, -0x1c8(%rbp)
jmp 0x62f42
movq -0x1c8(%rbp), %rax
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x18(%rbp), %rdi
callq 0x57750
movq %rax, -0x1e0(%rbp)
jmp 0x62f70
movq -0x1e0(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x47f60
testb $0x1, %al
jne 0x62f9a
jmp 0x6311a
leaq -0x198(%rbp), %rdi
callq 0x47fc0
movq (%rax), %rax
movq %rax, -0x1c0(%rbp)
movq -0x1c0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movl %eax, -0x1e4(%rbp)
jmp 0x62fc8
movl -0x1e4(%rbp), %eax
cmpl $0x11, %eax
je 0x62ffb
jmp 0x63109
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x11120
jmp 0x6314b
movq -0x1c0(%rbp), %rdi
callq 0x6b870
movl %eax, -0x1e8(%rbp)
jmp 0x6300f
movl -0x1e8(%rbp), %eax
cmpl $0x0, %eax
jne 0x63081
leaq 0x765bc(%rip), %rsi     # 0xd95dd
leaq -0x190(%rbp), %rdi
callq 0x11420
movq %rax, -0x1f0(%rbp)
jmp 0x63036
movq -0x1c0(%rbp), %rdi
callq 0x401a0
movq %rax, -0x1f8(%rbp)
jmp 0x6304b
movq -0x1f8(%rbp), %rsi
movq -0x1f0(%rbp), %rdi
callq 0x113e0
movq %rax, -0x200(%rbp)
jmp 0x63067
movq -0x200(%rbp), %rdi
leaq 0x76573(%rip), %rsi     # 0xd95e8
callq 0x11420
jmp 0x6307c
jmp 0x63107
movq -0x1c0(%rbp), %rdi
callq 0x40180
movb %al, -0x201(%rbp)
jmp 0x63095
movb -0x201(%rbp), %al
testb $0x1, %al
jne 0x63105
jmp 0x630a1
leaq 0x76535(%rip), %rsi     # 0xd95dd
leaq -0x190(%rbp), %rdi
callq 0x11420
movq %rax, -0x210(%rbp)
jmp 0x630bd
movq -0x1c0(%rbp), %rdi
callq 0x401a0
movq %rax, -0x218(%rbp)
jmp 0x630d2
movq -0x218(%rbp), %rsi
movq -0x210(%rbp), %rdi
callq 0x113e0
movq %rax, -0x220(%rbp)
jmp 0x630ee
movq -0x220(%rbp), %rdi
leaq 0x76507(%rip), %rsi     # 0xd9603
callq 0x11420
jmp 0x63103
jmp 0x63105
jmp 0x63107
jmp 0x63109
leaq -0x198(%rbp), %rdi
callq 0x47fe0
jmp 0x62f5e
movq -0x1d8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x11460
jmp 0x6312f
leaq -0x190(%rbp), %rdi
callq 0x11120
movq -0x1d0(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x118b0
nopw (%rax,%rax)
// File: jstaursky[P]hutch/src/Sleigh/slgh_compile.cc
// Function: SleighCompile::process()
void SleighCompile::process(void)

{				// Do all post processing on the parsed data structures
  checkNops();
  if (getDefaultSpace() == (AddrSpace *)0)
    reportError("No default space specified",false);
  if (errors>0) return;
  checkConsistency();
  if (errors>0) return;
  checkLocalCollisions();
  if (errors>0) return;
  buildPatterns();
  if (errors>0) return;
  buildDecisionTrees();
  if (errors>0) return;
  try {
    buildXrefs();		// Make sure we can build crossrefs properly
  } catch(SleighError &err) {
    cerr << err.explain << endl;
    errors += 1;
    return;
  }
  checkUniqueAllocation();
  symtab.purge();		// Get rid of any symbols we don't plan to save
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x62dc0
movq -0x50(%rbp), %rdi
callq 0x14970
cmpq $0x0, %rax
jne 0x63201
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x118c0
movq -0x58(%rbp), %rdx
leaq 0x764b6(%rip), %rsi     # 0xd9656
leaq -0x28(%rbp), %rdi
callq 0x14430
jmp 0x631ab
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x603b0
jmp 0x631bc
leaq -0x28(%rbp), %rdi
callq 0x11300
leaq -0x29(%rbp), %rdi
callq 0x114d0
jmp 0x63201
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x631f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x11300
leaq -0x29(%rbp), %rdi
callq 0x114d0
jmp 0x6332e
movq -0x50(%rbp), %rax
cmpl $0x0, 0x358(%rax)
jle 0x63213
jmp 0x63328
movq -0x50(%rbp), %rdi
callq 0x62510
movq -0x50(%rbp), %rax
cmpl $0x0, 0x358(%rax)
jle 0x6322e
jmp 0x63328
movq -0x50(%rbp), %rdi
callq 0x62c60
movq -0x50(%rbp), %rax
cmpl $0x0, 0x358(%rax)
jle 0x63249
jmp 0x63328
movq -0x50(%rbp), %rdi
callq 0x62240
movq -0x50(%rbp), %rax
cmpl $0x0, 0x358(%rax)
jle 0x63264
jmp 0x63328
movq -0x50(%rbp), %rdi
callq 0x62050
movq -0x50(%rbp), %rax
cmpl $0x0, 0x358(%rax)
jle 0x6327f
jmp 0x63328
movq -0x50(%rbp), %rdi
callq 0x55820
jmp 0x6328a
jmp 0x6330f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6332e
movq -0x38(%rbp), %rdi
callq 0x111e0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq 0xced25(%rip), %rdi     # 0x131fe8
callq 0x113e0
movq %rax, -0x60(%rbp)
jmp 0x632ce
movq -0x60(%rbp), %rdi
movq 0xcecc7(%rip), %rsi     # 0x131fa0
callq 0x114a0
jmp 0x632e0
movq -0x50(%rbp), %rax
movl 0x358(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x358(%rax)
callq 0x11810
jmp 0x63328
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x11810
jmp 0x6330d
jmp 0x6332e
movq -0x50(%rbp), %rdi
callq 0x63340
movq -0x50(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0xa48d0
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x118b0
movq %rax, %rdi
callq 0x15590
nop