LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31d5
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x31ca
leaq 0x3e97(%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 0x2b5e
movq %r14, %rdi
movq %rcx, %rdx
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2d60
movq %r14, %rdi
movq %rcx, %rdx
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2f24
movq %r14, %rdi
movq %rcx, %rdx
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2c1a
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 0x3359
leaq 0x3e55(%rip), %rsi      # 0x704c
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x32e9
leaq 0x3e56(%rip), %rsi      # 0x7063
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 0x3238
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x3245
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 0x7d7b(%rip), %rsi      # 0xaff0
movq 0x7d3c(%rip), %rdx      # 0xafb8
movq %rbx, %rdi
callq 0x2270
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x329e
callq 0x2160
jmp 0x329e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32b9
callq 0x2160
jmp 0x32b9
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32d4
callq 0x2160
jmp 0x32d4
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x32e1
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7b02(%rip), %r14      # 0xafc8
leaq 0x3cb5(%rip), %rsi      # 0x7182
movl $0x21, %edx
movq %r14, %rdi
callq 0x21a0
leaq 0x3cc3(%rip), %rsi      # 0x71a4
movl $0x10, %edx
movq %r14, %rdi
callq 0x21a0
movq (%rbx), %rax
movl 0x4(%rax), %esi
movq %r14, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x3caf(%rip), %rsi      # 0x71b5
movl $0x11, %edx
movq %rax, %rdi
callq 0x21a0
movq (%rbx), %rax
movl 0x8(%rax), %esi
movq %r14, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x3c9c(%rip), %rsi      # 0x71c7
movl $0x13, %edx
movq %rax, %rdi
callq 0x21a0
movq (%rbx), %rax
movl 0xc(%rax), %esi
movq %r14, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x3c8b(%rip), %rsi      # 0x71db
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_O1/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 0x7400(%rip), %rcx      # 0xabd0
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x38c2
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x37ef
callq 0x2160
movl $0x8, %edi
callq 0x2180
leaq 0x7410(%rip), %rcx      # 0xac10
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x38e6
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x381f
callq 0x2160
movl $0x8, %edi
callq 0x2180
leaq 0x7410(%rip), %rcx      # 0xac40
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x390a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x384f
callq 0x2160
movl $0x8, %edi
callq 0x2180
leaq 0x7410(%rip), %rcx      # 0xac70
movq %rcx, (%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x392e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x387f
callq 0x2160
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x3893
jmp 0x38ae
jmp 0x3893
jmp 0x38ae
jmp 0x3893
jmp 0x38ae
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x38a4
callq 0x2160
movq $0x0, (%rsp)
jmp 0x38b1
movq %rax, %r14
movq %rbx, %rdi
callq 0x3952
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x488a
movq 0x60(%r14), %rax
cmpq 0x40(%r14), %rax
je 0x4873
movb (%r14), %al
testb $0x1, %al
je 0x4873
movq 0x40(%r14), %rsi
addq $0x30, %r14
movq %r15, %rdi
callq 0x4892
movq %r14, %rdi
callq 0x4924
movb $0x1, %bpl
jmp 0x4875
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_O1/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
pushq %rax
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 0x5b24
movl %edx, %r14d
testl %edx, %edx
jle 0x5b42
movl %esi, %r15d
movl %ecx, 0x4(%rsp)
imull %r14d, %r15d
shlq $0x2, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r12
leaq 0x10(%rbx), %rbp
xorl %r13d, %r13d
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20f0
movq %r12, (%rbp)
movl %r14d, %r14d
leaq (,%r14,4), %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
movl 0x4(%rsp), %ecx
movl (%rbx), %edx
xorl %esi, %esi
cmpq %rsi, %rcx
movl %edx, %edi
cmovel %r13d, %edi
testq %rsi, %rsi
cmovel %r13d, %edi
movl %edi, (%rax,%rsi,4)
incq %rsi
cmpq %rsi, %r14
jne 0x5afa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %r14
leaq 0x16e4(%rip), %rsi      # 0x721c
movq %rax, %rdi
callq 0x2070
jmp 0x5b5e
movl $0x10, %edi
callq 0x20c0
movq %rax, %r14
leaq 0x16ed(%rip), %rsi      # 0x7243
movq %rax, %rdi
callq 0x2070
movq 0x548b(%rip), %rsi      # 0xaff0
movq 0x544c(%rip), %rdx      # 0xafb8
movq %r14, %rdi
callq 0x2270
jmp 0x5b76
movq %rax, %r15
movq %r14, %rdi
callq 0x2110
jmp 0x5b88
jmp 0x5b85
movq %rax, %r15
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5b96
callq 0x21c0
movq $0x0, 0x18(%rbx)
movq %r15, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/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 0x618b
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 0x614b
movl $0x0, 0x58(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movq %rsi, %rcx
movq %rdi, %rsi
movl 0x2c(%rdi), %edi
cmpl $0x1, %edi
jne 0x620b
movslq 0x30(%rsi), %rax
cmpq $0x2, %rax
jl 0x628f
movq (%rsi), %rdi
movl 0x4(%rdi), %r8d
incl %r8d
cmpl %r8d, %eax
jg 0x628f
cmpl 0x10(%rdi), %eax
je 0x628f
movq (%rdx), %rdx
movq 0x18(%rdx), %rdx
cmpl $0x0, (%rdx,%rax,4)
je 0x628f
cmpl 0x28(%rsi), %eax
je 0x628f
movq 0x30(%rcx), %rdx
movq 0x40(%rcx), %rdi
addq $-0x4, %rdi
cmpq %rdi, %rdx
je 0x6291
movl %eax, (%rdx)
addq $0x4, %rdx
movq %rdx, 0x30(%rcx)
jmp 0x628f
jle 0x629e
movq (%rsi), %rax
cmpl 0x8(%rax), %edi
jg 0x629e
movl $0x0, 0x4(%rsp)
cmpl $0x0, 0x4(%rax)
js 0x626e
movq (%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x20(%rsi), %rdi
movl $0x1, %r8d
cmpl $0x0, (%rdx,%r8,4)
je 0x625e
movl 0x28(%rsi), %r9d
cmpq %r9, %r8
je 0x625e
movslq 0x4(%rsp), %r9
leal 0x1(%r9), %r10d
movl %r10d, 0x4(%rsp)
movl %r8d, (%rdi,%r9,4)
leaq 0x1(%r8), %r9
movslq 0x4(%rax), %r10
cmpq %r10, %r8
movq %r9, %r8
jle 0x623c
leaq 0x10(%rsi), %rdi
movq 0x2c(%rsi), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0x14(%rsi)
addq $0x20, %rsi
leaq 0x4(%rsp), %rdx
callq 0x3142
popq %rax
retq
addq $0x30, %rsi
movq %rcx, %rdi
popq %rax
jmp 0x4ba6
movl $0x8, %edi
callq 0x20c0
leaq 0xfce(%rip), %rcx       # 0x727d
movq %rcx, (%rax)
movq 0x4cef(%rip), %rsi      # 0xafa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4cdc(%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 0x6438
movl $0x1, %r13d
movq 0x4c97(%rip), %r15      # 0xafc8
leaq 0xd(%rsp), %rbp
cmpl %r13d, 0x10(%rax)
je 0x6423
movq %r15, %rdi
movl %r13d, %esi
callq 0x2280
movl $0x2, %edx
movq %rax, %rdi
leaq 0xf37(%rip), %rsi       # 0x7291
callq 0x21a0
movq 0x8(%r14), %rax
movl 0x8(%rax), %edi
testl %edi, %edi
jle 0x639c
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 0x637f
testl %edi, %edi
je 0x63cd
movslq %edi, %rax
movq (%r14), %r12
leaq (%r12,%rax,4), %rbx
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x645f
movq %r12, %rdi
movq %rbx, %rsi
callq 0x653a
movq 0x8(%r14), %rax
cmpl $0x0, 0x8(%rax)
jle 0x640c
xorl %ebx, %ebx
movb $0x9, 0xd(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %rbp, %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 0x63d9
movb $0xa, 0xc(%rsp)
movl $0x1, %edx
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
callq 0x21a0
leal 0x1(%r13), %ecx
movq 0x8(%r14), %rax
cmpl 0x4(%rax), %r13d
movl %ecx, %r13d
jle 0x6336
movq 0x4b89(%rip), %rdi      # 0xafc8
leaq 0xe4e(%rip), %rsi       # 0x7294
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_O1/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:
cmpl $0x0, 0x5c(%rdi)
jle 0x6802
movq 0x40(%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rsi
xorl %r8d, %r8d
movslq (%rax,%r8,4), %r9
movslq (%rdx,%r9,4), %r10
movslq (%rdi), %r11
imulq %r9, %r11
addq %r10, %r11
movl (%rcx,%r11,4), %r10d
addl %r10d, (%rsi,%r9,4)
movslq (%rdi), %r9
movslq (%rax,%r8,4), %r10
imulq %r10, %r9
movslq (%rdx,%r10,4), %r10
addq %r9, %r10
movl $0x0, (%rcx,%r10,4)
movslq (%rax,%r8,4), %r9
incl (%rdx,%r9,4)
decl 0x8(%rdi)
incq %r8
movslq 0x5c(%rdi), %r9
cmpq %r9, %r8
jl 0x67b7
movl $0x0, 0x5c(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x62b6
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 0x3725
callq 0x31f0
jmp 0x3725
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3732
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6256
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 0x37c3
movq %rdx, %r12
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x37da
callq 0x31f0
jmp 0x37da
jmp 0x37d4
movq %rdx, %r12
movq %rax, %r15
cmpl $0x2, %r12d
jne 0x386b
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 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30f0
leaq 0x48(%rsp), %rdi
callq 0x3090
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %rax, %rsi
callq 0x30f0
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x6326
xorl %ebp, %ebp
leaq 0xb27e(%rip), %rsi      # 0xead8
movq 0xb75f(%rip), %rdx      # 0xefc0
movq %r14, %rdi
callq 0x3350
jmp 0x38af
movq %r15, %rdi
callq 0x3100
movl $0x10, %edi
callq 0x3130
movq %rax, %r14
leaq 0x6992(%rip), %rsi      # 0xa219
movq %rax, %rdi
callq 0x33a0
leaq 0xb2ea(%rip), %rax      # 0xeb80
movq %rax, (%r14)
leaq 0xb208(%rip), %rsi      # 0xeaa8
movq 0xb719(%rip), %rdx      # 0xefc0
movq %r14, %rdi
callq 0x3350
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38cd
callq 0x31f0
jmp 0x38cd
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38e8
callq 0x31f0
jmp 0x38e8
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x38f5
movq %r14, %rdi
callq 0x31a0
leaq 0x48(%rsp), %rdi
callq 0x3070
callq 0x3340
jmp 0x391b
movq %rax, %rbx
jmp 0x3916
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
callq 0x3340
movq %rbx, %rdi
callq 0x3360
movq %rax, %rdi
callq 0x6245
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb217(%rip), %r14      # 0xf250
leaq 0xb218(%rip), %r15      # 0xf258
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rbx), %rsi
testl %eax, %eax
je 0x4068
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq (%rbx), %rdi
cmpl $0x2, %eax
jne 0x4096
addq $0x20, %rdi
movq %rdi, %rbx
jmp 0x4040
addq $0x8, %rsi
movq %r14, %rdi
callq 0x8778
cmpq %r15, %rax
je 0x40be
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x4040
movq (%rdi), %rax
callq *0x38(%rax)
jmp 0x4040
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
jne 0x40be
movq (%rbx), %rax
movq 0x8(%rax), %rbx
movq 0x10(%rax), %r14
cmpq %r14, %rbx
je 0x40be
movq %rbx, %rdi
callq 0x402a
addq $0x8, %rbx
jmp 0x40ab
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpl $0x0, (%rsi)
jne 0x4703
movq %rdi, %r15
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %rdi
callq 0x8c20
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x3280
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x465a
callq 0x31f0
cmpl $0x2, 0x28(%r14)
jne 0x4703
addq $0x50, %r14
movq %rsp, %rdi
movq $0x0, (%rdi)
movq %r14, %rsi
callq 0x4796
movq %rax, %rbx
cmpq %r14, %rax
je 0x46f1
movq (%r15), %rax
movq (%rsp), %rdi
movq %rdi, (%r15)
movq %rax, (%rsp)
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
callq 0x6ac6
leaq 0x8(%rsp), %rsi
movq %r14, 0x20(%rsi)
leaq 0xab8c(%rip), %rdi      # 0xf250
callq 0x8c90
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x46d9
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x28(%rsp)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x46f1
callq 0x31f0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4700
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %r14
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x4712
callq 0x31f0
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4736
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x28(%rsp)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x474e
callq 0x31f0
xorl %r14d, %r14d
jmp 0x4756
movq %rax, %rbx
testq %r14, %r14
je 0x476b
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
jmp 0x476b
jmp 0x4768
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x477f
movq (%rdi), %rax
callq *0x38(%rax)
jmp 0x477f
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x478e
callq 0x31f0
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45ec
movq %rax, %rbx
cmpq %r14, %rax
jne 0x4de9
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4796
movq %rax, %rbx
cmpq %r14, %rax
je 0x4e06
leaq 0xa4a1(%rip), %rdi      # 0xf280
leaq 0x8(%rsp), %rsi
callq 0x83da
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4df9
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 0x654c
leaq 0x9ce2(%rip), %rsi      # 0xeb08
movq 0xa193(%rip), %rdx      # 0xefc0
movq %r15, %rdi
callq 0x3350
movq %rax, %rbx
movq %r15, %rdi
callq 0x31a0
jmp 0x4e47
jmp 0x4e44
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4e57
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4796
movq %rax, %rbx
cmpq %r15, %rax
je 0x4ef4
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
je 0x4ef4
movl $0x20, %edi
callq 0x3220
movq %rax, %r15
leaq 0x9d7e(%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 0x83da
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4eda
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
movq (%r14), %rdi
movq %r15, (%r14)
testq %rdi, %rdi
je 0x4ef4
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 0x4f14
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::lambda(__gnu_cxx::__normal_iterator<tokenize_phase2::token_t const*, std::vector<tokenize_phase2::token_t, std::allocator<tokenize_phase2::token_t>>>, internal_data::lambda&)
token_seq_type::const_iterator lambda(token_seq_type::const_iterator first, internal_data::lambda &lam){
        token_seq_type::const_iterator iter = first;
        if(iter->kind != kind_t::lambda){
            return first;
        }
        ++iter;
        while(iter->kind == kind_t::variable){
            internal_data::variable v;
            v.str = std::string(iter->beg, iter->end);
            lam.variable_seq.push_back(v);
            ++iter;
        }
        if(iter->kind != kind_t::dot){
            return first;
        }
        ++iter;
        token_seq_type::const_iterator result = sequence(iter, lam.seq);
        if(result == iter){
            // sequence�̃p�[�X���s�D
            return first;
        }
        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x1, (%rdi)
jne 0x500b
leaq 0x20(%rsp), %rbx
leaq 0x48(%rsp), %r14
movq %rsi, 0x30(%rsp)
leaq 0x8(%rsi), %r13
movq %rdi, (%rsp)
leaq 0x50(%rdi), %r15
leaq 0x9d31(%rip), %r12      # 0xec98
leaq 0x38(%rsp), %rbp
movl -0x28(%r15), %eax
testl %eax, %eax
jne 0x4fe4
movq %r12, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq -0x20(%r15), %rsi
movq -0x18(%r15), %rdx
movq %r14, 0x38(%rsp)
movq %rbp, %rdi
callq 0x8c20
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x3280
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x4fbd
callq 0x31f0
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
callq 0x66b2
movq %r12, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x4fde
callq 0x31f0
addq $0x28, %r15
jmp 0x4f6c
cmpl $0x3, %eax
jne 0x5007
movq 0x30(%rsp), %rsi
addq $0x20, %rsi
movq %r15, %rdi
callq 0x4e5f
cmpq %rax, %r15
movq (%rsp), %rdi
cmovneq %rax, %rdi
jmp 0x500b
movq (%rsp), %rdi
movq %rdi, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x501f
movq %rax, %r14
movq %r12, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x5036
callq 0x31f0
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::variable(__gnu_cxx::__normal_iterator<tokenize_phase2::token_t const*, std::vector<tokenize_phase2::token_t, std::allocator<tokenize_phase2::token_t>>>, internal_data::variable&)
token_seq_type::const_iterator variable(token_seq_type::const_iterator first, internal_data::variable &var){
        token_seq_type::const_iterator iter = first;
        if(iter->kind == kind_t::variable){
            var.str = std::string(iter->beg, iter->end);
            return ++iter;
        }else{
            return first;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jne 0x5093
movq %rsi, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8c20
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3280
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x508f
callq 0x31f0
addq $0x28, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::expr_no_sequence(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 expr_no_sequence(std::unique_ptr<internal_data::expr> &e, token_seq_type::const_iterator first){
        token_seq_type::const_iterator iter = first;
        token_seq_type::const_iterator r = first;
        if(iter->kind == kind_t::lambda){
            internal_data::lambda *ptr = new internal_data::lambda();
            iter = lambda(iter, *ptr);
            e.reset(ptr);
            r = iter;
        }else if(iter->kind == kind_t::variable){
            internal_data::variable *ptr = new internal_data::variable();
            iter = variable(iter, *ptr);
            e.reset(ptr);
            r = iter;
        }else if(iter->kind == kind_t::lparen){
            ++iter;
            std::unique_ptr<internal_data::expr> f;
            token_seq_type::const_iterator s = expr(f, iter);
            if(s != first){
                iter = s;
                if(iter->kind == kind_t::rparen){
                    ++s;
                    e.swap(f);
                    r = s;
                }else{
                    throw parsing_error(first->line);
                }
            }
        }
        return r;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
testl %eax, %eax
je 0x512b
cmpl $0x4, %eax
je 0x50ea
cmpl $0x1, %eax
jne 0x5182
movl $0x28, %edi
callq 0x3220
movq %rax, %r15
movq %rax, %rdi
callq 0x671a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f2e
jmp 0x516e
leaq 0x28(%rbx), %rsi
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
callq 0x4796
cmpq %rbx, %rax
je 0x5124
cmpl $0x5, (%rax)
jne 0x518f
addq $0x28, %rax
movq (%r14), %rcx
movq 0x8(%rsp), %rdx
movq %rdx, (%r14)
movq %rcx, 0x8(%rsp)
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x5177
movl $0x28, %edi
callq 0x3220
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x20(%r15)
leaq 0x9b49(%rip), %rcx      # 0xec98
movq %rcx, (%r15)
leaq 0x18(%r15), %rcx
movq %rcx, 0x8(%r15)
movq %rax, 0x10(%r15)
movb $0x0, 0x18(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x503e
movq %rax, %rbx
movq (%r14), %rdi
movq %r15, (%r14)
testq %rdi, %rdi
je 0x5182
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, %r14
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x654c
leaq 0x9959(%rip), %rsi      # 0xeb08
movq 0x9e0a(%rip), %rdx      # 0xefc0
movq %r14, %rdi
callq 0x3350
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
jmp 0x51db
movq %rax, %rbx
movq %r15, %rdi
callq 0x31f0
jmp 0x51eb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x51eb
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: parsing_phase::lines(__gnu_cxx::__normal_iterator<tokenize_phase2::token_t const*, std::vector<tokenize_phase2::token_t, std::allocator<tokenize_phase2::token_t>>>)
bool lines(token_seq_type::const_iterator first){
        token_seq_type::const_iterator iter = first;
        token_seq_type::const_iterator jter = iter;
        for(; (jter = line(iter)) != iter && jter->kind != kind_t::end; iter = jter){
            if(jter->kind == kind_t::dot){
                ++jter;
            }
        }
        if(jter->kind == kind_t::end){
            return true;
        }else{
            return false;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x4d9b
movq %rax, %rbx
cmpq %r14, %rax
je 0x5229
movl (%rbx), %eax
cmpl $0x3, %eax
je 0x5215
cmpl $0x6, %eax
jne 0x5219
jmp 0x5229
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x4d9b
cmpq %rbx, %rax
movq %rax, %rbx
jne 0x5207
cmpl $0x6, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::sequence::copy() const
expr *copy() const override{
            sequence *r = new sequence;
            for(auto iter = vec.begin(); iter != vec.end(); ++iter){
                r->push_back(std::move(std::unique_ptr<expr>((*iter)->copy())));
            }
            return r;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3220
movq %rax, %r14
leaq 0x8012(%rip), %rax      # 0xec20
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq 0x8(%rbx), %r13
cmpq 0x10(%rbx), %r13
je 0x6c71
leaq 0x8(%r14), %r15
leaq 0x8(%rsp), %r12
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x83da
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6c5e
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
addq $0x8, %r13
cmpq 0x10(%rbx), %r13
jne 0x6c34
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6c95
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::sequence::replace(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, internal_data::expr const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, internal_data::expr const*>>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>>>> const&, bool&) const
expr *replace(const variable_map &map, const expr_lookup_table &global_map, bool &mod) const override{
            sequence *r = new sequence;
            for(auto iter = vec.begin(); iter != vec.end(); ++iter){
                r->push_back(std::move(std::unique_ptr<expr>((*iter)->replace(map, global_map, mod))));
            }
            return r;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x20, %edi
callq 0x3220
leaq 0x7f4f(%rip), %rcx      # 0xec20
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rax)
movq 0x8(%r12), %r13
cmpq 0x10(%r12), %r13
je 0x6d46
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %rbp
movq (%r13), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x83da
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6d32
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
addq $0x8, %r13
cmpq 0x10(%r12), %r13
jne 0x6cfd
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6d6d
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::sequence::local_replace(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, internal_data::expr const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, internal_data::expr const*>>> const&, bool&) const
virtual expr *local_replace(const variable_map &map, bool &mod) const{
            sequence *r = new sequence;
            for(auto iter = vec.begin(); iter != vec.end(); ++iter){
                r->push_back(std::move(std::unique_ptr<expr>((*iter)->local_replace(map, mod))));
            }
            return r;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %edi
callq 0x3220
leaq 0x7e7a(%rip), %rcx      # 0xec20
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rax)
movq 0x8(%r15), %r12
cmpq 0x10(%r15), %r12
je 0x6e18
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %r13
leaq 0x8(%rsp), %rbp
movq (%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq %rax, 0x8(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x83da
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6e05
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
addq $0x8, %r12
cmpq 0x10(%r15), %r12
jne 0x6dd5
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6e3f
movq (%rdi), %rax
callq *0x38(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::sequence::to_str[abi:cxx11]() const
std::string to_str() const override{
            std::string r;
            std::size_t count = 0;
            for(auto &i : vec){
                bool nest = i->get_kind() == kind::sequence || i->get_kind() == kind::lambda;
                if(nest){
                    r += "(";
                }
                r += i->to_str();
                if(nest){
                    r += ")";
                }
                if(count < vec.size() - 1){
                    r += " ";
                }
                ++count;
            }
            return std::move(r);
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %r15
je 0x6f51
movq %rsi, %r14
xorl %ebp, %ebp
leaq 0x18(%rsp), %r12
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
movq (%rdi), %rax
callq *(%rax)
movb $0x1, %bl
cmpl $0x1, %eax
je 0x6eb9
movq (%r15,%r13,8), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x2, %eax
sete %bl
testb %bl, %bl
je 0x6ecc
movq %r12, %rdi
leaq 0x33db(%rip), %rsi      # 0xa2a2
callq 0x33b0
movq (%r15,%r13,8), %rsi
movq (%rsi), %rax
leaq 0x38(%rsp), %rdi
callq *0x20(%rax)
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq %r12, %rdi
callq 0x30d0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x6f01
callq 0x31f0
testb %bl, %bl
je 0x6f14
movq %r12, %rdi
leaq 0x33d9(%rip), %rsi      # 0xa2e8
callq 0x33b0
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x3, %rax
decq %rax
cmpq %rax, %r13
jae 0x6f37
movq %r12, %rdi
leaq 0x3375(%rip), %rsi      # 0xa2a7
callq 0x33b0
incq %r13
leaq (%r15,%rbp), %rax
addq $0x8, %rax
addq $0x8, %rbp
cmpq 0x10(%rsp), %rax
jne 0x6e9a
movq 0x8(%rsp), %rax
leaq 0x10(%rax), %rsi
movq %rsi, (%rax)
movq 0x18(%rsp), %rcx
leaq 0x28(%rsp), %rdx
cmpq %rdx, %rcx
je 0x6f7a
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x6f80
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6fb3
movq %rax, %rbx
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x6fb6
callq 0x31f0
jmp 0x6fb6
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x6fca
callq 0x31f0
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::sequence::equal(internal_data::expr const*) const
virtual bool equal(const expr *other) const{
            if(other->get_kind() != expr::kind::sequence){
                return false;
            }
            const sequence *other_seq = static_cast<const sequence*>(other);
            auto iter = vec.begin();
            for(auto &i : other_seq->vec){
                if(!i->equal(&*i)){
                    return false;
                }
                ++iter;
            }
            return true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
cmpl $0x1, %eax
jne 0x7029
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r15, %r14
sete %bl
je 0x702b
movq (%r14), %rdi
movq (%rdi), %rax
movq %rdi, %rsi
callq *0x28(%rax)
testb %al, %al
je 0x702b
addq $0x8, %r14
cmpq %r15, %r14
sete %bl
je 0x702b
movq (%r14), %rdi
movq (%rdi), %rax
movq %rdi, %rsi
callq *0x28(%rax)
addq $0x8, %r14
testb %al, %al
jne 0x700b
jmp 0x702b
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::variable::replace(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, internal_data::expr const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, internal_data::expr const*>>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<internal_data::expr, std::default_delete<internal_data::expr>>>>> const&, bool&) const
expr *replace(const variable_map &map, const expr_lookup_table &global_map, bool &mod) const override{
            auto iter = map.find(str);
            if(iter != map.end()){
                mod = true;
                return iter->second->copy();
            }else{
                auto jter = global_map.find(str);
                if(jter != global_map.end()){
                    mod = true;
                    return jter->second->copy();
                }else{
                    return copy();
                }
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
leaq 0x8(%rdi), %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x71ee
addq $0x8, %r13
cmpq %r13, %rax
jne 0x70fb
movq %r15, %rdi
movq %r12, %rsi
callq 0x7278
addq $0x8, %r15
cmpq %r15, %rax
je 0x7111
movb $0x1, (%rbx)
movq 0x40(%rax), %rdi
movq (%rdi), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
jmp 0x7105
nop