LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xf350
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf607
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xf63a
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdi
movl 0x4(%rax), %esi
xorl %edx, %edx
callq 0x4480
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x28(%rbp), %rsi
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x3190
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::GetPtr(unsigned int, unsigned int&) const
ERROR_T BTreeNode::GetPtr(const SIZE_T offset, SIZE_T &ptr) const
{
  char *p=ResolvePtr(offset);

  if (p==0) { 
    return ERROR_NOMEM;
  }
  
  memcpy(&ptr,p,sizeof(SIZE_T));
  return ERROR_NOERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xf440
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf683
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xf696
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xf510
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf6d7
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xf70a
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdi
movl 0x8(%rax), %esi
xorl %edx, %edx
callq 0x4480
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x28(%rbp), %rsi
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x3190
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::GetKeyVal(unsigned int, KeyValuePair&) const
ERROR_T BTreeNode::GetKeyVal(const SIZE_T offset, KeyValuePair &p) const
{
  ERROR_T rc= GetKey(offset,p.key);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
callq 0xf5d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xf75c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf773
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
addq $0x30, %rdx
callq 0xf6a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::SetKey(unsigned int, Block const&)
ERROR_T BTreeNode::SetKey(const SIZE_T offset, const KEY_T &k)
{
  char *p=ResolveKey(offset);

  if (p==0) { 
    return ERROR_NOMEM;
  }

  memcpy(p,k.data,info.keysize);

  return ERROR_NOERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xf350
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf7b7
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xf7d8
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rsi
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x3190
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::SetPtr(unsigned int, unsigned int const&)
ERROR_T BTreeNode::SetPtr(const SIZE_T offset, const SIZE_T &ptr)
{
  char *p=ResolvePtr(offset);

  if (p==0) { 
    return ERROR_NOMEM;
  }

  memcpy(p,&ptr,sizeof(SIZE_T));

  return ERROR_NOERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xf440
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf823
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xf836
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: cpottamus[P]btree_lab/btree_ds.cc
// Function: BTreeNode::SetVal(unsigned int, Block const&)
ERROR_T BTreeNode::SetVal(const SIZE_T offset, const VALUE_T &v)
{
  char *p=ResolveVal(offset);
  
  if (p==0) { 
    return ERROR_NOMEM;
  }
  
  memcpy(p,v.data,info.valuesize);
  
  return ERROR_NOERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xf510
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf877
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xf898
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rsi
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x3190
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
callq 0xf780
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xf8ec
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf903
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
addq $0x30, %rdx
callq 0xf840
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x3282
movq 0x38(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x3290
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x3290
movq 0x18(%rsp), %rcx
movq %rax, %rdx
movl 0x14(%rsp), %eax
addl (%rdx), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x3200
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x327d
movq 0x18(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jle 0x321b
movl 0x24(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x327b
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x3290
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x32d0
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x3290
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x32d0
movl 0x24(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x327d
jmp 0x31a6
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x2c(%rsp)
cmpl $0x2, 0x2c(%rsp)
jl 0x348c
movq 0x20(%rsp), %rax
movl $0x0, 0x38(%rsp)
movl 0x2c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, 0x34(%rsp)
movl 0x4(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x3290
movq %rax, %rcx
movl 0x1c(%rsp), %eax
subl (%rcx), %eax
movl %eax, 0x30(%rsp)
cmpl $0x0, 0x30(%rsp)
jg 0x3378
jmp 0x347c
jmp 0x337a
movl 0x38(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x347a
movq 0x48(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0x3290
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x3290
movq %rax, %rcx
movl 0x18(%rsp), %eax
addl (%rcx), %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x33d3
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x3475
movl 0x3c(%rsp), %eax
cmpl 0x30(%rsp), %eax
jle 0x33ed
movl 0x34(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x3473
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0x3290
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x32d0
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x3290
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x32d0
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x3290
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x32d0
movl 0x34(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x34(%rsp)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x3475
jmp 0x337a
jmp 0x347c
movl 0x2c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3326
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x90(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
cmpl $0x1, 0x8(%rax)
jl 0x3965
movq 0x10(%rsp), %rax
cmpl $0x5, 0x8(%rax)
jle 0x3a67
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0x20c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movl 0x8(%rax), %esi
leaq 0x28(%rsp), %rdi
callq 0x3bc0
jmp 0x3990
leaq 0x11689(%rip), %rsi     # 0x15020
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x3b70
jmp 0x39a8
leaq 0x11688(%rip), %rdx     # 0x15037
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3b20
jmp 0x39c0
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2240
jmp 0x39d1
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0x1d60e(%rip), %rsi     # 0x20ff0
movq 0x1d5cf(%rip), %rdx     # 0x20fb8
callq 0x2290
jmp 0x3b19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3a4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3a45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x3a3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2110
leaq 0x48(%rsp), %rdi
callq 0x2110
leaq 0x28(%rsp), %rdi
callq 0x2110
testb $0x1, 0x1b(%rsp)
jne 0x3a58
jmp 0x3a62
movq 0x8(%rsp), %rdi
callq 0x2140
jmp 0x3b0f
movq 0x10(%rsp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x3a8e
movq 0x10(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x3170
jmp 0x3b07
movq 0x10(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x3ab5
movq 0x10(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x3300
jmp 0x3b05
movq 0x10(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x3adc
movq 0x10(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x34a0
jmp 0x3b03
movq 0x10(%rsp), %rax
cmpl $0x5, 0x8(%rax)
jne 0x3b01
movq 0x10(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x36a0
jmp 0x3b03
jmp 0x3b05
jmp 0x3b07
addq $0xa8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x22b0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x1d128(%rip), %rdi     # 0x20fc8
leaq 0x112af(%rip), %rsi     # 0x15156
callq 0x21a0
movq %rax, %rdi
leaq 0x112c2(%rip), %rsi     # 0x15178
callq 0x21a0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x3f90
movq %rax, %rdi
callq 0x3fa0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x22a0
movq %rax, %rdi
leaq 0x112a3(%rip), %rsi     # 0x15189
callq 0x21a0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x3f90
movq %rax, %rdi
callq 0x6d20
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x22a0
movq %rax, %rdi
leaq 0x11283(%rip), %rsi     # 0x1519b
callq 0x21a0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x3f90
movq %rax, %rdi
callq 0x4070
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x22a0
movq %rax, %rdi
leaq 0x11265(%rip), %rsi     # 0x151af
callq 0x21a0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x3f90
movq %rax, %rdi
callq 0x3fb0
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x22a0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21d0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x9ec0
movl $0x0, 0x54(%rsp)
movq 0x8(%rsp), %rcx
movl 0x54(%rsp), %eax
cmpl (%rcx), %eax
jge 0x43c5
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x9f40
jmp 0x436d
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x9ed0
jmp 0x437e
leaq 0x48(%rsp), %rdi
callq 0xa000
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x4345
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x444c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xa000
jmp 0x444c
leaq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa020
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa050
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa080
testb $0x1, %al
jne 0x4402
jmp 0x443d
leaq 0x20(%rsp), %rdi
callq 0xa0c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa0d0
testb $0x1, %al
jne 0x4421
jmp 0x442f
movq 0x10(%rsp), %rdi
callq 0x2280
jmp 0x442d
jmp 0x442f
jmp 0x4431
leaq 0x20(%rsp), %rdi
callq 0xa110
jmp 0x43ed
leaq 0x58(%rsp), %rdi
callq 0xa130
addq $0x78, %rsp
retq
leaq 0x58(%rsp), %rdi
callq 0xa130
movq 0x38(%rsp), %rdi
callq 0x22b0
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movq %rdi, %rax
movq %rax, 0x58(%rsp)
movq %rdi, %rax
movq %rax, 0x60(%rsp)
callq 0x4ad0
movl $0x8, %edi
callq 0x21b0
movq %rax, 0x68(%rsp)
jmp 0x4792
movq 0x68(%rsp), %rdi
movq $0x0, (%rdi)
callq 0x4b50
movq 0x68(%rsp), %rsi
leaq 0x98(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x4b80
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x4ae0
jmp 0x47cb
leaq 0x98(%rsp), %rdi
callq 0x4bb0
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x8, %edi
callq 0x21b0
movq %rax, 0x40(%rsp)
jmp 0x47f3
movq 0x40(%rsp), %rdi
movq $0x0, (%rdi)
callq 0x4c80
movq 0x40(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x4cb0
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x4c10
jmp 0x482c
leaq 0x80(%rsp), %rdi
callq 0x4ce0
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x8, %edi
callq 0x21b0
movq %rax, 0x28(%rsp)
jmp 0x4854
movq 0x28(%rsp), %rdi
movq $0x0, (%rdi)
callq 0x4db0
movq 0x28(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4de0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4d40
jmp 0x488a
leaq 0x78(%rsp), %rdi
callq 0x4e10
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x8, %edi
callq 0x21b0
movq %rax, 0x10(%rsp)
jmp 0x48af
movq 0x10(%rsp), %rdi
movq $0x0, (%rdi)
callq 0x4ee0
movq 0x10(%rsp), %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4f10
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x4e70
jmp 0x48e3
leaq 0x70(%rsp), %rdi
callq 0x4f40
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x4992
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x4bb0
jmp 0x4992
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x4ce0
jmp 0x4992
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x4e10
jmp 0x4992
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4f40
movq 0x60(%rsp), %rdi
callq 0x4fa0
movq 0x90(%rsp), %rdi
callq 0x22b0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x8, %rsi
leaq 0x28(%rsp), %rdi
callq 0x9460
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0xaf50
movb %al, 0x17(%rsp)
jmp 0xae6a
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0xae82
jmp 0xae74
movq 0x8(%rsp), %rdi
callq 0xaf70
testb $0x1, %al
jne 0xaeab
movb $0x0, 0x47(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0xaeea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x94c0
jmp 0xaeff
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0xb010
movq %rax, (%rsp)
jmp 0xaebf
movq (%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0xb020
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0xb070
jmp 0xaedd
movb $0x1, 0x47(%rsp)
movl $0x1, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x94c0
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x22b0
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl 0x40(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x40(%rdi)
addq $0x10, %rdi
callq 0xf630
movq %rax, %rdi
leaq 0x4c(%rsp), %rsi
callq 0x11f10
movl %eax, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rdi
movl 0x30(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0xdca0
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0xebf1
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movslq 0x40(%rax), %rsi
callq 0x11f40
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
movslq 0x30(%rsp), %rsi
callq 0x11f70
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x32d0
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xeb91
movq 0x20(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl 0x34(%rsp), %edx
callq 0x11f90
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0xec5a
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movslq 0x40(%rax), %rsi
callq 0x11f40
movq 0x20(%rsp), %rdi
movq %rax, (%rsp)
addq $0x38, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x3290
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x32d0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xec0b
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
callq 0xf630
movq %rax, %rdi
callq 0x120a0
movq 0x20(%rsp), %rdi
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %esi
movq 0x38(%rsp), %rdx
callq 0x12190
movq 0x20(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl 0x34(%rsp), %edx
callq 0x12470
movq 0x20(%rsp), %rax
movl 0x40(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x40(%rax)
addq $0x58, %rsp
retq
nopl (%rax)
// File: It4innovations[P]Handicap/src/GraphLabelings/GraphLabeling.h
// Function: GraphLabeling::markLabelsToSolution(int, int)
inline void markLabelsToSolution(int label, int missingNeighbours) {
			for (int slot = 0; slot < missingNeighbours; ++slot) {
				this->disabledNumbersArray[slot] = this->intermediateNSumResults[this->levelOfRecursion].top();
				const int neighbourLabel = this->disabledNumbersArray[slot];
				solution->prepareSetLabel(label, neighbourLabel);
				solution->prepareSetLabel(neighbourLabel, label);
				this->intermediateNSumResults[this->levelOfRecursion].pop();
			}
			solution->setLabels();
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x12083
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movslq 0x40(%rax), %rsi
callq 0x11f40
movq %rax, %rdi
callq 0x4120
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4(%rsp)
addq $0x38, %rdi
movslq 0x14(%rsp), %rsi
callq 0x3290
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, (%rax)
addq $0x38, %rdi
movslq 0x14(%rsp), %rsi
callq 0x3290
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x10(%rsp)
addq $0x10, %rdi
callq 0xf630
movq %rax, %rdi
leaq 0x1c(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x125e0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xf630
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
callq 0x125e0
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movslq 0x40(%rax), %rsi
callq 0x11f40
movq %rax, %rdi
callq 0x4130
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x11fb3
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xf630
movq %rax, %rdi
callq 0x12640
addq $0x28, %rsp
retq
nop
// File: It4innovations[P]Handicap/src/GraphLabelings/../Outputs/../Structures/LabelingSolution.h
// Function: LabelingSolution<int>::selectNextLabel()
int selectNextLabel() {
			int nextLabel = -1, missCount = 1000, l = 0, p = this->getColumnsSize() - 1;
			int countL, countP;
			while (l < p) {
				countL = this->getFreeCellsInColumn(l);
				countP = this->getFreeCellsInColumn(p);
				if (countL != 0 && countL < missCount) {
					missCount = countL;
					nextLabel = l;
					if (nextLabel == 1) break;
				} else if (countP != 0 && countP < missCount) {
					missCount = countP;
					nextLabel = p;
					if (nextLabel == 1) break;
				}
				l += 1;
				p -= 1;
			}

			return nextLabel;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
movl $0x3e8, 0x18(%rsp)      # imm = 0x3E8
movl $0x0, 0x14(%rsp)
callq 0x12860
subl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x1217d
movq (%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x11f10
movq (%rsp), %rdi
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x11f10
movl %eax, 0x8(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x12134
movl 0xc(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x12134
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x1, 0x1c(%rsp)
jne 0x12132
jmp 0x1217d
jmp 0x12162
cmpl $0x0, 0x8(%rsp)
je 0x12160
movl 0x8(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x12160
movl 0x8(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x1, 0x1c(%rsp)
jne 0x1215e
jmp 0x1217d
jmp 0x12160
jmp 0x12162
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x120d6
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: It4innovations[P]Handicap/src/GraphLabelings/GraphLabeling.h
// Function: GraphLabeling::unmarkLabelsFromSolution(int, int)
inline void unmarkLabelsFromSolution(const int label, const int missingNeigbours) {
			for (int slot = 0; slot < missingNeigbours; ++slot) {
				solution->prepareUnsetLabel(label);
				solution->prepareUnsetLabel(intermediateNSumResults[levelOfRecursion].top());
				intermediateNSumResults[levelOfRecursion].pop();
			}
			solution->unsetLabels();
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x12527
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xf630
movq %rax, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x13e20
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xf630
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rsp)
movq %rax, %rdi
addq $0x30, %rdi
movslq 0x40(%rax), %rsi
callq 0x11f40
movq %rax, %rdi
callq 0x4120
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x13e20
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movslq 0x40(%rax), %rsi
callq 0x11f40
movq %rax, %rdi
callq 0x4130
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x12493
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xf630
movq %rax, %rdi
callq 0x13e70
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x58(%rcx), %eax
jge 0x1270e
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x12750
movq 0x20(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
addq $0x28, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x12750
movq 0x8(%rsp), %rdi
movslq (%rax), %rsi
callq 0x3290
movl 0x14(%rsp), %edx
movq 0x20(%rsp), %rdi
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
addq $0x28, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x12750
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x28, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x12750
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
addq $0x4, %rdx
callq 0x127d0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1265b
movq 0x20(%rsp), %rax
movl $0x0, 0x58(%rax)
addq $0x38, %rsp
retq
nop
// File: It4innovations[P]Handicap/src/GraphLabelings/../Outputs/../Structures/Matrix.h
// Function: Matrix<int>::set(int const&, int const&)
void set(const int & column, const T & value) {
			const int freeCellInColumn = this->freeCellInColumn[column] - 1;
			this->data[column * rows + freeCellInColumn] = value;
			--this->freeCellInColumn[column];
			++this->filledCells;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
movq 0x18(%rsp), %rax
movslq (%rax), %rsi
callq 0x3290
movq (%rsp), %rdi
movl (%rax), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %edx
movq 0x10(%rdi), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
imull (%rdi), %ecx
addl 0xc(%rsp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x18, %rdi
movq 0x18(%rsp), %rax
movslq (%rax), %rsi
callq 0x3290
movq %rax, %rcx
movq (%rsp), %rax
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: It4innovations[P]Handicap/src/GraphLabelings/Solution/SolutionValidator.h
// Function: SolutionValidator::validate(std::unique_ptr<LabelingSolution<int>, std::default_delete<LabelingSolution<int>>>&)
bool validate(std::unique_ptr<LabelingSolution<int>> & solution) {
			bool isCorrectSolution = true;
			for (int i = 0; i < this->verticesCount && isCorrectSolution; ++i) {
				if (solution->getFreeCellsInColumn(i) == 0 && solution->getWeight(i) == 0) continue;
				isCorrectSolution = false;
			}

			return isCorrectSolution;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x1, 0x17(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movl 0x10(%rsp), %ecx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
jge 0x12bb0
movb 0x17(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x12bba
jmp 0x12c06
movq 0x18(%rsp), %rdi
callq 0xf630
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x11f10
cmpl $0x0, %eax
jne 0x12bf4
movq 0x18(%rsp), %rdi
callq 0xf630
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x128e0
cmpl $0x0, %eax
jne 0x12bf4
jmp 0x12bf9
movb $0x0, 0x17(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x12b95
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: It4innovations[P]Handicap/src/GraphLabelings/../Outputs/../Structures/LabelingSolution.h
// Function: LabelingSolution<int>::unsetLabels()
void unsetLabels() {
			for (int i = 0; i < currentUnsetVectorIndex; ++i) {
				const int latestFiledCellInColumn = this->getFreeCellsInColumn(unsetVector[i]);
				magicWeight[unsetVector[i]] += this->get(latestFiledCellInColumn, unsetVector[i]);
				Matrix<T>::unsetLastInsertValue(unsetVector[i]);
			}
			currentUnsetVectorIndex = 0;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x5c(%rcx), %eax
jge 0x13f4c
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x11f70
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x11f10
movq 0x10(%rsp), %rdi
movl %eax, 0x18(%rsp)
addq $0x40, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x11f70
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x18(%rsp), %rsi
callq 0x130f0
movq 0x10(%rsp), %rdi
movl %eax, 0xc(%rsp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, (%rsp)
addq $0x40, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x11f70
movq (%rsp), %rdi
movslq (%rax), %rsi
callq 0x3290
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rdi
addl (%rax), %ecx
movl %ecx, (%rax)
addq $0x40, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x11f70
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x13f60
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x13e8b
movq 0x10(%rsp), %rax
movl $0x0, 0x5c(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: kaityo256[P]thermostats/thermostats.cpp
// Function: Vars::Vars()
Vars () {
    p = 0.0;
    q = 0.0;
    zeta = 0.0;
    eta = 0.0;
    theta = 0.0;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kaityo256[P]thermostats/thermostats.cpp
// Function: RungeKutta<NoseHoover>::operator()(Vars)
Vars operator()(Vars v) {
    Vars k1 = diff(v);
    Vars k2 = diff(v + k1 * hdt);
    Vars k3 = diff(v + k2 * hdt);
    Vars k4 = diff(v + k3 * dt);
    v = v + (k1 + k2 * 2.0 + k3 * 2.0 + k4) * (dt / 6.0);
    return v;
  }

// Assembly:
subq $0x348, %rsp            # imm = 0x348
movq %rsi, %rax
movq %rdi, 0x58(%rsp)
movq %rdi, 0x68(%rsp)
leaq 0x350(%rsp), %rsi
movq %rsi, 0x60(%rsp)
movq %rax, 0x340(%rsp)
movq 0x340(%rsp), %rax
movq %rax, 0x50(%rsp)
addq $0x10, %rax
movq %rax, 0x30(%rsp)
leaq 0x2f0(%rsp), %rdi
movl $0x28, %edx
callq 0x20f0
movq 0x30(%rsp), %rsi
movq 0x310(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups 0x2f0(%rsp), %xmm0
movups 0x300(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x318(%rsp), %rdi
callq 0x58e0
movq 0x50(%rsp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x38(%rsp)
movsd 0x8(%rax), %xmm0
leaq 0x278(%rsp), %rdi
leaq 0x318(%rsp), %rsi
callq 0x5a20
movq 0x60(%rsp), %rsi
leaq 0x2a0(%rsp), %rdi
leaq 0x278(%rsp), %rdx
callq 0x59a0
movq 0x38(%rsp), %rsi
movq 0x2c0(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups 0x2a0(%rsp), %xmm0
movups 0x2b0(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x2c8(%rsp), %rdi
callq 0x58e0
movq 0x50(%rsp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x40(%rsp)
movsd 0x8(%rax), %xmm0
leaq 0x200(%rsp), %rdi
leaq 0x2c8(%rsp), %rsi
callq 0x5a20
movq 0x60(%rsp), %rsi
leaq 0x228(%rsp), %rdi
leaq 0x200(%rsp), %rdx
callq 0x59a0
movq 0x40(%rsp), %rsi
movq 0x248(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups 0x228(%rsp), %xmm0
movups 0x238(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x250(%rsp), %rdi
callq 0x58e0
movq 0x50(%rsp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x48(%rsp)
movsd (%rax), %xmm0
leaq 0x188(%rsp), %rdi
leaq 0x250(%rsp), %rsi
callq 0x5a20
movq 0x60(%rsp), %rsi
leaq 0x1b0(%rsp), %rdi
leaq 0x188(%rsp), %rdx
callq 0x59a0
movq 0x48(%rsp), %rsi
movq 0x1d0(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups 0x1b0(%rsp), %xmm0
movups 0x1c0(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x1d8(%rsp), %rdi
callq 0x58e0
leaq 0x98(%rsp), %rdi
leaq 0x2c8(%rsp), %rsi
movsd 0x4aa1(%rip), %xmm0     # 0xa028
callq 0x5a20
leaq 0xc0(%rsp), %rdi
leaq 0x318(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0x59a0
leaq 0x70(%rsp), %rdi
leaq 0x250(%rsp), %rsi
movsd 0x4a6a(%rip), %xmm0     # 0xa028
callq 0x5a20
leaq 0xe8(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x59a0
leaq 0x110(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
leaq 0x1d8(%rsp), %rdx
callq 0x59a0
movq 0x50(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x4a15(%rip), %xmm1     # 0xa020
divsd %xmm1, %xmm0
leaq 0x138(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0x5a20
movq 0x60(%rsp), %rsi
leaq 0x160(%rsp), %rdi
leaq 0x138(%rsp), %rdx
callq 0x59a0
movq 0x60(%rsp), %rdi
leaq 0x160(%rsp), %rsi
movl $0x28, %edx
callq 0x20f0
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movl $0x28, %edx
callq 0x20f0
movq 0x68(%rsp), %rax
addq $0x348, %rsp            # imm = 0x348
retq
nopw %cs:(%rax,%rax)
// File: kaityo256[P]thermostats/thermostats.cpp
// Function: NoseHoover::operator()(Vars)
Vars operator()(Vars v) {
    Vars dv;
    dv.p = -v.q - v.p * v.zeta / Q;
    dv.q = v.p;
    dv.zeta = v.p * v.p - T;
    dv.eta = v.zeta * T / Q;
    return dv;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x5290
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movsd 0x8(%rdx), %xmm0
movq %xmm0, %rsi
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
xorq %r8, %rsi
movq %rsi, %xmm0
movsd (%rdx), %xmm1
mulsd 0x10(%rdx), %xmm1
divsd (%rcx), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd (%rdx), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd (%rdx), %xmm0
movsd (%rdx), %xmm1
mulsd %xmm1, %xmm0
movsd 0x46c9(%rip), %xmm1     # 0xa038
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x46b0(%rip), %xmm0     # 0xa030
mulsd 0x10(%rdx), %xmm0
divsd (%rcx), %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kaityo256[P]thermostats/thermostats.cpp
// Function: Vars::Vars(double, double, double, double, double)
Vars (double _p, double _q, double _zeta, double _eta, double _theta) {
    p = _p;
    q = _q;
    zeta = _zeta;
    eta = _eta;
    theta = _theta;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd %xmm2, -0x20(%rsp)
movsd %xmm3, -0x28(%rsp)
movsd %xmm4, -0x30(%rsp)
movq -0x8(%rsp), %rax
movsd -0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
retq
nop
// File: kaityo256[P]thermostats/thermostats.cpp
// Function: NoseHoover::H(Vars)
double H(Vars v) {
    double e = 0;
    e += (v.p * v.p * 0.5);
    e += (v.q * v.q * 0.5);
    e += (v.zeta * v.zeta * 0.5 / Q);
    e += v.eta;
    return e;
  }

// Assembly:
leaq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rsp)
movsd (%rax), %xmm0
mulsd (%rax), %xmm0
movsd -0x10(%rsp), %xmm1
movsd 0x4502(%rip), %xmm2     # 0xa010
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x8(%rax), %xmm0
mulsd 0x8(%rax), %xmm0
movsd -0x10(%rsp), %xmm1
movsd 0x44dc(%rip), %xmm2     # 0xa010
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x10(%rax), %xmm0
mulsd 0x10(%rax), %xmm0
movsd 0x44bc(%rip), %xmm1     # 0xa010
mulsd %xmm1, %xmm0
divsd (%rcx), %xmm0
addsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x18(%rax), %xmm0
addsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
retq
// File: kaityo256[P]thermostats/thermostats.cpp
// Function: KineticMoments::operator()(Vars)
Vars operator()(Vars v) {
    Vars dv;
    dv.p = -v.q - v.p * v.zeta / Qzeta - v.p * v.p * v.p * v.eta / Qeta;
    dv.q = v.p;
    dv.zeta = v.p * v.p - T;
    dv.eta = v.p * v.p * v.p * v.p - 3.0 * T * v.p * v.p;
    dv.theta = v.zeta * T / Qzeta + 3.0 * T * v.p * v.p * v.eta / Qeta;
    return dv;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x5290
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movsd 0x8(%rdx), %xmm0
movq %xmm0, %rsi
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
xorq %r8, %rsi
movq %rsi, %xmm0
movsd (%rdx), %xmm1
mulsd 0x10(%rdx), %xmm1
divsd (%rcx), %xmm1
subsd %xmm1, %xmm0
movsd (%rdx), %xmm1
mulsd (%rdx), %xmm1
mulsd (%rdx), %xmm1
mulsd 0x18(%rdx), %xmm1
divsd 0x8(%rcx), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd (%rdx), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd (%rdx), %xmm0
movsd (%rdx), %xmm1
mulsd %xmm1, %xmm0
movsd 0x20df(%rip), %xmm1     # 0xa038
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
movsd (%rdx), %xmm0
mulsd (%rdx), %xmm0
mulsd (%rdx), %xmm0
movsd (%rdx), %xmm2
movsd 0x20c6(%rip), %xmm1     # 0xa040
mulsd (%rdx), %xmm1
mulsd (%rdx), %xmm1
movq %xmm1, %rsi
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
xorq %r8, %rsi
movq %rsi, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x2082(%rip), %xmm0     # 0xa030
mulsd 0x10(%rdx), %xmm0
divsd (%rcx), %xmm0
movsd 0x2081(%rip), %xmm1     # 0xa040
mulsd (%rdx), %xmm1
mulsd (%rdx), %xmm1
mulsd 0x18(%rdx), %xmm1
divsd 0x8(%rcx), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rdi)
addq $0x28, %rsp
retq
nop
// File: kaityo256[P]thermostats/thermostats.cpp
// Function: KineticMoments::H(Vars)
double H(Vars v) {
    double e = 0;
    e += (v.p * v.p * 0.5);
    e += (v.q * v.q * 0.5);
    e += (v.zeta * v.zeta * 0.5 / Qzeta);
    e += (v.eta * v.eta * 0.5 / Qeta);
    e += v.theta;
    return e;
  }

// Assembly:
leaq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rsp)
movsd (%rax), %xmm0
mulsd (%rax), %xmm0
movsd -0x10(%rsp), %xmm1
movsd 0x2002(%rip), %xmm2     # 0xa010
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x8(%rax), %xmm0
mulsd 0x8(%rax), %xmm0
movsd -0x10(%rsp), %xmm1
movsd 0x1fdc(%rip), %xmm2     # 0xa010
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x10(%rax), %xmm0
mulsd 0x10(%rax), %xmm0
movsd 0x1fbc(%rip), %xmm1     # 0xa010
mulsd %xmm1, %xmm0
divsd (%rcx), %xmm0
addsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x18(%rax), %xmm0
mulsd 0x18(%rax), %xmm0
movsd 0x1f96(%rip), %xmm1     # 0xa010
mulsd %xmm1, %xmm0
divsd 0x8(%rcx), %xmm0
addsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x20(%rax), %xmm0
addsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
retq
nopw (%rax,%rax)
// File: kaityo256[P]thermostats/thermostats.cpp
// Function: NoseHooverChain::operator()(Vars)
Vars operator()(Vars v) {
    Vars dv;
    dv.p = -v.q - v.p * v.zeta / Qzeta;
    dv.q = v.p;
    dv.zeta = v.p * v.p - T - v.eta * v.zeta / Qeta;
    dv.eta = v.zeta * v.zeta / Qzeta - T;
    dv.theta = T * (v.zeta / Qzeta + v.eta / Qeta);
    return dv;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x5290
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movsd 0x8(%rdx), %xmm0
movq %xmm0, %rsi
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
xorq %r8, %rsi
movq %rsi, %xmm0
movsd (%rdx), %xmm1
mulsd 0x10(%rdx), %xmm1
divsd (%rcx), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd (%rdx), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd (%rdx), %xmm0
movsd (%rdx), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1a09(%rip), %xmm1     # 0xa038
addsd %xmm1, %xmm0
movsd 0x18(%rdx), %xmm1
mulsd 0x10(%rdx), %xmm1
divsd 0x8(%rcx), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x10(%rdx), %xmm0
mulsd 0x10(%rdx), %xmm0
divsd (%rcx), %xmm0
movsd 0x19cf(%rip), %xmm1     # 0xa030
subsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x10(%rdx), %xmm1
divsd (%rcx), %xmm1
movsd 0x18(%rdx), %xmm0
divsd 0x8(%rcx), %xmm0
addsd %xmm0, %xmm1
movsd 0x19a7(%rip), %xmm0     # 0xa030
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rdi)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: kaityo256[P]thermostats/thermostats.cpp
// Function: Langevin::operator()(Vars)
Vars operator()(Vars v) {
    Vars dv;
    dv.p = -v.q - gamma * v.p + nd(mt);
    dv.q = v.p;
    return dv;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x5290
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
movsd 0x1388(%rsi), %xmm0
movsd (%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movq %rsi, %rdi
addq $0x1398, %rdi           # imm = 0x1398
callq 0x8dd0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rdi)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xb1a0
testb $0x1, %al
jne 0x5aa6
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0x5180
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0xb1d0
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x55d0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x54b0
jmp 0x5a32
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xb1e0
jmp 0x5a42
movq (%rsp), %rdi
movb $0x0, 0x1b(%rsp)
leaq 0x1fe66(%rip), %rsi     # 0x258b8
leaq 0x5817(%rip), %rdx      # 0xb270
callq 0x5590
jmp 0x5ab5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x5a88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5210
leaq 0x2f(%rsp), %rdi
callq 0x53c0
testb $0x1, 0x1b(%rsp)
jne 0x5a9b
jmp 0x5aa4
movq (%rsp), %rdi
callq 0x52a0
jmp 0x5aab
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x55c0
nopw %cs:(%rax,%rax)