LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/pelrun[P]aft/rs232.c
// Function: RS232_disableDTR
void RS232_disableDTR(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status &= ~TIOCM_DTR;    /* turn off DTR */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa159
leaq 0xc(%rsp), %rdx
andb $-0x3, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa167
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6abd(%rip), %rdi      # 0x10c1d
callq 0x3230
jmp 0xa138
leaq 0x6ac8(%rip), %rdi      # 0x10c36
callq 0x3230
jmp 0xa153
// File: /workspace/github_cpp_makefile_star2_O1/pelrun[P]aft/rs232.c
// Function: RS232_enableRTS
void RS232_enableRTS(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status |= TIOCM_RTS;    /* turn on RTS */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa1b3
leaq 0xc(%rsp), %rdx
orb $0x4, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa1c1
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6a63(%rip), %rdi      # 0x10c1d
callq 0x3230
jmp 0xa192
leaq 0x6a6e(%rip), %rdi      # 0x10c36
callq 0x3230
jmp 0xa1ad
// File: /workspace/github_cpp_makefile_star2_O1/pelrun[P]aft/rs232.c
// Function: RS232_disableRTS
void RS232_disableRTS(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status &= ~TIOCM_RTS;    /* turn off RTS */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa20d
leaq 0xc(%rsp), %rdx
andb $-0x5, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa21b
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6a09(%rip), %rdi      # 0x10c1d
callq 0x3230
jmp 0xa1ec
leaq 0x6a14(%rip), %rdi      # 0x10c36
callq 0x3230
jmp 0xa207
// File: /workspace/github_cpp_makefile_star2_O1/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::reader_lock()
void RWLock::reader_lock()
{
  unique_lock<std::mutex> l(lock);
  if(writers.load() || write_waiters.load())
  {
    read_waiters.fetch_add(1);
    do { read.wait(l); }
    while(writers.load() || write_waiters.load());
    read_waiters.fetch_sub(1);
  }
  readers.fetch_add(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
leaq -0x28(%rbp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x4cd6
movb $0x1, 0x8(%r14)
movl 0x4(%rbx), %eax
testl %eax, %eax
jne 0x4b43
movl 0xc(%rbx), %eax
testl %eax, %eax
je 0x4b6c
lock
incl 0x8(%rbx)
leaq 0x38(%rbx), %r14
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4090
movl 0x4(%rbx), %eax
testl %eax, %eax
jne 0x4b4f
movl 0xc(%rbx), %eax
testl %eax, %eax
jne 0x4b4f
lock
decl 0x8(%rbx)
lock
incl (%rbx)
leaq -0x28(%rbp), %rdi
callq 0x4cbc
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::reader_release()
void RWLock::reader_release()
{
  unique_lock<std::mutex> l(lock);
  readers.fetch_sub(1);
  if(writers.load() > 0){
    write.notify_all();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x4cd6
movb $0x1, 0x8(%r14)
lock
decl (%rbx)
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x4bc5
addq $0x68, %rbx
movq %rbx, %rdi
callq 0x43d0
leaq -0x20(%rbp), %rdi
callq 0x4cbc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::writer_lock()
void RWLock::writer_lock()
{
  unique_lock<std::mutex> l(lock);
  if(readers.load() || writers.load()){
    write_waiters.fetch_add(1);
    do { write.wait(l); }
    while(readers.load() || writers.load());
    write_waiters.fetch_sub(1);
  }
  writers.store(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
leaq -0x28(%rbp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x4cd6
movb $0x1, 0x8(%r14)
movl (%rbx), %eax
testl %eax, %eax
jne 0x4c12
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x4c3a
lock
incl 0xc(%rbx)
leaq 0x68(%rbx), %r14
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4090
movl (%rbx), %eax
testl %eax, %eax
jne 0x4c1e
movl 0x4(%rbx), %eax
testl %eax, %eax
jne 0x4c1e
lock
decl 0xc(%rbx)
movl $0x1, %eax
xchgl %eax, 0x4(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x4cbc
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::writer_release()
void RWLock::writer_release()
{
  unique_lock<std::mutex> l(lock);
  writers.store(0);
  if(write_waiters.load()){
    write.notify_all();
  } else if(read_waiters.load()){
    read.notify_all();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x4cd6
movb $0x1, 0x8(%r14)
xorl %eax, %eax
xchgl %eax, 0x4(%rbx)
movl 0xc(%rbx), %ecx
movl $0x68, %eax
testl %ecx, %ecx
jne 0x4c9e
movl 0x8(%rbx), %ecx
movl $0x38, %eax
testl %ecx, %ecx
je 0x4ca9
addq %rax, %rbx
movq %rbx, %rdi
callq 0x43d0
leaq -0x20(%rbp), %rdi
callq 0x4cbc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/UBOdin[P]jitd-cpp/src/cog_tester.cpp
// Function: build_buffer(int, int)
RecordBuffer build_buffer(int len, int max)
{
  int i;
  RecordBuffer buff(new std::vector<Record>(len));
  for(i = 0; i < len; i++){
    (*buff)[i].key = rand() % max;
    (*buff)[i].value = (Value)0xDEADBEEF;
  }
  return buff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r12d
movq %rdi, %r14
movl $0x18, %edi
callq 0x4270
movq %rax, %r15
movslq %r12d, %rsi
movb $0x1, %r13b
leaq -0x29(%rbp), %rdx
movq %rax, %rdi
callq 0x66b2
movq %r15, (%r14)
leaq 0x8(%r14), %rdi
xorl %r13d, %r13d
movq %r15, %rsi
callq 0x6a04
testl %r12d, %r12d
jle 0x4ddb
movl %r12d, %r15d
shlq $0x4, %r15
xorl %r12d, %r12d
movl $0xdeadbeef, %r13d      # imm = 0xDEADBEEF
callq 0x4070
cltd
idivl %ebx
movslq %edx, %rax
movq (%r14), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx,%r12)
movq %r13, 0x8(%rcx,%r12)
addq $0x10, %r12
cmpq %r12, %r15
jne 0x4db8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testb %r13b, %r13b
je 0x4e02
movl $0x18, %esi
movq %r15, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
callq 0x4270
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%rbx)
leaq 0x8(%rbx), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x6a04
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movl $0xdeadbeef, %eax       # imm = 0xDEADBEEF
movq %rax, -0x28(%rbp)
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x4ea9
leaq -0x30(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x4290
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4e92
movaps -0x30(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rdi)
jmp 0x4e9a
movq %r12, %rdx
callq 0x6aea
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
je 0x4e6c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4ec9
callq 0x6810
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x4d5c
movq (%r14), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x50da
movq %r15, %rax
subq %r14, %rax
sarq $0x4, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x73ee
movq %r14, %rdi
movq %r15, %rsi
callq 0x74f3
movl $0x10, %edi
callq 0x4270
movq %rax, %r14
movl $0x30, %edi
callq 0x4270
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r15
testq %r15, %r15
je 0x5115
movq 0x13ebb(%rip), %rdx     # 0x18fc0
cmpb $0x0, (%rdx)
je 0x5110
incl 0x8(%r15)
jmp 0x5115
lock
incl 0x8(%r15)
movq -0x30(%rbp), %rsi
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
movl $0x4, 0x8(%rax)
leaq 0x13722(%rip), %rdi     # 0x18850
movq %rdi, (%rax)
movq %rcx, 0x10(%rax)
movq %r15, 0x18(%rax)
testq %r15, %r15
je 0x5155
movq 0x13e7b(%rip), %rcx     # 0x18fc0
cmpb $0x0, (%rcx)
je 0x5150
incl 0x8(%r15)
jmp 0x5155
lock
incl 0x8(%r15)
movq %rdx, 0x20(%rax)
movq %rsi, 0x28(%rax)
leaq -0x38(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x79b4
movq -0x40(%rbp), %rax
movq %rax, (%r14)
movq -0x38(%rbp), %rax
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x5196
movq 0x13e38(%rip), %rcx     # 0x18fc0
cmpb $0x0, (%rcx)
je 0x5192
incl 0x8(%rax)
jmp 0x5196
lock
incl 0x8(%rax)
movq %r14, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x731a
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x51b3
callq 0x6810
testq %r15, %r15
je 0x51c0
movq %r15, %rdi
callq 0x6810
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x51ce
callq 0x6810
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x51ef
callq 0x6810
xorl %r12d, %r12d
jmp 0x51fa
movq %rax, %rbx
movb $0x1, %r12b
testq %r15, %r15
je 0x520f
movq %r15, %rdi
callq 0x6810
jmp 0x520f
movq %rax, %rbx
movb $0x1, %r12b
testb %r12b, %r12b
je 0x5226
movl $0x10, %esi
movq %r14, %rdi
callq 0x4280
jmp 0x5226
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x5234
callq 0x6810
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/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
testl %esi, %esi
jle 0x6d0a
movl %esi, %r14d
incl %r14d
movq 0x122de(%rip), %r15     # 0x18fc8
leaq 0xa548(%rip), %r12      # 0x11239
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x42d0
decl %r14d
cmpl $0x1, %r14d
jg 0x6cf1
movq 0x122b7(%rip), %r14     # 0x18fc8
leaq 0xa547(%rip), %rsi      # 0x1125f
movl $0x6, %edx
movq %r14, %rdi
callq 0x42d0
movq 0x28(%rbx), %rsi
subq 0x20(%rbx), %rsi
sarq $0x4, %rsi
movq %r14, %rdi
callq 0x4230
leaq 0xa4fc(%rip), %rsi      # 0x1123c
movl $0xf, %edx
movq %rax, %rdi
callq 0x42d0
movq 0x20(%rbx), %r15
cmpq %r15, 0x28(%rbx)
je 0x6da6
xorl %r12d, %r12d
leaq 0xa4eb(%rip), %r13      # 0x1124c
movq 0x12260(%rip), %r14     # 0x18fc8
xorl %edx, %edx
testl %r12d, %r12d
setne %dl
movq %r13, %rsi
leaq 0xab82(%rip), %rax      # 0x118fc
cmoveq %rax, %rsi
addl %edx, %edx
movq %r14, %rdi
callq 0x42d0
movq (%r15), %rsi
movq %r14, %rdi
callq 0x4230
addq $0x10, %r15
cmpl $0x4, %r12d
ja 0x6da6
incl %r12d
cmpq 0x28(%rbx), %r15
jne 0x6d68
cmpq 0x28(%rbx), %r15
je 0x6dc4
movq 0x12215(%rip), %rdi     # 0x18fc8
leaq 0xa495(%rip), %rsi      # 0x1124f
movl $0x5, %edx
callq 0x42d0
movq 0x121fd(%rip), %rdi     # 0x18fc8
leaq 0xa483(%rip), %rsi      # 0x11255
movl $0x3, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %rcx
cmpq %rax, %rcx
jbe 0x714a
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movl $0x1, %esi
cmpq %rdx, (%rax)
jge 0x7149
movq %rax, 0x18(%rdi)
movl %esi, %r8d
shlq $0x4, %r8
addq %r8, %rax
addl %esi, %esi
cmpq %rcx, %rax
jb 0x712f
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x829e
leal 0x1(%rbx), %r13d
movq 0x10d4a(%rip), %r15     # 0x18fc8
leaq 0x8fb4(%rip), %r12      # 0x11239
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x42d0
decl %r13d
cmpl $0x1, %r13d
jg 0x8285
movq 0x10d23(%rip), %r15     # 0x18fc8
leaq 0x901f(%rip), %rsi      # 0x112cb
movl $0x6, %edx
movq %r15, %rdi
callq 0x42d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4250
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4190
movq 0x10(%r14), %r15
incl %ebx
leaq -0x2a(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x8315
movq 0x10cbb(%rip), %rax     # 0x18fc0
cmpb $0x0, (%rax)
je 0x8310
incl 0x8(%r15)
jmp 0x8315
lock
incl 0x8(%r15)
leaq -0x2a(%rbp), %rdi
callq 0x42e0
movq (%r12), %rax
movq %r12, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0x8337
movq %r15, %rdi
callq 0x6810
movq 0x20(%r14), %r15
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r14
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x836a
movq 0x10c66(%rip), %rax     # 0x18fc0
cmpb $0x0, (%rax)
je 0x8365
incl 0x8(%r15)
jmp 0x836a
lock
incl 0x8(%r15)
leaq -0x2c(%rbp), %rdi
callq 0x42e0
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0x838b
movq %r15, %rdi
callq 0x6810
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x839c
movq %rax, %rbx
testq %r15, %r15
je 0x83ac
movq %r15, %rdi
callq 0x6810
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10560(%rip), %rax     # 0x18930
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq (%rsi), %r15
leaq -0x22(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x8418
movq 0x10bb8(%rip), %rax     # 0x18fc0
cmpb $0x0, (%rax)
je 0x8413
incl 0x8(%r15)
jmp 0x8418
lock
incl 0x8(%r15)
leaq -0x22(%rbp), %rdi
callq 0x42e0
movq (%r12), %rax
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq *(%rax)
testq %r15, %r15
je 0x843b
movq %r15, %rdi
callq 0x6810
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq 0x30(%rbx), %rdi
movups %xmm0, 0x28(%rbx)
testq %rdi, %rdi
je 0x8458
callq 0x6810
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x8466
callq 0x6810
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x48(%rbx)
movq (%r14), %r15
leaq -0x22(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r14
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x84a5
movq 0x10b2b(%rip), %rax     # 0x18fc0
cmpb $0x0, (%rax)
je 0x84a0
incl 0x8(%r15)
jmp 0x84a5
lock
incl 0x8(%r15)
leaq -0x22(%rbp), %rdi
callq 0x42e0
movq (%r14), %rax
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq *(%rax)
testq %r15, %r15
je 0x84c7
movq %r15, %rdi
callq 0x6810
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq 0x40(%rbx), %rdi
movups %xmm0, 0x38(%rbx)
testq %rdi, %rdi
je 0x84e4
callq 0x6810
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x84f2
callq 0x6810
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x49(%rbx)
movb 0x48(%rbx), %cl
orb %cl, %al
je 0x850b
xorb $0x1, %cl
jmp 0x8529
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rcx
cmpq (%rax), %rcx
setl %cl
movb %cl, 0x4a(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x853b
movq %rax, %r14
testq %r15, %r15
je 0x8550
movq %r15, %rdi
callq 0x6810
jmp 0x8550
movq %rax, %r14
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x855e
callq 0x6810
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x856c
callq 0x6810
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x857a
callq 0x6810
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x8588
callq 0x6810
movq %r14, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x48(%rdi)
jne 0x85c0
cmpb $0x0, 0x49(%rbx)
jne 0x8629
cmpb $0x1, 0x4a(%rbx)
jne 0x85df
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 0x85f6
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x49(%rbx)
cmpb $0x0, 0x48(%rbx)
je 0x8600
xorl %eax, %eax
jmp 0x8626
movb $0x1, %al
cmpb $0x0, 0x49(%rbx)
jne 0x8626
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rcx
cmpq (%rax), %rcx
setl %al
movb %al, 0x4a(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x8c26
leal 0x1(%rbx), %r13d
movq 0x103c2(%rip), %r15     # 0x18fc8
leaq 0x862c(%rip), %r12      # 0x11239
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x42d0
decl %r13d
cmpl $0x1, %r13d
jg 0x8c0d
movq 0x1039b(%rip), %r15     # 0x18fc8
leaq 0x869e(%rip), %rsi      # 0x112d2
movl $0x6, %edx
movq %r15, %rdi
callq 0x42d0
leaq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x4aec
movq %rax, %r15
leaq 0x8562(%rip), %rsi      # 0x111b9
movl $0x1, %edx
movq %rax, %rdi
callq 0x42d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4250
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4190
movq 0x20(%r14), %r15
incl %ebx
leaq -0x2a(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x8cc0
movq 0x10310(%rip), %rax     # 0x18fc0
cmpb $0x0, (%rax)
je 0x8cbb
incl 0x8(%r15)
jmp 0x8cc0
lock
incl 0x8(%r15)
leaq -0x2a(%rbp), %rdi
callq 0x42e0
movq (%r12), %rax
movq %r12, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0x8ce2
movq %r15, %rdi
callq 0x6810
movq 0x30(%r14), %r15
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r14
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x8d15
movq 0x102bb(%rip), %rax     # 0x18fc0
cmpb $0x0, (%rax)
je 0x8d10
incl 0x8(%r15)
jmp 0x8d15
lock
incl 0x8(%r15)
leaq -0x2c(%rbp), %rdi
callq 0x42e0
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0x8d36
movq %r15, %rdi
callq 0x6810
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8d47
movq %rax, %rbx
testq %r15, %r15
je 0x8d57
movq %r15, %rdi
callq 0x6810
movq %rbx, %rdi
callq 0x4400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8fa0
movb $0x1, 0x48(%rbx)
movq %rbx, %rdi
callq 0x8ffc
cmpb $0x0, 0x48(%rbx)
je 0x8fd0
cmpb $0x0, 0x49(%rbx)
jne 0x8fea
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 0x8fea
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_O1/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
cmpb $0x0, 0x48(%rdi)
jne 0x90ae
cmpq $0x0, 0x28(%rbx)
jne 0x90ae
movq 0x8(%rbx), %r14
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x4340
movq (%r14), %r15
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x9054
movq 0xff7c(%rip), %rax      # 0x18fc0
cmpb $0x0, (%rax)
je 0x904f
incl 0x8(%r14)
jmp 0x9054
lock
incl 0x8(%r14)
leaq -0x30(%rbp), %rdi
callq 0x42e0
movq (%r15), %rax
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
callq *(%rax)
testq %r14, %r14
je 0x9076
movq %r14, %rdi
callq 0x6810
movaps -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x30(%rbp)
movq 0x30(%rbx), %rdi
movups %xmm0, 0x28(%rbx)
testq %rdi, %rdi
je 0x9093
callq 0x6810
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x90a1
callq 0x6810
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x48(%rbx)
cmpb $0x1, 0x48(%rbx)
jne 0x9150
cmpq $0x0, 0x38(%rbx)
jne 0x9150
movq 0x18(%rbx), %r14
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x4340
movq (%r14), %r15
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x90f6
movq 0xfeda(%rip), %rax      # 0x18fc0
cmpb $0x0, (%rax)
je 0x90f1
incl 0x8(%r14)
jmp 0x90f6
lock
incl 0x8(%r14)
leaq -0x30(%rbp), %rdi
callq 0x42e0
movq (%r15), %rax
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
callq *(%rax)
testq %r14, %r14
je 0x9118
movq %r14, %rdi
callq 0x6810
movaps -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x30(%rbp)
movq 0x40(%rbx), %rdi
movups %xmm0, 0x38(%rbx)
testq %rdi, %rdi
je 0x9135
callq 0x6810
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x9143
callq 0x6810
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
jmp 0x915d
movq %rax, %rbx
testq %r14, %r14
je 0x916d
movq %r14, %rdi
callq 0x6810
movq %rbx, %rdi
callq 0x4400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x248(%rbp), %rdi
movl $0x8, %edx
callq 0x4370
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x4380
movq 0xf682(%rip), %rdi      # 0x18fc8
leaq 0x7db2(%rip), %rsi      # 0x116ff
movl $0x6, %edx
callq 0x42d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xf663(%rip), %rdi      # 0x18fc8
callq 0x42d0
movq %rax, %r12
leaq 0x7845(%rip), %rsi      # 0x111b9
movl $0x1, %edx
movq %rax, %rdi
callq 0x42d0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x4250
movsbl %al, %esi
movq %r12, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4190
leaq -0x248(%rbp), %rsi
movq %r15, %rdi
xorl %edx, %edx
movl %r14d, %ecx
callq 0x9a8b
movl %eax, %r14d
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x4380
movq 0xf5f6(%rip), %rdi      # 0x18fc8
leaq 0x7d2d(%rip), %rsi      # 0x11706
movl $0x5, %edx
callq 0x42d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xf5d7(%rip), %rdi      # 0x18fc8
callq 0x42d0
movq %rax, %rbx
leaq 0x7d0c(%rip), %rsi      # 0x1170c
movl $0x3, %edx
movq %rax, %rdi
callq 0x42d0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x43f0
movq %rax, %rbx
leaq 0x7cee(%rip), %rsi      # 0x11710
movl $0x2, %edx
movq %rax, %rdi
callq 0x42d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4190
leaq -0x248(%rbp), %rdi
callq 0x4060
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9a74
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x4060
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
movq (%rdx), %rdi
cmpl $0x3, 0x8(%rdi)
jne 0xc2d8
movl %esi, %r14d
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
leaq 0x27a4(%rip), %rcx      # 0xea6a
movq %rcx, 0x20(%rbx)
cmpl %r14d, %eax
jle 0xc2e8
leaq 0x204b(%rip), %rax      # 0xe321
jmp 0xc2ef
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0xc30a
leaq 0x24ad(%rip), %rax      # 0xe79c
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x2776(%rip), %rax      # 0xea78
movq %rax, 0x18(%rbx)
movb $0x1, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x22(%rbp), %rdi
callq 0x4340
movq (%rbx), %r15
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xc7bd
movq 0xc811(%rip), %rax      # 0x18fc0
cmpb $0x0, (%rax)
je 0xc7b9
incl 0x8(%rbx)
jmp 0xc7bd
lock
incl 0x8(%rbx)
leaq -0x22(%rbp), %rdi
callq 0x42e0
leaq -0x24(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0xc7f5
movq 0xc7db(%rip), %rax      # 0x18fc0
cmpb $0x0, (%rax)
je 0xc7f0
incl 0x8(%r15)
jmp 0xc7f5
lock
incl 0x8(%r15)
leaq -0x24(%rbp), %rdi
callq 0x42e0
movq (%r12), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *(%rax)
testq %r15, %r15
je 0xc817
movq %r15, %rdi
callq 0x6810
testq %rbx, %rbx
je 0xc824
movq %rbx, %rdi
callq 0x6810
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
testq %r15, %r15
je 0xc844
movq %r15, %rdi
callq 0x6810
testq %rbx, %rbx
je 0xc851
movq %rbx, %rdi
callq 0x6810
movq %r14, %rdi
callq 0x4400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0xd176
leal 0x1(%rbx), %r13d
movq 0xbe72(%rip), %r15      # 0x18fc8
leaq 0x40dc(%rip), %r12      # 0x11239
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x42d0
decl %r13d
cmpl $0x1, %r13d
jg 0xd15d
movq 0xbe4b(%rip), %r15      # 0x18fc8
leaq 0x4767(%rip), %rsi      # 0x118eb
movl $0x6, %edx
movq %r15, %rdi
callq 0x42d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4250
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4190
movq 0x10(%r14), %r15
incl %ebx
leaq -0x2a(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0xd1ed
movq 0xbde3(%rip), %rax      # 0x18fc0
cmpb $0x0, (%rax)
je 0xd1e8
incl 0x8(%r15)
jmp 0xd1ed
lock
incl 0x8(%r15)
leaq -0x2a(%rbp), %rdi
callq 0x42e0
movq (%r12), %rax
movq %r12, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0xd20f
movq %r15, %rdi
callq 0x6810
movq 0x20(%r14), %r15
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r14
movq 0x8(%r15), %r15
testq %r15, %r15
je 0xd242
movq 0xbd8e(%rip), %rax      # 0x18fc0
cmpb $0x0, (%rax)
je 0xd23d
incl 0x8(%r15)
jmp 0xd242
lock
incl 0x8(%r15)
leaq -0x2c(%rbp), %rdi
callq 0x42e0
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0xd263
movq %r15, %rdi
callq 0x6810
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd274
movq %rax, %rbx
testq %r15, %r15
je 0xd284
movq %r15, %rdi
callq 0x6810
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %rbx
leaq -0x80(%rbp), %rdi
movq %rbx, %rsi
callq 0x4340
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xd4cd
movq 0xbb01(%rip), %rax      # 0x18fc0
cmpb $0x0, (%rax)
je 0xd4c9
incl 0x8(%rbx)
jmp 0xd4cd
lock
incl 0x8(%rbx)
leaq -0x80(%rbp), %rdi
callq 0x42e0
movq %r14, -0x30(%rbp)
movq %rbx, -0x28(%rbp)
testq %rbx, %rbx
je 0xd4f8
movq 0xbad6(%rip), %rax      # 0x18fc0
cmpb $0x0, (%rax)
je 0xd4f4
incl 0x8(%rbx)
jmp 0xd4f8
lock
incl 0x8(%rbx)
cmpq $0x0, 0x30(%r15)
je 0xd5d1
leaq 0x20(%r15), %rsi
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq *0x38(%r15)
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xd521
callq 0x6810
cmpb $0x1, -0x58(%rbp)
jne 0xd546
leaq -0x78(%rbp), %rdx
leaq -0x80(%rbp), %rcx
movq %r15, %rdi
movq %r12, %rsi
callq 0xdbba
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq 0xdbf8
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movl $0x18, %edi
callq 0x4270
leaq -0xda(%rip), %rcx       # 0xd488
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq %r15, 0x10(%rax)
leaq -0x50(%rbp), %rsi
movq %rax, (%rsi)
leaq 0xbb1(%rip), %rax       # 0xe130
movq %rax, 0x18(%rsi)
leaq 0xbba(%rip), %rax       # 0xe144
movq %rax, 0x10(%rsi)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xd5ae
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq -0x80(%rbp), %rdi
callq 0xdb8e
testq %rbx, %rbx
je 0xd5c4
movq %rbx, %rdi
callq 0x6810
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x40d0
jmp 0xd5f4
movq %rax, %r14
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xd601
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xd601
movq %rax, %rdi
callq 0x4d4d
jmp 0xd5fe
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0xdb8e
jmp 0xd61d
movq %rax, %r14
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xd61d
callq 0x6810
testq %rbx, %rbx
je 0xd62a
movq %rbx, %rdi
callq 0x6810
movq %r14, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x28, %rsp
movq (%rdi), %rsi
movl 0x8(%rsi), %r15d
cmpl $0x3, %r15d
jne 0xe88e
movq %rdi, %r14
leaq -0x28(%rbp), %rdi
callq 0x6f1c
movl $0x30, %edi
callq 0x4270
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rbx
testq %rbx, %rbx
je 0xe7f2
movq 0xa7dc(%rip), %rdx      # 0x18fc0
cmpb $0x0, (%rdx)
je 0xe7ee
incl 0x8(%rbx)
jmp 0xe7f2
lock
incl 0x8(%rbx)
movq -0x28(%rbp), %rsi
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
movl $0x4, 0x8(%rax)
leaq 0xa045(%rip), %rdi      # 0x18850
movq %rdi, (%rax)
movq %rcx, 0x10(%rax)
movq %rbx, 0x18(%rax)
testq %rbx, %rbx
je 0xe830
movq 0xa79e(%rip), %rcx      # 0x18fc0
cmpb $0x0, (%rcx)
je 0xe82c
incl 0x8(%rbx)
jmp 0xe830
lock
incl 0x8(%rbx)
movq %rdx, 0x20(%rax)
movq %rsi, 0x28(%rax)
leaq -0x38(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x79b4
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq 0x8(%r14), %rdi
movups %xmm0, (%r14)
testq %rdi, %rdi
je 0xe865
callq 0x6810
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xe873
callq 0x6810
testq %rbx, %rbx
je 0xe880
movq %rbx, %rdi
callq 0x6810
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xe88e
callq 0x6810
cmpl $0x3, %r15d
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
testq %rbx, %rbx
je 0xe8b5
movq %rbx, %rdi
callq 0x6810
jmp 0xe8b5
movq %rax, %r14
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xe8c3
callq 0x6810
movq %r14, %rdi
callq 0x4400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x18, %edi
callq 0x4270
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq -0x28(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x6a04
movl $0x18, %edi
callq 0x4270
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq -0x38(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x6a04
cmpq %r15, %r12
jae 0xe9a7
movq (%r12), %rax
cmpq (%r14), %rax
jge 0xe979
movq -0x30(%rbp), %rdi
jmp 0xe97d
movq -0x40(%rbp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xe999
addq $0x8, %rdi
movups (%r12), %xmm0
movups %xmm0, (%rsi)
addq $0x10, (%rdi)
jmp 0xe9a1
movq %r12, %rdx
callq 0x6aea
addq $0x10, %r12
jmp 0xe965
leaq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xea12
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xe9c8
callq 0x6810
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xe9d6
callq 0x6810
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xe9fc
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xe9fc
callq 0x6810
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xea0a
callq 0x6810
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq -0x10(%rbp), %rbx
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21e0
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_O1/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
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x4a27
movq 0x4dba(%rip), %rax      # 0x97d8
movl %esi, %ecx
cvtsi2ss %rcx, %xmm0
jmp 0x4a92
movl %esi, %eax
cvtsi2ss %rax, %xmm0
movq 0x4dab(%rip), %rdx      # 0x97e0
movq 0x4d9c(%rip), %rax      # 0x97d8
subq %rax, %rdx
sarq $0x5, %rdx
movl $0x1, %ecx
cmpq $0x2, %rdx
jb 0x4a83
mulss 0x1712(%rip), %xmm0     # 0x6168
movss 0x170e(%rip), %xmm1     # 0x616c
ucomiss %xmm0, %xmm1
ja 0x4a83
movl $0x2, %esi
movss 0x16f8(%rip), %xmm2     # 0x6168
movl %esi, %ecx
cmpq %rcx, %rdx
jbe 0x4a83
mulss %xmm2, %xmm0
leal 0x1(%rcx), %esi
ucomiss %xmm0, %xmm1
jbe 0x4a70
mulss 0x16e5(%rip), %xmm0     # 0x6170
shlq $0x5, %rcx
addq %rcx, %rax
movss %xmm0, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
callq 0x4308
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rcx, %rcx
je 0x4af9
movq (%rdi), %rdx
xorl %edi, %edi
movl $0x1, %esi
xorl %eax, %eax
movzbl (%rdx,%rdi), %edi
leal -0x3a(%rdi), %r8d
cmpb $-0xb, %r8b
jbe 0x4b00
leal (%rax,%rax,4), %eax
leal (%rdi,%rax,2), %eax
addl $-0x30, %eax
movl %esi, %edi
incl %esi
cmpq %rdi, %rcx
ja 0x4ad7
jmp 0x4afb
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x1660(%rip), %rsi      # 0x6174
movq %rax, %rdi
callq 0x22e0
movq 0x44ad(%rip), %rsi      # 0x8fd0
movq 0x4496(%rip), %rdx      # 0x8fc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %ecx, %r15d
movl %edx, %r14d
movq %rdi, %rbx
leaq -0x1c0(%rbp), %rdi
movl $0x8, %edx
callq 0x2290
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
testl %r15d, %r15d
je 0x4ba0
movl %r15d, %esi
movq %rbx, %rdi
callq 0x4c5c
leaq -0x1c0(%rbp), %rdi
callq 0x20a0
cmpl $-0x1, %eax
je 0x4bda
movsbl %r14b, %edx
leaq -0x1c0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x22d0
cmpq $0x0, -0x38(%rbp)
je 0x4ba0
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d46
jmp 0x4ba0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4be8
callq 0x2170
movq 0x43b1(%rip), %rsi      # 0x8fa0
leaq -0x1c0(%rbp), %rdi
callq 0x2200
leaq -0x148(%rbp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c1c
movq %rax, %r14
movq %rbx, %rdi
callq 0x4104
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4c35
callq 0x2170
movq 0x4364(%rip), %rsi      # 0x8fa0
leaq -0x1c0(%rbp), %rdi
callq 0x2200
leaq -0x148(%rbp), %rdi
callq 0x2080
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r13
movl %esi, (%rdi)
leaq 0x8(%rdi), %rax
movq %rax, -0x38(%rbp)
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 0x53bc
testl %r15d, %r15d
je 0x5030
leaq -0x2c(%rbp), %rbx
movl $0x0, -0x2c(%rbp)
movq 0x28(%r13), %rsi
cmpq 0x30(%r13), %rsi
je 0x5020
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x28(%r13)
jmp 0x502b
movq %r14, %rdi
movq %rbx, %rdx
callq 0x457a
decl %r15d
jne 0x4fff
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x5454
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x504d
movq %rax, %rbx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x505d
callq 0x2170
movq -0x38(%rbp), %rdi
callq 0x42b4
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x50cc
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x5562
cmpl $0x0, (%rbx)
je 0x50c4
movq 0x20(%rbx), %rax
movq (%r14), %rcx
addq $0x8, %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %edi
movq (%rcx), %rsi
cmpq %rdi, %rsi
jbe 0x50b6
movl %esi, (%rax,%rdx,4)
incq %rdx
movl (%rbx), %esi
addq $0x20, %rcx
cmpq %rsi, %rdx
jb 0x50a8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x10c0(%rip), %rsi      # 0x61a0
movq %rax, %rdi
callq 0x22e0
movq 0x3ee1(%rip), %rsi      # 0x8fd0
movq 0x3eca(%rip), %rdx      # 0x8fc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22b0
nop