LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x50(%rbp)
movq -0x50(%rbp), %rsi
movq %rsi, -0x78(%rbp)
addq $0x10, %rsi
leaq -0x60(%rbp), %rdi
callq 0x5560
movq -0x78(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x5, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x10(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x56f0
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, -0x18(%rbp)
subl $0x3, %eax
je 0x535e
jmp 0x5349
movl -0x64(%rbp), %eax
subl $0x5, %eax
je 0x5369
jmp 0x5353
movq -0x70(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x5372
movq -0x70(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x5372
movq -0x70(%rbp), %rcx
movl -0x18(%rbp), %eax
xchgl %eax, (%rcx)
movq -0x78(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x20(%rbp)
movl $0x5, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x24(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x56f0
movl %eax, -0x7c(%rbp)
jmp 0x53a2
movl -0x7c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x8c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x53d5
jmp 0x53ba
movl -0x8c(%rbp), %eax
subl $0x5, %eax
je 0x53e3
jmp 0x53c7
movq -0x88(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x53f9
movq -0x88(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x53f9
movq -0x88(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x53f9
movq %rax, %rdi
callq 0x56c0
cmpl $0x0, -0x2c(%rbp)
je 0x5411
movq -0x78(%rbp), %rdi
addq $0x68, %rdi
callq 0x43f0
jmp 0x54b3
movq -0x78(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl $0x5, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x3c(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x56f0
movl %eax, -0x90(%rbp)
jmp 0x5444
movl -0x90(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x9c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x547a
jmp 0x545f
movl -0x9c(%rbp), %eax
subl $0x5, %eax
je 0x5488
jmp 0x546c
movq -0x98(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x549e
movq -0x98(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x549e
movq -0x98(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x549e
movq %rax, %rdi
callq 0x56c0
cmpl $0x0, -0x44(%rbp)
je 0x54b1
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
callq 0x43f0
jmp 0x54b3
leaq -0x60(%rbp), %rdi
callq 0x55a0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb $0x0, -0x15(%rbp)
movl $0x18, %edi
callq 0x4290
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movb $0x1, -0x25(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x16(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x7180
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x71a0
jmp 0x576f
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdi
movb $0x0, -0x25(%rbp)
callq 0x7210
jmp 0x5782
leaq -0x16(%rbp), %rdi
callq 0x7240
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5820
callq 0x4070
movq -0x58(%rbp), %rdi
cltd
idivl -0x10(%rbp)
movslq %edx, %rax
movq %rax, -0x60(%rbp)
callq 0x7260
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x7290
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rdi
movq %rcx, (%rax)
callq 0x7260
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x7290
movl $0xdeadbeef, %ecx       # imm = 0xDEADBEEF
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5792
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x7240
testb $0x1, -0x25(%rbp)
jne 0x5810
jmp 0x581e
movq -0x48(%rbp), %rdi
movl $0x18, %esi
callq 0x42a0
jmp 0x583d
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x5833
movq -0x58(%rbp), %rdi
callq 0x72b0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x18, %edi
callq 0x4290
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x72d0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7210
leaq -0x28(%rbp), %rdi
callq 0x72f0
jmp 0x58ab
movl $0xdeadbeef, %eax       # imm = 0xDEADBEEF
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4450
movb %al, -0x51(%rbp)
jmp 0x58cc
movb -0x51(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x58d7
jmp 0x5916
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4160
jmp 0x58e6
movq -0x48(%rbp), %rdi
callq 0x7310
movq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x7330
jmp 0x58fd
jmp 0x58b4
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x72b0
jmp 0x5933
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5929
movq -0x48(%rbp), %rdi
callq 0x72b0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4420
nopl (%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x20(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5710
movq -0x90(%rbp), %rdi
callq 0x7310
movq %rax, %rdi
callq 0x73d0
movq -0x90(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x7310
movq %rax, %rdi
callq 0x7440
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x7580
jmp 0x5bcb
movl $0x10, %edi
callq 0x4290
movq %rax, -0xa8(%rbp)
jmp 0x5bde
movb $0x1, -0x82(%rbp)
movl $0x30, %edi
callq 0x4290
movq %rax, -0xb0(%rbp)
jmp 0x5bf8
movb $0x1, -0x81(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x20(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
callq 0x73a0
movq -0xc0(%rbp), %rdi
callq 0x7310
movq %rax, %rdi
callq 0x73d0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x7400
movq -0xc0(%rbp), %rdi
callq 0x7310
movq %rax, %rdi
callq 0x7440
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7400
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x78(%rbp), %rcx
callq 0x75c0
jmp 0x5c81
movq -0xb0(%rbp), %rsi
movb $0x0, -0x81(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7630
jmp 0x5c9a
movq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7510
jmp 0x5cac
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdi
movb $0x0, -0x82(%rbp)
callq 0x7530
jmp 0x5cc8
leaq -0x50(%rbp), %rdi
callq 0x7560
leaq -0x60(%rbp), %rdi
callq 0x72b0
leaq -0x20(%rbp), %rdi
callq 0x72b0
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x5d77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x5d59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x5d32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7560
leaq -0x60(%rbp), %rdi
callq 0x72b0
testb $0x1, -0x81(%rbp)
jne 0x5d46
jmp 0x5d57
movq -0xb0(%rbp), %rdi
movl $0x30, %esi
callq 0x42a0
jmp 0x5d59
testb $0x1, -0x82(%rbp)
jne 0x5d64
jmp 0x5d75
movq -0xa8(%rbp), %rdi
movl $0x10, %esi
callq 0x42a0
jmp 0x5d77
leaq -0x20(%rbp), %rdi
callq 0x72b0
movq -0x38(%rbp), %rdi
callq 0x4420
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %esi
callq 0x9990
movq 0x268b2(%rip), %rdi     # 0x2ffc8
leaq 0x16c1a(%rip), %rsi     # 0x20337
callq 0x4280
movq -0x28(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rsi, %rdi
addq $0x28, %rdi
addq $0x20, %rsi
callq 0x9e40
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x4440
movq %rax, %rdi
leaq 0x16bc4(%rip), %rsi     # 0x20314
callq 0x4280
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x6, -0x1c(%rbp)
movb %al, -0x31(%rbp)
jge 0x9787
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
leaq -0x18(%rbp), %rdi
callq 0x9fa0
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x9790
jmp 0x97e1
movl -0x1c(%rbp), %ecx
leaq 0x17222(%rip), %rsi     # 0x209bc
leaq 0x16b83(%rip), %rax     # 0x20324
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movq 0x26819(%rip), %rdi     # 0x2ffc8
callq 0x4280
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x7ad0
movq -0x40(%rbp), %rdi
movq (%rax), %rsi
callq 0x4440
leaq -0x18(%rbp), %rdi
callq 0xa030
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9768
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
leaq -0x18(%rbp), %rdi
callq 0x9fa0
testb $0x1, %al
jne 0x97f8
jmp 0x980b
movq 0x267c9(%rip), %rdi     # 0x2ffc8
leaq 0x16b21(%rip), %rsi     # 0x20327
callq 0x4280
movq 0x267b6(%rip), %rdi     # 0x2ffc8
leaq 0x16b14(%rip), %rsi     # 0x2032d
callq 0x4280
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x1, -0x14(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rsi
addq $0x28, %rsi
leaq -0x20(%rbp), %rdi
callq 0xa310
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0xa126
jmp 0xa13e
leaq -0x20(%rbp), %rdi
callq 0xa010
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xa370
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xa147
jmp 0xa16b
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0xa350
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
jmp 0xa107
movq -0x40(%rbp), %rsi
addq $0x28, %rsi
leaq -0x20(%rbp), %rdi
callq 0xa3a0
testb $0x1, %al
jne 0xa182
jmp 0xa18e
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
callq 0xa310
testb $0x1, %al
jne 0xa1a5
jmp 0xa1ce
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xa3e0
movq %rax, -0x28(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0x9990
movq 0x22602(%rip), %rdi     # 0x2ffc8
leaq 0x129ac(%rip), %rsi     # 0x20379
callq 0x4280
movq %rax, %rdi
movq 0x225c4(%rip), %rsi     # 0x2ffa0
callq 0x42c0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x7930
movq %rax, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x79c0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x7930
movq %rax, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x79c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xb0, %rsp
movq %rsi, -0x50(%rbp)
movq %rdx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xa050
movq -0x60(%rbp), %rdi
leaq 0x21ec9(%rip), %rax     # 0x2f920
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x78(%rbp)
callq 0xdc00
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x70(%rbp)
callq 0xdc00
movq -0x60(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x68(%rbp)
callq 0xdc20
movq -0x60(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x58(%rbp)
callq 0xdc20
movq -0x50(%rbp), %rdi
callq 0x7930
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x7a30
jmp 0xdab1
movq -0x60(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x90(%rbp)
leaq -0x28(%rbp), %rsi
movq %rsi, -0x98(%rbp)
callq 0xdc40
movq -0x98(%rbp), %rdi
callq 0x7af0
movq -0x90(%rbp), %rdi
callq 0x7ab0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movb %al, -0x81(%rbp)
jmp 0xdafc
movq -0x80(%rbp), %rdi
movq -0x60(%rbp), %rax
movb -0x81(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x48(%rax)
callq 0x7930
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x7a30
jmp 0xdb23
movq -0x60(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x48(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0xdc40
movq -0xb0(%rbp), %rdi
callq 0x7af0
movq -0xa8(%rbp), %rdi
callq 0x7ab0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movb %al, -0x99(%rbp)
jmp 0xdb6e
movq -0x60(%rbp), %rdi
movb -0x99(%rbp), %al
andb $0x1, %al
movb %al, 0x49(%rdi)
callq 0xdc70
jmp 0xdb84
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x7af0
movq -0x68(%rbp), %rdi
callq 0x7af0
movq -0x70(%rbp), %rdi
callq 0x7750
movq -0x78(%rbp), %rdi
callq 0x7750
movq -0x30(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x48(%rax)
je 0xdd99
movq -0x10(%rbp), %rax
testb $0x1, 0x49(%rax)
je 0xdd99
jmp 0xde1e
movq -0x10(%rbp), %rax
testb $0x1, 0x4a(%rax)
je 0xdddd
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x7ab0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x7ab0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x48(%rax)
jmp 0xde15
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x7ab0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x7ab0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x49(%rax)
movq -0x10(%rbp), %rdi
callq 0xdc70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0x9990
movq 0x21742(%rip), %rdi     # 0x2ffc8
leaq 0x11af3(%rip), %rsi     # 0x20380
callq 0x4280
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
callq 0x4700
movq %rax, %rdi
leaq 0x1196d(%rip), %rsi     # 0x20219
callq 0x4280
movq %rax, %rdi
movq 0x216e5(%rip), %rsi     # 0x2ffa0
callq 0x42c0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x7930
movq %rax, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x79c0
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x7930
movq %rax, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x79c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rsi
callq 0xa370
testb $0x1, %al
jne 0xebd1
movq -0x18(%rbp), %rax
movb $0x1, 0x48(%rax)
movq -0x18(%rbp), %rdi
callq 0xeca0
movq -0x18(%rbp), %rax
testb $0x1, 0x48(%rax)
jne 0xec22
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x7ab0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x7ab0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x48(%rax)
jmp 0xec6a
movq -0x18(%rbp), %rax
testb $0x1, 0x49(%rax)
jne 0xec68
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x7ab0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x7ab0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x49(%rax)
jmp 0xec6a
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x48(%rax)
jne 0xed24
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0xeda0
cmpq $0x0, %rax
jne 0xed22
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x7930
movq %rax, %rsi
leaq -0x18(%rbp), %rdi
callq 0x7a30
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
leaq -0x18(%rbp), %rsi
callq 0xdc40
leaq -0x18(%rbp), %rdi
callq 0x7af0
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x7ab0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x48(%rax)
jmp 0xed24
movq -0x30(%rbp), %rax
testb $0x1, 0x48(%rax)
je 0xed98
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0xeda0
cmpq $0x0, %rax
jne 0xed96
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x7930
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x7a30
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
leaq -0x28(%rbp), %rsi
callq 0xdc40
leaq -0x28(%rbp), %rdi
callq 0x7af0
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0x7ab0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x49(%rax)
jmp 0xed98
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rsi, -0x260(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x43a0
xorl %eax, %eax
movl %eax, %esi
leaq -0x230(%rbp), %rdi
callq 0x43b0
movq 0x20633(%rip), %rdi     # 0x2ffc8
leaq 0x10e23(%rip), %rsi     # 0x207bf
callq 0x4280
movq %rax, -0x258(%rbp)
jmp 0xf9aa
movq -0x260(%rbp), %rsi
movq -0x258(%rbp), %rdi
callq 0x4240
movq %rax, -0x268(%rbp)
jmp 0xf9c6
movq -0x268(%rbp), %rdi
leaq 0x10845(%rip), %rsi     # 0x20219
callq 0x4280
movq %rax, -0x270(%rbp)
jmp 0xf9e2
movq -0x270(%rbp), %rdi
movq 0x205b0(%rip), %rsi     # 0x2ffa0
callq 0x42c0
jmp 0xf9f7
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq -0x220(%rbp), %rsi
xorl %edx, %edx
callq 0xfb10
movl %eax, -0x274(%rbp)
jmp 0xfa14
movl -0x274(%rbp), %eax
movl %eax, -0x250(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
callq 0x43b0
movq 0x20591(%rip), %rdi     # 0x2ffc8
leaq 0x10d88(%rip), %rsi     # 0x207c6
callq 0x4280
movq %rax, -0x280(%rbp)
jmp 0xfa4c
movq -0x260(%rbp), %rsi
movq -0x280(%rbp), %rdi
callq 0x4240
movq %rax, -0x288(%rbp)
jmp 0xfa68
movq -0x288(%rbp), %rdi
leaq 0x10d56(%rip), %rsi     # 0x207cc
callq 0x4280
movq %rax, -0x290(%rbp)
jmp 0xfa84
movq -0x290(%rbp), %rdi
movl -0x250(%rbp), %esi
callq 0x4410
movq %rax, -0x298(%rbp)
jmp 0xfa9f
movq -0x298(%rbp), %rdi
leaq 0x10d23(%rip), %rsi     # 0x207d0
callq 0x4280
movq %rax, -0x2a0(%rbp)
jmp 0xfabb
movq -0x2a0(%rbp), %rdi
movq 0x204d7(%rip), %rsi     # 0x2ffa0
callq 0x42c0
jmp 0xfad0
leaq -0x220(%rbp), %rdi
callq 0x4060
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x4060
movq -0x248(%rbp), %rdi
callq 0x4420
nop
// File: 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
subq $0xb0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, %rax
movq -0x98(%rbp), %rdi
movq %rax, -0x90(%rbp)
movq %rax, %rcx
movq %rcx, -0x88(%rbp)
movq %rax, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
callq 0xf390
cmpl $0x3, 0x8(%rax)
je 0x12f47
movq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x4140
movq -0x90(%rbp), %rdi
callq 0x17d80
jmp 0x1300b
movq -0x98(%rbp), %rdi
callq 0xf390
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x12fb9
leaq 0x4e32(%rip), %rdx      # 0x17da0
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x18370
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x183b0
jmp 0x12f97
leaq -0x48(%rbp), %rdi
callq 0x17ac0
jmp 0x1300b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x17ac0
jmp 0x1301b
leaq 0x5420(%rip), %rdx      # 0x183e0
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x18370
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x183b0
jmp 0x12fe9
leaq -0x80(%rbp), %rdi
callq 0x17ac0
jmp 0x1300b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x17ac0
jmp 0x1301b
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1419b
jmp 0x14201
movq -0x48(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x14210
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x7790
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x14240
movb %al, -0x49(%rbp)
jmp 0x141d7
movb -0x49(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7750
jmp 0x14190
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7750
jmp 0x14207
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4420
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0x9990
movq 0x1b842(%rip), %rdi     # 0x2ffc8
leaq 0xc21e(%rip), %rsi      # 0x209ab
callq 0x4280
movq %rax, %rdi
movq 0x1b804(%rip), %rsi     # 0x2ffa0
callq 0x42c0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x7930
movq %rax, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x79c0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x7930
movq %rax, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x79c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x120, %rsp            # imm = 0x120
movq %rsi, -0xf0(%rbp)
movq %rdi, %rax
movq -0xf0(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
callq 0x7930
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xf360
movq -0xe0(%rbp), %rax
movq -0xd8(%rbp), %rsi
addq $0x20, %rax
movq %rax, -0xd0(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xab40
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x16230
jmp 0x15430
leaq -0x60(%rbp), %rdi
callq 0x7560
leaq -0x50(%rbp), %rdi
callq 0x16290
testb $0x1, %al
jne 0x1544b
jmp 0x154df
movq -0xe0(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x16310
movq %rax, -0xf8(%rbp)
jmp 0x1546b
movq -0xf8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x110(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x16310
movq %rax, -0x108(%rbp)
jmp 0x1548f
movq -0x108(%rbp), %rcx
movq -0x110(%rbp), %rdx
movq -0xe8(%rbp), %rsi
movq -0x100(%rbp), %rdi
callq 0x162b0
jmp 0x154b2
jmp 0x154df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7560
jmp 0x155b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x155a9
leaq -0x20(%rbp), %rdi
callq 0xf390
movq %rax, %rcx
movq -0xe0(%rbp), %rax
movq %rcx, -0x118(%rbp)
leaq -0x160(%rip), %rcx      # 0x153a0
movq %rcx, -0xb8(%rbp)
movq $0x0, -0xb0(%rbp)
movq %rax, -0xc0(%rbp)
movq 0x1aa98(%rip), %rcx     # 0x2ffb8
leaq -0xa8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x16330
jmp 0x1553c
leaq -0x90(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x16370
jmp 0x15551
movq -0x118(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x90(%rbp), %rsi
callq *%rax
jmp 0x1556a
leaq -0x90(%rbp), %rdi
callq 0x16410
leaq -0x50(%rbp), %rdi
callq 0x16430
leaq -0x20(%rbp), %rdi
callq 0x7560
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x16410
leaq -0x50(%rbp), %rdi
callq 0x16430
leaq -0x20(%rbp), %rdi
callq 0x7560
movq -0x68(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf390
cmpl $0x3, 0x8(%rax)
jne 0x18542
movq -0x10(%rbp), %rdi
callq 0xf450
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x99d0
movl $0x30, %edi
callq 0x4290
movq %rax, -0x88(%rbp)
jmp 0x1842f
movb $0x1, -0x79(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x28(%rbp), %rsi
movq %rsi, -0x98(%rbp)
callq 0x73a0
movq -0x98(%rbp), %rdi
callq 0x7310
movq %rax, %rdi
callq 0x73d0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x7400
movq -0x98(%rbp), %rdi
callq 0x7310
movq %rax, %rdi
callq 0x7440
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x7400
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x70(%rbp), %rcx
callq 0x75c0
jmp 0x184b5
movq -0x88(%rbp), %rsi
movb $0x0, -0x79(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7630
jmp 0x184cb
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x18640
leaq -0x38(%rbp), %rdi
callq 0x7560
leaq -0x58(%rbp), %rdi
callq 0x72b0
movb $0x1, -0x1(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x72b0
jmp 0x18546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x18537
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x72b0
testb $0x1, -0x79(%rbp)
jne 0x18524
jmp 0x18535
movq -0x88(%rbp), %rdi
movl $0x30, %esi
callq 0x42a0
jmp 0x18537
leaq -0x28(%rbp), %rdi
callq 0x72b0
jmp 0x18554
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4420
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x18, %edi
movq %rdi, -0x60(%rbp)
callq 0x4290
movq %rax, %rdi
movq %rdi, -0x68(%rbp)
callq 0x72d0
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7210
movq -0x60(%rbp), %rdi
callq 0x4290
movq %rax, -0x58(%rbp)
jmp 0x1875c
movq -0x58(%rbp), %rdi
callq 0x72d0
movq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x7210
jmp 0x18774
jmp 0x18776
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa310
testb $0x1, %al
jne 0x1878c
jmp 0x18831
leaq -0x10(%rbp), %rdi
callq 0xa010
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0xa370
testb $0x1, %al
jne 0x187a7
jmp 0x187f5
leaq -0x30(%rbp), %rdi
callq 0x7310
movq %rax, -0x80(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xa010
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x7330
jmp 0x187cb
jmp 0x18821
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x18863
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x72b0
jmp 0x18863
leaq -0x40(%rbp), %rdi
callq 0x7310
movq %rax, -0x88(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xa010
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x7330
jmp 0x1881f
jmp 0x18821
jmp 0x18823
leaq -0x10(%rbp), %rdi
callq 0xa030
jmp 0x18776
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x18880
jmp 0x18844
leaq -0x40(%rbp), %rdi
callq 0x72b0
leaq -0x30(%rbp), %rdi
callq 0x72b0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x72b0
movq -0x48(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x180(%rbp)
movq %rdi, %rax
movq %rax, -0x178(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movq %rax, %rdi
leaq 0x2f95(%rip), %rsi      # 0xa14c
callq 0x2080
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x71fa
movl $0x8, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, -0x188(%rbp)
callq 0x7360
movq -0x188(%rbp), %rdi
movq 0x7dea(%rip), %rsi      # 0xefd8
movq 0x7dfb(%rip), %rdx      # 0xeff0
callq 0x22f0
leaq -0x140(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rdi
callq 0x2290
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x721d
jmp 0x7278
movq -0x18(%rbp), %rdx
leaq -0x120(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x22a0
movq %rax, -0x190(%rbp)
jmp 0x723b
movq -0x190(%rbp), %rax
cmpq $0x0, %rax
je 0x7276
leaq -0x140(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x2190
jmp 0x725d
jmp 0x7276
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x148(%rbp)
movl %eax, -0x14c(%rbp)
jmp 0x72fa
jmp 0x7206
movq -0x18(%rbp), %rdi
callq 0x2250
jmp 0x7283
leaq -0x170(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x20d0
jmp 0x7298
movq -0x180(%rbp), %rdi
leaq -0x170(%rbp), %rsi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0x77c0
jmp 0x72b4
leaq -0x170(%rbp), %rdi
callq 0x2368
leaq -0x140(%rbp), %rdi
callq 0x2368
movq -0x178(%rbp), %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x148(%rbp)
movl %eax, -0x14c(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x2368
leaq -0x140(%rbp), %rdi
callq 0x2368
movq -0x148(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x2240
movzwl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movzwl -0xe(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x400, -0xc(%rbp)      # imm = 0x400
jae 0x7618
leaq 0x820e(%rip), %rdi      # 0xf808
xorl %eax, %eax
movl %eax, %esi
callq 0x7930
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq -0xc(%rbp), %rsi
callq 0x7950
jmp 0x76b1
movl -0xc(%rbp), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
leaq 0x81ce(%rip), %rdi      # 0xf808
callq 0x7990
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x767e
movss -0x10(%rbp), %xmm0
movss 0x2afc(%rip), %xmm1     # 0xa154
divss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss 0x2ae7(%rip), %xmm0     # 0xa150
ucomiss -0x10(%rbp), %xmm0
jbe 0x7671
jmp 0x767e
jmp 0x7673
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x762c
movss 0x2ace(%rip), %xmm0     # 0xa154
mulss -0x10(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq 0x816c(%rip), %rdi      # 0xf808
callq 0x7930
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq -0x18(%rbp), %rsi
callq 0x79b0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0x2270
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x77ae
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x2350
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x772a
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x2350
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x777a
movl $0x10, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x2a13(%rip), %rsi      # 0xa158
callq 0x2330
jmp 0x774c
movq -0x38(%rbp), %rdi
movq 0x7879(%rip), %rsi      # 0xefd0
movq 0x7862(%rip), %rdx      # 0xefc0
callq 0x22f0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2130
jmp 0x77b7
movq -0x28(%rbp), %rdi
imull $0xa, -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x2350
movq %rax, %rcx
movl -0x3c(%rbp), %eax
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x76de
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2300
// File: 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
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1d8(%rbp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
leaq -0x198(%rbp), %rdi
movl $0x8, %edx
callq 0x22e0
leaq -0x1b8(%rbp), %rdi
callq 0x2230
movq -0x1d8(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
callq 0x79f0
cmpl $0x0, -0x18(%rbp)
je 0x7872
movq -0x1d8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x7a10
jmp 0x7835
jmp 0x7872
movq -0x1d8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
callq 0x5800
leaq -0x1b8(%rbp), %rdi
callq 0x2368
leaq -0x198(%rbp), %rdi
callq 0x20e0
jmp 0x791b
jmp 0x7874
leaq -0x198(%rbp), %rdi
callq 0x20a0
movl %eax, -0x1e4(%rbp)
jmp 0x7888
movl -0x1e4(%rbp), %eax
cmpl $-0x1, %eax
je 0x78d7
movsbl -0x11(%rbp), %edx
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x2320
jmp 0x78ac
leaq -0x1b8(%rbp), %rdi
callq 0x2270
cmpq $0x0, %rax
je 0x78d5
movq -0x1d8(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x7b10
jmp 0x78d3
jmp 0x78d5
jmp 0x7874
movb $0x1, -0x1b9(%rbp)
testb $0x1, -0x1b9(%rbp)
jne 0x78f3
movq -0x1d8(%rbp), %rdi
callq 0x5800
leaq -0x1b8(%rbp), %rdi
callq 0x2368
leaq -0x198(%rbp), %rdi
callq 0x20e0
movq -0x1e0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x2300
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x87c0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x30(%rbp)
callq 0x5890
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x87e0
jmp 0x827a
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x82d0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movl $0x0, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x59c0
jmp 0x82a3
jmp 0x82a5
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8281
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5ca0
movq -0x40(%rbp), %rdi
callq 0x5de0
jmp 0x82ea
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x88e0
jmp 0x82e4
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x7990
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
je 0x838a
movl $0x10, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x1e1a(%rip), %rsi      # 0xa16c
callq 0x2330
jmp 0x8359
movq -0x40(%rbp), %rdi
movq 0x6c6c(%rip), %rsi      # 0xefd0
movq 0x6c55(%rip), %rdx      # 0xefc0
callq 0x22f0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2130
jmp 0x8431
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x89e0
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl (%rcx), %eax
jae 0x8427
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5c80
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movq %rax, -0x48(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x59a0
movq %rax, %rdi
callq 0x2270
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x8417
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x59a0
movq %rax, %rdi
callq 0x2270
movq -0x28(%rbp), %rdi
movl %eax, -0x4c(%rbp)
addq $0x20, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5c80
movl -0x4c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x8419
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x83a2
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2300
nopw (%rax,%rax)