LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/buffercache.cc
// Function: BufferCache::CheckDeleteOldest()
ERROR_T BufferCache::CheckDeleteOldest()
{
  // In a real buffer cache, we would use a priority queue to make this O(1)

  map<SIZE_T, Block, cache_compare_lessthan>::iterator oldestptr=blockmap.end();
  double oldest = curtime+1;

  // Only delete if the cache is full
  if (blockmap.size() < cachesize) {
    return ERROR_NOERROR;
  }

  // Find oldest

  for (map<SIZE_T, Block, cache_compare_lessthan>::iterator i=blockmap.begin();
	 i!=blockmap.end();
	 ++i) {
       if ((*i).second.lastaccessed<oldest) { 
	 oldestptr=i;
	 oldest=(*i).second.lastaccessed;
       }
  }
  
  // write and delete it if it exists
 
  if (oldestptr!=blockmap.end()) { 
    if ((*oldestptr).second.dirty) {
      double reqtime;
      int rc=disk->Write((*oldestptr).first,
			 (*oldestptr).second,
			 reqtime);
      curtime+=reqtime;
      diskwrites++;
      if (rc!=ERROR_NOERROR) { 
	return rc;
      }
    }
    blockmap.erase(oldestptr);
  }
  return ERROR_NOERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl 0x8(%rdi), %eax
xorl %ebp, %ebp
cmpq %rax, 0x38(%rdi)
jb 0x43c1
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
leaq 0x18(%rdi), %r12
movsd 0x40(%rdi), %xmm0
addsd 0x42b5(%rip), %xmm0     # 0x85f8
movq 0x28(%rdi), %rax
movq %r12, %r15
cmpq %r12, %rax
je 0x4374
movsd 0x40(%rax), %xmm1
ucomisd %xmm1, %xmm0
cmovaq %rax, %r15
minsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %rax, %rdi
callq 0x2130
movsd (%rsp), %xmm0
jmp 0x434a
cmpq %r12, %r15
je 0x43c1
cmpb $0x1, 0x48(%r15)
jne 0x43b4
movq (%r14), %rdi
movl 0x20(%r15), %esi
leaq 0x28(%r15), %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rcx
callq 0x3c74
movl %eax, %ebp
movsd (%r12), %xmm0
addsd 0x40(%r14), %xmm0
movsd %xmm0, 0x40(%r14)
incl 0x5c(%r14)
testl %eax, %eax
jne 0x43c1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x49a0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/buffercache.cc
// Function: BufferCache::Detach()
ERROR_T BufferCache::Detach()
{
  // write out all of our data and then throw it away

  for (map<SIZE_T, Block, cache_compare_lessthan>::iterator i=blockmap.begin();
	 i!=blockmap.end();
	 ++i) {
    if ((*i).second.dirty) { 
      double reqtime;
      int rc=disk->Write((*i).first,
			 (*i).second,
			 reqtime);
      curtime+=reqtime;
      diskwrites++;
      if (rc!=ERROR_NOERROR) { 
	return rc;
      }
    }
  }
  blockmap.clear();
  return ERROR_NOERROR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq 0x28(%rdi), %r12
leaq 0x18(%rdi), %r13
leaq 0x8(%rsp), %r15
cmpq %r13, %r12
je 0x449a
cmpb $0x1, 0x48(%r12)
jne 0x448d
movq (%r14), %rdi
movl 0x20(%r12), %esi
leaq 0x28(%r12), %rdx
movq %r15, %rcx
callq 0x3c74
movsd 0x8(%rsp), %xmm0
addsd 0x40(%r14), %xmm0
movsd %xmm0, 0x40(%r14)
incl 0x5c(%r14)
testl %eax, %eax
jne 0x44a4
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
jmp 0x4451
movq %rbx, %rdi
callq 0x49ee
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/buffercache.cc
// Function: BufferCache::ReadBlock(unsigned int, Block&)
ERROR_T BufferCache::ReadBlock(const SIZE_T inblocknum, Block &outblock) 
{
  map<SIZE_T, Block, cache_compare_lessthan>::iterator b;

  b = blockmap.find(inblocknum);

  if (b!=blockmap.end()) {
    // It's in  cache, just update its lastaccessed and return it
    outblock=(*b).second;
    (*b).second.lastaccessed=curtime;
    reads++;
    return ERROR_NOERROR;
  } else {
    // It's not in cache, so time to allocate it
    CheckDeleteOldest();
    // read it from disk
    if (!(disk->IsBlockAllocated(inblocknum))) { 
      if (PRINT_BUFFERCACHE_ALLOCATION_ERRORS) {
	cerr << "BufferCache::ReadBlock: Attempt to read unallocated block " << inblocknum<<endl;
      }
    }
    double reqtime;
    int rc = disk->Read(inblocknum,
			outblock,
			reqtime);
    curtime+=reqtime;
    diskreads++;
    if (rc!=ERROR_NOERROR) { 
      return rc;
    } else {
      outblock.lastaccessed=curtime;
      outblock.dirty=false;
      blockmap[inblocknum]=outblock;
      reads++;
      return ERROR_NOERROR;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
leaq 0x10(%rdi), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4a1c
movq %rax, %r12
leaq 0x18(%rbx), %rax
cmpq %rax, %r12
je 0x4554
movq %r12, %rsi
addq $0x28, %rsi
movq %r14, %rdi
callq 0x2cbe
movsd 0x40(%rbx), %xmm0
movsd %xmm0, 0x40(%r12)
incl 0x50(%rbx)
xorl %ebp, %ebp
jmp 0x45be
movq %rbx, %rdi
callq 0x4310
movq (%rbx), %rdi
movl 0x4(%rsp), %esi
callq 0x3afe
movq (%rbx), %rdi
movl 0x4(%rsp), %esi
leaq 0x8(%rsp), %r12
movq %r14, %rdx
movq %r12, %rcx
callq 0x3c1c
movl %eax, %ebp
movsd (%r12), %xmm0
addsd 0x40(%rbx), %xmm0
movsd %xmm0, 0x40(%rbx)
incl 0x58(%rbx)
testl %eax, %eax
jne 0x45be
movsd %xmm0, 0x18(%r14)
movb $0x0, 0x20(%r14)
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x48ee
movq %rax, %rdi
movq %r14, %rsi
callq 0x2cbe
incl 0x50(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/buffercache.cc
// Function: BufferCache::WriteBlock(unsigned int, Block const&)
ERROR_T BufferCache::WriteBlock(const SIZE_T inblocknum, const Block &inblock)
{
  map<SIZE_T, Block, cache_compare_lessthan>::iterator b;
  
  b = blockmap.find(inblocknum);

  if (b!=blockmap.end()) {
    // It's in  cache, so just replace the block
    (*b).second=inblock;
    (*b).second.lastaccessed=curtime;
    (*b).second.dirty=true;
    writes++;
    return ERROR_NOERROR;
  } else {
    // It's not in cache, so time to allocate it
    CheckDeleteOldest();
    if (!(disk->IsBlockAllocated(inblocknum))) { 
      if (PRINT_BUFFERCACHE_ALLOCATION_ERRORS) {
	cerr << "BufferCache::WriteBlock: Attempt to write unallocated block " << inblocknum << endl;
      }
    }
    Block myblock=inblock;
    myblock.lastaccessed=curtime;
    myblock.dirty=true;
    blockmap[inblocknum]=myblock;
    writes++;
    return ERROR_NOERROR;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
leaq 0x10(%rdi), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4a1c
movq %rax, %r12
leaq 0x18(%rbx), %rax
cmpq %rax, %r12
je 0x4629
movq %r12, %rdi
addq $0x28, %rdi
movq %r14, %rsi
callq 0x2cbe
movsd 0x40(%rbx), %xmm0
movsd %xmm0, 0x40(%r12)
movb $0x1, 0x48(%r12)
incl 0x54(%rbx)
jmp 0x4687
movq %rbx, %rdi
callq 0x4310
movq (%rbx), %rdi
leaq 0x4(%rsp), %r12
movl (%r12), %esi
callq 0x3afe
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2b80
movsd 0x40(%rbx), %xmm0
movsd %xmm0, 0x18(%r13)
movb $0x1, 0x20(%r13)
movq %r15, %rdi
movq %r12, %rsi
callq 0x48ee
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2cbe
incl 0x54(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x2c6e
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2c6e
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/buffercache.cc
// Function: BufferCache::FlushBlock(unsigned int)
ERROR_T BufferCache::FlushBlock(const SIZE_T blocknum)
{
  map<SIZE_T, Block, cache_compare_lessthan>::iterator b;
  
  b = blockmap.find(blocknum);

  if (b==blockmap.end()) { 
    return ERROR_NOERROR;
  } else {
    if ((*b).second.dirty) { 
      double reqtime;
      int rc;
      rc=disk->Write((*b).first,
		     (*b).second,
		     reqtime);
      diskwrites++;
      curtime+=reqtime;
      if (rc!=ERROR_NOERROR) { 
	return rc;
      }
    }
    blockmap.erase(b);
    return ERROR_NOERROR;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4a1c
movq %rax, %r15
leaq 0x18(%r14), %rcx
xorl %eax, %eax
cmpq %rcx, %r15
je 0x472b
cmpb $0x1, 0x48(%r15)
jne 0x471e
movq (%r14), %rdi
movl 0x20(%r15), %esi
movq %r15, %rdx
addq $0x28, %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rcx
callq 0x3c74
incl 0x5c(%r14)
movsd (%r12), %xmm0
addsd 0x40(%r14), %xmm0
movsd %xmm0, 0x40(%r14)
testl %eax, %eax
jne 0x472b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x49a0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/buffercache.cc
// Function: BufferCache::Print(std::ostream&) const
ostream & BufferCache::Print(ostream &os) const
{
  os << "BufferCache(cachesize="<<cachesize
     << ", blocksize="<<GetBlockSize()
     << ", curtime="<<curtime
     << ", allocs="<<allocs
     << ", deallocs="<<deallocs
     << ", reads="<<reads
     << ", writes="<<writes
     << ", diskreads="<<diskreads
     << ", diskwrites="<<diskwrites
     << ", blocks = {";

  
  for (map<SIZE_T, Block, cache_compare_lessthan>::const_iterator b=blockmap.begin(); 
       b!=blockmap.end(); 
       ++b) {
    if (b!=blockmap.begin()) { 
      os << ", ";
    }
    os << (*b).first << ((*b).second.dirty ? "(dirty)" : "");
  }
  os << "}, disk="<<*disk<<")";
  
  return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3eb0(%rip), %rsi      # 0x8600
movq %rbx, %rdi
callq 0x21b0
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x3dc0(%rip), %rsi      # 0x852b
movq %rax, %rdi
callq 0x21b0
movq %rax, %r15
movq %r14, %rdi
callq 0x44c4
movl %eax, %esi
movq %r15, %rdi
callq 0x2120
leaq 0x3e88(%rip), %rsi      # 0x8617
movq %rax, %rdi
callq 0x21b0
movsd 0x40(%r14), %xmm0
movq %rax, %rdi
callq 0x2320
leaq 0x3e76(%rip), %rsi      # 0x8622
movq %rax, %rdi
callq 0x21b0
movl 0x48(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x3e65(%rip), %rsi      # 0x862c
movq %rax, %rdi
callq 0x21b0
movl 0x4c(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x3e56(%rip), %rsi      # 0x8638
movq %rax, %rdi
callq 0x21b0
movl 0x50(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x3e44(%rip), %rsi      # 0x8641
movq %rax, %rdi
callq 0x21b0
movl 0x54(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x3e33(%rip), %rsi      # 0x864b
movq %rax, %rdi
callq 0x21b0
movl 0x58(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x3e25(%rip), %rsi      # 0x8658
movq %rax, %rdi
callq 0x21b0
movl 0x5c(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x3e18(%rip), %rsi      # 0x8666
movq %rax, %rdi
callq 0x21b0
movq 0x28(%r14), %r15
leaq 0x18(%r14), %r13
leaq 0x3e11(%rip), %rbp      # 0x8676
leaq 0x3f75(%rip), %r12      # 0x87e1
cmpq %r13, %r15
je 0x48b3
cmpq 0x28(%r14), %r15
je 0x4886
movq %rbx, %rdi
leaq 0x3df2(%rip), %rsi      # 0x8673
callq 0x21b0
movl 0x20(%r15), %esi
movq %rbx, %rdi
callq 0x2120
cmpb $0x0, 0x48(%r15)
movq %r12, %rsi
cmovneq %rbp, %rsi
movq %rax, %rdi
callq 0x21b0
movq %r15, %rdi
callq 0x2230
movq %rax, %r15
jmp 0x486c
leaq 0x3dc4(%rip), %rsi      # 0x867e
movq %rbx, %rdi
callq 0x21b0
movq (%r14), %rdi
movq %rax, %rsi
callq 0x3e2a
leaq 0x3e91(%rip), %rsi      # 0x8765
movq %rax, %rdi
callq 0x21b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree.cc
// Function: BTreeIndex::BTreeIndex(unsigned int, unsigned int, BufferCache*, bool)
BTreeIndex::BTreeIndex(SIZE_T keysize, 
 SIZE_T valuesize,
 BufferCache *cache,
 bool unique) 
{
  superblock.info.keysize=keysize;
  superblock.info.valuesize=valuesize;
  buffercache=cache;
  // note: ignoring unique now

  //Calculate maximum number of keys per bllock
  SIZE_T blockSize = buffercache->GetBlockSize();
  maxNumKeys = (blockSize - sizeof(NodeMetadata))/(16);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x7eea(%rip), %rax      # 0xcd80
movq %rax, (%rdi)
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x725a
movl %r12d, 0x1c(%rbx)
movl %ebp, 0x20(%rbx)
movq %r15, 0x8(%rbx)
movq %r15, %rdi
callq 0x44c4
movl %eax, %eax
movabsq $0xfffffffe4, %rcx      # imm = 0xFFFFFFFE4
addq %rax, %rcx
shrq $0x4, %rcx
movl %ecx, 0x40(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7264
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree.cc
// Function: BTreeIndex::AllocateNode(unsigned int&)
ERROR_T BTreeIndex::AllocateNode(SIZE_T &n)
{
  n=superblock.info.freelist;

  if (n==0) { 
    return ERROR_NOSPACE;
  }

  BTreeNode node;

  node.Unserialize(buffercache,n);

  assert(node.info.nodetype==BTREE_UNALLOCATED_BLOCK);

  superblock.info.freelist=node.info.freelist;

  superblock.Serialize(buffercache,superblock_index);

  buffercache->NotifyAllocateBlock(n);

  return ERROR_NOERROR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl 0x2c(%rdi), %eax
movl %eax, (%rsi)
testl %eax, %eax
je 0x4ffc
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x725a
movq 0x8(%r14), %rsi
movl (%rbx), %edx
movq %r15, %rdi
callq 0x73fc
cmpl $0x0, 0x8(%rsp)
jne 0x5009
leaq 0x18(%r14), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x2c(%r14)
movq 0x8(%r14), %rsi
movl 0x10(%r14), %edx
callq 0x7338
movq 0x8(%r14), %rdi
movl (%rbx), %esi
callq 0x44da
leaq 0x8(%rsp), %rdi
callq 0x7264
xorl %eax, %eax
jmp 0x4fff
pushq $-0x7
popq %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3698(%rip), %rdi      # 0x86a8
leaq 0x36bd(%rip), %rsi      # 0x86d4
leaq 0x36bf(%rip), %rcx      # 0x86dd
pushq $0x52
popq %rdx
callq 0x2110
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7264
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree.cc
// Function: BTreeIndex::DeallocateNode(unsigned int const&)
ERROR_T BTreeIndex::DeallocateNode(const SIZE_T &n)
{
  BTreeNode node;

  node.Unserialize(buffercache,n);

  assert(node.info.nodetype!=BTREE_UNALLOCATED_BLOCK);

  node.info.nodetype=BTREE_UNALLOCATED_BLOCK;

  node.info.freelist=superblock.info.freelist;

  node.Serialize(buffercache,n);

  superblock.info.freelist=n;

  superblock.Serialize(buffercache,superblock_index);

  buffercache->NotifyDeallocateBlock(n);

  return ERROR_NOERROR;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x725a
movq 0x8(%r14), %rsi
movl (%rbx), %edx
movq %r15, %rdi
callq 0x73fc
cmpl $0x0, 0x8(%rsp)
je 0x50bf
leaq 0x8(%rsp), %rdi
andl $0x0, (%rdi)
movl 0x2c(%r14), %eax
movl %eax, 0x14(%rdi)
movq 0x8(%r14), %rsi
movl (%rbx), %edx
callq 0x7338
leaq 0x18(%r14), %rdi
movl (%rbx), %eax
movl %eax, 0x2c(%r14)
movq 0x8(%r14), %rsi
movl 0x10(%r14), %edx
callq 0x7338
movq 0x8(%r14), %rdi
movl (%rbx), %esi
callq 0x44e8
leaq 0x8(%rsp), %rdi
callq 0x7264
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3642(%rip), %rdi      # 0x8708
leaq 0x3607(%rip), %rsi      # 0x86d4
leaq 0x3660(%rip), %rcx      # 0x8734
pushq $0x64
popq %rdx
callq 0x2110
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7264
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree.cc
// Function: BTreeIndex::Display(std::ostream&, BTreeDisplayType) const
ERROR_T BTreeIndex::Display(ostream &o, BTreeDisplayType display_type) const
{
  ERROR_T rc;
  if (display_type==BTREE_DEPTH_DOT) { 
    o << "digraph tree { \n";
  }
  rc=DisplayInternal(superblock.info.rootnode,o,display_type);
  if (display_type==BTREE_DEPTH_DOT) { 
    o << "}\n";
  }
  return ERROR_NOERROR;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, %edx
jne 0x6bb7
leaq 0x1c45(%rip), %rsi      # 0x87d1
movq %rbx, %rdi
callq 0x21b0
leaq 0x28(%r14), %rsi
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x666e
leaq 0x1c35(%rip), %rsi      # 0x87e2
movq %rbx, %rdi
callq 0x21b0
jmp 0x6bc8
movl %edx, %ecx
leaq 0x28(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x666e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree_ds.cc
// Function: NodeMetadata::Print(std::ostream&) const
ostream & NodeMetadata::Print(ostream &os) const 
{
  os << "NodeMetaData(nodetype="<<(nodetype==BTREE_UNALLOCATED_BLOCK ? "UNALLOCATED_BLOCK" :
				   nodetype==BTREE_SUPERBLOCK ? "SUPERBLOCK" :
				   nodetype==BTREE_ROOT_NODE ? "ROOT_NODE" :
				   nodetype==BTREE_INTERIOR_NODE ? "INTERIOR_NODE" :
				   nodetype==BTREE_LEAF_NODE ? "LEAF_NODE" : "UNKNOWN_TYPE")
     << ", keysize="<<keysize<<", valuesize="<<valuesize<<", blocksize="<<blocksize
     << ", rootnode="<<rootnode<<", freelist="<<freelist<<", numkeys="<<numkeys<<")";
  return os;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x17c3(%rip), %rsi      # 0x8922
movq %rbx, %rdi
callq 0x21b0
movl (%r14), %ecx
cmpq $0x4, %rcx
jae 0x7180
leaq 0x1a15(%rip), %rdx      # 0x8b8c
movslq (%rdx,%rcx,4), %rsi
addq %rdx, %rsi
jmp 0x7195
cmpl $0x4, %ecx
leaq 0x17d2(%rip), %rcx      # 0x895c
leaq 0x17d5(%rip), %rsi      # 0x8966
cmoveq %rcx, %rsi
movq %rax, %rdi
callq 0x21b0
leaq 0x17cf(%rip), %rsi      # 0x8973
movq %rax, %rdi
callq 0x21b0
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x17bf(%rip), %rsi      # 0x897e
movq %rax, %rdi
callq 0x21b0
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x1351(%rip), %rsi      # 0x852b
movq %rax, %rdi
callq 0x21b0
movl 0xc(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x1796(%rip), %rsi      # 0x898b
movq %rax, %rdi
callq 0x21b0
movl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x1787(%rip), %rsi      # 0x8997
movq %rax, %rdi
callq 0x21b0
movl 0x14(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x1778(%rip), %rsi      # 0x89a3
movq %rax, %rdi
callq 0x21b0
movl 0x18(%r14), %esi
movq %rax, %rdi
callq 0x2120
leaq 0x151f(%rip), %rsi      # 0x8765
movq %rax, %rdi
callq 0x21b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::~BTreeNode()
BTreeNode::~BTreeNode()
{
  if (data) { 
    delete [] data;
  }
  data=0;
  info.nodetype=BTREE_UNALLOCATED_BLOCK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x7276
callq 0x2280
andq $0x0, 0x20(%rbx)
andl $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::BTreeNode(int, unsigned int, unsigned int, unsigned int)
BTreeNode::BTreeNode(int node_type, SIZE_T key_size, SIZE_T value_size, SIZE_T block_size)
{
  info.nodetype=node_type;
  info.keysize=key_size;
  info.valuesize=value_size;
  info.blocksize=block_size;
  info.rootnode=0;
  info.freelist=0;
  info.numkeys=0;				       
  data=0;
  if (info.nodetype!=BTREE_UNALLOCATED_BLOCK && info.nodetype!=BTREE_SUPERBLOCK) {
    data = new char [info.GetNumDataBytes()];
    memset(data,0,info.GetNumDataBytes());
  }
}

// Assembly:
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
andq $0x0, 0x10(%rdi)
andl $0x0, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
cmpl $0x2, %esi
jae 0x72a0
retq
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rdi, %r14
addl $-0x1c, %ebx
movq %rbx, %rdi
callq 0x2030
movq %rax, 0x20(%r14)
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::BTreeNode(BTreeNode const&)
BTreeNode::BTreeNode(const BTreeNode &rhs) 
{
  info.nodetype=rhs.info.nodetype;
  info.keysize=rhs.info.keysize;
  info.valuesize=rhs.info.valuesize;
  info.blocksize=rhs.info.blocksize;
  info.rootnode=rhs.info.rootnode;
  info.freelist=rhs.info.freelist;
  info.numkeys=rhs.info.numkeys;				       
  data=0;
  if (rhs.data) { 
   data=new char [info.GetNumDataBytes()];
    memcpy(data,rhs.data,info.GetNumDataBytes());
  }
}

// Assembly:
movdqu (%rsi), %xmm0
movdqu %xmm0, (%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movl 0x18(%rsi), %eax
movl %eax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
cmpq $0x0, 0x20(%rsi)
je 0x7329
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pshufd $0xff, %xmm0, %xmm0     # xmm0 = xmm0[3,3,3,3]
movd %xmm0, %r15d
addl $-0x1c, %r15d
movq %r15, %rdi
callq 0x2030
movq %rax, 0x20(%r14)
movq 0x20(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2160
retq
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::Serialize(BufferCache*, unsigned int) const
ERROR_T BTreeNode::Serialize(BufferCache *b, const SIZE_T blocknum) const
{
  assert((unsigned)info.blocksize==b->GetBlockSize());

  Block block(sizeof(info)+info.GetNumDataBytes());

  memcpy(block.data,&info,sizeof(info));
  if (info.nodetype!=BTREE_UNALLOCATED_BLOCK && info.nodetype!=BTREE_SUPERBLOCK) { 
    memcpy(block.data+sizeof(info),data,info.GetNumDataBytes());
  }

  return b->WriteBlock(blocknum,block);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0xc(%rdi), %ebp
movq %rsi, %rdi
callq 0x44c4
cmpl %eax, %ebp
jne 0x73ca
movl 0xc(%r15), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2aea
movq 0x8(%r12), %rax
movups (%r15), %xmm0
movups 0xc(%r15), %xmm1
movups %xmm1, 0xc(%rax)
movups %xmm0, (%rax)
cmpl $0x2, (%r15)
jb 0x73a0
movq 0x10(%rsp), %rdi
addq $0x1c, %rdi
movq 0x20(%r15), %rsi
movl 0xc(%r15), %edx
addl $-0x1c, %edx
callq 0x2160
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x45ce
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x2c6e
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15dd(%rip), %rdi      # 0x89ae
leaq 0x1602(%rip), %rsi      # 0x89da
leaq 0x1607(%rip), %rcx      # 0x89e6
pushq $0x64
popq %rdx
callq 0x2110
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2c6e
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::Unserialize(BufferCache*, unsigned int)
ERROR_T  BTreeNode::Unserialize(BufferCache *b, const SIZE_T blocknum)
{
  Block block;

  ERROR_T rc;

  rc=b->ReadBlock(blocknum,block);

  if (rc!=ERROR_NOERROR) {
    return rc;
  }

  memcpy(&info,block.data,sizeof(info));
  
  if (data) { 
    delete [] data;
    data=0;
  }

  assert(b->GetBlockSize()==(unsigned)info.blocksize);

  if (info.nodetype!=BTREE_UNALLOCATED_BLOCK && info.nodetype!=BTREE_SUPERBLOCK) {
    data = new char [info.GetNumDataBytes()];
    memcpy(data,block.data+sizeof(info),info.GetNumDataBytes());
  }
  
  return ERROR_NOERROR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movq %r12, %rdi
callq 0x2ac4
movq %r15, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x44fe
movl %eax, %ebx
testl %eax, %eax
jne 0x7490
movq 0x8(%rsp), %rax
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, 0xc(%r14)
movups %xmm0, (%r14)
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x7455
callq 0x2280
andq $0x0, 0x20(%r14)
movq %r15, %rdi
callq 0x44c4
movl %eax, %r15d
cmpl 0xc(%r14), %eax
jne 0x74a6
cmpl $0x2, (%r14)
jb 0x7490
addl $-0x1c, %r15d
movq %r15, %rdi
callq 0x2030
movq %rax, 0x20(%r14)
movq 0x8(%rsp), %rsi
addq $0x1c, %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2160
movq %rsp, %rdi
callq 0x2c6e
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1579(%rip), %rdi      # 0x8a26
leaq 0x1526(%rip), %rsi      # 0x89da
leaq 0x1597(%rip), %rcx      # 0x8a52
movl $0x84, %edx
callq 0x2110
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2c6e
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::ResolveKey(unsigned int) const
char * BTreeNode::ResolveKey(const SIZE_T offset) const
{
  switch (info.nodetype) { 
  case BTREE_INTERIOR_NODE:
  case BTREE_ROOT_NODE:
    assert(offset<info.numkeys);
    return data+sizeof(SIZE_T)+offset*(sizeof(SIZE_T)+info.keysize);
    break;
  case BTREE_LEAF_NODE:
    assert(offset<info.numkeys);
    return data+sizeof(SIZE_T)+offset*(info.keysize+info.valuesize);
    break;
  default:
    return 0;
  }
}

// Assembly:
pushq %rax
movl (%rdi), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x7502
cmpl %esi, 0x18(%rdi)
jbe 0x7526
movq 0x20(%rdi), %rax
movl %esi, %ecx
movl 0x4(%rdi), %edx
addq $0x4, %rdx
imulq %rcx, %rdx
addq %rdx, %rax
addq $0x4, %rax
jmp 0x7524
cmpl $0x4, %eax
jne 0x7522
cmpl %esi, 0x18(%rdi)
jbe 0x7545
movq 0x20(%rdi), %rax
movl 0x8(%rdi), %ecx
addl 0x4(%rdi), %ecx
imull %esi, %ecx
addq %rcx, %rax
addq $0x4, %rax
jmp 0x7524
xorl %eax, %eax
popq %rcx
retq
leaq 0x1561(%rip), %rdi      # 0x8a8e
leaq 0x14a6(%rip), %rsi      # 0x89da
leaq 0x1567(%rip), %rcx      # 0x8aa2
movl $0x94, %edx
callq 0x2110
leaq 0x1542(%rip), %rdi      # 0x8a8e
leaq 0x1487(%rip), %rsi      # 0x89da
leaq 0x1548(%rip), %rcx      # 0x8aa2
movl $0x98, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::ResolvePtr(unsigned int) const
char * BTreeNode::ResolvePtr(const SIZE_T offset) const
{
  switch (info.nodetype) { 
  case BTREE_INTERIOR_NODE:
  case BTREE_ROOT_NODE:
    assert(offset<=info.numkeys);
    return data+offset*(sizeof(SIZE_T)+info.keysize);
    break;
  case BTREE_LEAF_NODE:
    assert(offset==0);
    return data;
    break;
  default:
    return 0;
  }
}

// Assembly:
pushq %rax
movl (%rdi), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x7587
cmpl %esi, 0x18(%rdi)
jb 0x759a
movl %esi, %ecx
movl 0x4(%rdi), %eax
addq $0x4, %rax
imulq %rcx, %rax
addq 0x20(%rdi), %rax
jmp 0x7598
cmpl $0x4, %eax
jne 0x7596
testl %esi, %esi
jne 0x75b9
movq 0x20(%rdi), %rax
jmp 0x7598
xorl %eax, %eax
popq %rcx
retq
leaq 0x1531(%rip), %rdi      # 0x8ad2
leaq 0x1432(%rip), %rsi      # 0x89da
leaq 0x1538(%rip), %rcx      # 0x8ae7
movl $0xa6, %edx
callq 0x2110
leaq 0x1557(%rip), %rdi      # 0x8b17
leaq 0x1413(%rip), %rsi      # 0x89da
leaq 0x1519(%rip), %rcx      # 0x8ae7
movl $0xaa, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::ResolveVal(unsigned int) const
char * BTreeNode::ResolveVal(const SIZE_T offset) const
{
  switch (info.nodetype) { 
  case BTREE_LEAF_NODE:
    assert(offset<info.numkeys);
    return data+sizeof(SIZE_T)+offset*(info.keysize+info.valuesize)+info.keysize;
    break;
  default:
    return 0;
  }
}

// Assembly:
cmpl $0x4, (%rdi)
jne 0x75f9
cmpl %esi, 0x18(%rdi)
jbe 0x75fc
movl 0x4(%rdi), %eax
movl 0x8(%rdi), %ecx
addl %eax, %ecx
imull %esi, %ecx
addq 0x20(%rdi), %rcx
addq %rcx, %rax
addq $0x4, %rax
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x148a(%rip), %rdi      # 0x8a8e
leaq 0x13cf(%rip), %rsi      # 0x89da
leaq 0x150f(%rip), %rcx      # 0x8b21
movl $0xb8, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::GetKey(unsigned int, Block&) const
ERROR_T BTreeNode::GetKey(const SIZE_T offset, KEY_T &k) const
{
  char *p=ResolveKey(offset);

  if (p==0) { 
    return ERROR_NOMEM;
  }
  
  k.Resize(info.keysize,false);
  memcpy(k.data,p,info.keysize);
  return ERROR_NOERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x74d8
testq %rax, %rax
je 0x765e
movq %rax, %r15
movl 0x4(%r14), %esi
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2b18
movq 0x8(%rbx), %rdi
movl 0x4(%r14), %edx
movq %r15, %rsi
callq 0x2160
jmp 0x7661
pushq $-0x2
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::GetVal(unsigned int, Block&) const
ERROR_T BTreeNode::GetVal(const SIZE_T offset, VALUE_T &v) const
{
  char *p=ResolveVal(offset);

  if (p==0) { 
    return ERROR_NOMEM;
  }
  
  v.Resize(info.valuesize,false);
  memcpy(v.data,p,info.valuesize);
  return ERROR_NOERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x75d8
testq %rax, %rax
je 0x76c6
movq %rax, %r15
movl 0x8(%r14), %esi
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2b18
movq 0x8(%rbx), %rdi
movl 0x8(%r14), %edx
movq %r15, %rsi
callq 0x2160
jmp 0x76c9
pushq $-0x2
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/It4innovations[P]Handicap/src/GraphLabelings/../Solvers/kSumProblemSolver.h
// Function: kSumProblemSolver<int>::solve2SUM(std::unique_ptr<int [], std::default_delete<int []>> const&, std::stack<int, std::deque<int, std::allocator<int>>>&)
void solve2SUM(const std::unique_ptr<T[]> & labels, std::stack<T> & solution) {
			int sum = 0, lhs = 0, rhs = this->labelsCount - 1;
			while (lhs < rhs) {
				sum = labels[lhs] + labels[rhs];
				if (sum < this->searchNumber) {
					lhs += 1;
				} else if (sum > this->searchNumber) {
					rhs -= 1;
				} else {
					solution.emplace(labels[lhs]);
					solution.emplace(labels[rhs]);
					rhs -= 1;
					lhs += 1;
				}
			}
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdi), %ebp
decl %ebp
xorl %r13d, %r13d
movslq %r13d, %rax
movq (%r14), %rcx
movl 0x4(%r15), %edx
movslq %ebp, %r12
shlq $0x2, %r12
cmpl %ebp, %r13d
jge 0x2985
movl (%rcx,%r12), %esi
addl (%rcx,%rax,4), %esi
cmpl %edx, %esi
jl 0x2980
jle 0x2964
decl %ebp
addq $-0x4, %r12
jmp 0x294a
leaq (%rcx,%rax,4), %rsi
movq %rbx, %rdi
callq 0x47e6
addq (%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x47e6
decl %ebp
incl %r13d
jmp 0x2939
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/It4innovations[P]Handicap/src/GraphLabelings/../Solvers/kSumProblemSolver.h
// Function: kSumProblemSolver<int>::solve3SUM(std::unique_ptr<int [], std::default_delete<int []>> const&, std::stack<int, std::deque<int, std::allocator<int>>>&)
void solve3SUM(const std::unique_ptr<T[]> & labels, std::stack<T> & solution) {
			int sum, lhs, rhs, searchWeight;
			for (int i = labelsCount - 1; i >= 2; --i) {
				lhs = 0;
				rhs = i - 1;
				searchWeight = searchNumber - labels[i];
				if (searchWeight <= 0) continue;
				while (lhs < rhs) {
					sum = labels[lhs] + labels[rhs];
					if (sum < searchWeight) {
						lhs += 1;
					} else if (sum > searchWeight) {
						rhs -= 1;
					} else {
						solution.emplace(labels[lhs]);
						solution.emplace(labels[rhs]);
						solution.emplace(labels[i]);
						rhs -= 1;
						lhs += 1;
					}
				}
			}
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %r8
movl (%rdi), %eax
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x18(%rsp), %r14
cmpl $0x2, %eax
jle 0x2a60
movl %eax, %ecx
leaq -0x1(%rax), %r13
movl 0x4(%rdi), %ebp
movq (%r8), %rdx
subl -0x4(%rdx,%rax,4), %ebp
movq %r13, %rax
jle 0x29bb
leal -0x2(%rcx), %ebx
xorl %r15d, %r15d
leaq (,%r13,4), %rax
movq %rax, 0x20(%rsp)
movq (%r8), %rax
movslq %ebx, %r12
movslq %r15d, %rcx
leaq (%rax,%rcx,4), %rsi
cmpl %ebx, %r15d
jge 0x2a58
movl (%rax,%r12,4), %ecx
addl (%rsi), %ecx
cmpl %ebp, %ecx
jge 0x2a11
incl %r15d
addq $0x4, %rsi
jmp 0x29f9
jg 0x2a54
movq %r14, %rdi
callq 0x47e6
shlq $0x2, %r12
movq 0x8(%rsp), %rax
addq (%rax), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x47e6
movq 0x8(%rsp), %rax
movq (%rax), %rsi
addq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x47e6
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %r8
incl %r15d
decl %ebx
jmp 0x29ec
movq %r13, %rax
jmp 0x29bb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/It4innovations[P]Handicap/src/GraphLabelings/../Solvers/kSumProblemSolver.h
// Function: kSumProblemSolver<int>::solve4SUM(std::unique_ptr<int [], std::default_delete<int []>> const&, std::stack<int, std::deque<int, std::allocator<int>>>&)
void solve4SUM(const std::unique_ptr<T[]> & labels, std::stack<T> & solution) {
			int sum, lhs, rhs, searchWeight;
			for (int i = labelsCount - 1; i >= 3; --i) {
				for (int j = i - 1; j >= 2; --j) {
					lhs = 0;
					rhs = j - 1;
					searchWeight = searchNumber - labels[i] - labels[j];
					if (searchWeight <= 0) continue;
					while (lhs < rhs) {
						sum = labels[lhs] + labels[rhs];
						if (sum < searchWeight) {
							lhs += 1;
						} else if (sum > searchWeight) {
							rhs -= 1;
						} else {
							solution.emplace(labels[lhs]);
							solution.emplace(labels[rhs]);
							solution.emplace(labels[j]);
							solution.emplace(labels[i]);
							rhs -= 1;
							lhs += 1;
						}
					}
				}
			}
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, %rdx
movl (%rdi), %r8d
leal -0x2(%r8), %eax
movq %rsi, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x28(%rsp), %r15
cmpl $0x4, %r8d
jl 0x2b8a
decq %r8
movq %rax, 0x18(%rsp)
movq %rax, %r9
movq %r8, 0x10(%rsp)
movq %r9, %rbp
cmpl $0x2, %ebp
jl 0x2b7d
leaq -0x1(%rbp), %r9
movl 0x4(%rdi), %ebx
movq (%rdx), %rax
movl (%rax,%r8,4), %ecx
addl (%rax,%rbp,4), %ecx
subl %ecx, %ebx
testl %ebx, %ebx
jle 0x2ab6
xorl %r13d, %r13d
shlq $0x2, %rbp
movl %r9d, %r14d
movq (%rdx), %rax
movslq %r14d, %r12
movslq %r13d, %rcx
leaq (%rax,%rcx,4), %rsi
cmpl %r14d, %r13d
jge 0x2ab6
movl (%rax,%r12,4), %ecx
addl (%rsi), %ecx
cmpl %ebx, %ecx
jge 0x2b08
incl %r13d
addq $0x4, %rsi
jmp 0x2af0
jg 0x2b75
movq %r15, %rdi
movq %r9, 0x30(%rsp)
callq 0x47e6
shlq $0x2, %r12
movq 0x8(%rsp), %rax
addq (%rax), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x47e6
movq 0x8(%rsp), %rax
movq (%rax), %rsi
addq %rbp, %rsi
movq %r15, %rdi
callq 0x47e6
movq 0x10(%rsp), %rax
leaq (,%rax,4), %rsi
movq 0x8(%rsp), %rax
addq (%rax), %rsi
movq %r15, %rdi
callq 0x47e6
movq 0x30(%rsp), %r9
movq 0x10(%rsp), %r8
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
incl %r13d
decl %r14d
jmp 0x2ae3
movq 0x18(%rsp), %rax
decq %rax
jmp 0x2a9c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/It4innovations[P]Handicap/src/GraphLabelings/../Solvers/kSumProblemSolver.h
// Function: kSumProblemSolver<int>::solve5SUM(std::unique_ptr<int [], std::default_delete<int []>> const&, std::stack<int, std::deque<int, std::allocator<int>>>&)
void solve5SUM(const std::unique_ptr<T[]> & labels, std::stack<T> & solution) {
			int sum, lhs, rhs, searchWeight;
			for (int k = labelsCount - 1; k >= 4; --k) {
				for (int i = k-1; i >= 3; --i) {
					for (int j = i - 1; j >= 2; --j) {
						lhs = 0;
						rhs = j - 1;
						searchWeight = searchNumber - labels[i] - labels[j] - labels[k];
						if (searchWeight <= 0) continue;
						while (lhs < rhs) {
							sum = labels[lhs] + labels[rhs];
							if (sum < searchWeight) {
								lhs += 1;
							} else if (sum > searchWeight) {
								rhs -= 1;
							} else {
								solution.emplace(labels[lhs]);
								solution.emplace(labels[rhs]);
								solution.emplace(labels[j]);
								solution.emplace(labels[i]);
								solution.emplace(labels[k]);
								rhs -= 1;
								lhs += 1;
							}
						}
					}
				}
			}
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, %r8
movl (%rdi), %r9d
leal -0x2(%r9), %eax
movq %rax, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x30(%rsp), %r14
cmpl $0x5, %r9d
jl 0x2cf0
decq %r9
movq 0x10(%rsp), %r10
movq %r9, 0x18(%rsp)
cmpl $0x3, %r10d
jl 0x2ce6
movq %r10, %rbp
movq %r10, 0x20(%rsp)
cmpl $0x2, %ebp
jle 0x2cde
movl %ebp, %eax
movl 0x4(%rdi), %r13d
movq (%r8), %rcx
movl (%rcx,%r10,4), %edx
addl -0x4(%rcx,%rbp,4), %edx
decq %rbp
addl (%rcx,%r9,4), %edx
subl %edx, %r13d
testl %r13d, %r13d
jle 0x2bf4
leal -0x2(%rax), %ebx
xorl %r15d, %r15d
movq (%r8), %rax
movslq %ebx, %r12
movslq %r15d, %rcx
leaq (%rax,%rcx,4), %rsi
cmpl %ebx, %r15d
jge 0x2bf4
movl (%rax,%r12,4), %ecx
addl (%rsi), %ecx
cmpl %r13d, %ecx
jge 0x2c49
incl %r15d
addq $0x4, %rsi
jmp 0x2c30
jg 0x2cd7
movq %r14, %rdi
callq 0x47e6
shlq $0x2, %r12
movq 0x8(%rsp), %rax
addq (%rax), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x47e6
leaq (,%rbp,4), %rsi
movq 0x8(%rsp), %rax
addq (%rax), %rsi
movq %r14, %rdi
callq 0x47e6
movq 0x20(%rsp), %rax
leaq (,%rax,4), %rsi
movq 0x8(%rsp), %rax
addq (%rax), %rsi
movq %r14, %rdi
callq 0x47e6
movq 0x18(%rsp), %rax
leaq (,%rax,4), %rsi
movq 0x8(%rsp), %rax
addq (%rax), %rsi
movq %r14, %rdi
callq 0x47e6
movq 0x20(%rsp), %r10
movq 0x18(%rsp), %r9
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %r8
incl %r15d
decl %ebx
jmp 0x2c23
decq %r10
jmp 0x2be2
decq 0x10(%rsp)
jmp 0x2bcb
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/It4innovations[P]Handicap/src/GraphLabelings/../Solvers/kSumProblemSolver.h
// Function: kSumProblemSolver<int>::solve(std::unique_ptr<int [], std::default_delete<int []>> const&, int const&, std::stack<int, std::deque<int, std::allocator<int>>>&)
void solve(const std::unique_ptr<T[]> & labels, const int & labelsCount, std::stack<T> & solution) {
			this->labelsCount = labelsCount;
			if (nSum < 1 || nSum > 5) {
				throw std::runtime_error("It does not implement " + std::to_string(nSum) + " nSum\n");
			}

			if (this->nSum == 2) {
				this->solve2SUM(labels, solution);
			} else if (this->nSum == 3) {
				this->solve3SUM(labels, solution);
			} else if (this->nSum == 4) {
				this->solve4SUM(labels, solution);
			} else if (this->nSum == 5) {
				this->solve5SUM(labels, solution);
			}
		}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
movl (%rdx), %eax
movl %eax, (%rdi)
movl 0x8(%rdi), %eax
leal -0x6(%rax), %edx
cmpl $-0x6, %edx
jbe 0x2d87
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x2d7e
leaq 0x42db(%rip), %rdx      # 0x7004
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rcx, %rdx
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x291e
movq %r14, %rdi
movq %rcx, %rdx
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2a70
movq %r14, %rdi
movq %rcx, %rdx
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2b9a
movq %r14, %rdi
movq %rcx, %rdx
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2994
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %rbx
movl 0x8(%r14), %esi
movq %rsp, %rdi
callq 0x2e7c
leaq 0x42a7(%rip), %rsi      # 0x704c
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x2e58
leaq 0x42aa(%rip), %rdx      # 0x7063
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2e39
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x2230
xorl %ebp, %ebp
movq 0x920f(%rip), %rsi      # 0xbff0
movq 0x91d0(%rip), %rdx      # 0xbfb8
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x20b0
jmp 0x2e05
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x20b0
jmp 0x2e17
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x20b0
testb %bpl, %bpl
jne 0x2e29
jmp 0x2e31
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/It4innovations[P]Handicap/src/Outputs/GraphInfoPrinter.h
// Function: GraphInfoPrinter::print(std::shared_ptr<ExtendedHandicapGraph>&)
static void print(std::shared_ptr<ExtendedHandicapGraph> & graph) {
			std::cout << "extended handicap regular graphs\n"
			          << "Vertices count: " << graph->getVerticesCount()
			          << "\nRegular number: " << graph->getRegularConstant()
			          << "\nMagic constant l: " << graph->getMagicConstant()
			          << "\nMissing label: " << graph->getMissingLabel()
			          << '\n';
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x9069(%rip), %rdi      # 0xbfc8
leaq 0x421c(%rip), %rsi      # 0x7182
callq 0x2180
leaq 0x4232(%rip), %rsi      # 0x71a4
movq %rax, %rdi
callq 0x2180
movq (%rbx), %rcx
movl 0x4(%rcx), %esi
movq %rax, %rdi
callq 0x2290
leaq 0x4226(%rip), %rsi      # 0x71b5
movq %rax, %rdi
callq 0x2180
movq (%rbx), %rcx
movl 0x8(%rcx), %esi
movq %rax, %rdi
callq 0x2290
leaq 0x421b(%rip), %rsi      # 0x71c7
movq %rax, %rdi
callq 0x2180
movq (%rbx), %rcx
movl 0xc(%rcx), %esi
movq %rax, %rdi
callq 0x2290
leaq 0x4212(%rip), %rsi      # 0x71db
movq %rax, %rdi
callq 0x2180
movq (%rbx), %rcx
movl 0x10(%rcx), %esi
movq %rax, %rdi
callq 0x2290
pushq $0xa
popq %rsi
movq %rax, %rdi
popq %rbx
jmp 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/It4innovations[P]Handicap/src/Concurrency/ThreadPool.h
// Function: ThreadPool::execute()
void execute() {
			std::vector<std::thread> threads;
			for (int i = 0; i < this->numberOfThread; i++) {
				threads.emplace_back(std::thread([this]() {
					while (true) {
						std::function<void()> task;
						bool result = this->queue.tryPop(task);
						if (!result) break;
						task();
					}
				}));
			}
			for (auto & thread : threads) {
				if (thread.joinable()) {
					thread.join();
				}
			}
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
movaps %xmm0, (%r14)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq %rsp, %r12
cmpl (%rbx), %ebp
jge 0x3132
movq %rbx, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x420c
movq %r14, %rdi
movq %r15, %rsi
callq 0x41e4
movq %r15, %rdi
callq 0x4274
incl %ebp
jmp 0x3108
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x3155
cmpq $0x0, (%rbx)
je 0x314f
movq %rbx, %rdi
callq 0x2270
addq $0x8, %rbx
jmp 0x313c
leaq 0x10(%rsp), %rdi
callq 0x4282
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x317d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4274
jmp 0x3180
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4282
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/It4innovations[P]Handicap/src/GraphLabelings/../Graphs/Validators/GraphValidator.h
// Function: GraphValidator::GraphValidator()
GraphValidator() {
			this->rules.emplace_back(std::unique_ptr<EvenVerticesCountRule> (new EvenVerticesCountRule()));
			this->rules.emplace_back(std::unique_ptr<PositiveEdgesCountRule> (new PositiveEdgesCountRule()));
			this->rules.emplace_back(std::unique_ptr<PositiveRegularConstantRule> (new PositiveRegularConstantRule()));
			this->rules.emplace_back(std::unique_ptr<PositiveVerticesCountRule> (new PositiveVerticesCountRule()));
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
pushq $0x8
popq %rdi
callq 0x2190
leaq 0x897b(%rip), %rcx      # 0xbbf8
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x33a2
movq %rsp, %rdi
callq 0x33c4
pushq $0x8
popq %rdi
callq 0x2190
leaq 0x8993(%rip), %rcx      # 0xbc38
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x33dc
movq %rsp, %rdi
callq 0x33fe
pushq $0x8
popq %rdi
callq 0x2190
leaq 0x899b(%rip), %rcx      # 0xbc68
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3416
movq %rsp, %rdi
callq 0x3438
pushq $0x8
popq %rdi
callq 0x2190
leaq 0x89a3(%rip), %rcx      # 0xbc98
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3450
movq %rsp, %rdi
callq 0x3472
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x3472
jmp 0x3353
jmp 0x3350
movq %rax, %r14
movq %rsp, %rdi
callq 0x3438
jmp 0x3353
jmp 0x3350
movq %rax, %r14
movq %rsp, %rdi
callq 0x33fe
jmp 0x3353
jmp 0x3350
movq %rax, %r14
movq %rsp, %rdi
callq 0x33c4
jmp 0x3353
movq %rax, %r14
movq %rbx, %rdi
callq 0x348a
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/It4innovations[P]Handicap/src/Concurrency/ThreadSafeQueue.h
// Function: ThreadSafeQueue<std::function<void ()>>::tryPop(std::function<void ()>&)
bool tryPop(T & out) {
			std::lock_guard<std::mutex> lock{this->mut};
			if (this->queue.empty() || !this->valid) {
				return false;
			}
			out = std::move(this->queue.front());
			this->queue.pop();
			return true;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x3f6e
movq 0x60(%r14), %rax
cmpq 0x40(%r14), %rax
je 0x44f9
movb (%r14), %al
testb $0x1, %al
je 0x44f9
movq 0x40(%r14), %rsi
addq $0x30, %r14
movq %r15, %rdi
callq 0x4520
movq %r14, %rdi
callq 0x4582
movb $0x1, %bpl
jmp 0x44fb
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2130
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/It4innovations[P]Handicap/src/GraphLabelings/GraphLabeling.h
// Function: GraphLabeling::prepareSolve(int, std::vector<int, std::allocator<int>>, std::mutex&)
void prepareSolve(int label, std::vector<int> vec, std::mutex & mut) {
			++this->levelOfRecursion;
			const int freeSlots = solution->getFreeCellsInColumn(label);
			for (int slot = 0; slot < (int) vec.size(); ++slot) {
				this->intermediateNSumResults[levelOfRecursion].emplace(vec[slot]);
			}
			this->markLabelsToSolution(label, freeSlots);

			for (int slot = 0; slot < freeSlots; ++slot) {
				this->intermediateNSumResults[levelOfRecursion].emplace(this->disabledNumbersArray[slot]);
			}

			const int nextLabelIndex = solution->selectNextLabel();
			this->solve(nextLabelIndex, mut);

			// unmark numbers from solution
			this->unmarkLabelsFromSolution(label, freeSlots);

			--levelOfRecursion;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdi, %rbx
incl 0x40(%rdi)
movq %rdx, %r12
movl %esi, %ebp
movq 0x10(%rdi), %rax
movslq %esi, %rcx
movq 0x18(%rax), %rax
movl (%rax,%rcx,4), %r15d
xorl %r13d, %r13d
xorl %r14d, %r14d
movq (%r12), %rsi
movq 0x8(%r12), %rax
subq %rsi, %rax
shrq $0x2, %rax
cltq
cmpq %rax, %r14
jge 0x5105
movslq 0x40(%rbx), %rax
imulq $0x50, %rax, %rdi
addq 0x30(%rbx), %rdi
addq %r13, %rsi
callq 0x47e6
incq %r14
addq $0x4, %r13
jmp 0x50d1
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x5980
xorl %r14d, %r14d
testl %r15d, %r15d
movl $0x0, %r12d
cmovgl %r15d, %r12d
shlq $0x2, %r12
cmpq %r14, %r12
je 0x5149
movslq 0x40(%rbx), %rax
imulq $0x50, %rax, %rdi
addq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
addq %r14, %rsi
callq 0x47e6
addq $0x4, %r14
jmp 0x5126
movq 0x10(%rbx), %rdi
callq 0x5a1e
movq %rbx, %rdi
movl %eax, %esi
movq (%rsp), %rdx
callq 0x5aac
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x5c1a
decl 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop