LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/It4innovations[P]Handicap/src/GraphLabelings/../Outputs/../Structures/Matrix.h
// Function: Matrix<int>::Matrix(int, int, int)
Matrix(const int rows, const int columns, const int missingLabel) : rows(rows), columns(columns) {
			if (rows < 1) {
				throw std::runtime_error("Number of rows at matrix are invalid.\n");
			}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
andl $0x0, 0x8(%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
testl %esi, %esi
jle 0x56be
movl %edx, %r15d
testl %edx, %edx
jle 0x56da
movl %ecx, %ebp
movl %esi, %r12d
movq %rdi, %r14
imull %r15d, %r12d
shlq $0x2, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %r13
leaq 0x10(%r14), %rbx
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2100
movq %r13, (%rbx)
movl %r15d, %r12d
leaq (,%r12,4), %rdi
callq 0x2030
leaq 0x10(%rsp), %r15
andq $0x0, (%r15)
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x596c
movq %r15, %rdi
callq 0x3192
movq (%rbx), %rax
movl %ebp, %ecx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rdx, %r12
je 0x56af
movl $0x0, %edi
cmpq %rdx, %rcx
je 0x56a1
movl (%r14), %edi
testq %rdx, %rdx
cmovel %esi, %edi
movl %edi, (%rax,%rdx,4)
incq %rdx
jmp 0x568f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %r14
leaq 0x1b4c(%rip), %rsi      # 0x721c
movq %rax, %rdi
callq 0x2080
jmp 0x56f4
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %r14
leaq 0x1b57(%rip), %rsi      # 0x7243
movq %rax, %rdi
callq 0x2080
movq 0x68f5(%rip), %rsi      # 0xbff0
movq 0x68b6(%rip), %rdx      # 0xbfb8
movq %r14, %rdi
callq 0x2280
jmp 0x570c
movq %rax, %r15
movq %r14, %rdi
callq 0x2120
jmp 0x571e
jmp 0x571b
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0x3192
movq %r15, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
xorl %r15d, %r15d
testl %edx, %edx
cmovlel %r15d, %ebx
movl $0x200, %r12d           # imm = 0x200
cmpq %r15, %rbx
je 0x5a0c
movslq 0x40(%r14), %rax
movq 0x30(%r14), %rdi
imulq $0x50, %rax, %rcx
movq 0x30(%rdi,%rcx), %rax
cmpq 0x38(%rdi,%rcx), %rax
jne 0x59c9
addq %rdi, %rcx
movq 0x48(%rcx), %rax
movq -0x8(%rax), %rax
addq %r12, %rax
movl -0x4(%rax), %eax
movq 0x38(%r14), %rcx
movl %eax, (%rcx,%r15,4)
movq 0x10(%r14), %rcx
movslq 0x58(%rcx), %rdx
movq 0x28(%rcx), %rsi
movl %ebp, (%rsi,%rdx,8)
movl %eax, 0x4(%rsi,%rdx,8)
leal 0x2(%rdx), %r8d
movl %r8d, 0x58(%rcx)
movl %eax, 0x8(%rsi,%rdx,8)
movl %ebp, 0xc(%rsi,%rdx,8)
movslq 0x40(%r14), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x4a86
incq %r15
jmp 0x599e
movq 0x10(%r14), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5caa
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %edx, %edx
cmovgl %edx, %ebp
movl $0x200, %r15d           # imm = 0x200
movq 0x10(%r14), %rdi
subl $0x1, %ebp
jb 0x5c9a
movslq 0x5c(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x5c(%rdi)
movq 0x40(%rdi), %rcx
movl %ebx, (%rcx,%rax,4)
movslq 0x40(%r14), %rdx
movq 0x30(%r14), %rax
imulq $0x50, %rdx, %rsi
movq 0x30(%rax,%rsi), %rdx
cmpq 0x38(%rax,%rsi), %rdx
jne 0x5c73
addq %rax, %rsi
movq 0x48(%rsi), %rdx
movq -0x8(%rdx), %rdx
addq %r15, %rdx
movl -0x4(%rdx), %edx
movslq 0x5c(%rdi), %rsi
leal 0x1(%rsi), %r8d
movl %r8d, 0x5c(%rdi)
movl %edx, (%rcx,%rsi,4)
movslq 0x40(%r14), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, %rdi
callq 0x4a86
jmp 0x5c33
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6384
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x4
popq %r14
xorl %r15d, %r15d
movslq 0x58(%rbx), %rax
cmpq %rax, %r15
jge 0x5cef
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdx
leaq (%rdx,%r14), %rsi
addq $-0x4, %rsi
addq %r14, %rdx
movl 0x4(%rsi), %ecx
movslq (%rsi), %rdi
subl %ecx, (%rax,%rdi,4)
movq %rbx, %rdi
callq 0x5cfa
incq %r15
addq $0x8, %r14
jmp 0x5cb9
andl $0x0, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq (%rsi), %rax
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %r8
movslq (%r8,%rax,4), %r9
movslq (%rdi), %r10
imulq %rax, %r10
addq %r9, %r10
movl (%rdx), %eax
movl %eax, -0x4(%rcx,%r10,4)
movslq (%rsi), %rax
decl (%r8,%rax,4)
incl 0x8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rax
movl 0x2c(%rdi), %esi
cmpl $0x1, %esi
jne 0x5d89
movslq 0x30(%rax), %rsi
cmpq $0x2, %rsi
jl 0x5dfc
movq (%rax), %rdi
movl 0x4(%rdi), %r8d
incl %r8d
cmpl %r8d, %esi
jg 0x5dfc
cmpl 0x10(%rdi), %esi
je 0x5dfc
movq (%rdx), %rdx
movq 0x18(%rdx), %rdx
cmpl $0x0, (%rdx,%rsi,4)
je 0x5dfc
cmpl 0x28(%rax), %esi
je 0x5dfc
addq $0x30, %rax
movq %rcx, %rdi
movq %rax, %rsi
popq %rax
jmp 0x47e6
jle 0x5dfe
movq (%rax), %rdi
cmpl 0x8(%rdi), %esi
jg 0x5dfe
andl $0x0, 0x4(%rsp)
movq (%rdx), %rdx
leaq 0x20(%rax), %rsi
movq 0x20(%rax), %r8
pushq $0x1
popq %r9
xorl %r10d, %r10d
movslq 0x4(%rdi), %r11
addq $0x2, %r11
cmpq %r11, %r9
jge 0x5ddf
movq 0x18(%rdx), %r11
cmpl $0x0, (%r11,%r9,4)
je 0x5dda
movl 0x28(%rax), %r11d
cmpq %r11, %r9
je 0x5dda
movslq %r10d, %r11
incl %r10d
movl %r10d, 0x4(%rsp)
movl %r9d, (%r8,%r11,4)
incq %r9
jmp 0x5daa
leaq 0x10(%rax), %rdi
movq 0x2c(%rax), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0x14(%rax)
leaq 0x4(%rsp), %rdx
callq 0x2d00
popq %rax
retq
pushq $0x8
popq %rdi
callq 0x20d0
leaq 0x1470(%rip), %rcx      # 0x727d
movq %rcx, (%rax)
movq 0x6191(%rip), %rsi      # 0xbfa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq (%rdi), %rcx
movq (%rsi), %rdx
movb $0x1, %al
xorl %esi, %esi
cmpq %rcx, %rsi
jge 0x5e54
testb $0x1, %al
je 0x5e54
movq 0x18(%rdx), %rax
cmpl $0x0, (%rax,%rsi,4)
jne 0x5e49
movq 0x20(%rdx), %rax
cmpl $0x0, (%rax,%rsi,4)
je 0x5e50
xorl %eax, %eax
incq %rsi
jmp 0x5e2c
movb $0x1, %al
jmp 0x5e4b
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x613f(%rip), %r15      # 0xbfc8
pushq $0x23
popq %rsi
movq %r15, %rdi
callq 0x21b0
movl (%r12), %esi
movq %rax, %rdi
callq 0x2290
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x21b0
pushq $0x1
popq %r12
pushq $0x9
popq %r13
movq 0x8(%r14), %rax
movl 0x4(%rax), %ecx
addl $0x2, %ecx
cmpl %ecx, %r12d
jge 0x5f63
cmpl %r12d, 0x10(%rax)
je 0x5f5b
movq %r15, %rdi
movl %r12d, %esi
callq 0x2290
movq %rax, %rdi
leaq 0x13ac(%rip), %rsi      # 0x7291
callq 0x2180
movq (%r14), %rdi
movq 0x8(%r14), %rax
movq (%rbx), %rcx
movslq %r12d, %rdx
xorl %esi, %esi
movslq 0x8(%rax), %r8
cmpq %r8, %rsi
jge 0x5f1d
movq 0x10(%rcx), %r8
movslq (%rcx), %r9
imulq %rdx, %r9
addq %rsi, %r9
movl (%r8,%r9,4), %r8d
movl %r8d, (%rdi,%rsi,4)
incq %rsi
jmp 0x5ef9
leaq (%rdi,%r8,4), %rsi
callq 0x5f84
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movslq 0x8(%rax), %rax
movq %r15, %rdi
cmpq %rax, %rbp
jge 0x5f53
movl %r13d, %esi
callq 0x21b0
movq (%r14), %rcx
movl (%rcx,%rbp,4), %esi
movq %rax, %rdi
callq 0x2290
incq %rbp
jmp 0x5f28
pushq $0xa
popq %rsi
callq 0x21b0
incl %r12d
jmp 0x5eb3
movq 0x605e(%rip), %rdi      # 0xbfc8
leaq 0x1323(%rip), %rsi      # 0x7294
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x5c(%rbx), %rax
cmpq %rax, %r15
jge 0x63d7
movq 0x40(%rbx), %rsi
movslq (%rsi,%r14), %rax
addq %r14, %rsi
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
movslq (%rdx,%rax,4), %rdx
movslq (%rbx), %rdi
imulq %rax, %rdi
addq %rdx, %rdi
movl (%rcx,%rdi,4), %ecx
movq 0x20(%rbx), %rdx
addl %ecx, (%rdx,%rax,4)
movq %rbx, %rdi
callq 0x63e2
incq %r15
addq $0x4, %r14
jmp 0x6392
andl $0x0, 0x5c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movsd 0x10(%rsp), %xmm6
xorpd 0x1195(%rip), %xmm6     # 0x5060
movsd 0x8(%rsp), %xmm3
movsd 0x18(%rsp), %xmm0
movapd %xmm3, %xmm4
mulsd %xmm0, %xmm4
movsd (%rsi), %xmm2
movsd 0x8(%rsi), %xmm1
divsd %xmm2, %xmm4
subsd %xmm4, %xmm6
movapd %xmm3, %xmm7
mulsd %xmm3, %xmm7
mulsd %xmm3, %xmm7
movsd 0x20(%rsp), %xmm4
movapd %xmm3, %xmm5
unpcklpd %xmm7, %xmm5            # xmm5 = xmm5[0],xmm7[0]
mulsd %xmm4, %xmm7
divsd %xmm1, %xmm7
subsd %xmm7, %xmm6
movsd %xmm6, (%rdi)
movsd %xmm3, 0x8(%rdi)
movsd 0x11c1(%rip), %xmm6     # 0x50e8
mulsd %xmm3, %xmm6
mulsd %xmm3, %xmm6
movsd 0x11b9(%rip), %xmm7     # 0x50f0
mulsd %xmm3, %xmm7
mulsd %xmm3, %xmm7
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm5, %xmm3
movapd 0x1121(%rip), %xmm5     # 0x5070
unpcklpd %xmm6, %xmm5            # xmm5 = xmm5[0],xmm6[0]
addpd %xmm3, %xmm5
movupd %xmm5, 0x10(%rdi)
divsd %xmm2, %xmm0
mulsd %xmm4, %xmm7
divsd %xmm1, %xmm7
addsd %xmm0, %xmm7
movsd %xmm7, 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x5815
testb %al, %al
je 0x3639
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3150
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30f0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5838
xorl %ebp, %ebp
leaq 0xa451(%rip), %rsi      # 0xdac0
movq 0xa94a(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x3360
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3130
testb %bpl, %bpl
jne 0x3695
jmp 0x369d
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x5895
movq %rax, %r15
leaq 0x48(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x57c4
movq (%rbx), %rsi
leaq 0x48(%rsp), %rdi
pushq $0x4
popq %rdx
callq 0x3390
movq (%r14), %rsi
leaq 0x48(%rsp), %rdi
movq %r15, %rdx
callq 0x3290
leaq 0x48(%rsp), %rdi
callq 0x30b0
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 0x30b0
jmp 0x372a
movq %rdx, %r12
movq %rax, %r15
movq %r14, %rdi
callq 0x737e
jmp 0x373c
jmp 0x3736
movq %rdx, %r12
movq %rax, %r15
cmpl $0x2, %r12d
jne 0x37cb
movq %r15, %rdi
callq 0x3270
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x3080
movq %r15, %rdi
callq 0x3100
pushq $0x10
popq %rdi
callq 0x3150
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 0x58b8
xorl %ebp, %ebp
leaq 0xa31e(%rip), %rsi      # 0xdad8
movq 0xa7ff(%rip), %rdx      # 0xdfc0
movq %r14, %rdi
callq 0x3360
jmp 0x37fc
movq %r15, %rdi
callq 0x3100
pushq $0x10
popq %rdi
callq 0x3150
movq %rax, %r14
movq %rax, %rdi
callq 0x589c
leaq 0xa2bb(%rip), %rsi      # 0xdaa8
movq 0xa7cc(%rip), %rdx      # 0xdfc0
movq %r14, %rdi
callq 0x3360
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3130
jmp 0x3811
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x3130
testb %bpl, %bpl
jne 0x3825
jmp 0x382d
movq %rax, %rbx
movq %r14, %rdi
callq 0x31b0
leaq 0x48(%rsp), %rdi
callq 0x3070
callq 0x3350
jmp 0x3853
movq %rax, %rbx
jmp 0x384e
movq %rax, %rbx
movq %r14, %rdi
callq 0x31b0
callq 0x3350
movq %rbx, %rdi
callq 0x3370
movq %rax, %rdi
callq 0x57b3
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa4f7(%rip), %r14      # 0xe258
leaq 0xa4f8(%rip), %r15      # 0xe260
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%rbx), %rsi
testl %eax, %eax
jne 0x3da5
addq $0x8, %rsi
movq %r14, %rdi
callq 0x7a50
cmpq %r15, %rax
je 0x3de6
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x3d68
movq (%rdi), %rax
callq *0x38(%rax)
jmp 0x3d68
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq (%rbx), %rdi
cmpl $0x2, %eax
jne 0x3dbe
addq $0x20, %rdi
movq %rdi, %rbx
jmp 0x3d68
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
jne 0x3de6
movq (%rbx), %rax
movq 0x8(%rax), %rbx
movq 0x10(%rax), %r14
cmpq %r14, %rbx
je 0x3de6
movq %rbx, %rdi
callq 0x3d52
addq $0x8, %rbx
jmp 0x3dd3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x50, %rsp
movq %rsi, %rbx
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpl $0x0, (%rsi)
jne 0x42dc
movq %rdi, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %rdi
callq 0x7ef0
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x3260
movq %r14, %rdi
callq 0x3130
cmpl $0x2, 0x28(%rbx)
jne 0x42dc
addq $0x50, %rbx
movq %rsp, %rdi
andq $0x0, (%rdi)
movq %rbx, %rsi
callq 0x4340
movq %rax, %r14
cmpq %rbx, %rax
je 0x42ca
movq (%r15), %rax
movq (%rsp), %rdi
movq %rdi, (%r15)
movq %rax, (%rsp)
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %r15
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x32d0
leaq 0x8(%rsp), %rsi
movq %r15, 0x20(%rsi)
leaq 0x9f9d(%rip), %rdi      # 0xe258
callq 0x7f5e
leaq 0x8(%rsp), %rdi
callq 0x5a76
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x42d9
movq (%rdi), %rax
callq *0x38(%rax)
movq %r14, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5a76
jmp 0x431a
movq %rax, %rbx
testq %r15, %r15
je 0x431a
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
jmp 0x431a
jmp 0x4317
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x432e
movq (%rdi), %rax
callq *0x38(%rax)
jmp 0x432e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rdi)
movq %r14, %rsi
callq 0x4206
movq %rax, %rbx
cmpq %r14, %rax
jne 0x4743
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4340
movq %rax, %rbx
cmpq %r14, %rax
je 0x4760
leaq 0x9b4f(%rip), %rdi      # 0xe288
leaq 0x8(%rsp), %rsi
callq 0x76f2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4753
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x3150
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x5a8c
leaq 0x938a(%rip), %rsi      # 0xdb08
movq 0x983b(%rip), %rdx      # 0xdfc0
movq %r15, %rdi
callq 0x3360
movq %rax, %rbx
movq %r15, %rdi
callq 0x31b0
jmp 0x479f
jmp 0x479c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x47af
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4340
movq %rax, %rbx
cmpq %r15, %rax
je 0x4847
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
je 0x4847
pushq $0x20
popq %rdi
callq 0x3220
movq %rax, %r15
leaq 0x9428(%rip), %rax      # 0xdc20
movq %rax, (%r15)
leaq 0x8(%r15), %rdi
andq $0x0, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
andq $0x0, (%r14)
callq 0x76f2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4830
movq (%rdi), %rax
callq *0x38(%rax)
andq $0x0, 0x8(%rsp)
movq (%r14), %rdi
movq %r15, (%r14)
testq %rdi, %rdi
je 0x4847
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 0x4867
movq (%rdi), %rax
callq *0x38(%rax)
andq $0x0, 0x8(%rsp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4948
leaq 0x48(%rsp), %r12
movq %rsi, 0x8(%rsp)
leaq 0x8(%rsi), %r13
movq %rdi, (%rsp)
leaq 0x50(%rdi), %r15
leaq 0x93e6(%rip), %rbx      # 0xdc98
leaq 0x38(%rsp), %rbp
leaq 0x10(%rsp), %r14
movl -0x28(%r15), %eax
testl %eax, %eax
jne 0x4921
movq %rbx, 0x10(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
movq -0x20(%r15), %rsi
movq -0x18(%r15), %rdx
movq %r12, 0x38(%rsp)
movq %rbp, %rdi
callq 0x7ef0
leaq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x3260
movq %rbp, %rdi
callq 0x3130
movq %r13, %rdi
movq %r14, %rsi
callq 0x5b12
movq %r14, %rdi
callq 0x5b3e
addq $0x28, %r15
jmp 0x48bc
cmpl $0x3, %eax
jne 0x4944
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
movq %r15, %rdi
callq 0x47b7
cmpq %rax, %r15
movq (%rsp), %rdi
cmovneq %rax, %rdi
jmp 0x4948
movq (%rsp), %rdi
movq %rdi, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x495c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5b3e
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jne 0x49bc
movq %rsi, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rsp, %r15
movq %r15, %rdi
callq 0x7ef0
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3260
movq %r15, %rdi
callq 0x3130
addq $0x28, %rbx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4a41
cmpl $0x4, %eax
je 0x4a0c
cmpl $0x1, %eax
jne 0x4a8e
pushq $0x28
popq %rdi
callq 0x3220
movq %rax, %r15
movq %rax, %rdi
callq 0x5b52
movq %rbx, %rdi
movq %r15, %rsi
callq 0x487e
jmp 0x4a7a
leaq 0x28(%rbx), %rsi
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
callq 0x4340
cmpq %rbx, %rax
je 0x4a9b
cmpl $0x5, (%rax)
jne 0x4aa2
addq $0x28, %rax
movq (%r14), %rdi
movq 0x8(%rsp), %rcx
movq %rcx, (%r14)
movq %rdi, 0x8(%rsp)
movq %rax, %rbx
jmp 0x4a83
pushq $0x28
popq %rdi
callq 0x3220
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
leaq 0x9239(%rip), %rax      # 0xdc98
movq %rax, (%r15)
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
movb $0x0, 0x18(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4971
movq %rax, %rbx
movq (%r14), %rdi
movq %r15, (%r14)
testq %rdi, %rdi
je 0x4a8e
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rdi
jmp 0x4a83
pushq $0x10
popq %rdi
callq 0x3150
movq %rax, %r14
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x5a8c
leaq 0x9048(%rip), %rsi      # 0xdb08
movq 0x94f9(%rip), %rdx      # 0xdfc0
movq %r14, %rdi
callq 0x3360
movq %rax, %rbx
movq %r14, %rdi
callq 0x31b0
jmp 0x4aec
movq %rax, %rbx
movq %r15, %rdi
callq 0x3200
jmp 0x4afc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4afc
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x46f8
movl (%rax), %ecx
cmpq %rbx, %rax
je 0x4bd2
cmpl $0x3, %ecx
je 0x4bc9
movq %rax, %rbx
cmpl $0x6, %ecx
jne 0x4bab
jmp 0x4bd2
addq $0x28, %rax
movq %rax, %rbx
jmp 0x4bab
cmpl $0x6, %ecx
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x3220
movq %rax, %r14
leaq 0x7be0(%rip), %rax      # 0xdc20
movq %rax, (%r14)
leaq 0x8(%r14), %r15
andq $0x0, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq 0x8(%rbx), %r13
leaq 0x8(%rsp), %r12
cmpq 0x10(%rbx), %r13
je 0x6099
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x76f2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x608d
movq (%rdi), %rax
callq *0x38(%rax)
andq $0x0, 0x8(%rsp)
addq $0x8, %r13
jmp 0x605d
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 0x60bd
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x3220
leaq 0x7b31(%rip), %rcx      # 0xdc20
movq %rcx, (%rax)
leaq 0x8(%rax), %rbp
andq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movq %rax, 0x10(%rsp)
movups %xmm0, 0x8(%rax)
movq 0x8(%r12), %r13
cmpq 0x10(%r12), %r13
je 0x6154
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 0x76f2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6148
movq (%rdi), %rax
callq *0x38(%rax)
andq $0x0, 0x8(%rsp)
addq $0x8, %r13
jmp 0x610c
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 0x617b
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x3220
leaq 0x7a76(%rip), %rcx      # 0xdc20
movq %rcx, (%rax)
leaq 0x8(%rax), %r13
andq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movq %rax, 0x10(%rsp)
movups %xmm0, 0x8(%rax)
movq 0x8(%r15), %r12
leaq 0x8(%rsp), %rbp
cmpq 0x10(%r15), %r12
je 0x620d
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 0x76f2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6201
movq (%rdi), %rax
callq *0x38(%rax)
andq $0x0, 0x8(%rsp)
addq $0x8, %r12
jmp 0x61cb
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 0x6234
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rsi), %rbp
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
leaq 0x18(%rsp), %r12
leaq 0x38(%rsp), %r13
cmpq 0x10(%rsp), %rbp
je 0x631b
movq (%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
je 0x62a4
movq (%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x2, %eax
jne 0x62b7
movb $0x1, %bl
movq %r12, %rdi
leaq 0x2fc8(%rip), %rsi      # 0x9278
callq 0x33b0
jmp 0x62b9
xorl %ebx, %ebx
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *0x20(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x33c0
movq %r13, %rdi
callq 0x3130
testb %bl, %bl
je 0x62ec
movq %r12, %rdi
leaq 0x2fd7(%rip), %rsi      # 0x92be
callq 0x33b0
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x3, %rax
decq %rax
cmpq %rax, %r15
jae 0x630f
movq %r12, %rdi
leaq 0x2f73(%rip), %rsi      # 0x927d
callq 0x33b0
incq %r15
addq $0x8, %rbp
jmp 0x627d
movq 0x8(%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rcx
leaq 0x28(%rsp), %rdx
cmpq %rdx, %rcx
je 0x6344
movq %rcx, (%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x634a
movups (%rdx), %xmm0
movups %xmm0, (%rax)
leaq 0x18(%rsp), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
movq %rdx, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x3130
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x638b
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3130
jmp 0x638e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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 0x63db
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r15, %r14
sete %bl
je 0x63dd
movq (%r14), %rdi
movq (%rdi), %rax
movq %rdi, %rsi
callq *0x28(%rax)
addq $0x8, %r14
testb %al, %al
jne 0x63bd
jmp 0x63dd
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6556
addq $0x8, %r13
cmpq %r13, %rax
jne 0x649b
movq %r15, %rdi
movq %r12, %rsi
callq 0x65ec
addq $0x8, %r15
cmpq %r15, %rax
je 0x64b1
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 0x64a5
nop
// File: /workspace/github_cpp_makefile_star2_O2/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::variable::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
expr *local_replace(const variable_map &map, bool &mod) const{
            auto iter = map.find(str);
            if(iter != map.end()){
                mod = true;
                return iter->second->copy();
            }else{
                return copy();
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rsi
movq %r15, %rdi
callq 0x6556
addq $0x8, %r15
cmpq %r15, %rax
je 0x64e9
movb $0x1, (%rbx)
movq 0x40(%rax), %rdi
movq (%rdi), %rax
jmp 0x64ef
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/pointwiseproduct[P]untyped_lambda/untyped_lambda.cpp
// Function: internal_data::lambda::copy() const
expr *copy() const{
            lambda *r = new lambda;
            for(auto iter = variable_seq.begin(); iter != variable_seq.end(); ++iter){
                variable v;
                v.str = iter->str;
                r->variable_seq.push_back(v);
            }
            for(auto iter = get_seq()->vec.begin(); iter != get_seq()->vec.end(); ++iter){
                r->get_seq()->push_back(std::move(std::unique_ptr<expr>((*iter)->copy())));
            }
            return r;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x3220
movq %rax, %rbx
movq %rax, %rdi
callq 0x5b52
movq 0x8(%r14), %r15
movq %rbx, %r13
addq $0x8, %r13
leaq 0x75b6(%rip), %r12      # 0xdc98
leaq 0x10(%rsp), %rbp
cmpq 0x10(%r14), %r15
je 0x6731
movq %r12, 0x10(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
addq $0x8, %r15
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x3170
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5b12
movq %rbp, %rdi
callq 0x5b3e
addq $0x20, %r15
jmp 0x66e7
movq 0x20(%r14), %rax
movq 0x8(%rax), %r13
leaq 0x8(%rsp), %r15
cmpq 0x10(%rax), %r13
je 0x6786
movq 0x20(%rbx), %r12
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, 0x8(%rsp)
addq $0x8, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x76f2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6776
movq (%rdi), %rax
callq *0x38(%rax)
andq $0x0, 0x8(%rsp)
addq $0x8, %r13
movq 0x20(%r14), %rax
jmp 0x673e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3200
jmp 0x67c7
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x67c7
movq (%rdi), %rax
callq *0x38(%rax)
jmp 0x67c7
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5b3e
movq %r14, %rdi
callq 0x3370
nop