LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x20(%rdi)
cmpq $0x0, 0x20(%rsi)
je 0x7d2a
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 0x2170
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4b3c
cmpl %eax, %ebp
jne 0x7dcc
movl 0xc(%r15), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2c84
movq 0x8(%r12), %rax
movups (%r15), %xmm0
movups 0xc(%r15), %xmm1
movups %xmm1, 0xc(%rax)
movups %xmm0, (%rax)
cmpl $0x2, (%r15)
jb 0x7da2
movq 0x10(%rsp), %rdi
addq $0x1c, %rdi
movq 0x20(%r15), %rsi
movl 0xc(%r15), %edx
addl $-0x1c, %edx
callq 0x2170
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4c52
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x2e26
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bdb(%rip), %rdi      # 0x99ae
leaq 0x1c00(%rip), %rsi      # 0x99da
leaq 0x1c05(%rip), %rcx      # 0x99e6
movl $0x64, %edx
callq 0x2110
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2e26
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c58
movq %r15, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x4b7a
movl %eax, %ebx
testl %eax, %eax
jne 0x7e97
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 0x7e5c
callq 0x2280
movq $0x0, 0x20(%r14)
movq %r15, %rdi
callq 0x4b3c
movl %eax, %r15d
cmpl 0xc(%r14), %eax
jne 0x7ead
cmpl $0x2, (%r14)
jb 0x7e97
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 0x2170
movq %rsp, %rdi
callq 0x2e26
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b72(%rip), %rdi      # 0x9a26
leaq 0x1b1f(%rip), %rsi      # 0x99da
leaq 0x1b90(%rip), %rcx      # 0x9a52
movl $0x84, %edx
callq 0x2110
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2e26
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7f0a
cmpl %esi, 0x18(%rdi)
jbe 0x7f2e
movq 0x20(%rdi), %rax
movl %esi, %ecx
movl 0x4(%rdi), %edx
addq $0x4, %rdx
imulq %rcx, %rdx
addq %rdx, %rax
addq $0x4, %rax
jmp 0x7f2c
cmpl $0x4, %eax
jne 0x7f2a
cmpl %esi, 0x18(%rdi)
jbe 0x7f4d
movq 0x20(%rdi), %rax
movl 0x8(%rdi), %ecx
addl 0x4(%rdi), %ecx
imull %esi, %ecx
addq %rcx, %rax
addq $0x4, %rax
jmp 0x7f2c
xorl %eax, %eax
popq %rcx
retq
leaq 0x1b59(%rip), %rdi      # 0x9a8e
leaq 0x1a9e(%rip), %rsi      # 0x99da
leaq 0x1b5f(%rip), %rcx      # 0x9aa2
movl $0x94, %edx
callq 0x2110
leaq 0x1b3a(%rip), %rdi      # 0x9a8e
leaq 0x1a7f(%rip), %rsi      # 0x99da
leaq 0x1b40(%rip), %rcx      # 0x9aa2
movl $0x98, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7f8f
cmpl %esi, 0x18(%rdi)
jb 0x7fa2
movl %esi, %ecx
movl 0x4(%rdi), %eax
addq $0x4, %rax
imulq %rcx, %rax
addq 0x20(%rdi), %rax
jmp 0x7fa0
cmpl $0x4, %eax
jne 0x7f9e
testl %esi, %esi
jne 0x7fc1
movq 0x20(%rdi), %rax
jmp 0x7fa0
xorl %eax, %eax
popq %rcx
retq
leaq 0x1b29(%rip), %rdi      # 0x9ad2
leaq 0x1a2a(%rip), %rsi      # 0x99da
leaq 0x1b30(%rip), %rcx      # 0x9ae7
movl $0xa6, %edx
callq 0x2110
leaq 0x1b4f(%rip), %rdi      # 0x9b17
leaq 0x1a0b(%rip), %rsi      # 0x99da
leaq 0x1b11(%rip), %rcx      # 0x9ae7
movl $0xaa, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8001
cmpl %esi, 0x18(%rdi)
jbe 0x8004
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 0x1a82(%rip), %rdi      # 0x9a8e
leaq 0x19c7(%rip), %rsi      # 0x99da
leaq 0x1b07(%rip), %rcx      # 0x9b21
movl $0xb8, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7ee0
testq %rax, %rax
je 0x8066
movq %rax, %r15
movl 0x4(%r14), %esi
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2cba
movq 0x8(%rbx), %rdi
movl 0x4(%r14), %edx
movq %r15, %rsi
callq 0x2170
jmp 0x806b
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7fe0
testq %rax, %rax
je 0x80d2
movq %rax, %r15
movl 0x8(%r14), %esi
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2cba
movq 0x8(%rbx), %rdi
movl 0x8(%r14), %edx
movq %r15, %rsi
callq 0x2170
jmp 0x80d7
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::SetKeyVal(unsigned int, KeyValuePair const&)
ERROR_T BTreeNode::SetKeyVal(const SIZE_T offset, const KeyValuePair &p)
{
  ERROR_T rc=SetKey(offset,p.key);

  if (rc!=ERROR_NOERROR) { 
    return rc;
  } else {
    return SetVal(offset,p.value);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
callq 0x7ee0
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
testq %rax, %rax
je 0x81f3
movq 0x10(%rbx), %rsi
movl 0x4(%r14), %edx
movq %rax, %rdi
callq 0x2170
movq %r14, %rdi
movl %r15d, %esi
callq 0x7fe0
testq %rax, %rax
je 0x81f3
movq 0x38(%rbx), %rsi
movl 0x8(%r14), %edx
movq %rax, %rdi
callq 0x2170
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl (%rdi), %ebp
cmpl $0x2, %ebp
jl 0x2bca
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
decl %ebp
xorl %r13d, %r13d
movslq %r13d, %rdx
movq (%r14), %rsi
movl (%rsi,%rdx,4), %edi
movslq %ebp, %r12
movl (%rsi,%r12,4), %eax
addl %edi, %eax
cmpl 0x4(%r15), %eax
jl 0x2bbe
jle 0x2b60
decl %ebp
jmp 0x2bc1
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
leaq -0x4(%rcx), %r8
cmpq %r8, %rax
je 0x2b7d
movl %edi, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2b91
leaq (%rsi,%rdx,4), %rsi
movq %rbx, %rdi
callq 0x4b4e
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
shlq $0x2, %r12
addq (%r14), %r12
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x2bb1
movl (%r12), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2bbc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4b4e
decl %ebp
incl %r13d
cmpl %ebp, %r13d
jl 0x2b42
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x18, %rsp
movq %rdi, 0x10(%rsp)
movslq (%rdi), %rcx
cmpq $0x3, %rcx
jl 0x2d04
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x1(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %r15d
movq (%r14), %rax
movq %rcx, (%rsp)
subl -0x4(%rax,%rcx,4), %r15d
jle 0x2cf4
movq (%rsp), %rax
leal -0x2(%rax), %r13d
xorl %ebp, %ebp
movslq %ebp, %rdx
movq (%r14), %rsi
movl (%rsi,%rdx,4), %edi
movslq %r13d, %r12
movl (%rsi,%r12,4), %eax
addl %edi, %eax
cmpl %r15d, %eax
jl 0x2ce9
jle 0x2c53
decl %r13d
jmp 0x2ceb
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
leaq -0x4(%rcx), %r8
cmpq %r8, %rax
je 0x2c70
movl %edi, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2c84
leaq (%rsi,%rdx,4), %rsi
movq %rbx, %rdi
callq 0x4b4e
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
shlq $0x2, %r12
addq (%r14), %r12
leaq -0x4(%rcx), %rdx
cmpq %rdx, %rax
je 0x2ca4
movl (%r12), %edx
movl %edx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2cb7
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4b4e
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rsp), %rdx
leaq (,%rdx,4), %rsi
addq (%r14), %rsi
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x2cde
movl (%rsi), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2ce6
movq %rbx, %rdi
callq 0x4b4e
decl %r13d
incl %ebp
cmpl %r13d, %ebp
jl 0x2c2e
cmpq $0x3, (%rsp)
movq 0x8(%rsp), %rcx
jg 0x2c00
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, 0x30(%rsp)
movslq (%rdi), %rcx
movq %rcx, 0x8(%rsp)
cmpq $0x4, %rcx
jl 0x2ec9
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsp), %rax
leal -0x2(%rax), %ecx
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
decq %rax
movq %rax, 0x8(%rsp)
movq %rcx, 0x28(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x10(%rsp), %rdx
leaq -0x1(%rdx), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %r15d
movq (%r14), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movq %rdx, 0x18(%rsp)
addl (%rax,%rdx,4), %ecx
subl %ecx, %r15d
testl %r15d, %r15d
jle 0x2eaa
cmpl $0x2, 0x18(%rsp)
jl 0x2eaa
xorl %r13d, %r13d
movq 0x10(%rsp), %rax
movl %eax, %ebp
movslq %r13d, %rdx
movq (%r14), %rsi
movl (%rsi,%rdx,4), %edi
movslq %ebp, %r12
movl (%rsi,%r12,4), %eax
addl %edi, %eax
cmpl %r15d, %eax
jl 0x2e9e
jle 0x2dd2
decl %ebp
jmp 0x2ea1
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
leaq -0x4(%rcx), %r8
cmpq %r8, %rax
je 0x2def
movl %edi, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2e03
leaq (%rsi,%rdx,4), %rsi
movq %rbx, %rdi
callq 0x4b4e
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
shlq $0x2, %r12
addq (%r14), %r12
leaq -0x4(%rcx), %rdx
cmpq %rdx, %rax
je 0x2e23
movl (%r12), %edx
movl %edx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2e36
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4b4e
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x18(%rsp), %rdx
leaq (,%rdx,4), %rsi
addq (%r14), %rsi
leaq -0x4(%rcx), %rdx
cmpq %rdx, %rax
je 0x2e5d
movl (%rsi), %edx
movl %edx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2e6d
movq %rbx, %rdi
callq 0x4b4e
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rsp), %rdx
leaq (,%rdx,4), %rsi
addq (%r14), %rsi
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x2e94
movl (%rsi), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x2e9c
movq %rbx, %rdi
callq 0x4b4e
decl %ebp
incl %r13d
cmpl %ebp, %r13d
jl 0x2dae
cmpl $0x2, 0x18(%rsp)
jg 0x2d63
movq 0x28(%rsp), %rcx
decq %rcx
cmpq $0x4, 0x20(%rsp)
jg 0x2d47
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movl (%rdx), %eax
movl %eax, (%rdi)
movl 0x8(%rdi), %eax
leal -0x6(%rax), %edx
cmpl $-0x6, %edx
jbe 0x3189
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x317e
leaq 0x3ee3(%rip), %rdx      # 0x7004
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rcx, %rdx
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b1e
movq %r14, %rdi
movq %rcx, %rdx
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2d14
movq %r14, %rdi
movq %rcx, %rdx
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2ed8
movq %r14, %rdi
movq %rcx, %rdx
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2bda
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
movl 0x8(%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0x331a
leaq 0x3eb5(%rip), %rsi      # 0x7060
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x32aa
leaq 0x3eb6(%rip), %rsi      # 0x7077
leaq 0x48(%rsp), %rdi
callq 0x22b0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x31ec
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x31f9
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x2220
xorl %ebp, %ebp
movq 0x7dc7(%rip), %rsi      # 0xaff0
movq 0x7d88(%rip), %rdx      # 0xafb8
movq %rbx, %rdi
callq 0x2270
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3252
callq 0x2160
jmp 0x3252
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3265
callq 0x2160
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3278
callq 0x2160
testb %bpl, %bpl
jne 0x329a
jmp 0x32a2
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x329a
callq 0x2160
jmp 0x329a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7b4c(%rip), %r14      # 0xafc8
leaq 0x3d13(%rip), %rsi      # 0x7196
movl $0x21, %edx
movq %r14, %rdi
callq 0x21a0
leaq 0x3d21(%rip), %rsi      # 0x71b8
movl $0x10, %edx
movq %r14, %rdi
callq 0x21a0
movq (%rbx), %rax
movl 0x4(%rax), %esi
movq %r14, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x3d0d(%rip), %rsi      # 0x71c9
movl $0x11, %edx
movq %rax, %rdi
callq 0x21a0
movq (%rbx), %rax
movl 0x8(%rax), %esi
movq %r14, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x3cfa(%rip), %rsi      # 0x71db
movl $0x13, %edx
movq %rax, %rdi
callq 0x21a0
movq (%rbx), %rax
movl 0xc(%rax), %esi
movq %r14, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x3ce9(%rip), %rsi      # 0x71ef
movl $0x10, %edx
movq %rax, %rdi
callq 0x21a0
movq (%rbx), %rax
movl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x2280
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x21a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x10(%rdi)
movl $0x8, %edi
callq 0x2180
leaq 0x7482(%rip), %rcx      # 0xac08
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3870
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x37a5
callq 0x2160
movl $0x8, %edi
callq 0x2180
leaq 0x7492(%rip), %rcx      # 0xac48
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3894
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x37d5
callq 0x2160
movl $0x8, %edi
callq 0x2180
leaq 0x7492(%rip), %rcx      # 0xac78
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x38b8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3805
callq 0x2160
movl $0x8, %edi
callq 0x2180
leaq 0x7492(%rip), %rcx      # 0xaca8
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x38dc
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3835
callq 0x2160
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x3849
jmp 0x385c
jmp 0x3849
jmp 0x385c
jmp 0x3849
jmp 0x385c
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x385f
callq 0x2160
jmp 0x385f
movq %rax, %r14
movq %rbx, %rdi
callq 0x3900
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2200
testl %eax, %eax
jne 0x4826
movq 0x60(%r14), %rax
cmpq 0x40(%r14), %rax
je 0x480f
movb (%r14), %al
testb $0x1, %al
je 0x480f
movq 0x40(%r14), %rsi
addq $0x30, %r14
movq %r15, %rdi
callq 0x482e
movq %r14, %rdi
callq 0x48b2
movb $0x1, %bpl
jmp 0x4811
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2120
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/It4innovations[P]Handicap/src/GraphLabelings/../Outputs/../Structures/Matrix.h
// Function: Matrix<int>::Matrix(int, int, int)
Matrix(const int rows, const int columns, const int missingLabel) : rows(rows), columns(columns) {
			if (rows < 1) {
				throw std::runtime_error("Number of rows at matrix are invalid.\n");
			}

			if (columns < 1) {
				throw std::runtime_error("Number of columns at matrix are invalid.\n");
			}

			this->data = new T[rows * columns]();
			this->freeCellInColumn = std::unique_ptr<T[]>(new T[columns]);
			for (int i = 0; i < columns; i++) {
				if (i == 0 || i == missingLabel) {
					this->freeCellInColumn[i] = 0;
					continue;
				}
				this->freeCellInColumn[i] = this->rows;
			}
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
testl %esi, %esi
jle 0x5b37
movl %edx, %r15d
testl %edx, %edx
jle 0x5b55
movl %esi, %ebp
movl %ecx, 0xc(%rsp)
movl %r15d, %r12d
imull %esi, %r12d
shlq $0x2, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %r13
leaq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20f0
movq 0x10(%rsp), %rax
movq %r13, (%rax)
movl %r15d, %r15d
leaq (,%r15,4), %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
movl 0xc(%rsp), %ecx
leal 0x1(%r15), %edx
decq %r15
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq -0x4(,%rcx,4), %rsi
shlq $0x2, %rcx
shrl %edx
shlq $0x3, %rdx
movdqa 0x1597(%rip), %xmm1     # 0x7030
movdqa 0x159f(%rip), %xmm2     # 0x7040
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x159f(%rip), %xmm4     # 0x7050
xorl %edi, %edi
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %r8d
notl %r8d
testb $0x1, %r8b
je 0x5afc
cmpq %rdi, %rcx
movl %ebp, %r8d
cmovel %r14d, %r8d
testq %rdi, %rdi
cmovel %r14d, %r8d
movl %r8d, (%rax,%rdi)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %r8d
testb $0x1, %r8b
je 0x5b1b
cmpq %rdi, %rsi
movl %ebp, %r8d
cmovel %r14d, %r8d
movl %r8d, 0x4(%rax,%rdi)
paddq %xmm4, %xmm1
addq $0x8, %rdi
cmpq %rdi, %rdx
jne 0x5ab3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %r14
leaq 0x16e5(%rip), %rsi      # 0x7230
movq %rax, %rdi
callq 0x2070
jmp 0x5b71
movl $0x10, %edi
callq 0x20c0
movq %rax, %r14
leaq 0x16ee(%rip), %rsi      # 0x7257
movq %rax, %rdi
callq 0x2070
movq 0x5478(%rip), %rsi      # 0xaff0
movq 0x5439(%rip), %rdx      # 0xafb8
movq %r14, %rdi
callq 0x2270
jmp 0x5b89
movq %rax, %r15
movq %r14, %rdi
callq 0x2110
jmp 0x5b9b
jmp 0x5b98
movq %rax, %r15
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5ba9
callq 0x21c0
movq $0x0, 0x18(%rbx)
movq %r15, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/It4innovations[P]Handicap/src/GraphLabelings/../Outputs/../Structures/LabelingSolution.h
// Function: LabelingSolution<int>::setLabels()
void setLabels() {
			for (int i = 0; i < currentSetVectorIndex; ++i) {
				magicWeight[setVector[i].first] -= setVector[i].second;
				Matrix<T>::set(setVector[i].first, setVector[i].second);
			}
			currentSetVectorIndex = 0;
		}

// Assembly:
cmpl $0x0, 0x58(%rdi)
jle 0x619f
movq 0x28(%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rsi
xorl %r8d, %r8d
movl 0x4(%rax,%r8,8), %r9d
movslq (%rax,%r8,8), %r10
subl %r9d, (%rcx,%r10,4)
movslq (%rax,%r8,8), %r9
movslq (%rsi,%r9,4), %r10
movslq (%rdi), %r11
imulq %r9, %r11
addq %r10, %r11
movl 0x4(%rax,%r8,8), %r9d
movl %r9d, -0x4(%rdx,%r11,4)
movslq (%rax,%r8,8), %r9
decl (%rsi,%r9,4)
incl 0x8(%rdi)
incq %r8
movslq 0x58(%rdi), %r9
cmpq %r9, %r8
jl 0x615f
movl $0x0, 0x58(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/It4innovations[P]Handicap/src/GraphLabelings/../Solvers/CombinatorialGenerator.h
// Function: CombinatorialGenerator::computePossibleCombination(std::stack<int, std::deque<int, std::allocator<int>>>&, std::unique_ptr<LabelingSolution<int>, std::default_delete<LabelingSolution<int>>>&)
void computePossibleCombination(std::stack<int> & kSumResults,
		                                std::unique_ptr<LabelingSolution<int>> & matrix) {
			// solve 1-SUM problem
			if (sizeOfSet == 1) {
				bool checkIsWeightIsValid = missingWeight > 1
				                            && missingWeight <= graph->getVerticesCount() + 1
				                            && missingWeight != graph->getMissingLabel()
				                            && matrix->getFreeCellsInColumn(missingWeight) != 0
				                            && missingWeight != currentLabel;
				if (checkIsWeightIsValid) {
					kSumResults.emplace(missingWeight);
				}
				return;
			}

			// solve k-SUM, where k > 1
			if (sizeOfSet > 1 && sizeOfSet <= graph->getRegularConstant()) {
				int index = 0;
				for (int i = 1; i < graph->getVerticesCount() + 2; ++i) {
					if (matrix->getFreeCellsInColumn(i) && i != currentLabel) {
						allowedNumbersArray[index++] = i;
					}
				}

				solver.setK(sizeOfSet);
				solver.setSearchNumber(missingWeight);
				solver.solve(allowedNumbersArray, index, kSumResults);

				return;
			}

			throw "Invalid size of set";
		}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
movq %rdi, %rsi
movl 0x2c(%rdi), %r9d
cmpl $0x1, %r9d
jne 0x6225
movslq 0x30(%rsi), %rax
cmpq $0x2, %rax
jl 0x62af
movq (%rsi), %rdi
movl 0x4(%rdi), %r8d
incl %r8d
cmpl %r8d, %eax
jg 0x62af
cmpl 0x10(%rdi), %eax
je 0x62af
movq (%rdx), %rdx
movq 0x18(%rdx), %rdx
cmpl $0x0, (%rdx,%rax,4)
je 0x62af
cmpl 0x28(%rsi), %eax
je 0x62af
movq 0x30(%rcx), %rdx
movq 0x40(%rcx), %rdi
addq $-0x4, %rdi
cmpq %rdi, %rdx
je 0x62b5
movl %eax, (%rdx)
addq $0x4, %rdx
movq %rdx, 0x30(%rcx)
jmp 0x62af
jle 0x62c6
movq (%rsi), %rax
cmpl 0x8(%rax), %r9d
jg 0x62c6
movl $0x0, 0xc(%rsp)
movl 0x4(%rax), %r8d
testl %r8d, %r8d
js 0x6293
movq (%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x20(%rsi), %rdi
movl $0x1, %r9d
xorl %r10d, %r10d
cmpl $0x0, (%rdx,%r9,4)
je 0x6280
movl 0x28(%rsi), %r11d
cmpq %r11, %r9
je 0x6280
movslq %r10d, %r8
incl %r10d
movl %r10d, 0xc(%rsp)
movl %r9d, (%rdi,%r8,4)
movl 0x4(%rax), %r8d
leaq 0x1(%r9), %r11
movslq %r8d, %rbx
cmpq %rbx, %r9
movq %r11, %r9
jle 0x625d
movl 0x2c(%rsi), %r9d
leaq 0x10(%rsi), %rdi
movl %r9d, 0x18(%rsi)
movl 0x30(%rsi), %eax
movl %eax, 0x14(%rsi)
addq $0x20, %rsi
leaq 0xc(%rsp), %rdx
callq 0x30f6
addq $0x10, %rsp
popq %rbx
retq
addq $0x30, %rsi
movq %rcx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x4b4e
movl $0x8, %edi
callq 0x20c0
leaq 0xfba(%rip), %rcx       # 0x7291
movq %rcx, (%rax)
movq 0x4cc7(%rip), %rsi      # 0xafa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/It4innovations[P]Handicap/src/GraphLabelings/../Outputs/TextPrinter.h
// Function: TextPrinter::print(std::unique_ptr<LabelingSolution<int>, std::default_delete<LabelingSolution<int>>>&, int const&)
void print(std::unique_ptr<LabelingSolution<int> > & matrix, const int & numberOfSolution) {
			std::cout << '#' << numberOfSolution << '\n';
			for (int i = 1; i < this->graph->getVerticesCount()+2; ++i) {
				if (this->graph->getMissingLabel() == i) {
					continue;
				}
				std::cout << i << "\t|";

				for (int j = 0; j < graph->getRegularConstant(); j++) {
					this->neighbour[j] = matrix->get(j, i);
				}

				std::sort(this->neighbour.get(), this->neighbour.get() + this->graph->getRegularConstant());
				for (int j = 0; j < this->graph->getRegularConstant(); j++) {
					std::cout << '\t' << this->neighbour[j];
				}
				std::cout << '\n';
			}
			std::cout << "\n\n";
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
leaq 0xe(%rsp), %rsi
movb $0x23, (%rsi)
movq 0x4cb4(%rip), %rdi      # 0xafc8
movl $0x1, %edx
callq 0x21a0
movl (%r15), %esi
movq %rax, %rdi
callq 0x2280
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x21a0
movq 0x8(%r14), %rax
cmpl $0x0, 0x4(%rax)
js 0x6467
movl $0x1, %r13d
movq 0x4c6f(%rip), %r15      # 0xafc8
leaq 0xd(%rsp), %r12
cmpl %r13d, 0x10(%rax)
je 0x6456
movq %r15, %rdi
movl %r13d, %esi
callq 0x2280
movl $0x2, %edx
movq %rax, %rdi
leaq 0xf23(%rip), %rsi       # 0x72a5
callq 0x21a0
movq 0x8(%r14), %rax
movl 0x8(%rax), %edi
testl %edi, %edi
jle 0x63c4
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rdx
movq (%r14), %rsi
movslq %r13d, %r8
xorl %r9d, %r9d
movslq (%rcx), %rdi
imulq %r8, %rdi
addq %r9, %rdi
movl (%rdx,%rdi,4), %edi
movl %edi, (%rsi,%r9,4)
incq %r9
movslq 0x8(%rax), %rdi
cmpq %rdi, %r9
jl 0x63a7
testl %edi, %edi
je 0x643b
movslq %edi, %rax
movq (%r14), %rbp
leaq (,%rax,4), %rbx
addq %rbp, %rbx
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x648e
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x6569
movq 0x8(%r14), %rax
cmpl $0x0, 0x8(%rax)
jle 0x643b
xorl %ebx, %ebx
movb $0x9, 0xd(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21a0
movq (%r14), %rcx
movl (%rcx,%rbx,4), %esi
movq %rax, %rdi
callq 0x2280
incq %rbx
movq 0x8(%r14), %rax
movslq 0x8(%rax), %rax
cmpq %rax, %rbx
jl 0x6408
movb $0xa, 0xc(%rsp)
movl $0x1, %edx
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
callq 0x21a0
movq 0x8(%r14), %rax
leal 0x1(%r13), %ecx
cmpl 0x4(%rax), %r13d
movl %ecx, %r13d
jle 0x635e
movq 0x4b5a(%rip), %rdi      # 0xafc8
leaq 0xe33(%rip), %rsi       # 0x72a8
movl $0x2, %edx
callq 0x21a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: check_file_exist(boost::filesystem::path const&)
void check_file_exist(const fs::path &path){
    if(!fs::exists(path)){
#ifdef _MSC_VER
        throw no_file_exist(wstring_to_string(path.c_str()));
#else
        throw no_file_exist(path.c_str());
#endif
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3310
cmpl $0x1, (%rbx)
jbe 0x36c0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3130
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x30f0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x60e0
xorl %ebp, %ebp
leaq 0xb3c8(%rip), %rsi      # 0xeac0
movq 0xb8c1(%rip), %rdx      # 0xefc0
movq %rbx, %rdi
callq 0x3350
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x371d
callq 0x31f0
testb %bpl, %bpl
jne 0x3727
jmp 0x372f
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: open_file(boost::filesystem::path const&)
std::vector<char> open_file(const fs::path &path){
    try{
        const boost::uintmax_t size = fs::file_size(path);
        std::vector<char> r(size);
        std::ifstream ifile(path.c_str(), std::ios::binary);
        ifile.read(&r[0], size);
        return r;
    }catch(fs::filesystem_error ex){
#ifdef _MSC_VER
        throw open_file_exception(wstring_to_string(path.c_str()), ex.what());
#else
        throw open_file_exception(path.c_str(), ex.what());
#endif
    }catch(...){
        throw app_exception();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0x32e0
movq %rax, %r15
leaq 0x48(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x6080
movq (%rbx), %rsi
leaq 0x48(%rsp), %rdi
movl $0x4, %edx
callq 0x3380
movq (%r14), %rsi
leaq 0x48(%rsp), %rdi
movq %r15, %rdx
callq 0x32b0
leaq 0x48(%rsp), %rdi
callq 0x30a0
movq %r14, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r12
movq %rax, %r15
leaq 0x48(%rsp), %rdi
callq 0x30a0
jmp 0x37c0
movq %rdx, %r12
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x37d7
callq 0x31f0
jmp 0x37d7
jmp 0x37d1
movq %rdx, %r12
movq %rax, %r15
cmpl $0x2, %r12d
jne 0x3868
movq %r15, %rdi
callq 0x3290
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x3080
movq %r15, %rdi
callq 0x3100
movl $0x10, %edi
callq 0x3130
movq %rax, %r14
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30f0
leaq 0x48(%rsp), %rdi
callq 0x3090
leaq 0x28(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %rax, %rsi
callq 0x30f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
callq 0x6150
xorl %ebp, %ebp
leaq 0xb281(%rip), %rsi      # 0xead8
movq 0xb762(%rip), %rdx      # 0xefc0
movq %r14, %rdi
callq 0x3350
jmp 0x38ac
movq %r15, %rdi
callq 0x3100
movl $0x10, %edi
callq 0x3130
movq %rax, %r14
leaq 0x6995(%rip), %rsi      # 0xa219
movq %rax, %rdi
callq 0x33a0
leaq 0xb2ed(%rip), %rax      # 0xeb80
movq %rax, (%r14)
leaq 0xb20b(%rip), %rsi      # 0xeaa8
movq 0xb71c(%rip), %rdx      # 0xefc0
movq %r14, %rdi
callq 0x3350
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38c2
callq 0x31f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38d5
callq 0x31f0
testb %bpl, %bpl
jne 0x38f7
jmp 0x38ff
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38f7
callq 0x31f0
jmp 0x38f7
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
leaq 0x48(%rsp), %rdi
callq 0x3070
callq 0x3340
jmp 0x3925
movq %rax, %rbx
jmp 0x3920
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
callq 0x3340
movq %rbx, %rdi
callq 0x3360
movq %rax, %rdi
callq 0x606e
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::global_variable_replace(std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>&)
void global_variable_replace(std::unique_ptr<expr> &e){
        if(e->get_kind() == expr::kind::variable){
            variable *var = static_cast<variable*>(e.get());
            auto iter = assignment_table.find(var->str);
            if(iter != assignment_table.end()){
                e.reset(iter->second->copy());
                global_variable_replace(e);
            }
        }else if(e->get_kind() == expr::kind::lambda){
            lambda *lam = static_cast<lambda*>(e.get());
            global_variable_replace(lam->seq);
        }else if(e->get_kind() == expr::kind::sequence){
            sequence *seq = static_cast<sequence*>(e.get());
            for(auto &i : seq->vec){
                global_variable_replace(i);
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xb221(%rip), %r14      # 0xf250
leaq 0xb222(%rip), %r15      # 0xf258
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testl %eax, %eax
jne 0x407e
movq (%rbx), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x859a
cmpq %r15, %rax
je 0x40bf
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x4074
movq (%rdi), %rax
callq *0x38(%rax)
movq (%rbx), %rax
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
jmp 0x403e
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rbx), %rdi
cmpl $0x2, %eax
jne 0x4097
addq $0x20, %rdi
movq %rdi, %rbx
jmp 0x4036
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
jne 0x40bf
movq (%rbx), %rax
movq 0x8(%rax), %rbx
movq 0x10(%rax), %r14
cmpq %r14, %rbx
je 0x40bf
movq %rbx, %rdi
callq 0x4020
addq $0x8, %rbx
jmp 0x40ac
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::assignment(std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>&, __gnu_cxx::__normal_iterator<tokenize_phase2::token_t const*, std::vector<tokenize_phase2::token_t, std::allocator<tokenize_phase2::token_t>>>)
token_seq_type::const_iterator assignment(std::unique_ptr<internal_data::expr> &e, token_seq_type::const_iterator first){
        token_seq_type::const_iterator iter = first;
        std::string name;
        if(iter->kind == kind_t::variable){
            name = std::string(iter->beg, iter->end);
        }else{
            return first;
        }
        ++iter;
        if(iter->kind != kind_t::equal){
            return first;
        }
        ++iter;
        std::unique_ptr<internal_data::expr> f;
        token_seq_type::const_iterator result(expr(f, iter));
        if(result == iter){
            return std::move(result);
        }
        e.swap(f);
        internal_data::assignment_table.insert(std::make_pair(name, std::move(std::unique_ptr<internal_data::expr>(e->copy()))));
        return result;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpl $0x0, (%rsi)
jne 0x46a9
movq %rdi, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %rdi
callq 0x8a66
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x3280
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x4601
callq 0x31f0
cmpl $0x2, 0x28(%rbx)
jne 0x46a9
addq $0x50, %rbx
movq %rsp, %rdi
movq $0x0, (%rdi)
movq %rbx, %rsi
callq 0x473f
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rax
je 0x4695
movq (%r15), %rbx
movq %rdi, (%r15)
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
callq 0x68f6
leaq 0x8(%rsp), %rsi
movq %r15, 0x20(%rsi)
leaq 0xabea(%rip), %rdi      # 0xf250
callq 0x8ad8
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x467b
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x28(%rsp)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4698
callq 0x31f0
jmp 0x4698
movq %rdi, %rbx
testq %rbx, %rbx
je 0x46a6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq %r14, %rbx
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x46b8
callq 0x31f0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x46dc
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x28(%rsp)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4715
callq 0x31f0
jmp 0x4715
movq %rax, %r14
testq %r15, %r15
je 0x4715
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
jmp 0x4715
movq %rax, %r14
jmp 0x4715
movq %rax, %r14
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x4728
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
jmp 0x4728
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x4737
callq 0x31f0
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::line(__gnu_cxx::__normal_iterator<tokenize_phase2::token_t const*, std::vector<tokenize_phase2::token_t, std::allocator<tokenize_phase2::token_t>>>)
token_seq_type::const_iterator line(token_seq_type::const_iterator first){
        std::unique_ptr<internal_data::expr> e;
        auto result = assignment(e, first);
        if(result == first){
            result = expr(e, first);
            if(result == first){
                throw parsing_error(first->line);
            }
            internal_data::lines.push_back(std::move(e));
        }
        return result;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
movq %r14, %rsi
callq 0x4593
movq %rax, %rbx
cmpq %r14, %rax
jne 0x4c72
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x473f
movq %rax, %rbx
cmpq %r14, %rax
je 0x4c8f
leaq 0xa618(%rip), %rdi      # 0xf280
leaq 0x8(%rsp), %rsi
callq 0x8210
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4c82
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x3130
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x637c
leaq 0x9e59(%rip), %rsi      # 0xeb08
movq 0xa30a(%rip), %rdx      # 0xefc0
movq %r15, %rdi
callq 0x3350
movq %rax, %rbx
movq %r15, %rdi
callq 0x31a0
jmp 0x4cd0
jmp 0x4ccd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4ce0
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O3/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::sequence(__gnu_cxx::__normal_iterator<tokenize_phase2::token_t const*, std::vector<tokenize_phase2::token_t, std::allocator<tokenize_phase2::token_t>>>, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>&)
token_seq_type::const_iterator sequence(token_seq_type::const_iterator first, std::unique_ptr<internal_data::expr> &seq){
        token_seq_type::const_iterator iter = first;
        token_seq_type::const_iterator result = expr(seq, iter);
        if(result != first && seq->get_kind() != internal_data::expr::kind::sequence){
            internal_data::sequence *wrapper_seq = new internal_data::sequence;
            std::unique_ptr<internal_data::expr> wrapper(wrapper_seq);
            wrapper_seq->push_back(std::move(seq));
            seq.swap(wrapper);
        }
        return result;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x473f
movq %rax, %rbx
cmpq %r15, %rax
je 0x4d7d
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
je 0x4d7d
movl $0x20, %edi
callq 0x3220
movq %rax, %r15
leaq 0x9ef5(%rip), %rax      # 0xec20
movq %rax, (%r15)
leaq 0x8(%r15), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
xorl %eax, %eax
movq %rax, 0x18(%r15)
movq (%r14), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, (%r14)
callq 0x8210
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4d63
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
movq (%r14), %rdi
movq %r15, (%r14)
testq %rdi, %rdi
je 0x4d7d
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4d9d
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3360