LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/williewillus[P]panda_scratchpad/src/tests/j-lang150.cpp
// Function: tests::testName::setup()
virtual int setup() override {
                
				test_path = mnt_dir_ ;
				A_path = mnt_dir_ + "/A";
				AC_path = mnt_dir_ + "/A/C";
				B_path = mnt_dir_ + "/B";
				foo_path = mnt_dir_ + "/foo";
				bar_path = mnt_dir_ + "/bar";
				Afoo_path = mnt_dir_ + "/A/foo";
				Abar_path = mnt_dir_ + "/A/bar";
				Bfoo_path = mnt_dir_ + "/B/foo";
				Bbar_path = mnt_dir_ + "/B/bar";
				ACfoo_path = mnt_dir_ + "/A/C/foo";
				ACbar_path = mnt_dir_ + "/A/C/bar";
                return 0;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
addq $0x38, %rdi
movq %r14, %rsi
callq 0xa230
leaq 0x4283(%rip), %rdx      # 0xf012
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x58(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x425c(%rip), %rdx      # 0xf015
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x78(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x423b(%rip), %rdx      # 0xf01a
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x98(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x4217(%rip), %rdx      # 0xf01f
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0xb8(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x41f5(%rip), %rdx      # 0xf026
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0xd8(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x41c3(%rip), %rdx      # 0xf01d
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0xf8(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x41a1(%rip), %rdx      # 0xf024
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x118(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x417f(%rip), %rdx      # 0xf02b
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x138(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x415d(%rip), %rdx      # 0xf032
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x158(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x413b(%rip), %rdx      # 0xf039
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x178(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x411b(%rip), %rdx      # 0xf042
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
addq $0x198, %rbx            # imm = 0x198
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/williewillus[P]panda_scratchpad/src/tests/j-lang150.cpp
// Function: tests::testName::check_test(unsigned int, tests::DataTestResult*)
virtual int check_test( unsigned int last_checkpoint, DataTestResult *test_result) override {
                
				test_path = mnt_dir_ ;
				A_path =  mnt_dir_ + "/A";
				AC_path =  mnt_dir_ + "/A/C";
				B_path =  mnt_dir_ + "/B";
				foo_path =  mnt_dir_ + "/foo";
				bar_path =  mnt_dir_ + "/bar";
				Afoo_path =  mnt_dir_ + "/A/foo";
				Abar_path =  mnt_dir_ + "/A/bar";
				Bfoo_path =  mnt_dir_ + "/B/foo";
				Bbar_path =  mnt_dir_ + "/B/bar";
				ACfoo_path =  mnt_dir_ + "/A/C/foo";
				ACbar_path =  mnt_dir_ + "/A/C/bar";
                return 0;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
addq $0x38, %rdi
movq %r14, %rsi
callq 0xa230
leaq 0x3db3(%rip), %rdx      # 0xf012
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x58(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x3d8c(%rip), %rdx      # 0xf015
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x78(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x3d6b(%rip), %rdx      # 0xf01a
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x98(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x3d47(%rip), %rdx      # 0xf01f
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0xb8(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x3d25(%rip), %rdx      # 0xf026
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0xd8(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x3cf3(%rip), %rdx      # 0xf01d
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0xf8(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x3cd1(%rip), %rdx      # 0xf024
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x118(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x3caf(%rip), %rdx      # 0xf02b
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x138(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x3c8d(%rip), %rdx      # 0xf032
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x158(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x3c6b(%rip), %rdx      # 0xf039
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
leaq 0x178(%rbx), %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
leaq 0x3c4b(%rip), %rdx      # 0xf042
movq %r15, %rdi
movq %r14, %rsi
callq 0xa570
addq $0x198, %rbx            # imm = 0x198
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa550
movq %r15, %rdi
callq 0xa1d0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lishen2[P]Excel_formula_parser_cpp/main.cpp
// Function: printParser(ExcelFormula::FormulaParser&)
void printParser(FormulaParser& parser)
{
	vector<Token*> tokens = parser.getTokens();
	cout << "Formula:" << parser.getFormula() << endl;
	cout << "Tokens:" << endl;
	
	int indent = 0;
	for(vector<Token*>::iterator it = tokens.begin();
			it != tokens.end();
			++it)
	{
		if((*it)->getSubtype() == Token::Start)
		{
			++indent;
		}
		printIndent(indent);
		cout << (*it)->getPrintableString() << endl;
		if((*it)->getSubtype() == Token::Stop)
		{
			--indent;
		}
	}

	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rsi
leaq -0x38(%rbp), %rdi
callq 0x25d2
movq 0x5bd7(%rip), %rdi      # 0x7fd8
leaq 0x2bfe(%rip), %rsi      # 0x5006
callq 0x2160
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
movq 0x5bb1(%rip), %rdi      # 0x7fd8
leaq 0x2be1(%rip), %rsi      # 0x500f
callq 0x2160
movq %rax, %rdi
callq 0x20c0
xorl %ebx, %ebx
movq -0x38(%rbp), %r12
leaq -0x58(%rbp), %r14
movq 0x5b8c(%rip), %r15      # 0x7fd8
cmpq -0x30(%rbp), %r12
je 0x24a4
movq (%r12), %rax
xorl %ecx, %ecx
cmpl $0x1, 0x24(%rax)
sete %cl
addl %ecx, %ebx
movl %ebx, %edi
callq 0x239c
movq (%r12), %rsi
movq %r14, %rdi
callq 0x3c9e
movq %r15, %rdi
movq %r14, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2268
movq (%r12), %rax
xorl %ecx, %ecx
cmpl $0x2, 0x24(%rax)
sete %cl
subl %ecx, %ebx
addq $0x8, %r12
jmp 0x244c
movq 0x5b2d(%rip), %rdi      # 0x7fd8
callq 0x20c0
leaq -0x38(%rbp), %rdi
callq 0x26cc
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24cc
jmp 0x24cc
jmp 0x24cc
movq %rax, %rbx
jmp 0x24dd
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2268
leaq -0x38(%rbp), %rdi
callq 0x26cc
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/lishen2[P]Excel_formula_parser_cpp/main.cpp
// Function: main
int main(int argc, char* argv[])
{
	const char szFormula1[] = "=1+3+5";
	FormulaParser parser1(szFormula1);
	parser1.parserToToken1();
	parser1.parserToToken2();
	printParser(parser1);

	
	const char szFormula2[] = "=IF(R13C3>DATE(2002,1,6),0,IF(ISERROR(R[41]C[2]),0,IF(R13C3>=R[41]C[2],0, IF(AND(R[23]C[11]>=55,R[24]C[11]>=20),R53C3,0))))";
	FormulaParser parser2(szFormula2);
	parser2.parserToToken1();
	parser2.parserToToken2();
	printParser(parser2);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
leaq -0x10(%rbp), %rsi
movl $0x352b33, 0x3(%rsi)    # imm = 0x352B33
movl $0x332b313d, (%rsi)     # imm = 0x332B313D
leaq -0x170(%rbp), %rbx
movq %rbx, %rdi
callq 0x277c
movq %rbx, %rdi
callq 0x2858
leaq -0x170(%rbp), %rdi
callq 0x33a4
leaq -0x170(%rbp), %rdi
callq 0x23db
leaq 0x2adf(%rip), %rsi      # 0x5020
pushq $0x7c
popq %rcx
leaq -0x1f0(%rbp), %rax
movq %rax, %rdi
rep  movsb (%rsi), %es:(%rdi)
leaq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x277c
leaq -0xc0(%rbp), %rdi
callq 0x2858
leaq -0xc0(%rbp), %rdi
callq 0x33a4
leaq -0xc0(%rbp), %rdi
callq 0x23db
leaq -0xc0(%rbp), %rdi
callq 0x262a
leaq -0x170(%rbp), %rdi
callq 0x262a
xorl %eax, %eax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %rbp
retq
jmp 0x25ba
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x262a
jmp 0x25bd
movq %rax, %rbx
leaq -0x170(%rbp), %rdi
callq 0x262a
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O2/lishen2[P]Excel_formula_parser_cpp/FormulaParser.cpp
// Function: ExcelFormula::FormulaParser::clear()
void FormulaParser::clear()
	{
		for(vector<Token*>::const_iterator it = m_tokens.begin();
				it != m_tokens.end();
				++it)
		{
			delete *it;	
		}

		m_tokens.clear();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r12
pushq $0x28
popq %r14
cmpq 0x28(%rbx), %r12
je 0x37ba
movq (%r12), %r15
testq %r15, %r15
je 0x37a9
movq %r15, %rdi
callq 0x2268
movq %r15, %rdi
movq %r14, %rsi
callq 0x2180
addq $0x8, %r12
jmp 0x3792
movq 0x20(%rbx), %rax
cmpq %rax, %r12
je 0x37c7
movq %rax, 0x28(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lishen2[P]Excel_formula_parser_cpp/StrUtils.cpp
// Function: StrUtils::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
string StrUtils::trim(string& value)
{
	//trim begin
	for(size_t i = 0; i < value.size(); ++i)
	{
		if (!isEmpChar(value[i]))
		{
			value.erase(0, i);
			break;
		}
	}

	//trim end
	for(size_t i = value.size() - 1;
			i >= 0; --i)
	{
		if (!isEmpChar(value[i]))
		{
			value.erase(i + 1);
			break;
		}
	}

	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
xorl %edx, %edx
cmpq %rdx, %rsi
je 0x3b20
movzbl (%rax,%rdx), %ecx
cmpl $0x9, %ecx
je 0x3b05
cmpl $0x20, %ecx
jne 0x3b0a
incq %rdx
jmp 0x3af2
movq %r14, %rdi
xorl %esi, %esi
callq 0x2050
movq (%r14), %rax
movq 0x8(%r14), %rsi
jmp 0x3b20
decq %rsi
movzbl -0x1(%rax,%rsi), %ecx
cmpl $0x20, %ecx
je 0x3b1d
cmpl $0x9, %ecx
je 0x3b1d
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x2050
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lishen2[P]Excel_formula_parser_cpp/StrUtils.cpp
// Function: StrUtils::indexOf(int, char const**, char const*)
int StrUtils::indexOf(const int argc, const char* array[], const char* szStr)
{
	int retVal = -1;
	for(int i = 0; i < argc; ++i)
	{
		if (strcmp(array[i], szStr) == 0)
			return i;
	}
	return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
xorl %r13d, %r13d
testl %edi, %edi
cmovlel %r13d, %r15d
pushq $-0x1
popq %r12
cmpq %r13, %r15
je 0x3be5
movq (%r14,%r13,8), %rdi
movq %rbx, %rsi
callq 0x21c0
testl %eax, %eax
je 0x3be2
incq %r13
jmp 0x3bc8
movl %r13d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lishen2[P]Excel_formula_parser_cpp/TokenArray.cpp
// Function: ExcelFormula::TokenArray::getCurrent()
Token* TokenArray::getCurrent()
	{
		if (m_index >= m_tokens.size() || m_index < 0)
		{
			return NULL;
		}
		else
		{
			return m_tokens[m_index];
		}
	}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x3e91
pushq %rbp
movq %rsp, %rbp
movq (%rcx,%rax,8), %rax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/lishen2[P]Excel_formula_parser_cpp/TokenArray.cpp
// Function: ExcelFormula::TokenArray::releaseAll()
void TokenArray::releaseAll()
	{
		for(vector<Token*>::const_iterator it = m_tokens.begin();
				it != m_tokens.end();
				++it)
		{
			delete (*it);
		}
		m_tokens.clear();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r12
pushq $0x28
popq %r14
cmpq 0x10(%rbx), %r12
je 0x3f80
movq (%r12), %r15
testq %r15, %r15
je 0x3f6f
movq %r15, %rdi
callq 0x2268
movq %r15, %rdi
movq %r14, %rsi
callq 0x2180
addq $0x8, %r12
jmp 0x3f58
movq 0x8(%rbx), %rax
cmpq %rax, %r12
je 0x3f8d
movq %rax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lishen2[P]Excel_formula_parser_cpp/TokenStack.cpp
// Function: ExcelFormula::TokenStack::pop()
Token* TokenStack::pop()
	{
		if (m_stack.empty())
		{
			return NULL;
		}
		else
		{
			
			Token* efToken = m_stack.top()->clone();
			m_stack.pop();
			efToken->setSubtype(Token::Stop);
			return efToken;
			
			/*
			Token* topElement = m_stack.top();
			m_stack.pop();
			return topElement ;
			*/
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x4233
movq %rdi, %rbx
cmpq 0x38(%rdi), %rax
jne 0x4215
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
callq 0x3d22
movq %rax, %r14
movq %rbx, %rdi
callq 0x44c0
movl $0x2, 0x24(%r14)
jmp 0x4236
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/MDP.cpp
// Function: mdp::operator<<(std::ostream&, mdp::command_t const&)
std::ostream& operator<<(std::ostream& os, command_t const& command) {
    if (command.branches.empty())
        return os;
    os << "[] " << *command.guard << " -> ";
    os << *command.branches[0].prob << " : " << *command.branches[0].update;
    for (size_t i=1; i<command.branches.size(); ++i)
        os << "+" << *command.branches[i].prob << " : " << *command.branches[i].update;
    os << ";";
    return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %rax
cmpq 0x18(%rsi), %rax
je 0x9b76
movq %rsi, %r14
leaq 0x2c698(%rip), %rsi     # 0x3614d
movq %rbx, %rdi
callq 0x92d0
movq (%r14), %rsi
movq %rax, %rdi
callq 0x143f6
leaq 0x307ea(%rip), %rsi     # 0x3a2b9
movq %rax, %rdi
callq 0x92d0
movq 0x10(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x143f6
leaq 0x2f45b(%rip), %r15     # 0x38f48
movq %rax, %rdi
movq %r15, %rsi
callq 0x92d0
movq 0x10(%r14), %rcx
movq 0x10(%rcx), %rsi
movq %rax, %rdi
callq 0x143f6
pushq $0x1
popq %r13
xorl %ebp, %ebp
leaq 0x2c63c(%rip), %r12     # 0x36151
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
sarq $0x5, %rax
cmpq %rax, %r13
jae 0x9b67
movq %rbx, %rdi
movq %r12, %rsi
callq 0x92d0
movq 0x10(%r14), %rcx
movq 0x20(%rcx,%rbp), %rsi
movq %rax, %rdi
callq 0x143f6
movq %rax, %rdi
movq %r15, %rsi
callq 0x92d0
movq 0x10(%r14), %rcx
movq 0x30(%rcx,%rbp), %rsi
movq %rax, %rdi
callq 0x143f6
incq %r13
addq $0x20, %rbp
jmp 0x9b15
leaq 0x2c5e5(%rip), %rsi     # 0x36153
movq %rbx, %rdi
callq 0x92d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/MDP.cpp
// Function: mdp::operator<<(std::ostream&, mdp::mdp_t const&)
std::ostream& operator<<(std::ostream& os, mdp_t const& mdp) {
    os << "mdp" << std::endl << std::endl;
    os << "module " << mdp.module_name << std::endl << std::endl;

    for (auto const& var : mdp.variables)
        os << var << std::endl;
    for (auto const& cnst : mdp.constants)
        os << cnst << std::endl;

    os << std::endl;

    for (auto const& command : mdp.commands)
        os << command << std::endl;

    os << std::endl;
    os << "endmodule";
    return os;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3497b(%rip), %rsi     # 0x3e518
callq 0x92d0
movq %rax, %rdi
callq 0x9140
movq %rax, %rdi
callq 0x9140
leaq 0x2c59c(%rip), %rsi     # 0x36155
movq %rbx, %rdi
callq 0x92d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x9290
movq %rax, %rdi
callq 0x9140
movq %rax, %rdi
callq 0x9140
movq 0x20(%r14), %r15
movq 0x28(%r14), %r12
cmpq %r12, %r15
je 0x9c02
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14e28
movq %rax, %rdi
callq 0x9140
addq $0x30, %r15
jmp 0x9be4
movq 0x38(%r14), %r15
movq 0x40(%r14), %r12
movq %rbx, %rdi
cmpq %r12, %r15
je 0x9c28
movq %r15, %rsi
callq 0x13e64
movq %rax, %rdi
callq 0x9140
addq $0x28, %r15
jmp 0x9c0a
callq 0x9140
movq 0x50(%r14), %r15
movq 0x58(%r14), %r14
movq %rbx, %rdi
cmpq %r14, %r15
je 0x9c53
movq %r15, %rsi
callq 0x9a8f
movq %rbx, %rdi
callq 0x9140
addq $0x28, %r15
jmp 0x9c35
callq 0x9140
leaq 0x2c4fe(%rip), %rsi     # 0x3615d
movq %rbx, %rdi
callq 0x92d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/./include/environment.hpp
// Function: environment_t<ast::expr_t>::lookup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
ptr<element_t> lookup(std::string const& name) const {
        for (auto const& e : elems) {
            if (e.first == name)
                return e.second;
        }
        return nullptr;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
imulq $0x30, 0x8(%rsi), %r13
addq %rax, %r13
cmpq %r13, %rax
je 0xba6a
movq %r15, %rdi
callq 0xd3d0
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0xa5de
testb %al, %al
jne 0xba72
movq %r15, %rdi
callq 0xd3fa
movq 0x8(%rsp), %rax
jmp 0xba3c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xba81
addq $0x20, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xbde0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/expr_ast.cpp
// Function: ast::to_string[abi:cxx11](ast::expr_kind_t)
std::string to_string(expr_kind_t kind) {
    switch (kind) {
    case expr_kind_t::Let:
        return "Let";
    case expr_kind_t::LetFun:
        return "LetFun";
    case expr_kind_t::If:
        return "If";
    case expr_kind_t::App:
        return "App";
    case expr_kind_t::Rand:
        return "Rand";
    case expr_kind_t::Eq:
        return "Eq";
    case expr_kind_t::Neq:
        return "Neq";
    case expr_kind_t::Leq:
        return "Leq";
    case expr_kind_t::Geq:
        return "Geq";
    case expr_kind_t::Add:
        return "Add";
    case expr_kind_t::Sub:
        return "Sub";
    case expr_kind_t::Mul:
        return "Mul";
    case expr_kind_t::Div:
        return "Div";
    case expr_kind_t::And:
        return "And";
    case expr_kind_t::Or:
        return "Or";
    case expr_kind_t::Neg:
        return "Neg";
    case expr_kind_t::Typed:
        return "Typed";
    case expr_kind_t::Fun:
        return "Fun";
    case expr_kind_t::Int:
        return "Int";
    case expr_kind_t::Bool:
        return "Bool";
    case expr_kind_t::Var:
        return "Var";
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, %eax
leaq 0x2af47(%rip), %rcx     # 0x38388
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2afdf(%rip), %rsi     # 0x38430
jmp 0xd517
leaq 0x2b00d(%rip), %rsi     # 0x3846a
jmp 0xd517
leaq 0x2afe9(%rip), %rsi     # 0x38452
jmp 0xd517
leaq 0x2afd2(%rip), %rsi     # 0x38447
jmp 0xd517
leaq 0x2afc1(%rip), %rsi     # 0x38442
jmp 0xd517
leaq 0x2afbd(%rip), %rsi     # 0x3844a
jmp 0xd517
leaq 0x2afc9(%rip), %rsi     # 0x38462
jmp 0xd517
leaq 0x2af99(%rip), %rsi     # 0x3843b
jmp 0xd517
leaq 0x2afbb(%rip), %rsi     # 0x38466
jmp 0xd517
leaq 0x2af8a(%rip), %rsi     # 0x3843e
jmp 0xd517
leaq 0x2af9d(%rip), %rsi     # 0x3845a
jmp 0xd517
leaq 0x2af6e(%rip), %rsi     # 0x38434
jmp 0xd517
leaq 0x2afa8(%rip), %rsi     # 0x38477
jmp 0xd517
leaq 0x2afa8(%rip), %rsi     # 0x38480
jmp 0xd517
leaq 0x2af90(%rip), %rsi     # 0x38471
jmp 0xd517
leaq 0x2af64(%rip), %rsi     # 0x3844e
jmp 0xd517
leaq 0x2af63(%rip), %rsi     # 0x38456
jmp 0xd517
leaq 0x2af7f(%rip), %rsi     # 0x3847b
jmp 0xd517
leaq 0x2af68(%rip), %rsi     # 0x3846d
jmp 0xd517
leaq 0x2af50(%rip), %rsi     # 0x3845e
jmp 0xd517
leaq 0x2af20(%rip), %rsi     # 0x38437
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0xeb2e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/logic.cpp
// Function: logic::to_debug_string[abi:cxx11](logic::domain_kind_t)
std::string to_debug_string(domain_kind_t kind) {
    switch (kind) {
    case domain_kind_t::Int:
        return "Int";
    case domain_kind_t::Bool:
        return "Bool";
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0xfbf2
leaq 0x28890(%rip), %rsi     # 0x3847b
leaq 0xe(%rsp), %rdx
jmp 0xfbfe
leaq 0x2887e(%rip), %rsi     # 0x38477
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0xeb2e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/logic.cpp
// Function: logic::to_debug_string[abi:cxx11](logic::predicate_t const&)
std::string to_debug_string(predicate_t const& pred) {
    return "Pred(" +
        pred.arg_name + ", " +
        to_debug_string(pred.arg_domain) + ", " +
        to_debug_string(*pred.body) + ")";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2801c(%rip), %rsi     # 0x387d4
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xebef
leaq 0x27cc5(%rip), %rdx     # 0x38497
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0xeb69
movl 0x20(%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0xfbd8
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xeb88
leaq 0x27c8f(%rip), %rdx     # 0x38497
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xeb69
movq 0x28(%r14), %rsi
movq %rsp, %rdi
callq 0x1005d
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq %rsp, %rdx
callq 0xeb88
leaq 0x25b44(%rip), %rdx     # 0x36389
leaq 0xa0(%rsp), %rsi
movq %rbx, %rdi
callq 0xeb69
leaq 0xa0(%rsp), %rdi
callq 0x9130
movq %rsp, %rdi
callq 0x9130
leaq 0x80(%rsp), %rdi
callq 0x9130
leaq 0x60(%rsp), %rdi
callq 0x9130
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x40(%rsp), %rdi
callq 0x9130
leaq 0xc0(%rsp), %rdi
callq 0x9130
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x9130
jmp 0x108c7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9130
jmp 0x108d4
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x9130
jmp 0x108e6
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x9130
jmp 0x108f5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x40(%rsp), %rdi
callq 0x9130
leaq 0xc0(%rsp), %rdi
callq 0x9130
movq %rbx, %rdi
callq 0x94d0
movq %rax, %rbx
jmp 0x108ff
movq %rax, %rbx
jmp 0x10909
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/main.cpp
// Function: output_parse_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
void output_parse_error(std::string const& input, size_t pos) {
    std::string line;
    for (size_t i=0; i<pos; ++i) {
        line += input[i];
        if (input[i] == '\n')
            line = "";
    }
    std::cout << line << std::endl;
    std::cout << std::string(line.size(), ' ') << "^" << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r13d, %r13d
movq %rsp, %r15
leaq 0x24cc0(%rip), %r12     # 0x38499
cmpq %r13, %rbx
je 0x13808
movq (%r14), %rax
movsbl (%rax,%r13), %esi
movq %r15, %rdi
callq 0x9270
movq (%r14), %rax
cmpb $0xa, (%rax,%r13)
jne 0x13803
movq %r15, %rdi
movq %r12, %rsi
callq 0x9530
incq %r13
jmp 0x137d9
movq 0x48799(%rip), %rdi     # 0x5bfa8
movq %rsp, %rsi
callq 0x9290
movq %rax, %rdi
callq 0x9140
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x20(%rsp), %rdi
pushq $0x20
popq %rdx
callq 0x9340
movq 0x48767(%rip), %rdi     # 0x5bfa8
leaq 0x20(%rsp), %rsi
callq 0x9290
leaq 0x2568f(%rip), %rsi     # 0x38ee1
movq %rax, %rdi
callq 0x92d0
movq %rax, %rdi
callq 0x9140
leaq 0x20(%rsp), %rdi
callq 0x9130
movq %rsp, %rdi
callq 0x9130
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x13895
jmp 0x13895
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9130
jmp 0x13898
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9130
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/mdp_constant.cpp
// Function: mdp::operator<<(std::ostream&, mdp::constant_t const&)
std::ostream& operator<<(std::ostream& os, constant_t const& cnst) {
    // in PRISM v4.4, somehow can not use 'const' keyword
    if (cnst.is_int()) {
        int val = cnst.as_int();
        os << cnst.name << " : [" << val << " .. " << val+1 << "] init " << val << ";";
    } else {
        int val = cnst.as_bool();
        os << cnst.name << " bool init " << std::boolalpha << val << ";";
    }
    return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl 0x20(%rsi), %eax
movl %eax, %ecx
sarl $0x1f, %ecx
movq %rsi, %rdi
cmpl %eax, %ecx
jne 0x13edf
callq 0x13f34
movl %eax, %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9290
leaq 0x25192(%rip), %rsi     # 0x3902c
movq %rax, %rdi
callq 0x92d0
movq %rax, %rdi
movl %r14d, %esi
callq 0x94c0
leaq 0x2a727(%rip), %rsi     # 0x3e5db
movq %rax, %rdi
callq 0x92d0
leal 0x1(%r14), %esi
movq %rax, %rdi
callq 0x94c0
leaq 0x25162(%rip), %rsi     # 0x39031
movq %rax, %rdi
callq 0x92d0
movq %rax, %rdi
movl %r14d, %esi
jmp 0x13f12
callq 0x13f42
movzbl %al, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9290
leaq 0x254cc(%rip), %rsi     # 0x393c5
movq %rax, %rdi
callq 0x92d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
orl $0x1, 0x18(%rax,%rcx)
movq %rax, %rdi
movl %ebp, %esi
callq 0x94c0
leaq 0x22235(%rip), %rsi     # 0x36153
movq %rax, %rdi
callq 0x92d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/mdp_variable.cpp
// Function: mdp::operator<<(std::ostream&, mdp::variable_t const&)
std::ostream& operator<<(std::ostream& os, variable_t const& var) {
    if (var.is_int()) { // bounded integer
        std::string const& name = var.name;
        int min = var.as_int().bound.min;
        int max = var.as_int().bound.max;
        int init = var.as_int().init;
        if (min == max)
            os << name << " : int init " << min << ";";
        else
            os << name << " : [" << min << ".." << max << "] init " << init << ";";
    } else { // bool
        os << var.name << ": bool init " << std::boolalpha << var.as_bool().init << ";";
    }
    return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
movl 0x20(%rsi), %eax
movl %eax, %ecx
sarl $0x1f, %ecx
cmpl %eax, %ecx
jne 0x14e8d
movq %r14, %rdi
callq 0x14fc5
movl (%rax), %ebp
movq %r14, %rdi
callq 0x14fc5
movl 0x4(%rax), %r12d
movq %r14, %rdi
callq 0x14fc5
cmpl %r12d, %ebp
jne 0x14ecc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9290
leaq 0x24539(%rip), %rsi     # 0x393b4
movq %rax, %rdi
callq 0x92d0
movq %rax, %rdi
movl %ebp, %esi
jmp 0x14f23
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9290
leaq 0x24525(%rip), %rsi     # 0x393c4
movq %rax, %rdi
callq 0x92d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
orl $0x1, 0x18(%r15,%rax)
movq %r14, %rdi
callq 0x15071
movzbl (%rax), %esi
movq %r15, %rdi
callq 0x94a0
jmp 0x14f28
movl 0x8(%rax), %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9290
leaq 0x2414a(%rip), %rsi     # 0x3902c
movq %rax, %rdi
callq 0x92d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x94c0
leaq 0x244c6(%rip), %rsi     # 0x393c1
movq %rax, %rdi
callq 0x92d0
movq %rax, %rdi
movl %r12d, %esi
callq 0x94c0
leaq 0x2411c(%rip), %rsi     # 0x39031
movq %rax, %rdi
callq 0x92d0
movq %rax, %rdi
movl %r14d, %esi
callq 0x94c0
leaq 0x21224(%rip), %rsi     # 0x36153
movq %rax, %rdi
callq 0x92d0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: ident_len(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
size_t ident_len(std::string const& input, size_t pos) {
    if (!std::isalpha(input[pos]) || pos >= input.size())
        return 0;
    size_t len = 1;
    while ((std::isalnum(input[pos+len]) || input[pos+len] == '_') && pos < input.size()) {
        ++len;
    }
    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %r12
movsbl (%r12,%rsi), %edi
callq 0x9460
xorl %ebx, %ebx
testl %eax, %eax
je 0x15370
cmpq %r14, 0x8(%r15)
jbe 0x15370
addq %r12, %r14
incq %r14
xorl %ebx, %ebx
movsbl (%r14,%rbx), %ebp
movl %ebp, %edi
callq 0x9300
incq %rbx
cmpl $0x5f, %ebp
je 0x15358
testl %eax, %eax
jne 0x15358
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: expect_token(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, token_t::kind_t)
parser::result_t<token_t> expect_token(std::string const& input, size_t pos, token_t::kind_t kind) {
    auto token = next_token(input, pos);
    if (token.kind != kind) {
        return parser::result_t<token_t>::error(parser::error_t {
            parser::error_t::kind_t::UnexpectedToken, pos,
            "expected was " + token_kind_to_string(kind) + ", but coming is " + token.lexime
        });
    } else
        return token;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x1537c
cmpl %ebp, (%r15)
jne 0x15c00
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x1abd6
jmp 0x15c9b
movl $0x1, 0x98(%rsp)
movq %r14, 0xa0(%rsp)
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x15120
leaq 0x239fc(%rip), %rsi     # 0x39622
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xb97b
leaq 0x23a6b(%rip), %rdx     # 0x396a7
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xeb69
leaq 0xa8(%rsp), %r14
leaq 0x78(%rsp), %rdx
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x1abb6
leaq 0x98(%rsp), %rsi
movq %rbx, %rdi
callq 0x1aba4
movq %r14, %rdi
callq 0x9130
leaq 0x48(%rsp), %rdi
callq 0x9130
leaq 0x28(%rsp), %rdi
callq 0x9130
leaq 0x8(%rsp), %rdi
callq 0x9130
leaq 0x78(%rsp), %rdi
callq 0x9130
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x9130
jmp 0x15cc6
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x9130
jmp 0x15cd5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9130
jmp 0x15ce4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9130
jmp 0x15cf5
jmp 0x15cf2
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x9130
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::neg_formula(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
formula_result_t neg_formula(std::string const& input, size_t& pos) {
    auto not_token = next_token(input, pos);
    if (not_token.kind != token_t::kind_t::Not)
        return primary_formula(input, pos);
    pos = not_token.pos + not_token.lexime.size();

    auto inner_result = neg_formula(input, pos);
    if (inner_result.is_error())
        return inner_result;
    return formula_result_t::ok(make<logic::neg_formula_t>(inner_result.ok()));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rdx
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x1537c
cmpl $0x24, (%r12)
jne 0x16f5f
movq 0x60(%rsp), %rax
addq 0x50(%rsp), %rax
movq %rax, (%r14)
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x16ebf
cmpb $0x0, 0x40(%rsp)
je 0x16f6f
leaq 0x10(%rsp), %rdi
callq 0x1ad12
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1c68f
leaq 0x80(%rsp), %rdi
leaq 0x8(%rsp), %r14
andq $0x0, (%rdi)
movb $0x1, 0x30(%rbx)
movaps -0x8(%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x8(%r14)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0xa248
movq %r14, %rdi
callq 0xa248
jmp 0x16f7c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x16ad9
jmp 0x16f86
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ae4c
leaq 0x10(%rsp), %rdi
callq 0x1fba8
leaq 0x58(%rsp), %rdi
callq 0x9130
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1fba8
jmp 0x16fb6
jmp 0x16fb3
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x9130
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::and_formula(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
formula_result_t and_formula(std::string const& input, size_t& pos) {
    auto head_result = neg_formula(input, pos);
    if (head_result.is_error())
        return head_result;
    auto acc = head_result.ok();

    while (true) {
        auto and_token = next_token(input, pos);
        if (and_token.kind != token_t::kind_t::And)
            break;
        pos = and_token.pos + and_token.lexime.size();

        auto formula_result = neg_formula(input, pos);
        if (formula_result.is_error())
            return formula_result;
        acc = make<logic::and_formula_t>(acc, formula_result.ok());
    }
    return acc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x16ebf
cmpb $0x0, 0x30(%r12)
je 0x17092
leaq 0x50(%rsp), %rdi
callq 0x1ad12
movq %rsp, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0xc2b6
leaq 0x10(%rsp), %r12
leaq 0x40(%rsp), %rbp
movq (%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1537c
cmpl $0x22, 0x10(%rsp)
jne 0x170a1
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x16ebf
cmpb $0x0, 0x30(%rbx)
je 0x170c3
movq %rbx, %rdi
callq 0x1ad12
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1c768
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1fd28
leaq 0x48(%rsp), %rdi
callq 0xa248
movq %rbx, %rdi
callq 0x1fba8
leaq 0x20(%rsp), %rdi
callq 0x9130
jmp 0x1701d
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ae4c
jmp 0x170d7
leaq 0x20(%rsp), %rdi
callq 0x9130
movb $0x1, 0x30(%rbx)
movaps (%rsp), %xmm0
andq $0x0, 0x8(%rsp)
movups %xmm0, (%rbx)
andq $0x0, (%rsp)
jmp 0x170cd
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x50(%rsp), %rdi
callq 0x1fba8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x17124
movq %rax, %r14
jmp 0x17110
movq %rax, %r14
jmp 0x1711a
movq %rax, %r14
movq %rbx, %rdi
callq 0x1fba8
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x50(%rsp), %rdi
callq 0x1fba8
movq %r14, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::or_formula(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
formula_result_t or_formula(std::string const& input, size_t& pos) {
    auto head_result = and_formula(input, pos);
    if (head_result.is_error())
        return head_result;
    auto acc = head_result.ok();

    while (true) {
        auto or_token = next_token(input, pos);
        if (or_token.kind != token_t::kind_t::Or)
            break;
        pos = or_token.pos + or_token.lexime.size();

        auto formula_result = and_formula(input, pos);
        if (formula_result.is_error())
            return formula_result;
        acc = make<logic::or_formula_t>(acc, formula_result.ok());
    }
    return acc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x16fc8
cmpb $0x0, 0x30(%r12)
je 0x17200
leaq 0x50(%rsp), %rdi
callq 0x1ad12
movq %rsp, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0xc2b6
leaq 0x10(%rsp), %r12
leaq 0x40(%rsp), %rbp
movq (%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1537c
cmpl $0x21, 0x10(%rsp)
jne 0x1720f
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x16fc8
cmpb $0x0, 0x30(%rbx)
je 0x17231
movq %rbx, %rdi
callq 0x1ad12
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1c855
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1fd56
leaq 0x48(%rsp), %rdi
callq 0xa248
movq %rbx, %rdi
callq 0x1fba8
leaq 0x20(%rsp), %rdi
callq 0x9130
jmp 0x1718b
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ae4c
jmp 0x17245
leaq 0x20(%rsp), %rdi
callq 0x9130
movb $0x1, 0x30(%rbx)
movaps (%rsp), %xmm0
andq $0x0, 0x8(%rsp)
movups %xmm0, (%rbx)
andq $0x0, (%rsp)
jmp 0x1723b
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x50(%rsp), %rdi
callq 0x1fba8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x17292
movq %rax, %r14
jmp 0x1727e
movq %rax, %r14
jmp 0x17288
movq %rax, %r14
movq %rbx, %rdi
callq 0x1fba8
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x50(%rsp), %rdi
callq 0x1fba8
movq %r14, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::impl_formula(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
formula_result_t impl_formula(std::string const& input, size_t& pos) {
    auto head_result = or_formula(input, pos);
    if (head_result.is_error())
        return head_result;
    auto acc = head_result.ok();

    while (true) {
        auto impl_token = next_token(input, pos);
        if (impl_token.kind != token_t::kind_t::FatArrow)
            break;
        pos = impl_token.pos + impl_token.lexime.size();

        auto formula_result = or_formula(input, pos);
        if (formula_result.is_error())
            return formula_result;
        acc = make<logic::impl_formula_t>(acc, formula_result.ok());
    }
    return acc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x17136
cmpb $0x0, 0x30(%r12)
je 0x1736e
leaq 0x50(%rsp), %rdi
callq 0x1ad12
movq %rsp, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0xc2b6
leaq 0x10(%rsp), %r12
leaq 0x40(%rsp), %rbp
movq (%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1537c
cmpl $0xc, 0x10(%rsp)
jne 0x1737d
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x17136
cmpb $0x0, 0x30(%rbx)
je 0x1739f
movq %rbx, %rdi
callq 0x1ad12
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1c941
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1fd84
leaq 0x48(%rsp), %rdi
callq 0xa248
movq %rbx, %rdi
callq 0x1fba8
leaq 0x20(%rsp), %rdi
callq 0x9130
jmp 0x172f9
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ae4c
jmp 0x173b3
leaq 0x20(%rsp), %rdi
callq 0x9130
movb $0x1, 0x30(%rbx)
movaps (%rsp), %xmm0
andq $0x0, 0x8(%rsp)
movups %xmm0, (%rbx)
andq $0x0, (%rsp)
jmp 0x173a9
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x50(%rsp), %rdi
callq 0x1fba8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x17400
movq %rax, %r14
jmp 0x173ec
movq %rax, %r14
jmp 0x173f6
movq %rax, %r14
movq %rbx, %rdi
callq 0x1fba8
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x50(%rsp), %rdi
callq 0x1fba8
movq %r14, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::simple_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
result_t<logic::domain_kind_t> simple_type(std::string const& input, size_t& pos) {
    auto sty_result = expect_token(input, pos, token_t::kind_t::Ident);
    if (sty_result.is_error())
        return sty_result.convert<logic::domain_kind_t>();
    auto sty = sty_result.ok();
    pos = sty.pos + sty.lexime.size();

    if (sty.lexime == "int")
        return result_t<logic::domain_kind_t>::ok(logic::domain_kind_t::Int);
    else if (sty.lexime == "bool")
        return result_t<logic::domain_kind_t>::ok(logic::domain_kind_t::Bool);
    else
        return result_t<logic::domain_kind_t>::error(error_t {
                error_t::kind_t::UnexpectedToken, pos,
                "expected was 'int' or 'bool', but coming is " + sty.lexime
                });
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq (%rdx), %rdx
movq %rsp, %r14
pushq $0xa
popq %rcx
movq %r14, %rdi
callq 0x15bc7
cmpb $0x0, 0x30(%r14)
je 0x1747f
movq %rsp, %rdi
callq 0x1ac66
leaq 0x68(%rsp), %rdi
movq %rax, %rsi
callq 0x1acbe
leaq 0x78(%rsp), %r14
movq 0x8(%r14), %rax
addq -0x8(%r14), %rax
movq %rax, (%r15)
leaq 0x251b7(%rip), %rsi     # 0x3c621
movq %r14, %rdi
callq 0x9ec0
testb %al, %al
je 0x1748c
movb $0x1, 0x30(%rbx)
andl $0x0, (%rbx)
jmp 0x174e8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1ae70
jmp 0x174f0
leaq 0x250f9(%rip), %rsi     # 0x3c58c
movq %r14, %rdi
callq 0x9ec0
testb %al, %al
je 0x174ab
movb $0x1, 0x30(%rbx)
movl $0x1, (%rbx)
jmp 0x174e8
leaq 0x48(%rsp), %r12
movl $0x1, -0x10(%r12)
movq (%r15), %rax
movq %rax, -0x8(%r12)
leaq 0x221c3(%rip), %rsi     # 0x3968b
movq %r12, %rdi
movq %r14, %rdx
callq 0xebef
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ae8c
movq %r12, %rdi
callq 0x9130
movq %r14, %rdi
callq 0x9130
leaq 0x10(%rsp), %rdi
callq 0x9130
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x9130
jmp 0x1751c
movq %rax, %rbx
movq %r14, %rdi
callq 0x9130
jmp 0x1752b
jmp 0x17528
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9130
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::refinement_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
refty_result_t refinement_type(std::string const& input, size_t& pos) {
    size_t prev_pos= pos;
    auto refty_result = refty_detail(input, pos);
    if (refty_result.is_ok())
        return refty_result;
    pos = prev_pos;
    return refty_abbreviation(input, pos);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %r13
movq %rsp, %r12
movq %r12, %rdi
callq 0x1796b
cmpb $0x1, 0x38(%r12)
jne 0x180d7
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1b050
jmp 0x180e8
movq %r13, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x17ddf
movq %rsp, %rdi
callq 0x1fe92
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1fe92
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::expr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
expr_result_t expr(std::string const& input, size_t& pos) {
    auto token = next_token(input, pos);
    switch (token.kind) {
    case token_t::kind_t::Let:
        return let_expr(input, pos);
    case token_t::kind_t::LetFun:
        return letfun_expr(input, pos);
    case token_t::kind_t::If:
        return if_expr(input, pos);
    default:
        return or_expr(input, pos);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1537c
movl (%r12), %eax
cmpl $0x3, %eax
je 0x18ab1
cmpl $0x1, %eax
je 0x18aa1
testl %eax, %eax
jne 0x18ac1
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x18647
jmp 0x18acf
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x18afd
jmp 0x18acf
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x18fe5
jmp 0x18acf
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a8ad
leaq 0x18(%rsp), %rdi
callq 0x9130
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x9130
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::neg_expr_t(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
expr_result_t neg_expr_t(std::string const& input, size_t& pos) {
    auto minus_token = next_token(input, pos);
    if (minus_token.kind != token_t::kind_t::Not)
        return primary_expr(input, pos);
    pos = minus_token.pos + minus_token.lexime.size();

    auto inner_result = neg_expr_t(input, pos);
    if (inner_result.is_ok())
        return expr_result_t::ok(make<ast::neg_expr_t>(inner_result.ok()));
    else
        return inner_result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rdx
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x1537c
cmpl $0x24, (%r12)
jne 0x19ce3
movq 0x60(%rsp), %rax
addq 0x50(%rsp), %rax
movq %rax, (%r14)
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x19c43
cmpb $0x1, 0x40(%rsp)
jne 0x19cf3
leaq 0x10(%rsp), %rdi
callq 0x1b196
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1d5a7
leaq 0x80(%rsp), %rdi
leaq 0x8(%rsp), %r14
andq $0x0, (%rdi)
movb $0x1, 0x30(%rbx)
movaps -0x8(%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x8(%r14)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0xa248
movq %r14, %rdi
callq 0xa248
jmp 0x19d00
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x193e4
jmp 0x19d0a
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b172
leaq 0x10(%rsp), %rdi
callq 0x13e4a
leaq 0x58(%rsp), %rdi
callq 0x9130
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x19d28
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x13e4a
jmp 0x19d3c
jmp 0x19d39
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x9130
movq %rbx, %rdi
callq 0x94d0