LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/src/cog_tester.cpp
// Function: load_buffer(std::istream&)
RecordBuffer load_buffer(istream &input)
{
  RecordBuffer ret(new vector<Record>());
  Record r;
  r.value = (Value)0xDEADBEEF;
  while(!input.eof()){
    input >> r.key;
    ret->push_back(r);
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x4270
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5d74
leaq -0x28(%rbp), %r15
andq $0x0, (%r15)
movl $0xdeadbeef, %eax       # imm = 0xDEADBEEF
movq %rax, 0x8(%r15)
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x4975
movq %r14, %rdi
movq %r15, %rsi
callq 0x4290
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x578c
jmp 0x494e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x59d4
movq %r14, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/src/cog_tester.cpp
// Function: build_random_sorted_array(int, int)
RecordCogHandle build_random_sorted_array(int len, int max)
{
  RecordBuffer buff = build_buffer(len, max);
  sort(buff->begin(), buff->end());
  return CogHandle<Record>(new CogHandleBase<Record>(CogPtr<Record>(
          new SortedArrayCog<Record>(buff, buff->begin(), buff->end()))));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x4870
movq (%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x6610
pushq $0x10
popq %rdi
callq 0x4270
movq %rax, %rbx
pushq $0x30
popq %rdi
callq 0x4270
movq %rax, %r15
leaq -0x58(%rbp), %r12
leaq -0x48(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x5a64
movq (%r13), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %r15, %rdi
movq %r12, %rsi
callq 0x57f0
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x6c38
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x6510
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6528
leaq -0x30(%rbp), %rdi
callq 0x59d4
leaq -0x50(%rbp), %rdi
callq 0x59d4
leaq -0x40(%rbp), %rdi
callq 0x59d4
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x59d4
xorl %r15d, %r15d
jmp 0x4bb3
movq %rax, %r14
movb $0x1, %r15b
leaq -0x50(%rbp), %rdi
callq 0x59d4
testb %r15b, %r15b
jne 0x4bc6
jmp 0x4bd6
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x4280
jmp 0x4bd6
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x59d4
movq %r14, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/cog/ArrayCog.hpp
// Function: ArrayCog<Record>::printDebug(int)
void printDebug(int depth)
    {
      Cog<Tuple>::printPrefix(depth);
      std::cout << "Array[" << (end-start) << " elements] : { ";
      BufferElement<Tuple> curr = start;
      int i = 0;
      for(; (i < 6) && (curr != end); ++curr, ++i){
        std::cout << (i != 0 ? ", " : "") << curr->key;
      }
      if(curr != end) { std::cout << " ... "; }
      std::cout << " }\n";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x60cc
movq 0xffb3(%rip), %rdi      # 0x15fc8
leaq 0x8139(%rip), %rsi      # 0xe155
callq 0x4260
movq 0x28(%rbx), %rsi
subq 0x20(%rbx), %rsi
sarq $0x4, %rsi
movq %rax, %rdi
callq 0x4240
leaq 0x80f6(%rip), %rsi      # 0xe132
movq %rax, %rdi
callq 0x4260
movq 0x20(%rbx), %r15
xorl %r12d, %r12d
leaq 0x883f(%rip), %r13      # 0xe891
leaq 0x80e9(%rip), %r14      # 0xe142
movq 0x28(%rbx), %rax
cmpl $0x5, %r12d
ja 0x6092
cmpq %rax, %r15
je 0x6092
testl %r12d, %r12d
movq %r14, %rsi
cmoveq %r13, %rsi
movq 0xff4f(%rip), %rdi      # 0x15fc8
callq 0x4260
movq (%r15), %rsi
movq %rax, %rdi
callq 0x4240
addq $0x10, %r15
incl %r12d
jmp 0x6059
cmpq %rax, %r15
je 0x60aa
movq 0xff2a(%rip), %rdi      # 0x15fc8
leaq 0x80a0(%rip), %rsi      # 0xe145
callq 0x4260
movq 0xff17(%rip), %rdi      # 0x15fc8
leaq 0x8093(%rip), %rsi      # 0xe14b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4260
nop
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/iterator/BufferIterator.hpp
// Function: BufferIterator<Record>::seek(Record const&)
void seek(const Tuple &k)
    {
      unsigned int d = 1;
      BufferElement<Tuple> high = curr;
      while((high < end) && (*high < k)){
        curr = high;
        high += d;
        d *= 2;
      }
      if(high > end){ high = end; }
      if(curr < high){
        BufferElement<Tuple> temp = lower_bound(curr, high, k);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rdx
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %rcx
movq (%rsi), %r8
movl $0x1, %r9d
movq %rax, %rsi
cmpq %rcx, %rsi
jae 0x62b2
cmpq %r8, (%rsi)
jge 0x62b2
movq %rsi, 0x18(%rdi)
movl %r9d, %r10d
shlq $0x4, %r10
addq %rsi, %r10
addl %r9d, %r9d
movq %rsi, %rax
movq %r10, %rsi
jmp 0x628f
cmpq %rcx, %rsi
cmovaq %rcx, %rsi
cmpq %rsi, %rax
jae 0x62c7
movq %rax, %rdi
popq %rbp
jmp 0x62db
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/cog/ConcatCog.hpp
// Function: ConcatCog<Record>::printDebug(int)
void printDebug(int depth)
    {
      Cog<Tuple>::printPrefix(depth);
      std::cout << "Concat" << std::endl;
      lhs->printDebug(depth+1);
      rhs->printDebug(depth+1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x60cc
movq 0xebec(%rip), %rdi      # 0x15fc8
leaq 0x6db4(%rip), %rsi      # 0xe197
callq 0x4260
movq %rax, %rdi
callq 0x4140
movq 0x10(%r14), %rdi
incl %ebx
movl %ebx, %esi
callq 0x5938
movq 0x20(%r14), %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x5938
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/iterator/MergeIterator.hpp
// Function: MergeIterator<Record>::MergeIterator(std::shared_ptr<CogHandleBase<Record>>, std::shared_ptr<CogHandleBase<Record>>)
MergeIterator(
      CogHandle<Tuple> lhs, 
      CogHandle<Tuple> rhs
    )
    {
      lhsIter = lhs->iterator();
      lhsDone = lhsIter->atEnd();
      rhsIter = rhs->iterator();
      rhsDone = rhsIter->atEnd();
      updateBest();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0xe514(%rip), %rax      # 0x15938
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq (%rsi), %rsi
leaq -0x20(%rbp), %rdi
callq 0x5986
leaq 0x28(%rbx), %rdi
leaq -0x20(%rbp), %rsi
callq 0x75f4
leaq -0x18(%rbp), %rdi
callq 0x59d4
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x48(%rbx)
movq (%r14), %rsi
leaq -0x20(%rbp), %rdi
callq 0x5986
leaq 0x38(%rbx), %r14
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x75f4
leaq -0x18(%rbp), %rdi
callq 0x59d4
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x49(%rbx)
movq %rbx, %rdi
callq 0x74e2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x74af
jmp 0x74af
movq %rax, %r14
leaq 0x40(%rbx), %rdi
callq 0x59d4
leaq 0x30(%rbx), %rdi
callq 0x59d4
leaq 0x20(%rbx), %rdi
callq 0x59d4
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x59d4
movq %r14, %rdi
callq 0x43e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/iterator/MergeIterator.hpp
// Function: MergeIterator<Record>::next()
void next()
    {
      if(lhsDone && rhsDone) { return; }
      if(lhsBest) { lhsIter->next(); lhsDone = lhsIter->atEnd(); }
      else        { rhsIter->next(); rhsDone = rhsIter->atEnd(); }
      updateBest();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x48(%rdi)
jne 0x755a
cmpb $0x0, 0x49(%rbx)
je 0x755a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpb $0x1, 0x4a(%rbx)
jne 0x7579
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x48(%rbx)
jmp 0x7590
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x49(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x74e2
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/cog/BTreeCog.hpp
// Function: BTreeCog<Record>::printDebug(int)
void printDebug(int depth)
    {
      Cog<Tuple>::printPrefix(depth);
      std::cout << "BTree[" << sep << "]" << std::endl;
      lhs->printDebug(depth+1);
      rhs->printDebug(depth+1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x60cc
movq 0xe5ba(%rip), %rdi      # 0x15fc8
leaq 0x6789(%rip), %rsi      # 0xe19e
callq 0x4260
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x462c
leaq 0x6dd7(%rip), %rsi      # 0xe804
movq %rax, %rdi
callq 0x4260
movq %rax, %rdi
callq 0x4140
movq 0x20(%r14), %rdi
incl %ebx
movl %ebx, %esi
callq 0x5938
movq 0x30(%r14), %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x5938
nop
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/iterator/SeqIterator.hpp
// Function: SeqIterator<Record>::seek(Record const&)
void seek(const Tuple &k)
    {
      if(!(k < sep)) { lhsDone = true; }
      // check key first... may not need to init LHS.
      initNeeded();
      if(!lhsDone)     { lhsIter->seek(k); lhsDone = lhsIter->atEnd(); }
      else if(!rhsDone){ rhsIter->seek(k); rhsDone = rhsIter->atEnd(); }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x50(%rdi), %rax
jl 0x7b9a
movb $0x1, 0x48(%rbx)
movq %rbx, %rdi
callq 0x7bf6
cmpb $0x0, 0x48(%rbx)
je 0x7bca
cmpb $0x0, 0x49(%rbx)
jne 0x7be4
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x49(%rbx)
jmp 0x7be4
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x48(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/iterator/SeqIterator.hpp
// Function: SeqIterator<Record>::initNeeded()
inline void initNeeded()
    { 
      if(!lhsDone) {
        if(lhsIter.get() == NULL) { 
          lhsIter = lhs->iterator();
          lhsDone = lhsIter->atEnd();
        }
      }
      if(lhsDone)  {
        if(rhsIter.get() == NULL) { 
          rhsIter = rhs->iterator();
          rhsDone = rhsIter->atEnd();
        }
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb 0x48(%rdi), %al
testb %al, %al
jne 0x7c49
cmpq $0x0, 0x28(%rbx)
jne 0x7c49
leaq 0x28(%rbx), %r14
movq 0x8(%rbx), %rsi
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x5986
movq %r14, %rdi
movq %r15, %rsi
callq 0x75f4
leaq -0x20(%rbp), %rdi
callq 0x59d4
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x48(%rbx)
testb %al, %al
je 0x7c89
cmpq $0x0, 0x38(%rbx)
jne 0x7c89
leaq 0x38(%rbx), %r14
movq 0x18(%rbx), %rsi
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0x5986
movq %r14, %rdi
movq %r15, %rsi
callq 0x75f4
leaq -0x20(%rbp), %rdi
callq 0x59d4
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x49(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/src/jitd_tester.cpp
// Function: run_test_thread(JITD<Record, PureLocalPolicy<Record>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void run_test_thread(JITD<Record, JITD_TEST_POLICY> *jitd, string file, int per_op_sleep_ms)
{
  ifstream in(file);
  timeval start, end;
  gettimeofday(&start, NULL);
  cout << "Start[" << file << "]" << endl;
  int t = jitd_test(*jitd, in, false, per_op_sleep_ms);
  gettimeofday(&end, NULL);
  cout << "Time[" << file << "]: " << t << " s" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x240(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x4360
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x4370
movq 0xdd36(%rip), %rdi      # 0x15fc8
leaq 0x632e(%rip), %rsi      # 0xe5c7
callq 0x4260
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4210
leaq 0x6554(%rip), %rsi      # 0xe804
movq %rax, %rdi
callq 0x4260
movq %rax, %rdi
callq 0x4140
leaq -0x240(%rbp), %rsi
movq %r15, %rdi
xorl %edx, %edx
movl %r14d, %ecx
callq 0x8364
movl %eax, %r14d
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x4370
movq 0xdcdf(%rip), %rdi      # 0x15fc8
leaq 0x62de(%rip), %rsi      # 0xe5ce
callq 0x4260
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4210
leaq 0x62cd(%rip), %rsi      # 0xe5d4
movq %rax, %rdi
callq 0x4260
movq %rax, %rdi
movl %r14d, %esi
callq 0x43d0
leaq 0x62b7(%rip), %rsi      # 0xe5d8
movq %rax, %rdi
callq 0x4260
movq %rax, %rdi
callq 0x4140
leaq -0x240(%rbp), %rdi
callq 0x4060
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x834d
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x4060
movq %rbx, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/jitd.hpp
// Function: JITD<Record, PureLocalPolicy<Record>>::insert(std::shared_ptr<std::vector<Record, std::allocator<Record>>>)
void insert(Buffer<Tuple> records)
    {
      // Create a template for the new root structure
      ConcatCog<Tuple> *newRootCog = new ConcatCog<Tuple>(
        nullptr,
        CogHandle<Tuple>(new CogHandleBase<Tuple>(CogPtr<Tuple>(
          new ArrayCog<Tuple>(records))))
      );
      // newRootCog->lhs is a placeholder for the current root object
      
      // Define a new root handle to swap in
      CogHandle<Tuple> newRoot = 
        CogHandle<Tuple>(new CogHandleBase<Tuple>(CogPtr<Tuple>(newRootCog)));
      
      // As one atomic operation, perform:
      //   newRootCog->lhs = root
      //   root = newRoot
      swapInNewRoot(newRoot, newRootCog->lhs);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r13
movq %rdi, -0x48(%rbp)
pushq $0x30
popq %rdi
callq 0x4270
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
pushq $0x10
popq %rdi
callq 0x4270
movq %rax, %r15
pushq $0x30
popq %rdi
callq 0x4270
movq %rax, %r12
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x5a64
movb $0x1, %al
movl %eax, -0x2c(%rbp)
movb $0x1, %r13b
movq %r12, %rdi
movq %r14, %rsi
callq 0xa4fe
xorl %r13d, %r13d
leaq -0x78(%rbp), %rdi
movq %r12, %rsi
callq 0x6414
leaq -0x78(%rbp), %rsi
movq %r15, %rdi
callq 0x6510
leaq -0x98(%rbp), %rdi
movq %r15, %rsi
callq 0x6528
leaq -0x40(%rbp), %rsi
leaq -0x98(%rbp), %rdx
movq %rbx, %rdi
callq 0x5874
leaq -0x90(%rbp), %rdi
callq 0x59d4
leaq -0x70(%rbp), %rdi
callq 0x59d4
leaq -0x80(%rbp), %rdi
callq 0x59d4
leaq -0x38(%rbp), %rdi
callq 0x59d4
pushq $0x10
popq %rdi
callq 0x4270
movq %rax, %r15
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x7768
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x6510
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x6528
leaq -0x50(%rbp), %rdi
callq 0x59d4
addq $0x10, %rbx
leaq -0x68(%rbp), %rsi
movq -0x48(%rbp), %rdi
movq %rbx, %rdx
callq 0xa53c
leaq -0x60(%rbp), %rdi
callq 0x59d4
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x60(%rbp), %rdi
jmp 0x99db
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x59d4
jmp 0x9a50
movq %rax, %r14
pushq $0x10
popq %rsi
movq %r15, %rdi
jmp 0x9a4b
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x59d4
xorl %r13d, %r13d
movl $0x0, -0x2c(%rbp)
jmp 0x9a12
movq %rax, %r14
jmp 0x9a31
movq %rax, %r14
jmp 0x9a3c
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x59d4
testb %r13b, %r13b
je 0x9a2b
pushq $0x30
popq %rsi
movq %r12, %rdi
callq 0x4280
cmpb $0x0, -0x2c(%rbp)
je 0x9a3c
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x4280
leaq -0x38(%rbp), %rdi
callq 0x59d4
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x4280
movq %r14, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/jitd.hpp
// Function: JITD<Record, PureLocalPolicy<Record>>::remove(std::shared_ptr<std::vector<Record, std::allocator<Record>>>)
void remove(Buffer<Tuple> records)
    {
      DeleteCog<Tuple> *newRootCog = new DeleteCog<Tuple>(
        nullptr,
        CogHandle<Tuple>(new CogHandleBase<Tuple>(CogPtr<Tuple>(
          new ArrayCog<Tuple>(records))))
      );
      CogHandle<Tuple> newRoot = 
        CogHandle<Tuple>(new CogHandleBase<Tuple>(CogPtr<Tuple>(newRootCog)));
      swapInNewRoot(newRoot, newRootCog->source);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r13
movq %rdi, -0x48(%rbp)
pushq $0x30
popq %rdi
callq 0x4270
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
pushq $0x10
popq %rdi
callq 0x4270
movq %rax, %r15
pushq $0x30
popq %rdi
callq 0x4270
movq %rax, %r12
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x5a64
movb $0x1, %al
movl %eax, -0x2c(%rbp)
movb $0x1, %r13b
movq %r12, %rdi
movq %r14, %rsi
callq 0xa4fe
xorl %r13d, %r13d
leaq -0x78(%rbp), %rdi
movq %r12, %rsi
callq 0x6414
leaq -0x78(%rbp), %rsi
movq %r15, %rdi
callq 0x6510
leaq -0x98(%rbp), %rdi
movq %r15, %rsi
callq 0x6528
leaq -0x40(%rbp), %rsi
leaq -0x98(%rbp), %rdx
movq %rbx, %rdi
callq 0xa7a6
leaq -0x90(%rbp), %rdi
callq 0x59d4
leaq -0x70(%rbp), %rdi
callq 0x59d4
leaq -0x80(%rbp), %rdi
callq 0x59d4
leaq -0x38(%rbp), %rdi
callq 0x59d4
pushq $0x10
popq %rdi
callq 0x4270
movq %rax, %r15
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0xa852
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x6510
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x6528
leaq -0x50(%rbp), %rdi
callq 0x59d4
addq $0x10, %rbx
leaq -0x68(%rbp), %rsi
movq -0x48(%rbp), %rdi
movq %rbx, %rdx
callq 0xa53c
leaq -0x60(%rbp), %rdi
callq 0x59d4
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x60(%rbp), %rdi
jmp 0x9b95
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x59d4
jmp 0x9c0a
movq %rax, %r14
pushq $0x10
popq %rsi
movq %r15, %rdi
jmp 0x9c05
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x59d4
xorl %r13d, %r13d
movl $0x0, -0x2c(%rbp)
jmp 0x9bcc
movq %rax, %r14
jmp 0x9beb
movq %rax, %r14
jmp 0x9bf6
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x59d4
testb %r13b, %r13b
je 0x9be5
pushq $0x30
popq %rsi
movq %r12, %rdi
callq 0x4280
cmpb $0x0, -0x2c(%rbp)
je 0x9bf6
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x4280
leaq -0x38(%rbp), %rdi
callq 0x59d4
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x4280
movq %r14, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/policy/CrackOrSort.hpp
// Function: std::experimental::fundamentals_v1::optional<std::pair<int, std::function<bool (std::shared_ptr<Cog<Record>>&)>>> CrackOrSortArraysBigFirst<Record>(int, std::shared_ptr<Cog<Record>>)
ScoreFunctionReturn<Tuple> CrackOrSortArraysBigFirst(int threshold, CogPtr<Tuple> cog){ 
    if(cog->type != COG_ARRAY){ 
      // std::cerr << "Crack or Sort: Not an Array\n";
      return NO_TRANSFORMS; 
    }
    
    int size = cog->size();
    // std::cerr << "Crack or Sort: Size " << size << " / " << threshold << std::endl;
    // cog->printDebug(3);


    if(size > threshold){
      // std::cerr << "    ^--- Decided on Crack\n";
      return TRANSFORM_WITH(size, randomSplitArray<Tuple>);
    } else {
      // std::cerr << "    ^--- Decided on Sort\n";
      return TRANSFORM_WITH(size, sortArray<Tuple>);
    }

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
cmpl $0x3, 0x8(%rdi)
jne 0x9d91
movl %esi, %r14d
movq (%rdi), %rax
callq *0x8(%rax)
cmpl %r14d, %eax
jle 0x9da1
leaq -0x30(%rbp), %r14
movl %eax, -0x8(%r14)
andq $0x0, 0x8(%r14)
leaq 0x19a8(%rip), %rax      # 0xb737
jmp 0x9db5
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x9de2
leaq -0x30(%rbp), %r14
movl %eax, -0x8(%r14)
andq $0x0, 0x8(%r14)
leaq 0x1c56(%rip), %rax      # 0xba0b
movq %rax, (%r14)
leaq 0x1ed9(%rip), %rax      # 0xbc98
movq %rax, 0x18(%r14)
leaq 0x1edc(%rip), %rax      # 0xbca6
movq %rax, 0x10(%r14)
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xbcce
movq %r14, %rdi
callq 0xb06c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/policy/PureLocalPolicy.hpp
// Function: PureLocalPolicy<Record>::act()
inline bool act(){
      if(todos.empty()){ return false; }
      Action<Tuple> next = todos.top(); todos.pop();
      CogPtr<Tuple> target = next.target->get();
      CogPtr<Tuple> replacement = target;
      if(next.effect(replacement)){
        target->apply_to_children(std::bind(&PureLocalPolicy::dequeueCog, this, std::placeholders::_1));
        next.target->put(replacement);
        enqueueCog(next.target);
      }
      return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq (%rdi), %rbx
movq 0x8(%rdi), %r13
cmpq %r13, %rbx
je 0xa01f
movq %rdi, %r14
leaq -0xc0(%rbp), %rdi
movq %rbx, %rsi
callq 0xbea2
movq %r14, %rdi
callq 0xab1a
movq -0xc0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x7ed0
leaq -0x48(%rbp), %r15
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x6510
leaq -0xb0(%rbp), %rdi
movq %r15, %rsi
callq 0xbee4
testb %al, %al
je 0xa001
movq -0x38(%rbp), %r15
leaq 0x1f86(%rip), %rax      # 0xbefa
leaq -0xd8(%rbp), %rsi
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
movq %r14, 0x10(%rsi)
leaq -0x88(%rbp), %rdi
callq 0xb024
movq (%r15), %rax
leaq -0x88(%rbp), %rsi
movq %r15, %rdi
callq *0x10(%rax)
leaq -0x88(%rbp), %rdi
callq 0xb06c
movq -0xc0(%rbp), %r15
leaq -0x68(%rbp), %r12
leaq -0x48(%rbp), %rsi
movq %r12, %rdi
callq 0x6510
movq %r15, %rdi
movq %r12, %rsi
callq 0xa9d8
leaq -0x60(%rbp), %rdi
callq 0x59d4
leaq -0x58(%rbp), %r15
leaq -0xc0(%rbp), %rsi
movq %r15, %rdi
callq 0x5aa2
movq %r14, %rdi
movq %r15, %rsi
callq 0xab3e
leaq -0x50(%rbp), %rdi
callq 0x59d4
leaq -0x40(%rbp), %rdi
callq 0x59d4
leaq -0x30(%rbp), %rdi
callq 0x59d4
leaq -0xc0(%rbp), %rdi
callq 0xaea8
cmpq %r13, %rbx
setne %al
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0xa047
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x59d4
jmp 0xa064
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0xb06c
jmp 0xa064
jmp 0xa061
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x59d4
leaq -0x30(%rbp), %rdi
callq 0x59d4
jmp 0xa07d
jmp 0xa07a
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0xaea8
movq %rbx, %rdi
callq 0x43e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/jitd.hpp
// Function: JITD<Record, PureLocalPolicy<Record>>::iterator()
Iterator<Tuple> iterator()
    {
      // Root changes with each version, so we need to sync the pointer.
      CogHandle<Tuple> r = std::atomic_load(&root);
      
      // And grab an iterator on whatever falls out.
      return r->iterator();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0xbf2e
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x5986
leaq -0x18(%rbp), %rdi
callq 0x59d4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x59d4
movq %rbx, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/jitd.hpp
// Function: JITD<Record, PureLocalPolicy<Record>>::swapInNewRoot(std::shared_ptr<CogHandleBase<Record>>&, std::shared_ptr<CogHandleBase<Record>>&)
inline void swapInNewRoot(
      CogHandle<Tuple> &newRoot, CogHandle<Tuple> &placeholder
    ) {
      bool succeeded = false;
      while(!succeeded){
        placeholder = root;
        succeeded = std::atomic_compare_exchange_strong(
          &root,        // This value gets atomically replaced...
          &placeholder, // ... if this is currently its value
          newRoot       // This value replaces it.
        );
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x38(%rbp), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0xa66c
movq %r13, %rdi
movq %r15, %rsi
callq 0x5aa2
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xa620
movl %eax, %ebx
leaq -0x30(%rbp), %rdi
callq 0x59d4
testb %bl, %bl
je 0xa55a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x59d4
movq %rbx, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/cog/DeleteCog.hpp
// Function: DeleteCog<Record>::printDebug(int)
void printDebug(int depth)
    {
      Cog<Tuple>::printPrefix(depth);
      std::cout << "Delete" << std::endl;
      source->printDebug(depth+1);
      deleted->printDebug(depth+1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x60cc
movq 0xb7a6(%rip), %rdi      # 0x15fc8
leaq 0x4057(%rip), %rsi      # 0xe880
callq 0x4260
movq %rax, %rdi
callq 0x4140
movq 0x10(%r14), %rdi
incl %ebx
movl %ebx, %esi
callq 0x5938
movq 0x20(%r14), %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x5938
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/policy/PureLocalPolicy.hpp
// Function: PureLocalPolicy<Record>::enqueueCog(std::shared_ptr<CogHandleBase<Record>>)
inline void enqueueCog(CogHandle<Tuple> target)
    {
      // std::cerr << "Enqueue " << target << std::endl;
      CogPtr<Tuple> cog = target->get();
      std::experimental::optional<std::pair<Score,Transform<Tuple>>> op = score(cog);
      if(op){
        todos.emplace(
          target,
          op->second,
          op->first
        );        
      }
      cog->apply_to_children(std::bind(&PureLocalPolicy::enqueueCog, this, std::placeholders::_1));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x7ed0
leaq 0x20(%rbx), %r12
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x6510
leaq -0x98(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xafe2
leaq -0x40(%rbp), %rdi
callq 0x59d4
cmpb $0x1, -0x70(%rbp)
jne 0xabb4
leaq -0x90(%rbp), %rdx
leaq -0x98(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb004
movq -0x38(%rbp), %r14
leaq -0x81(%rip), %rax       # 0xab3e
leaq -0xb0(%rbp), %rsi
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
movq %rbx, 0x10(%rsi)
leaq -0x68(%rbp), %rdi
callq 0xb024
movq (%r14), %rax
leaq -0x68(%rbp), %rsi
movq %r14, %rdi
callq *0x10(%rax)
leaq -0x68(%rbp), %rdi
callq 0xb06c
leaq -0x98(%rbp), %rdi
callq 0xb08c
leaq -0x30(%rbp), %rdi
callq 0x59d4
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xac28
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xb06c
jmp 0xac2b
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0xb08c
jmp 0xac45
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x59d4
leaq -0x30(%rbp), %rdi
callq 0x59d4
movq %rbx, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/transform/transform_atomic.hpp
// Function: bool sortArray<Record>(std::shared_ptr<Cog<Record>>&)
bool sortArray(CogPtr<Tuple> &cog)
    {
      if(cog->type == COG_ARRAY){
        ArrayCog<Tuple> *arr = (ArrayCog<Tuple> *)cog.get();
        Buffer<Tuple> sorted = arr->sortedBuffer();
        cog = CogPtr<Tuple>(new SortedArrayCog<Tuple>(
          sorted, sorted->begin(), sorted->end()
        ));
        return true;
      }
      return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %rsi
movl 0x8(%rsi), %r13d
cmpl $0x3, %r13d
jne 0xba9c
movq %rdi, %rbx
leaq -0x38(%rbp), %rdi
callq 0x6104
pushq $0x30
popq %rdi
callq 0x4270
movq %rax, %r14
leaq -0x48(%rbp), %r15
leaq -0x38(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x5a64
movq (%r12), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x57f0
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x6c38
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0xbc5e
leaq -0x50(%rbp), %rdi
callq 0x59d4
leaq -0x40(%rbp), %rdi
callq 0x59d4
leaq -0x30(%rbp), %rdi
callq 0x59d4
cmpl $0x3, %r13d
sete %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x59d4
jmp 0xbac3
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x59d4
movq %rbx, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/include/data.hpp
// Function: std::pair<std::shared_ptr<std::vector<Record, std::allocator<Record>>>, std::shared_ptr<std::vector<Record, std::allocator<Record>>>> splitBuffer<Record>(std::vector<Record, std::allocator<Record>>::const_iterator, std::vector<Record, std::allocator<Record>>::const_iterator, Record const&)
inline std::pair<Buffer<Tuple>,Buffer<Tuple> > 
    splitBuffer(BufferElement<Tuple> curr, 
                BufferElement<Tuple> end, 
                const Tuple &pivot)
  {
    Buffer<Tuple> low (new std::vector<Tuple>);
    Buffer<Tuple> high(new std::vector<Tuple>);
    for(; curr < end; ++curr){
      if(*curr < pivot){ low ->push_back(*curr); }
      else             { high->push_back(*curr); }
    }
    return std::pair<Buffer<Tuple>,Buffer<Tuple> >(low, high);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, -0x30(%rbp)
pushq $0x18
popq %rbx
movq %rbx, %rdi
callq 0x4270
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x5d74
movq %rbx, %rdi
callq 0x4270
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5d74
cmpq %r15, %r12
jae 0xbbdd
movq (%r12), %rax
cmpq (%r14), %rax
movq %rbx, %rax
cmovlq %r13, %rax
movq (%rax), %rdi
movq %r12, %rsi
callq 0x578c
addq $0x10, %r12
jmp 0xbbb9
leaq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xbc38
leaq -0x38(%rbp), %rdi
callq 0x59d4
leaq -0x48(%rbp), %rdi
callq 0x59d4
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xbc26
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x59d4
leaq -0x48(%rbp), %rdi
callq 0x59d4
movq %rbx, %rdi
callq 0x43e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/UBOdin[P]jitd-cpp/src/driver.cpp
// Function: buffer_cmd(std::istream&)
RecordBuffer buffer_cmd(istream &toks)
{
  string fill;
  toks >> fill;

  if(string("random") == fill) {
    int len, max;
    toks >> len >> max;
    return build_buffer(len,max);        

  } else if(string("explicit") == fill) {
    return load_buffer(toks);
  
  } else if(string("file") == fill) {
    ifstream f;
    string filename;
    toks >> filename;
    f.open(filename);
    return load_buffer(f);        
    
  } else {
    cerr << "Invalid Fill Mode: " << fill << endl;
    exit(-1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x60(%rbp), %rsi
movq %r14, %rdi
callq 0x42e0
leaq 0xf4d(%rip), %rsi       # 0xe026
leaq -0x268(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x40d0
leaq -0x268(%rbp), %r15
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x5850
movl %eax, %r12d
movq %r15, %rdi
callq 0x4110
testb %r12b, %r12b
je 0xd13d
leaq -0x268(%rbp), %rsi
movq %r14, %rdi
callq 0x4160
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x4160
movl -0x268(%rbp), %esi
movl -0x40(%rbp), %edx
movq %rbx, %rdi
callq 0x4870
jmp 0xd212
leaq 0xee9(%rip), %rsi       # 0xe02d
leaq -0x268(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x40d0
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x5850
movl %eax, %r12d
movq %r15, %rdi
callq 0x4110
testb %r12b, %r12b
je 0xd180
movq %rbx, %rdi
movq %r14, %rsi
callq 0x490c
jmp 0xd212
leaq 0x1d39(%rip), %rsi      # 0xeec0
leaq -0x268(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x40d0
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x5850
movl %eax, %r12d
movq %r15, %rdi
callq 0x4110
testb %r12b, %r12b
je 0xd22e
leaq -0x268(%rbp), %rdi
callq 0x42b0
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x42e0
leaq -0x268(%rbp), %rdi
leaq -0x40(%rbp), %rsi
pushq $0x8
popq %rdx
callq 0x41f0
leaq -0x268(%rbp), %rsi
movq %rbx, %rdi
callq 0x490c
leaq -0x40(%rbp), %rdi
callq 0x4110
leaq -0x268(%rbp), %rdi
callq 0x4060
leaq -0x60(%rbp), %rdi
callq 0x4110
movq %rbx, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8dbb(%rip), %rdi      # 0x15ff0
leaq 0x1c89(%rip), %rsi      # 0xeec5
callq 0x4260
leaq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x4210
movq %rax, %rdi
callq 0x4140
pushq $-0x1
popq %rdi
callq 0x42d0
jmp 0xd281
jmp 0xd281
jmp 0xd281
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4110
leaq -0x268(%rbp), %rdi
callq 0x4060
jmp 0xd284
jmp 0xd281
jmp 0xd281
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/bendem[P]DiskGraph/src/term.cpp
// Function: exec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> exec(const string& cmd) {
    FILE* pipe = popen(cmd.c_str(), "r");
    if(!pipe) {
        throw exception();
    }
    char buffer[256];
    string result;
    while(!feof(pipe)) {
        if(fgets(buffer, 256, pipe) != NULL) {
            result += buffer;
        }
    }
    pclose(pipe);
    return split(result, '\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x143d(%rip), %rsi      # 0x514c
callq 0x2060
testq %rax, %rax
je 0x3db4
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x160(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %r14, %rdi
callq 0x2210
testl %eax, %eax
jne 0x3d69
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x2220
testq %rax, %rax
je 0x3d3b
movq %r12, %rdi
movq %r15, %rsi
callq 0x22c0
jmp 0x3d3b
movq %r14, %rdi
callq 0x21e0
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x21c0
leaq -0x60(%rbp), %rsi
pushq $0xa
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x40b3
leaq -0x60(%rbp), %rdi
callq 0x22e8
leaq -0x40(%rbp), %rdi
callq 0x22e8
movq %rbx, %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x20d0
movq 0x41ed(%rip), %rcx      # 0x7fb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x4207(%rip), %rsi      # 0x7fd8
movq 0x4218(%rip), %rdx      # 0x7ff0
movq %rax, %rdi
callq 0x2280
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x22e8
jmp 0x3df3
jmp 0x3df0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/bendem[P]DiskGraph/src/term.cpp
// Function: termSize()
TermSize termSize() {
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    TermSize ts;
    ts.height = w.ws_row;
    ts.width = w.ws_col;
    return ts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $0x1
popq %rdi
leaq -0x10(%rbp), %rbx
movl $0x5413, %esi           # imm = 0x5413
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21d0
movzwl (%rbx), %eax
movzwl 0x2(%rbx), %ecx
shlq $0x20, %rax
orq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/bendem[P]DiskGraph/src/string_manips.cpp
// Function: humanReadable[abi:cxx11](unsigned int)
pair<float, string> humanReadable(unsigned size) {
    if(size < 1024) {
        return pair<float, string> { size, human_readable_sizes[0] };
    }
    float res = size;
    unsigned i;
    for(i = 1; i < human_readable_sizes.size(); ++i) {
        res /= 1024;
        if(res < 1) {
            break;
        }
    }
    return pair<float, string>{ res*1024, human_readable_sizes[i] };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, -0xc(%rbp)
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x3fcd
movq 0x4809(%rip), %rdx      # 0x87c8
leaq -0xc(%rbp), %rsi
movq %rbx, %rdi
callq 0x4190
jmp 0x402e
movl %esi, %eax
cvtsi2ss %rax, %xmm0
movq 0x47f5(%rip), %rax      # 0x87d0
movq 0x47e6(%rip), %rsi      # 0x87c8
subq %rsi, %rax
sarq $0x5, %rax
pushq $0x1
popq %rdx
movss 0x115c(%rip), %xmm1     # 0x5150
movss 0x1158(%rip), %xmm2     # 0x5154
movl %edx, %ecx
cmpq %rcx, %rax
jbe 0x400f
mulss %xmm1, %xmm0
leal 0x1(%rcx), %edx
ucomiss %xmm0, %xmm2
jbe 0x3ffc
mulss 0x1141(%rip), %xmm0     # 0x5158
shlq $0x5, %rcx
addq %rcx, %rsi
movss %xmm0, (%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x21c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bendem[P]DiskGraph/src/string_manips.cpp
// Function: parseInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
unsigned parseInt(string str) {
    unsigned res = 0;
    for(unsigned i = 0; i < str.length(); ++i) {
        if(str[i] < '0' || str[i] > '9') {
            throw invalid_argument("NaN");
        }
        res = res * 10 + str[i] - '0';
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rcx
xorl %edx, %edx
xorl %eax, %eax
movl %edx, %edx
cmpq %rdx, %rcx
jbe 0x406b
movq (%rdi), %rsi
movzbl (%rsi,%rdx), %esi
leal -0x3a(%rsi), %r8d
cmpb $-0xb, %r8b
jbe 0x4070
imull $0xa, %eax, %eax
addl %esi, %eax
addl $-0x30, %eax
incl %edx
jmp 0x4047
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x10da(%rip), %rsi      # 0x515c
movq %rax, %rdi
callq 0x22b0
movq 0x3f3f(%rip), %rsi      # 0x7fd0
movq 0x3f28(%rip), %rdx      # 0x7fc0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/bendem[P]DiskGraph/src/string_manips.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, unsigned int)
vector<string> split(string str, char sep, unsigned default_size) {
    istringstream ss(str);
    string part;
    vector<string> vector;

    if(default_size != 0) {
        vector.reserve(default_size);
    }

    while(ss.peek() != EOF) {
        getline(ss, part, sep);
        if(part.length() != 0) {
            vector.push_back(part);
        }
    }

    return vector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %ecx, %r15d
movl %edx, %r14d
movq %rdi, %rbx
leaq -0x1b8(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2270
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
testl %r15d, %r15d
je 0x4106
movl %r15d, %esi
movq %rbx, %rdi
callq 0x41ac
leaq -0x1b8(%rbp), %rdi
callq 0x2080
cmpl $-0x1, %eax
je 0x4140
movsbl %r14b, %edx
leaq -0x1b8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x22a0
cmpq $0x0, -0x30(%rbp)
je 0x4106
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x4238
jmp 0x4106
leaq -0x38(%rbp), %rdi
callq 0x22e8
leaq -0x1b8(%rbp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4168
movq %rax, %r14
movq %rbx, %rdi
callq 0x37a8
leaq -0x38(%rbp), %rdi
callq 0x22e8
leaq -0x1b8(%rbp), %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/bendem[P]DiskGraph/src/table.cpp
// Function: Table::Table(unsigned int)
Table::Table(unsigned columns) : columns(columns) {
    this->line_sizes.reserve(columns);
    for(unsigned i = 0; i < columns; ++i) {
        this->line_sizes.push_back(0);
    }
    this->lines.reserve(columns);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x20(%rdi), %r14
movl %esi, %r12d
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %r14, %rdi
movq %r12, %rsi
callq 0x473e
leaq -0x2c(%rbp), %r13
subl $0x1, %r15d
jb 0x4467
andl $0x0, -0x2c(%rbp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x3b78
jmp 0x4450
movq %rbx, %rdi
movq %r12, %rsi
callq 0x47d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4483
movq %rax, %r15
movq %r14, %rdi
callq 0x3b54
movq %rbx, %rdi
callq 0x3976
movq %r15, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/bendem[P]DiskGraph/src/table.cpp
// Function: Table::addLine(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
Table& Table::addLine(vector<string> line) {
    if(line.size() != this->columns) {
        throw invalid_argument("invalid number of columns");
    }
    this->lines.push_back(line);
    for(unsigned i = 0; i < this->columns; ++i) {
        if(this->line_sizes[i] < line[i].length()) {
            this->line_sizes[i] = line[i].length();
        }
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x5, %rax
movl (%rdi), %ecx
cmpq %rcx, %rax
jne 0x44fa
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0x486e
movq 0x20(%r14), %rax
pushq $0x8
popq %rcx
xorl %edx, %edx
movl (%r14), %esi
cmpq %rsi, %rdx
jae 0x44f2
movl (%rax,%rdx,4), %edi
movq (%rbx), %rsi
movq (%rsi,%rcx), %rsi
cmpq %rdi, %rsi
jbe 0x44e9
movl %esi, (%rax,%rdx,4)
incq %rdx
addq $0x20, %rcx
jmp 0x44cf
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0xc64(%rip), %rsi       # 0x5170
movq %rax, %rdi
callq 0x22b0
movq 0x3ab5(%rip), %rsi      # 0x7fd0
movq 0x3a9e(%rip), %rdx      # 0x7fc0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/bendem[P]DiskGraph/src/table.cpp
// Function: Table::getLine[abi:cxx11](unsigned int) const
string Table::getLine(unsigned column) const {
    ostringstream ss;
    for(unsigned i = 0; i < this->columns; ++i) {
        ss << ' ';
        ss << this->lines[column][i];
        int diff = (int) (this->line_sizes[i] - this->lines[column][i].length());
        if(diff > 0) {
            for (; diff != 0; --diff) {
                ss << ' ';
            }
        }
    }
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, -0x38(%rbp)
leaq -0x1c0(%rbp), %r15
movq %r15, %rdi
callq 0x21b0
movl %r12d, %eax
xorl %ecx, %ecx
pushq $0x20
popq %r12
imulq $0x18, %rax, %r14
movq %r14, -0x48(%rbp)
movq %r13, -0x40(%rbp)
movl (%r13), %eax
movq %rcx, -0x30(%rbp)
cmpq %rax, %rcx
jae 0x4635
movq %r15, %rdi
movl %r12d, %esi
callq 0x2190
movq -0x30(%rbp), %r15
movq 0x8(%r13), %rax
movq %r15, %rbx
shlq $0x5, %rbx
movq (%rax,%r14), %rsi
addq %rbx, %rsi
leaq -0x1c0(%rbp), %rdi
callq 0x2140
leaq -0x1c0(%rbp), %rdx
movq 0x8(%r13), %rcx
movq 0x20(%r13), %rax
movl (%rax,%r15,4), %eax
movq (%rcx,%r14), %rcx
movl 0x8(%rcx,%rbx), %ebx
movl %eax, %ecx
subl %ebx, %ecx
testl %ecx, %ecx
movq %rdx, %r15
jle 0x4621
subl %eax, %ebx
movq %r15, %rdi
movl %r12d, %esi
callq 0x2190
incl %ebx
jne 0x4612
movq -0x30(%rbp), %rcx
incq %rcx
movq -0x48(%rbp), %r14
movq -0x40(%rbp), %r13
jmp 0x45b0
leaq -0x1b8(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x2230
leaq -0x1c0(%rbp), %rdi
callq 0x2030
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x466d
jmp 0x466d
movq %rax, %rbx
leaq -0x1c0(%rbp), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/bendem[P]DiskGraph/src/table.cpp
// Function: Table::toString[abi:cxx11]() const
string Table::toString() const {
    ostringstream ss;

    for(unsigned i = 0; i < this->columns; ++i) {
        ss << getLine(i) << endl;
    }

    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1c0(%rbp), %r15
movq %r15, %rdi
callq 0x21b0
xorl %r12d, %r12d
leaq -0x48(%rbp), %r13
cmpl (%r14), %r12d
jae 0x46e7
movq %r13, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x456e
movq %r15, %rdi
movq %r13, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x20c0
movq %r13, %rdi
callq 0x22e8
incl %r12d
jmp 0x46b4
leaq -0x1b8(%rbp), %rsi
movq %rbx, %rdi
callq 0x2230
leaq -0x1c0(%rbp), %rdi
callq 0x2030
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4719
movq %rax, %rbx
jmp 0x472a
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x22e8
leaq -0x1c0(%rbp), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/diegofilbal[P]YourJam/src/lista.cpp
// Function: Lista::insereFim(Lista const&)
bool Lista::insereFim(Lista const &lista_musicas){

    if(lista_musicas.getTamanho() > 0){ // Verifica se a lista não está vazia

        for(int i = 0; i < lista_musicas.getTamanho(); i++){ // Percorre cada música da lista e a adiciona ao sistema
            if(!insereFim(*lista_musicas.buscaMusicaPos(i))){ // Informa que a música atual já estava cadastrada no sistema
                std::cout << "A música " << lista_musicas.buscaMusicaPos(i)->getNome() << " de " << lista_musicas.buscaMusicaPos(i)->getArtista() << " já foi inserida!" << std::endl;
            }
        }
        return true; // Retorna código de sucesso
    }
    return false; // Lista vazia, retorna código de erro
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl 0x10(%rsi), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
jle 0x2506
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq -0xb0(%rbp), %r12
movl -0x2c(%rbp), %eax
cmpl %eax, %r15d
jge 0x2506
movq %rbx, %rdi
movl %r15d, %esi
callq 0x29dc
movq %r12, %rdi
movq %rax, %rsi
callq 0x32fc
movq %r14, %rdi
movq %r12, %rsi
callq 0x27f4
movl %eax, %r13d
movq %r12, %rdi
callq 0xafd4
testb %r13b, %r13b
jne 0x24f4
movq %r14, %r12
movq 0xeb73(%rip), %rdi      # 0x10fd0
leaq 0x9faa(%rip), %rsi      # 0xc40e
callq 0x2110
movq %rax, %r13
movq %rbx, %rdi
movl %r15d, %esi
callq 0x29dc
leaq -0x70(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xaff4
movq %r13, %rdi
movq %r14, %rsi
callq 0x20f0
movq %rax, %rdi
leaq 0xa3a2(%rip), %rsi      # 0xc83d
callq 0x2110
movq %rax, %r13
movq %rbx, %rdi
movl %r15d, %esi
callq 0x29dc
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xb016
movq %r13, %rdi
movq %r14, %rsi
callq 0x20f0
movq %r12, %r14
movq %rax, %rdi
leaq 0x9b2f(%rip), %rsi      # 0xc004
callq 0x2110
movq %rax, %rdi
callq 0x2080
leaq -0x50(%rbp), %rdi
callq 0x2070
leaq -0x70(%rbp), %rdi
callq 0x2070
incl %r15d
movl 0x10(%rbx), %eax
leaq -0xb0(%rbp), %r12
jmp 0x2415
cmpl $0x0, -0x2c(%rbp)
setg %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2532
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0xafd4
jmp 0x254c
movq %rax, %rbx
jmp 0x2543
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2070
leaq -0x70(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x21a0