LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: bhhbazinga[P]LockFreeHashTable/./HazardPointer/reclaimer.h
// Function: Reclaimer::ReclaimPool::Pop()
ReclaimNode* Pop() {
      if (nullptr == head->next) {
        return new ReclaimNode();
      }

      ReclaimNode* temp = head;
      head = head->next;
      temp->next = nullptr;
      return temp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rcx
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
jne 0xc8e0
movl $0x30, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0xc730
jmp 0xc8ba
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc909
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x2150
jmp 0xc913
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2230
nopl (%rax)
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::Less(LockFreeHashTable<int, int, std::hash<int>>::Node*, LockFreeHashTable<int, int, std::hash<int>>::Node*) const
bool Less(Node* node1, Node* node2) const {
    if (node1->reverse_hash != node2->reverse_hash) {
      return node1->reverse_hash < node2->reverse_hash;
    }

    if (node1->IsDummy() || node2->IsDummy()) {
      // When initialize bucket concurrently, that could happen.
      return false;
    }

    return static_cast<RegularNode*>(node1)->key <
           static_cast<RegularNode*>(node2)->key;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0xdca0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xdcda
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0xdcbe
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0xdcbe
jmp 0xdcc4
movb $0x0, -0x1(%rbp)
jmp 0xdcda
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x20(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: bhhbazinga[P]LockFreeHashTable/./lockfree_hashtable.h
// Function: LockFreeHashTable<int, int, std::hash<int>>::FindNode(LockFreeHashTable<int, int, std::hash<int>>::DummyNode*, LockFreeHashTable<int, int, std::hash<int>>::RegularNode*, int&)
bool FindNode(DummyNode* head, RegularNode* find_node, V& value) {
    Node* prev;
    Node* cur;
    HazardPointer prev_hp, cur_hp;
    bool found = SearchNode(head, find_node, &prev, &cur, prev_hp, cur_hp);
    auto& reclaimer = TableReclaimer<K, V>::GetInstance();
    if (found) {
      V* value_ptr;
      V* temp;
      do {
        // When find and insert concurrently value may be deleted,
        // see InsertRegularNode, so value must be marked as hazard.
        value_ptr = static_cast<RegularNode*>(cur)->value.load(
            std::memory_order_consume);
        temp = value_ptr;
        value_ptr = static_cast<RegularNode*>(cur)->value.load(
            std::memory_order_consume);
      } while (temp != value_ptr);
      reclaimer.ReclaimNoHazardPointer();
      value = *value_ptr;
    }
    return found;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xb020
leaq -0x50(%rbp), %rdi
callq 0xb020
jmp 0xe327
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq %rsp, %rax
leaq -0x50(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0xb040
movb %al, -0x81(%rbp)
jmp 0xe356
movb -0x81(%rbp), %al
andb $0x1, %al
movb %al, -0x5d(%rbp)
callq 0xba40
movq %rax, -0x90(%rbp)
jmp 0xe36f
movq -0x90(%rbp), %rax
movq %rax, -0x68(%rbp)
testb $0x1, -0x5d(%rbp)
je 0xe3fe
jmp 0xe382
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0xa1a0
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0xa1a0
movq %rax, -0x70(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x70(%rbp), %rax
jne 0xe382
movq -0x68(%rbp), %rdi
callq 0x2be0
jmp 0xe3cb
movq -0x70(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0xe3fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xe42a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xba10
jmp 0xe42a
movb -0x5d(%rbp), %al
movb %al, -0x91(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xba10
leaq -0x40(%rbp), %rdi
callq 0xba10
movb -0x91(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0xba10
movq -0x58(%rbp), %rdi
callq 0x2230
nopl (%rax)
// File: zakimjz[P]SLEUTH/calcdb.cpp
// Function: Dbase_Ctrl_Blk::get_first_blk()
void Dbase_Ctrl_Blk::get_first_blk()
{
   readall=0;

   fd.clear();
   fd.seekg(0,ios::beg);
   
   if (binary_input){
      fd.read((char *)buf, (buf_size*ITSZ));
      cur_blk_size = fd.gcount()/ITSZ; 
      if (cur_blk_size < 0){
         cerr << "problem in get_first_blk" << cur_blk_size << endl;
      }
      if (cur_blk_size < buf_size){
         fd.clear();
         fd.seekg(0,ios::end);
      }
   }
   
   cur_buf_pos = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x0, 0x224(%rdi)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x22a0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2200
testb $0x1, 0x1b8c9(%rip)     # 0x1e228
je 0x2a0f
movq -0x10(%rbp), %rdi
movq 0x210(%rdi), %rsi
movslq 0x208(%rdi), %rdx
shlq $0x2, %rdx
callq 0x21e0
movq -0x10(%rbp), %rdi
callq 0x2330
movq %rax, %rcx
movq -0x10(%rbp), %rax
shrq $0x2, %rcx
movl %ecx, 0x218(%rax)
cmpl $0x0, 0x218(%rax)
jge 0x29d7
movq 0x1b646(%rip), %rdi     # 0x1dff0
leaq 0x11666(%rip), %rsi     # 0x14017
callq 0x2160
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x218(%rax), %esi
callq 0x22b0
movq %rax, %rdi
movq 0x1b5e6(%rip), %rsi     # 0x1dfb8
callq 0x2190
movq -0x10(%rbp), %rcx
movl 0x218(%rcx), %eax
cmpl 0x208(%rcx), %eax
jge 0x2a0d
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x22a0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2200
jmp 0x2a0f
movq -0x10(%rbp), %rax
movl $0x0, 0x21c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zakimjz[P]SLEUTH/calcdb.cpp
// Function: Dbase_Ctrl_Blk::get_next_trans_ext()
void Dbase_Ctrl_Blk::get_next_trans_ext()
{
   // Need to get more items from file
   int res = cur_blk_size - cur_buf_pos;
   if (res > 0)
   {
      // First copy partial transaction to beginning of buffer
      for (int i=0; i < res; i++)
         buf[i] = buf[cur_buf_pos+i]; 
      cur_blk_size = res;
   }
   else
   {
      // No partial transaction in buffer
      cur_blk_size = 0;
   }

   fd.read((char *)(buf + cur_blk_size),
           ((buf_size - cur_blk_size)*ITSZ));
   
   res = fd.gcount();
   if (res < 0){
      cerr << "in get_next_trans_ext" << res << endl;
   }

  if (res < (buf_size - cur_blk_size)){
      fd.clear();
      fd.seekg(0,ios::end);
   }

   
   cur_blk_size += res/ITSZ;
   cur_buf_pos = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x218(%rcx), %eax
subl 0x21c(%rcx), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x2d3a
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2d2b
movq -0x18(%rbp), %rax
movq 0x210(%rax), %rcx
movl 0x21c(%rax), %edx
addl -0x10(%rbp), %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %edx
movq 0x210(%rax), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2cf0
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x218(%rax)
jmp 0x2d48
movq -0x18(%rbp), %rax
movl $0x0, 0x218(%rax)
movq -0x18(%rbp), %rdi
movq 0x210(%rdi), %rsi
movslq 0x218(%rdi), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl 0x208(%rdi), %eax
subl 0x218(%rdi), %eax
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x21e0
movq -0x18(%rbp), %rdi
callq 0x2330
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x2db8
movq 0x1b25e(%rip), %rdi     # 0x1dff0
leaq 0x11297(%rip), %rsi     # 0x14030
callq 0x2160
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x22b0
movq %rax, %rdi
movq 0x1b205(%rip), %rsi     # 0x1dfb8
callq 0x2190
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %eax
movl 0x208(%rdx), %ecx
subl 0x218(%rdx), %ecx
cmpl %ecx, %eax
jge 0x2df3
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x22a0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2200
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rdx
shrq $0x2, %rdx
movslq 0x218(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x218(%rax)
movl $0x0, 0x21c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: zakimjz[P]SLEUTH/calcdb.cpp
// Function: Dbase_Ctrl_Blk::print_trans()
void Dbase_Ctrl_Blk::print_trans(){
  cout << Cid << " " << Tid << " " << TransSz;
  for (int i=0; i < TransSz; i++)
    cout << " " << TransAry[i];
  cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x1b0a2(%rip), %esi     # 0x1e214
movq 0x1ae57(%rip), %rdi     # 0x1dfd0
callq 0x22b0
movq %rax, %rdi
leaq 0x10f15(%rip), %rsi     # 0x1409d
callq 0x2160
movq %rax, %rdi
movl 0x1b07a(%rip), %esi     # 0x1e210
callq 0x22b0
movq %rax, %rdi
leaq 0x10ef8(%rip), %rsi     # 0x1409d
callq 0x2160
movq %rax, %rdi
movl 0x1b051(%rip), %esi     # 0x1e204
callq 0x22b0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x1b03c(%rip), %eax     # 0x1e204
jge 0x31fe
movq 0x1adff(%rip), %rdi     # 0x1dfd0
leaq 0x10ec5(%rip), %rsi     # 0x1409d
callq 0x2160
movq %rax, %rdi
movq 0x1b021(%rip), %rax     # 0x1e208
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x22b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x31bf
movq 0x1adcb(%rip), %rdi     # 0x1dfd0
movq 0x1adac(%rip), %rsi     # 0x1dfb8
callq 0x2190
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zakimjz[P]SLEUTH/calcdb.cpp
// Function: Dbase_Ctrl_Blk::alloc_idlists()
void Dbase_Ctrl_Blk::alloc_idlists()
{
   //allocate space for Idlists
   Idlists.resize(NumF1);
   for (int i=0; i < NumF1; i++){
      Idlists[i] = new idlist;   
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x228, %rdi            # imm = 0x228
movslq 0x1afd6(%rip), %rsi     # 0x1e218
callq 0x35f0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x1afc1(%rip), %eax     # 0x1e218
jge 0x3295
movl $0x18, %edi
callq 0x2170
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
callq 0x3680
movq -0x18(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
movslq -0xc(%rbp), %rsi
callq 0x36a0
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x324e
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: zakimjz[P]SLEUTH/calcdb.cpp
// Function: Dbase_Ctrl_Blk::print_vertical()
void Dbase_Ctrl_Blk::print_vertical(){
  int i;
  for (i=0; i < NumF1; i++){
    cout << "item " << Dbase_Ctrl_Blk::FreqIdx[i] << endl;
    cout << *Idlists[i];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x1ad94(%rip), %eax     # 0x1e218
jge 0x34ec
movq 0x1ab43(%rip), %rdi     # 0x1dfd0
leaq 0x10bb2(%rip), %rsi     # 0x14046
callq 0x2160
movq %rax, %rdi
movq 0x1ad4d(%rip), %rax     # 0x1e1f0
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x22b0
movq %rax, %rdi
movq 0x1aaff(%rip), %rsi     # 0x1dfb8
callq 0x2190
movq -0x18(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
movslq -0xc(%rbp), %rsi
callq 0x36a0
movq (%rax), %rsi
movq 0x1aaf4(%rip), %rdi     # 0x1dfd0
callq 0x91c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x347b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: zakimjz[P]SLEUTH/eqclass.cpp
// Function: Eqnode::find_in_tlist(std::vector<int, std::allocator<int>>&, int, ival&, int)
bool Eqnode::find_in_tlist(vector<int> &par, int lit, 
                           ival &it, int stpos)
{
   //idlist::iterator ii;
   //for (ii = &tlist[stpos]; ii != tlist.end(); ++ii){
   idnode *ii;
   for (int i = stpos; i < tlist.size(); ++i){
      ii = &tlist[stpos];
      
      if (equal(par.begin(), par.end(), (*ii).parscope.begin())){
         if ((lit == (*ii).parscope.back()) &&
             (ival::compare((*ii).itscope, it) == equals)) return true;
      }
   }
   return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x60(%rbp), %rdi
movslq -0x3c(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x10, %rdi
callq 0x5480
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x5b20
movq -0x60(%rbp), %rdi
addq $0x10, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x61c0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6230
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6260
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x6230
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x61e0
testb $0x1, %al
jne 0x5ad5
jmp 0x5b10
movl -0x1c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x6290
movq %rax, %rcx
movl -0x6c(%rbp), %eax
cmpl (%rcx), %eax
jne 0x5b0e
movq -0x38(%rbp), %rdi
addq $0x4, %rdi
movq -0x28(%rbp), %rsi
callq 0x62d0
cmpl $0x0, %eax
jne 0x5b0e
movb $0x1, -0x1(%rbp)
jmp 0x5b24
jmp 0x5b10
jmp 0x5b12
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5a59
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nop
// File: zakimjz[P]SLEUTH/eqclass.cpp
// Function: operator<<(std::ostream&, Eqnode&)
ostream & operator<<(ostream& ostr, Eqnode& eqn){
   int *fidx = Dbase_Ctrl_Blk::FreqIdx;
   //ostr << fidx[eqn.val] << " (" << eqn.pos << ") - " << eqn.sup << endl;
   //ostr << fidx[eqn.val] << " - " << eqn.sup << " , " << eqn.isup <<
   //endl;
   if (mine_induced) ostr << " - " << eqn.isup << endl;
   else ostr << " - " << eqn.sup << endl;
   if (output_idlist) ostr << eqn.tlist;
   return ostr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x186a9(%rip), %rax     # 0x1e1f0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x1887e(%rip), %rax     # 0x1e3d3
testb $0x1, (%rax)
je 0x5b8a
movq -0x8(%rbp), %rdi
leaq 0xe51b(%rip), %rsi      # 0x14080
callq 0x2160
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x22b0
movq %rax, %rdi
movq 0x18435(%rip), %rsi     # 0x1dfb8
callq 0x2190
jmp 0x5bb8
movq -0x8(%rbp), %rdi
leaq 0xe4eb(%rip), %rsi      # 0x14080
callq 0x2160
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x22b0
movq %rax, %rdi
movq 0x18405(%rip), %rsi     # 0x1dfb8
callq 0x2190
leaq 0x18812(%rip), %rax     # 0x1e3d1
testb $0x1, (%rax)
je 0x5bd5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x91c0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: zakimjz[P]SLEUTH/eqclass.cpp
// Function: Eqclass::item(int)
int Eqclass::item(int n) {
   int i,k;
   //cout << "in item: " << n << " " << _prefix.size() << endl;
   for (i=0,k=0; i < _prefix.size(); i++){
      if (_prefix[i] != BranchIt){
         if (k == n) return _prefix[i];
         k++;
      }
   }
   return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x4b80
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5db0
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x6520
movslq (%rax), %rax
leaq 0x18447(%rip), %rcx     # 0x1e1c0
cmpq (%rcx), %rax
je 0x5da3
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x5d9a
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x6520
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5db7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5da5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5d45
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: zakimjz[P]SLEUTH/eqclass.cpp
// Function: Eqclass::get_scope(int, int&)
int Eqclass::get_scope(int pos, int &scope){
  int scnt=0;
  for (int i=0; i < _prefix.size(); i++){
    if (_prefix[i] == BranchIt) scnt--;
    else scnt++;
    if (i == pos) scope = scnt;
  }
  return scnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x4b80
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5e54
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x6520
movslq (%rax), %rax
leaq 0x183a3(%rip), %rcx     # 0x1e1c0
cmpq (%rcx), %rax
jne 0x5e2d
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5e36
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x5e47
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x5e49
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5de9
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zakimjz[P]SLEUTH/eqclass.cpp
// Function: Eqclass::set_prefix(std::vector<int, std::allocator<int>>&, Eqnode&)
void Eqclass::set_prefix(vector<int> &pref, Eqnode &node)
{
   _prefix = pref;
   
   int scope, scnt;
   scnt = get_scope(node.pos, scope); //what is the scope of node.pos

   while(scnt > scope){ 
     _prefix.push_back(BranchIt);
     scnt--;
   }
   _prefix.push_back(node.val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x6540
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
leaq -0x1c(%rbp), %rdx
callq 0x5dc0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x5ec9
movq -0x30(%rbp), %rdi
leaq 0x18311(%rip), %rax     # 0x1e1c0
movq (%rax), %rax
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x6790
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5e9c
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x67c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zakimjz[P]SLEUTH/eqclass.cpp
// Function: Eqclass::print_prefix(std::ostream&)
ostream & Eqclass::print_prefix(ostream& fout)
{
   for (int i=0; i < _prefix.size(); i++){
      if (_prefix[i] == BranchIt) fout << LOCAL_BRANCHIT << " ";
      else fout << Dbase_Ctrl_Blk::FreqIdx[_prefix[i]] << " ";
   }
   return fout;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4b80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x5fb3
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x6520
movslq (%rax), %rax
leaq 0x18289(%rip), %rcx     # 0x1e1c0
cmpq (%rcx), %rax
jne 0x5f5b
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22b0
movq %rax, %rdi
leaq 0xe149(%rip), %rsi      # 0x1409d
callq 0x2160
jmp 0x5fa3
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x18282(%rip), %rax     # 0x1e1f0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x6520
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
movslq (%rcx), %rcx
movl (%rax,%rcx,4), %esi
callq 0x22b0
movq %rax, %rdi
leaq 0xe0ff(%rip), %rsi      # 0x1409d
callq 0x2160
jmp 0x5fa5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5eff
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: zakimjz[P]SLEUTH/eqclass.cpp
// Function: Eqclass::print(bool)
void Eqclass::print(bool check_isup){
  list<Eqnode *>::iterator ni = _nodelist.begin();
  int st, en;
  for (; ni != _nodelist.end(); ni++){
     if (check_isup && (*ni)->isup < MINSUPPORT) continue;
     
     print_prefix();
     en = get_scope((*ni)->pos, st);
     while (en > st){
        st++;
        cout << LOCAL_BRANCHIT << " ";
     }
     //cout << Dbase_Ctrl_Blk::FreqIdx[(*ni)->val] << " - " 
     //      << (*ni)->sup << " , " << (*ni)->isup << endl;    
     cout << *(*ni);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
callq 0x6410
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x6440
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6830
testb $0x1, %al
jne 0x6010
jmp 0x60c0
testb $0x1, -0x9(%rbp)
je 0x6032
leaq -0x18(%rbp), %rdi
callq 0x6860
movq (%rax), %rax
movl 0xc(%rax), %eax
leaq 0x181a4(%rip), %rcx     # 0x1e1d0
cmpl (%rcx), %eax
jge 0x6032
jmp 0x60ac
movq -0x38(%rbp), %rdi
movq 0x17f93(%rip), %rsi     # 0x1dfd0
callq 0x5ee0
leaq -0x18(%rbp), %rdi
callq 0x6860
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %esi
leaq -0x1c(%rbp), %rdx
callq 0x5dc0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x6094
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq 0x17f57(%rip), %rdi     # 0x1dfd0
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22b0
movq %rax, %rdi
leaq 0xe010(%rip), %rsi      # 0x1409d
callq 0x2160
jmp 0x6061
leaq -0x18(%rbp), %rdi
callq 0x6860
movq (%rax), %rsi
movq 0x17f29(%rip), %rdi     # 0x1dfd0
callq 0x5b30
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x6880
movq %rax, -0x30(%rbp)
jmp 0x5fe9
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zakimjz[P]SLEUTH/eqclass.cpp
// Function: operator<<(std::ostream&, Eqclass&)
ostream& operator << (ostream& fout, Eqclass& eq)
{
  list<Eqnode *>::iterator ni = eq._nodelist.begin();
  int st, en;
  for (; ni != eq._nodelist.end(); ni++){
     eq.print_prefix(fout);
     en = eq.get_scope((*ni)->pos, st);
     while (en > st){
        st++;
        fout << LOCAL_BRANCHIT << " ";
     }
     fout << *(*ni);
  }
  return fout;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x6410
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x6440
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6830
testb $0x1, %al
jne 0x6118
jmp 0x61ad
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5ee0
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6860
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %esi
leaq -0x1c(%rbp), %rdx
callq 0x5dc0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x617c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22b0
movq %rax, %rdi
leaq 0xdf28(%rip), %rsi      # 0x1409d
callq 0x2160
jmp 0x614c
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6860
movq -0x40(%rbp), %rdi
movq (%rax), %rsi
callq 0x5b30
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x6880
movq %rax, -0x30(%rbp)
jmp 0x60f1
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zakimjz[P]SLEUTH/./idlist.h
// Function: ival::compare(ival&, ival&)
static ival_type compare(ival &n1, ival &n2){
      ival_type retval;
      if (n1.lb == n2.lb && n1.ub == n2.ub) retval = equals; //n1 equals n2
      else if (n1.lb < n2.lb && n1.ub >= n2.ub) retval = sup; //n1 contains n2
      else if (n1.lb > n2.lb && n1.ub <= n2.ub) retval = sub; //n2 contains n1
      else if (n1.ub < n2.lb) retval = before; //n1 comes before n2
      else if (n2.ub < n1.lb) retval = after; //n1 comes after n2
      else{ 
         retval = overlap;
         //cout << "wrong case in compare_interval: ";
         //cout << "[" << n1.lb << "," << n1.ub << "]";
         //cout << " [" << n2.lb << "," << n2.ub << "]" << endl;
      }
      return retval;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x6306
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x6306
movl $0x0, -0x14(%rbp)
jmp 0x6393
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x632d
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x632d
movl $0x1, -0x14(%rbp)
jmp 0x6391
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x6354
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x6354
movl $0x2, -0x14(%rbp)
jmp 0x638f
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x636c
movl $0x3, -0x14(%rbp)
jmp 0x638d
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6384
movl $0x4, -0x14(%rbp)
jmp 0x638b
movl $0x5, -0x14(%rbp)
jmp 0x638d
jmp 0x638f
jmp 0x6391
jmp 0x6393
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: zakimjz[P]SLEUTH/stats.cpp
// Function: Stats::add(iterstat&)
void Stats::add(iterstat &is){
   push_back(is);
   sumtime += is.time;
   sumcand += is.numcand;
   sumlarge += is.numlarge;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81e0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
addsd 0x164b2(%rip), %xmm0    # 0x1e240
movsd %xmm0, 0x164aa(%rip)    # 0x1e240
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl 0x164a6(%rip), %eax     # 0x1e248
movl %eax, 0x164a0(%rip)     # 0x1e248
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl 0x16497(%rip), %eax     # 0x1e24c
movl %eax, 0x16491(%rip)     # 0x1e24c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zakimjz[P]SLEUTH/stats.cpp
// Function: Stats::add(int, int, double, double)
void Stats::add(int cand, int freq, double time, double avgtid){
  iterstat *is = new iterstat(cand, freq, time, avgtid);
  push_back(*is);
  sumtime += is->time;
  sumcand += is->numcand;
  sumlarge += is->numlarge;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x18, %edi
callq 0x2170
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x8250
jmp 0x7e1f
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x81e0
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
addsd 0x163fb(%rip), %xmm0    # 0x1e240
movsd %xmm0, 0x163f3(%rip)    # 0x1e240
movq -0x28(%rbp), %rax
movl (%rax), %eax
addl 0x163ef(%rip), %eax     # 0x1e248
movl %eax, 0x163e9(%rip)     # 0x1e248
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
addl 0x163e0(%rip), %eax     # 0x1e24c
movl %eax, 0x163da(%rip)     # 0x1e24c
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x18, %esi
callq 0x2180
movq -0x30(%rbp), %rdi
callq 0x22d0
nopl (%rax,%rax)
// File: zakimjz[P]SLEUTH/stats.cpp
// Function: operator<<(std::ostream&, Stats&)
ostream& operator << (ostream& fout, Stats& stats){
  //fout << "SIZE " << stats.size() << endl;
  for (int i=0; i<stats.size(); i++){
    fout << "[ " << i+1 << " " << stats[i].numcand << " "
	 << stats[i].numlarge << " " << stats[i].time << " "
	 << stats[i].avgtid << " ] ";
  }
  fout << "[ SUM " << stats.sumcand << " " << stats.sumlarge << " "
       << stats.sumtime << " ] ";
  fout << stats.tottime;
  return fout;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8290
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x8156
movq -0x8(%rbp), %rdi
leaq 0xc011(%rip), %rsi      # 0x14084
callq 0x2160
movq %rax, %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x22b0
movq %rax, %rdi
leaq 0xc00d(%rip), %rsi      # 0x1409d
callq 0x2160
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x8350
movq -0x40(%rbp), %rdi
movl (%rax), %esi
callq 0x22b0
movq %rax, %rdi
leaq 0xbfe2(%rip), %rsi      # 0x1409d
callq 0x2160
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x8350
movq -0x38(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x22b0
movq %rax, %rdi
leaq 0xbfb6(%rip), %rsi      # 0x1409d
callq 0x2160
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x8350
movq -0x30(%rbp), %rdi
movsd 0x8(%rax), %xmm0
callq 0x2320
movq %rax, %rdi
leaq 0xbf88(%rip), %rsi      # 0x1409d
callq 0x2160
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x8350
movq -0x28(%rbp), %rdi
movsd 0x10(%rax), %xmm0
callq 0x2320
movq %rax, %rdi
leaq 0xbf44(%rip), %rsi      # 0x14087
callq 0x2160
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8047
movq -0x8(%rbp), %rdi
leaq 0xbf2a(%rip), %rsi      # 0x1408b
callq 0x2160
movq %rax, %rdi
movl 0x160d9(%rip), %esi     # 0x1e248
callq 0x22b0
movq %rax, %rdi
leaq 0xbf1f(%rip), %rsi      # 0x1409d
callq 0x2160
movq %rax, %rdi
movl 0x160c0(%rip), %esi     # 0x1e24c
callq 0x22b0
movq %rax, %rdi
leaq 0xbf02(%rip), %rsi      # 0x1409d
callq 0x2160
movq %rax, %rdi
movsd 0x16095(%rip), %xmm0    # 0x1e240
callq 0x2320
movq %rax, %rdi
leaq 0xbecd(%rip), %rsi      # 0x14087
callq 0x2160
movq -0x8(%rbp), %rdi
movsd 0x1606d(%rip), %xmm0    # 0x1e238
callq 0x2320
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zakimjz[P]SLEUTH/treeminer.cpp
// Function: F1cmp(int, int)
bool F1cmp(int x, int y){
   bool res = false;
   if ((*ITCNT)[x] < (*ITCNT)[y]) res = true;

   if (sort_type == incr) return res;
   else return !res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
movq 0x15197(%rip), %rdi     # 0x1e400
movslq -0x8(%rbp), %rsi
callq 0x6520
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq 0x15182(%rip), %rdi     # 0x1e400
movslq -0xc(%rbp), %rsi
callq 0x6520
movq %rax, %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x9295
movb $0x1, -0xd(%rbp)
cmpl $0x1, 0x1513c(%rip)     # 0x1e3d8
jne 0x92a8
movb -0xd(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x92b2
movb -0xd(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: zakimjz[P]SLEUTH/treeminer.cpp
// Function: form_f2_lists(Eqclass*)
void form_f2_lists(Eqclass *eq)
{
   list<Eqnode *>::iterator ni;
   idlist *l1, *l2;
   Eqnode *ins=NULL, *outs=NULL;
   int pit, nit;
   TimeTracker tt;
   
   tt.Start();
   pit = eq->prefix()[0];
   l1 = DCB->Idlists[pit];
   for (ni=eq->nlist().begin(); ni != eq->nlist().end(); ++ni){
      nit = (*ni)->val;
      l2 = DCB->Idlists[nit];
      ins = (*ni);
      //cout << "LISTS " << pit << " " << nit << " " << l1->size() 
      //     << " " << l2->size() << " " << ins->tlist.size() << endl;
      get_intersect(l1, l2, ins, outs, 0, 0, true);

   }
   stats.incrtime(1,tt.Stop());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xc390
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xbe90
leaq -0x60(%rbp), %rdi
callq 0xbf30
movq -0x8(%rbp), %rdi
callq 0xc150
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6520
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq 0x12cd5(%rip), %rdi     # 0x1e3a0
addq $0x228, %rdi            # imm = 0x228
movslq -0x34(%rbp), %rsi
callq 0x36a0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x63f0
movq %rax, %rdi
callq 0x6410
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x63f0
movq %rax, %rdi
callq 0x6440
movq %rax, -0x70(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6830
testb $0x1, %al
jne 0xb727
jmp 0xb796
leaq -0x10(%rbp), %rdi
callq 0x6860
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movq 0x12c61(%rip), %rdi     # 0x1e3a0
addq $0x228, %rdi            # imm = 0x228
movslq -0x38(%rbp), %rsi
callq 0x36a0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6860
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
xorl %r9d, %r9d
movl %r9d, %r8d
movl $0x1, (%rsp)
callq 0xa560
leaq -0x10(%rbp), %rdi
callq 0x76f0
jmp 0xb6ff
leaq -0x60(%rbp), %rdi
callq 0xc060
leaq 0x12c02(%rip), %rdi     # 0x1e3a8
movl $0x1, %esi
callq 0x7fa0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: zakimjz[P]SLEUTH/treeminer.cpp
// Function: get_Fk(std::__cxx11::list<Eqclass*, std::allocator<Eqclass*>>&)
void get_Fk(list<Eqclass *> &F2list){
   Eqclass *eq;

   while(!F2list.empty()){
      eq = F2list.front();
      form_f2_lists(eq);
      //if (output){
      //   if (mine_induced) eq->print(true);
      //   else eq->print();
      // }
      
      if (prune_type == prune) FK.add(2, eq);
      switch(alg_type){
      case treeminer:
         enumerate_freq(eq, 3); 
         break;
      case maxtreeminer:
         cout << "NOT IMPLEMENTED\n";
         break;
      }
      delete eq;
      F2list.pop_front();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc440
xorb $-0x1, %al
testb $0x1, %al
jne 0xb7e0
jmp 0xb886
movq -0x8(%rbp), %rdi
callq 0xc460
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb670
cmpl $0x1, 0x12be0(%rip)     # 0x1e3e0
jne 0xb817
movq -0x10(%rbp), %rdx
leaq 0x12bdb(%rip), %rdi     # 0x1e3e8
movl $0x2, %esi
callq 0x10a60
movl 0x12bbf(%rip), %eax     # 0x1e3dc
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0xb830
jmp 0xb826
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0xb840
jmp 0xb853
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0xb070
jmp 0xb853
movq 0x12789(%rip), %rdi     # 0x1dfd0
leaq 0x89e0(%rip), %rsi      # 0x1422e
callq 0x2160
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xb878
movq -0x20(%rbp), %rdi
callq 0x5be0
movq -0x20(%rbp), %rdi
movl $0x30, %esi
callq 0x2180
movq -0x8(%rbp), %rdi
callq 0xc490
jmp 0xb7cc
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: zakimjz[P]SLEUTH/./timetrack.h
// Function: TimeTracker::Stop()
double Stop() {
     double st, en;
     if (!running) return(-1.0);
     else {
        gettimeofday(&stop_time, (struct timezone *)0);
        st = start_time.tv_sec + (start_time.tv_usec/microsec);
        en = stop_time.tv_sec + (stop_time.tv_usec/microsec);
        running=false;
        return (double)(en - st);
     }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x20(%rax)
jne 0xc089
movsd 0x80f6(%rip), %xmm0     # 0x14178
movsd %xmm0, -0x8(%rbp)
jmp 0xc0f2
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2260
movq -0x28(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
cvtsi2sdq 0x8(%rax), %xmm1
movsd 0x80cf(%rip), %xmm2     # 0x14180
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
cvtsi2sdq 0x10(%rax), %xmm0
cvtsi2sdq 0x18(%rax), %xmm1
movsd 0x80ae(%rip), %xmm2     # 0x14180
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movb $0x0, 0x20(%rax)
movsd -0x20(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zakimjz[P]SLEUTH/./idlist.h
// Function: idnode::path_equal(idnode&)
bool path_equal(idnode &idn){
      int i;
      for (i=0; i < parscope.size(); i++){
         if (parscope[i] != idn.parscope[i]) return false;
      }
      return true;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x4b80
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xc224
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6520
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6520
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
je 0xc217
movb $0x0, -0x1(%rbp)
jmp 0xc228
jmp 0xc219
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc1bf
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: zakimjz[P]SLEUTH/./hashtable.h
// Function: FreqHT::clearall()
void clearall(){
      for (int i=0; i < chtable.size(); i++){
         if (chtable[i]){
            cHTable::iterator hi = chtable[i]->begin();
            for (; hi != chtable[i]->end(); hi++){
               delete (*hi).second;
            }
            chtable[i]->clear();
         }
      }
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x48(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0xcf60
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0xcefa
movq -0x48(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xcf80
cmpq $0x0, (%rax)
je 0xceea
movq -0x48(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xcf80
movq (%rax), %rdi
callq 0xcfa0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x48(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xcf80
movq (%rax), %rdi
callq 0xd000
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xcfd0
testb $0x1, %al
jne 0xce90
jmp 0xced5
leaq -0x20(%rbp), %rdi
callq 0xd030
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xcebe
movq -0x58(%rbp), %rdi
callq 0x3a30
movq -0x58(%rbp), %rdi
movl $0x18, %esi
callq 0x2180
jmp 0xcec0
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xd050
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
jmp 0xce60
movq -0x48(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xcf80
movq (%rax), %rdi
callq 0xd080
jmp 0xceec
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xce0b
addq $0x60, %rsp
popq %rbp
retq
// File: zakimjz[P]SLEUTH/./idlist.h
// Function: idnode::idnode(int, std::vector<int, std::allocator<int>>&, int, ival&, int, bool)
idnode(int c, vector<int> &pscope, int lit, ival &ivl, int d, 
          bool i=false){
      cid = c;
      itscope = ivl;
      parscope = pscope;
      parscope.push_back(lit);      
      depth = d;
      induced = i;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
andb $0x1, %al
movb %al, -0x2d(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x4, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3940
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3960
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x4(%rax)
movq -0x18(%rbp), %rsi
callq 0x6540
jmp 0xd89f
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x67c0
jmp 0xd8b2
movq -0x50(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0x28(%rax)
movb -0x2d(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x2c(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x3a30
movq -0x38(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: zakimjz[P]SLEUTH/./idlist.h
// Function: idnode::idnode(int, ival&, int, bool)
idnode(int c, ival &it, int d, bool i=false){
      cid = c;
      itscope = it;
      depth = d;
      induced = i;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x4, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3940
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0x3960
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x28(%rax)
movb -0x1d(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x2c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zakimjz[P]SLEUTH/./eqclass.h
// Function: Eqnode::supcmp(Eqnode*, Eqnode*)
static bool supcmp (Eqnode *n1, Eqnode *n2){
      bool res = false;
      if ((n1)->sup < (n2)->sup) res = true;
      
      if (sort_type == incr) return res;
      else return !res;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xe034
movb $0x1, -0x19(%rbp)
cmpl $0x1, 0x1039d(%rip)     # 0x1e3d8
jne 0xe047
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe051
movb -0x19(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: zakimjz[P]SLEUTH/hashtable.cpp
// Function: eqcmp(std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*)
bool eqcmp(vector<int> *v1, vector<int> *v2)
{
   if (v1->size() != v2->size()) return false;
   for (int i=0; i < v1->size(); i++){
      if ((*v1)[i] != (*v2)[i]) return false;
   }
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b80
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4b80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x10d98
movb $0x0, -0x1(%rbp)
jmp 0x10dfc
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b80
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x10df8
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6520
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6520
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
je 0x10deb
movb $0x0, -0x1(%rbp)
jmp 0x10dfc
jmp 0x10ded
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10d9f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zakimjz[P]SLEUTH/hashtable.cpp
// Function: FreqHT::find(int, std::vector<int, std::allocator<int>>&, int)
bool FreqHT::find(int iter, vector<int> &cand, int hval)
{
   if (chtable[iter] == NULL) return false;

   int hres = chtable[iter]->hash_funct()(hval);   
   cHTFind p = chtable[iter]->equal_range(hres);
   
   //cout << "FIND " << hres << " xx  " << cand << endl;
   cHTable::iterator hi = p.first;
   for (; hi!=p.second; hi++){
      if (eqcmp(&cand, (*hi).second)) return true;
   }
   return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movslq -0x14(%rbp), %rsi
callq 0xcf80
cmpq $0x0, (%rax)
jne 0x10e49
movb $0x0, -0x1(%rbp)
jmp 0x10ef6
movq -0x78(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xcf80
movq (%rax), %rdi
callq 0x10f90
movl -0x24(%rbp), %esi
leaq -0x29(%rbp), %rdi
callq 0xd390
movq -0x78(%rbp), %rdi
movl %eax, -0x28(%rbp)
movslq -0x14(%rbp), %rsi
callq 0xcf80
movq (%rax), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x11020
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rsi
addq $0x10, %rsi
leaq -0x60(%rbp), %rdi
callq 0xcfd0
testb $0x1, %al
jne 0x10eb1
jmp 0x10ef2
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xd030
movq -0x80(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x10d60
testb $0x1, %al
jne 0x10ed5
jmp 0x10edb
movb $0x1, -0x1(%rbp)
jmp 0x10ef6
jmp 0x10edd
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0xd050
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
jmp 0x10e9a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop