LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::typed_expr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
expr_result_t typed_expr(std::string const& input, size_t& pos) {
    auto expr_result = neg_expr_t(input, pos);
    if (expr_result.is_error())
        return expr_result;

    auto colon_token = next_token(input, pos);
    if (colon_token.kind != token_t::kind_t::Colon)
        return expr_result;
    pos = colon_token.pos + colon_token.lexime.size();

    auto type_result = refinement_type(input, pos);
    if (type_result.is_error())
        return type_result.convert<ptr<ast::expr_t>>();

    auto expr = expr_result.ok();
    auto type = type_result.ok();

    return expr_result_t::ok(make<ast::typed_expr_t>(expr, type));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x58(%rsp), %r12
movq %r12, %rdi
callq 0x19c43
cmpb $0x0, 0x30(%r12)
je 0x19e5e
movq (%r14), %rdx
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x1537c
cmpl $0x1c, 0x28(%rsp)
jne 0x19e6d
movq 0x40(%rsp), %rax
addq 0x30(%rsp), %rax
movq %rax, (%r14)
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1809e
cmpb $0x0, 0xc8(%rsp)
je 0x19e7c
leaq 0x58(%rsp), %rdi
callq 0x1b196
movq %rsp, %rdi
movq %rax, %rsi
callq 0xbde0
leaq 0x90(%rsp), %rdi
callq 0x1b0da
leaq 0xd0(%rsp), %rdi
movq %rax, %rsi
callq 0xc10c
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
leaq 0xd0(%rsp), %rdx
callq 0x1d7b7
leaq 0x110(%rsp), %rdi
leaq 0x18(%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
leaq 0xd0(%rsp), %rdi
callq 0xc28a
leaq 0x8(%rsp), %rdi
callq 0xa248
jmp 0x19e8c
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b172
jmp 0x19ea3
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b172
jmp 0x19e99
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b274
leaq 0x90(%rsp), %rdi
callq 0x1fe92
leaq 0x38(%rsp), %rdi
callq 0x9130
leaq 0x58(%rsp), %rdi
callq 0x13e4a
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xc28a
jmp 0x19edb
jmp 0x19ed3
movq %rax, %rbx
jmp 0x19ee5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x90(%rsp), %rdi
callq 0x1fe92
jmp 0x19ef9
jmp 0x19ef6
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x9130
jmp 0x19f0a
jmp 0x19f07
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x13e4a
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::applicative_expr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
expr_result_t applicative_expr(std::string const& input, size_t& pos) {
    auto f_result = typed_expr(input, pos);
    if (f_result.is_error())
        return f_result;
    auto f = f_result.ok();

    std::vector<ptr<ast::expr_t>> args;
    while (true) {
        auto e_result = typed_expr(input, pos);
        if (e_result.is_error())
            break;
        args.push_back(e_result.ok());
    }

    if (args.empty())
        return f;
    else
        return expr_result_t::ok(make<ast::app_expr_t>(f, args));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x78(%rsp), %r12
movq %r12, %rdi
callq 0x19d4e
cmpb $0x0, 0x30(%r12)
je 0x19fa9
leaq 0x78(%rsp), %rdi
callq 0x1b196
movq %rsp, %rdi
movq %rax, %rsi
callq 0xbde0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x19d4e
cmpb $0x0, 0x70(%rsp)
je 0x19fbb
movq %r13, %rdi
callq 0x1b196
movq %r12, %rdi
movq %rax, %rsi
callq 0x1b290
movq %r13, %rdi
callq 0x13e4a
jmp 0x19f77
leaq 0x78(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b172
jmp 0x1a043
leaq 0x40(%rsp), %rdi
callq 0x13e4a
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x1a019
leaq 0x30(%rsp), %rdi
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
callq 0x1da37
leaq 0x48(%rsp), %rdi
leaq 0x38(%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 0x1a02f
movb $0x1, 0x30(%rbx)
movaps (%rsp), %xmm0
andq $0x0, 0x8(%rsp)
movups %xmm0, (%rbx)
andq $0x0, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0x1b2bc
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x78(%rsp), %rdi
callq 0x13e4a
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1a06a
jmp 0x1a065
movq %rax, %rbx
jmp 0x1a090
movq %rax, %rbx
jmp 0x1a07c
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x13e4a
leaq 0x10(%rsp), %rdi
callq 0x1b2bc
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x78(%rsp), %rdi
callq 0x13e4a
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::and_expr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
expr_result_t and_expr(std::string const& input, size_t& pos) {
    auto head_result = equive_expr(input, pos);
    if (head_result.is_error())
        return head_result;
    auto acc = head_result.ok();

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

        auto e_result = equive_expr(input, pos);
        if (e_result.is_error())
            return e_result;
        acc = make<ast::and_expr_t>(acc, e_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 0x1a4cc
cmpb $0x0, 0x30(%r12)
je 0x1a807
leaq 0x50(%rsp), %rdi
callq 0x1b196
movq %rsp, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0xbde0
leaq 0x10(%rsp), %r12
leaq 0x40(%rsp), %rbp
movq (%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1537c
cmpl $0x22, 0x10(%rsp)
jne 0x1a816
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a4cc
cmpb $0x0, 0x30(%rbx)
je 0x1a838
movq %rbx, %rdi
callq 0x1b196
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1efa3
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2045e
leaq 0x48(%rsp), %rdi
callq 0xa248
movq %rbx, %rdi
callq 0x13e4a
leaq 0x20(%rsp), %rdi
callq 0x9130
jmp 0x1a792
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b172
jmp 0x1a84c
leaq 0x20(%rsp), %rdi
callq 0x9130
movb $0x1, 0x30(%rbx)
movaps (%rsp), %xmm0
andq $0x0, 0x8(%rsp)
movups %xmm0, (%rbx)
andq $0x0, (%rsp)
jmp 0x1a842
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x50(%rsp), %rdi
callq 0x13e4a
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a86d
movq %rax, %r14
jmp 0x1a89b
movq %rax, %r14
jmp 0x1a887
movq %rax, %r14
jmp 0x1a891
movq %rax, %r14
movq %rbx, %rdi
callq 0x13e4a
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x50(%rsp), %rdi
callq 0x13e4a
movq %r14, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/parser.cpp
// Function: parser::or_expr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
expr_result_t or_expr(std::string const& input, size_t& pos) {
    auto head_result = and_expr(input, pos);
    if (head_result.is_error())
        return head_result;
    auto acc = head_result.ok();

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

        auto e_result = and_expr(input, pos);
        if (e_result.is_error())
            return e_result;
        acc = make<ast::and_expr_t>(acc, e_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 0x1a73d
cmpb $0x0, 0x30(%r12)
je 0x1a977
leaq 0x50(%rsp), %rdi
callq 0x1b196
movq %rsp, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0xbde0
leaq 0x10(%rsp), %r12
leaq 0x40(%rsp), %rbp
movq (%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1537c
cmpl $0x21, 0x10(%rsp)
jne 0x1a986
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a73d
cmpb $0x0, 0x30(%rbx)
je 0x1a9a8
movq %rbx, %rdi
callq 0x1b196
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1efa3
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2045e
leaq 0x48(%rsp), %rdi
callq 0xa248
movq %rbx, %rdi
callq 0x13e4a
leaq 0x20(%rsp), %rdi
callq 0x9130
jmp 0x1a902
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b172
jmp 0x1a9bc
leaq 0x20(%rsp), %rdi
callq 0x9130
movb $0x1, 0x30(%rbx)
movaps (%rsp), %xmm0
andq $0x0, 0x8(%rsp)
movups %xmm0, (%rbx)
andq $0x0, (%rsp)
jmp 0x1a9b2
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x50(%rsp), %rdi
callq 0x13e4a
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a9dd
movq %rax, %r14
jmp 0x1aa0b
movq %rax, %r14
jmp 0x1a9f7
movq %rax, %r14
jmp 0x1aa01
movq %rax, %r14
movq %rbx, %rdi
callq 0x13e4a
leaq 0x20(%rsp), %rdi
callq 0x9130
leaq 0x8(%rsp), %rdi
callq 0xa248
leaq 0x50(%rsp), %rdi
callq 0x13e4a
movq %r14, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/./include/result.hpp
// Function: result_t<std::shared_ptr<logic::term_t>, parser::error_t>::error(parser::error_t const&)
static result_t error(error_t const& e) {
        result_t result;
        result.m_is_ok = false;
        result.assign_err(e);
        return result;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x30(%rdi)
callq 0x13c1a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1fb90
movq %r14, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/./include/result.hpp
// Function: result_t<std::shared_ptr<logic::term_t>, parser::error_t>::result_t(result_t<std::shared_ptr<logic::term_t>, parser::error_t>&&)
result_t(result_t&& src) :
        m_is_ok{src.m_is_ok}
    {
        if (m_is_ok)
            assign_ok(std::move(src.m_ok));
        else
            assign_err(std::move(src.m_error));
    }

// Assembly:
movb 0x30(%rsi), %al
movb %al, 0x30(%rdi)
cmpb $0x1, %al
jne 0x1fb68
andq $0x0, 0x8(%rdi)
movups (%rsi), %xmm0
andq $0x0, 0x8(%rsi)
movups %xmm0, (%rdi)
andq $0x0, (%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/./include/result.hpp
// Function: result_t<logic::domain_kind_t, parser::error_t>::operator=(result_t<logic::domain_kind_t, parser::error_t>&&)
result_t& operator=(result_t&& rhs) {
        if (m_is_ok == rhs.m_is_ok) {
            if (m_is_ok)
                m_ok = std::move(rhs.m_ok);
            else
                m_error = std::move(rhs.m_error);
        } else {
            clear();
            m_is_ok = rhs.m_is_ok;
            if (m_is_ok)
                assign_ok(std::move(rhs.m_ok));
            else
                assign_err(std::move(rhs.m_error));
        }
        return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x30(%rdi), %al
cmpb 0x30(%rsi), %al
jne 0x1b01f
testb %al, %al
jne 0x1b032
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fedc
jmp 0x1b044
movq %rbx, %rdi
callq 0x1fde0
movb 0x30(%r14), %al
movb %al, 0x30(%rbx)
cmpb $0x1, %al
jne 0x1b039
movl (%r14), %eax
movl %eax, (%rbx)
jmp 0x1b044
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fb68
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/simple_type.cpp
// Function: simty::type_t::from(ast::refinement_type_t const&)
ptr<type_t> type_t::from(ast::refinement_type_t const& ty) {
    switch (ty.domain) {
    case logic::domain_kind_t::Int:
        return make<int_type_t>();
    case logic::domain_kind_t::Bool:
        return make<bool_type_t>();
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x20(%rsi)
je 0x204a4
movq %rsp, %rdi
callq 0x22627
jmp 0x204ac
movq %rsp, %rdi
callq 0x224d6
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0xa248
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/simple_type.cpp
// Function: simty::type_t::from(ast::dependent_type_t const&)
ptr<type_t> type_t::from(ast::dependent_type_t const& ty) {
    std::vector<ptr<type_t>> args;
    for (auto const& arg : ty.args)
        args.push_back(type_t::from(arg));
    auto ret_ty = type_t::from(ty.ret_type);
    return make<fun_type_t>(args, ret_ty);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
movq (%rsi), %r13
movq 0x8(%rsi), %rbx
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %rbp
cmpq %rbx, %r13
je 0x20533
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2048c
movq %r12, %rdi
movq %rbp, %rsi
callq 0x22cd6
movq %r15, %rdi
callq 0xa248
addq $0x38, %r13
jmp 0x2050a
addq $0x18, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2048c
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x22777
leaq 0x48(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movq 0x18(%rsp), %rbx
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0xa248
leaq 0x10(%rsp), %rdi
callq 0xa248
leaq 0x20(%rsp), %rdi
callq 0x22314
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x205b4
jmp 0x205a9
movq %rax, %rbx
jmp 0x205b9
movq %rax, %rbx
movq %r15, %rdi
callq 0xa248
leaq 0x20(%rsp), %rdi
callq 0x22314
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/simple_type.cpp
// Function: simty::to_debug_string[abi:cxx11](simty::type_t const&)
std::string to_debug_string(type_t const& ty) {
    switch (ty.kind()) {
    case simty::kind_t::Int:
        return "Int";
    case simty::kind_t::Bool:
        return "Bool";
    case simty::kind_t::Fun: {
        auto const& fun_ty = cast<fun_type_t>(ty);
        std::string result = "(" + to_debug_string(*fun_ty.args[0]);
        for (size_t i=1; i<fun_ty.args.size(); ++i)
            result += ", " + to_debug_string(*fun_ty.args[i]);
        result += ") -> ";
        result += to_debug_string(*fun_ty.ret);
        return result;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
cmpl $0x2, %eax
je 0x21e7a
cmpl $0x1, %eax
jne 0x21f21
leaq 0x16606(%rip), %rsi     # 0x3847b
jmp 0x21f28
movq %r14, %rdi
callq 0x216e3
movq %rax, %r14
movq 0x8(%rax), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x21e44
leaq 0x16983(%rip), %rsi     # 0x38823
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rdx
callq 0xb97b
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x9130
pushq $0x1
popq %rbp
pushq $0x10
popq %rbx
leaq 0x28(%rsp), %r12
leaq 0x165c9(%rip), %r13     # 0x38497
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %rbp
jae 0x21f37
movq (%rax,%rbx), %rsi
movq %r12, %rdi
callq 0x21e44
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xb97b
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x9540
movq %r15, %rdi
callq 0x9130
movq %r12, %rdi
callq 0x9130
incq %rbp
addq $0x10, %rbx
jmp 0x21ece
leaq 0x1654f(%rip), %rsi     # 0x38477
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xeb2e
jmp 0x21f6f
leaq 0x1837a(%rip), %rsi     # 0x3a2b8
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x9520
movq 0x20(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21e44
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x9540
leaq 0x8(%rsp), %rdi
callq 0x9130
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x21fb0
jmp 0x21fb7
jmp 0x21fb7
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x21fbe
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x9130
jmp 0x21fab
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x9130
jmp 0x21fba
movq %rax, %r14
movq (%rsp), %rdi
callq 0x9130
movq %r14, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/./include/result.hpp
// Function: result_t<std::shared_ptr<simty::type_t>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> operator&&<std::shared_ptr<simty::type_t>, std::shared_ptr<simty::type_t>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(result_t<std::shared_ptr<simty::type_t>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, result_t<std::shared_ptr<simty::type_t>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
inline static result_t<U, E> operator&&(result_t<T, E> const& lhs, result_t<U, E> const& rhs) {
    if (lhs.is_ok())
        return rhs;
    else
        return result_t<U, E>::error(lhs.error());
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x20(%rsi)
jne 0x22026
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x223d0
jmp 0x22039
movq %rsi, %rdi
callq 0x13c2e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x23d64
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/./include/simple_type.hpp
// Function: simty::operator==(simty::type_t const&, simty::type_t const&)
inline static bool operator==(type_t const& lhs, type_t const& rhs) {
    if (lhs.kind() != rhs.kind())
        return false;
    if (lhs.kind() != kind_t::Fun)
        return true;
    auto const& l = cast<fun_type_t>(lhs);
    auto const& r = cast<fun_type_t>(rhs);
    if (!(*l.ret == *r.ret))
        return false;
    if (l.args.size() != r.args.size())
        return false;
    for (size_t i=0; i<l.args.size(); ++i) {
        if (!(l.args[i] == r.args[i]))
            return false;
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl %eax, %ebp
jne 0x222ab
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movl %eax, %ecx
movb $0x1, %al
cmpl $0x2, %ecx
jne 0x222ad
movq %r14, %rdi
callq 0x216e3
movq %rax, %r14
movq %rbx, %rdi
callq 0x216e3
movq %rax, %rbx
movq 0x20(%r14), %rdi
movq 0x20(%rax), %rsi
callq 0x22217
testb %al, %al
je 0x222ab
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rdx
subq %rcx, %rdx
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
subq %rsi, %rax
cmpq %rax, %rdx
jne 0x222ab
sarq $0x4, %rdx
incq %rdx
xorl %edi, %edi
decq %rdx
sete %al
je 0x222ad
movq (%rcx,%rdi), %r8
leaq 0x10(%rdi), %r9
cmpq (%rsi,%rdi), %r8
movq %r9, %rdi
je 0x22290
jmp 0x222ad
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/test.cpp
// Function: rand_test::~rand_test()
PML_CUSTOM_TEST(rand_test, lang_feature_test) {
    using namespace ast;
    using namespace evaluator;
    parse_test("rand(1, 4)", "Rand(1, 4)");

    for (int i=0; i<16; ++i) {
        auto n1 = cast<int_expr_t>(*eval(make<rand_expr_t>(1, 4))).n;
        assert_(1 <= n1 && n1 <= 4, "1 <= rand(1, 4) <= 4");
    }

    parse_test("rand(1, 4) + 42", "Add(Rand(1, 4), 42)");
    auto n2 = cast<int_expr_t>(*eval(
                make<add_expr_t>(
                    make<rand_expr_t>(1, 4),
                    make<int_expr_t>(42)))).n;
    assert_(43 <= n2 && n2 <= 46, "43 <= rand(1, 4) + 42 <= 46");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x352b7(%rip), %rax     # 0x5b738
movq %rax, (%rdi)
movq 0x35b5d(%rip), %rdi     # 0x5bfe8
leaq 0x15d33(%rip), %rsi     # 0x3c1c5
callq 0x92d0
movq %rax, %r14
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x10(%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x9290
leaq 0x12d11(%rip), %rsi     # 0x391cd
movq %rax, %rdi
callq 0x92d0
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x94c0
leaq 0x15cfd(%rip), %rsi     # 0x3c1d3
movq %rax, %rdi
callq 0x92d0
movq %rax, %rdi
callq 0x9140
leaq 0x8(%rsp), %rdi
callq 0x9130
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xa0db
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/test.cpp
// Function: translation_test::translation_test()
PML_TEST(translation_test) {
    using namespace ast;
    using namespace mdp;
    assert_eq(
            translate_to_mdp(ast::int_expr_t{42}).mdp,
            mdp_t {
                "default",
                {},
                {
                    mdp::constant_t{"c42", 42}
                },
                {}
            });
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
leaq 0x3517f(%rip), %rax     # 0x5b7b8
movq %rax, (%rdi)
leaq 0x334e5(%rip), %rax     # 0x59b28
leaq 0xb8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x2a, 0x8(%rsi)
leaq 0xc8(%rsp), %rdi
callq 0x32330
leaq 0x15de9(%rip), %rsi     # 0x3c452
leaq 0x50(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xeb2e
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rsp)
andq $0x0, 0x80(%rsp)
leaq 0x15dca(%rip), %rsi     # 0x3c45a
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xeb2e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x2a
popq %rdx
callq 0x2c102
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x5(%rsp), %rcx
callq 0x2c122
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rdx
movups %xmm0, 0x50(%rdx)
andq $0x0, 0x60(%rdx)
leaq 0xc8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2bfb6
leaq 0x50(%rsp), %rdi
callq 0xa08a
leaq 0x28(%rsp), %rdi
callq 0xa326
leaq 0x8(%rsp), %rdi
callq 0x9130
leaq 0xc8(%rsp), %rdi
callq 0x2c15c
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa08a
xorl %ebp, %ebp
jmp 0x26738
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0xa326
jmp 0x2674a
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x9130
testb %bpl, %bpl
jne 0x2675e
jmp 0x26777
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa12a
leaq 0x50(%rsp), %rdi
callq 0x9130
jmp 0x26777
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x2c15c
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/test.cpp
// Function: parsing_formula_test::parsing_formula_test()
PML_TEST(parsing_formula_test) {
    std::string input = "true \\/ true /\\ false";
    parser::parse_formula(input).case_of(
        ok >> [&](ptr<logic::formula_t> const& formula) {
            assert_(formula != nullptr, "\"" + input + "\" was parsed to nullptr");
            assert_eq(
                    logic::to_debug_string(*formula),
                    "Or(Top, And(Top, Bot))");
        },
        error >> [this](parser::error_t err) {
            std::string msg = "parse error at " +
                std::to_string(err.pos) + " : " +
                err.message;
            assert_(false, msg);
        });
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
leaq 0x3455a(%rip), %rax     # 0x5b9a0
movq %rax, (%rdi)
leaq 0x1505f(%rip), %rsi     # 0x3c4af
leaq 0x20(%rsp), %r14
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
callq 0xeb2e
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x1aa7a
leaq 0x78(%rsp), %rax
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rax
movq %rbx, (%rax)
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x40(%rsp), %rdi
callq 0x2d2b6
leaq 0x40(%rsp), %rdi
callq 0x1fba8
leaq 0x20(%rsp), %rdi
callq 0x9130
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1fba8
jmp 0x274ce
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9130
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/test.cpp
// Function: parsing_term_test::parsing_term_test()
PML_TEST(parsing_term_test) {
    std::string input = "a+b*c";
    parser::parse_term(input).case_of(
        ok >> [&](ptr<logic::term_t> const& term) {
            assert_(term != nullptr, "\"" + input + "\" was parsed to nullptr");
            assert_eq(
                    logic::to_debug_string(*term),
                    "Add(a, Mul(b, c))");
        },
        error >> [this](parser::error_t err) {
            std::string msg = "parse error at " +
                std::to_string(err.pos) + " : " +
                err.message;
            assert_(false, msg);
        });
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
leaq 0x34458(%rip), %rax     # 0x5b9e0
movq %rax, (%rdi)
leaq 0x14f6f(%rip), %rsi     # 0x3c501
leaq 0x20(%rsp), %r14
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
callq 0xeb2e
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x1aa99
leaq 0x78(%rsp), %rax
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rax
movq %rbx, (%rax)
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x40(%rsp), %rdi
callq 0x2d64e
leaq 0x40(%rsp), %rdi
callq 0x1fb90
leaq 0x20(%rsp), %rdi
callq 0x9130
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1fb90
jmp 0x27610
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9130
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/test.cpp
// Function: parsing_deptype_test::parsing_deptype_test()
PML_TEST(parsing_deptype_test) {
    std::unordered_map<std::string, std::string> inputs = {
        {"{n:int|true} -> {x:bool|x}", "Dep([Ref(n, Int, Top)], Ref(x, Bool, x))"},
        {"(int, int) -> int", "Dep([Ref(@blah, Int, Top), Ref(@blah, Int, Top)], Ref(@blah, Int, Top))"}
    };
    for (auto const& input : inputs) {
        parser::parse_deptype(input.first).case_of(
            ok >> [&](ast::dependent_type_t const& ty) {
                assert_eq(
                    ast::to_debug_string(ty),
                    input.second);
            },
            error >> [&](parser::error_t err) {
                assert_(false, format("parse error at {} : {}",
                        std::to_string(err.pos), err.message));
            });
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
leaq 0x340ff(%rip), %rax     # 0x5ba60
movq %rax, (%rdi)
leaq 0x14c64(%rip), %rsi     # 0x3c5cf
leaq 0x14c78(%rip), %rdx     # 0x3c5ea
leaq 0x68(%rsp), %rdi
callq 0x2e2c4
leaq 0xa8(%rsp), %rdi
leaq 0x14c88(%rip), %rsi     # 0x3c613
leaq 0x14c93(%rip), %rdx     # 0x3c625
callq 0x2e304
leaq 0xe8(%rsp), %rdx
leaq 0x8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x20(%rsp), %r8
leaq 0x10(%rsp), %r9
xorl %ecx, %ecx
callq 0x2dc1c
pushq $0x40
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x68, %rdi
callq 0x2db66
addq $-0x40, %r14
cmpq $-0x40, %r14
jne 0x279c7
movq 0x40(%rsp), %r14
leaq 0x68(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
testq %r14, %r14
je 0x27a44
leaq 0x8(%r14), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x1aa5b
movq %rbx, 0x20(%rsp)
movq %rbp, 0x28(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2e344
movq %r15, %rdi
callq 0x1fef8
movq (%r14), %r14
jmp 0x279f2
leaq 0x30(%rsp), %rdi
callq 0x2e2a8
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x40
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x68, %rdi
callq 0x2db66
addq $-0x40, %r14
cmpq $-0x40, %r14
jne 0x27a67
jmp 0x27ab0
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x2db66
jmp 0x27ab0
movq %rax, %rbx
jmp 0x27ab0
movq %rax, %rbx
jmp 0x27aa6
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x1fef8
leaq 0x30(%rsp), %rdi
callq 0x2e2a8
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/test.cpp
// Function: subst_term_test::subst_term_test()
PML_TEST(subst_term_test) {
    assert_eq(
            *logic::subst(
                make<logic::prob_term_t>(make<logic::var_formula_t>("x")),
                "x", make<logic::top_formula_t>()),
            logic::prob_term_t{make<logic::top_formula_t>()});
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r13
andl $0x0, 0x8(%rdi)
leaq 0x33f39(%rip), %rax     # 0x5baa0
movq %rax, (%rdi)
leaq 0x14835(%rip), %rsi     # 0x3c3a6
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x2e783
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x2e674
leaq 0x38(%rsp), %rcx
leaq 0x28(%rsp), %rax
movaps -0x8(%rax), %xmm0
movaps %xmm0, -0x8(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rax)
leaq 0x147fb(%rip), %rsi     # 0x3c3a6
leaq 0xa8(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xeb2e
leaq 0x80(%rsp), %rdi
callq 0x1c1ff
leaq 0x18(%rsp), %rax
leaq 0x88(%rsp), %r15
movaps -0x8(%r15), %xmm0
movaps %xmm0, -0x8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r15)
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0xf49b
movq 0x40(%rsp), %rbx
leaq 0x60(%rsp), %rdi
callq 0x1c1ff
leaq 0x78(%rsp), %r14
leaq 0x68(%rsp), %rbp
movaps -0x8(%rbp), %xmm0
movaps %xmm0, -0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rbp)
leaq 0x90(%rsp), %r12
leaq 0x70(%rsp), %rsi
movq %r12, %rdi
callq 0x125aa
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2e4ea
leaq 0x90(%rsp), %rdi
callq 0x125c2
movq %r14, %rdi
callq 0xa248
movq %rbp, %rdi
callq 0xa248
leaq 0x48(%rsp), %rdi
callq 0xa248
leaq 0x18(%rsp), %rdi
callq 0xa248
movq %r15, %rdi
callq 0xa248
leaq 0xa8(%rsp), %rdi
callq 0x9130
leaq 0x38(%rsp), %rdi
callq 0xa248
leaq 0x28(%rsp), %rdi
callq 0xa248
leaq 0x58(%rsp), %rdi
callq 0xa248
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0x125c2
movq %r14, %rdi
callq 0xa248
movq %rbp, %rdi
callq 0xa248
jmp 0x27ceb
movq %rax, %r13
leaq 0x48(%rsp), %rdi
callq 0xa248
jmp 0x27cfa
movq %rax, %r13
leaq 0x18(%rsp), %rdi
callq 0xa248
movq %r15, %rdi
callq 0xa248
jmp 0x27d11
movq %rax, %r13
leaq 0xa8(%rsp), %rdi
callq 0x9130
jmp 0x27d23
movq %rax, %r13
leaq 0x38(%rsp), %rdi
callq 0xa248
leaq 0x28(%rsp), %rdi
callq 0xa248
leaq 0x58(%rsp), %rdi
callq 0xa248
movq %r13, %rdi
callq 0x94d0
movq %rax, %r13
jmp 0x27d37
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/test.cpp
// Function: lang_feature_test::parse_test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void parse_test(std::string const& input, std::string const& output) {
        parser::parse(input).case_of(
            ok >> [&](ptr<ast::expr_t> const& ast) {
                assert_(
                    ast != nullptr,
                    "\"" + input + "\" was parsed to nullptr");
                assert_eq(ast::to_debug_string(*ast), output);
            },
            error >> [this](parser::error_t err) {
                std::string msg = "parse error at" +
                    std::to_string(err.pos) + " : " +
                    err.message;
                assert_(false, msg);
            });
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x1aa1d
leaq 0x50(%rsp), %rax
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rax
movq %r15, (%rax)
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %r12, %rdi
callq 0x299ce
leaq 0x18(%rsp), %rdi
callq 0x13e4a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13e4a
movq %rbx, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/./include/result.hpp
// Function: auto result_t<std::shared_ptr<ast::expr_t>, parser::error_t>::case_of<lang_feature_test::parse_test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(std::shared_ptr<ast::expr_t> const&), lang_feature_test::parse_test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(parser::error_t)>(ok_adaptor<lang_feature_test::parse_test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(std::shared_ptr<ast::expr_t> const&)> const&, error_adaptor<lang_feature_test::parse_test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(parser::error_t)> const&) const
auto case_of(ok_adaptor<F> const& ok_adap, error_adaptor<G> const& err_adap) const {
        using ok_ret_type = decltype(ok_adap.f(std::declval<ok_t>()));
        using err_ret_type = decltype(err_adap.f(std::declval<error_t>()));
        static_assert(std::is_same<ok_ret_type, err_ret_type>::value, "result_t::case_of: return types are different!");
        if (m_is_ok)
            return ok_adap.f(m_ok);
        else
            return err_adap.f(m_error);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rax
cmpb $0x1, 0x30(%rdi)
jne 0x299f0
movq (%rsi), %rdi
movq %rax, %rsi
addq $0x38, %rsp
popq %rbx
popq %r14
jmp 0x29a36
movq (%rdx), %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x13c1a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29afc
leaq 0x18(%rsp), %rdi
callq 0x9130
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x9130
movq %rbx, %rdi
callq 0x94d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/./include/test.hpp
// Function: test::test_base::assert_(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assert_(bool is_ok, std::string const& msg = "") {
        assert_count++;
        if (is_ok)
            return;
        std::stringstream ss;
        ss << "\033[31mtest[" << name() <<  "] fail.. \033[39m ";
        ss << "assertion: " << msg << std::endl;
        throw test_fail_exception{ss.str()};
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
incl 0x8(%rdi)
testl %esi, %esi
je 0x29bfe
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x28(%rsp), %rdi
callq 0x91e0
leaq 0x38(%rsp), %r14
leaq 0x12549(%rip), %rsi     # 0x3c163
movq %r14, %rdi
callq 0x92d0
movq %rax, %r12
movq (%r15), %rax
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq *0x10(%rax)
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x9290
leaq 0x12527(%rip), %rsi     # 0x3c16e
movq %rax, %rdi
callq 0x92d0
leaq 0x8(%rsp), %rdi
callq 0x9130
leaq 0x1251e(%rip), %rsi     # 0x3c17e
movq %r14, %rdi
callq 0x92d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x9290
movq %rax, %rdi
callq 0x9140
pushq $0x28
popq %rdi
callq 0x9150
movq %rax, %rbx
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9440
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x29e50
xorl %ebp, %ebp
leaq 0x3193a(%rip), %rsi     # 0x5b5e8
leaq 0x1d1(%rip), %rdx       # 0x29e86
movq %rbx, %rdi
callq 0x94b0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x9130
testb %bpl, %bpl
jne 0x29cd4
jmp 0x29cf2
movq %rax, %r14
movq %rbx, %rdi
callq 0x9210
jmp 0x29cf2
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x9130
jmp 0x29cf2
jmp 0x29cef
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x9220
movq %r14, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/./include/test.hpp
// Function: void test::test_base::assert_eq<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assert_eq(T1 const& lhs, T2 const& rhs) {
        assert_count++;
        if (lhs == rhs)
            return;
        std::stringstream ss;
        ss << "\033[31mtest[" << name() <<  "] fail.. \033[39m ";
        ss << "assertion: " << lhs << " == " << rhs << std::endl;
        throw test_fail_exception{ss.str()};
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
incl 0x8(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xa5de
testb %al, %al
je 0x29d42
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rdi
callq 0x91e0
leaq 0x30(%rsp), %r15
leaq 0x1240b(%rip), %rsi     # 0x3c163
movq %r15, %rdi
callq 0x92d0
movq %rax, %r13
movq (%r12), %rax
movq %rsp, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq %rsp, %rsi
movq %r13, %rdi
callq 0x9290
leaq 0x123ec(%rip), %rsi     # 0x3c16e
movq %rax, %rdi
callq 0x92d0
movq %rsp, %rdi
callq 0x9130
leaq 0x123e5(%rip), %rsi     # 0x3c17e
movq %r15, %rdi
callq 0x92d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x9290
leaq 0x123d7(%rip), %rsi     # 0x3c18a
movq %rax, %rdi
callq 0x92d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x9290
movq %rax, %rdi
callq 0x9140
pushq $0x28
popq %rdi
callq 0x9150
movq %rax, %rbx
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x9440
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x29e50
xorl %ebp, %ebp
leaq 0x317eb(%rip), %rsi     # 0x5b5e8
leaq 0x82(%rip), %rdx        # 0x29e86
movq %rbx, %rdi
callq 0x94b0
movq %rax, %r14
movq %rsp, %rdi
callq 0x9130
testb %bpl, %bpl
jne 0x29e21
jmp 0x29e3d
movq %rax, %r14
movq %rbx, %rdi
callq 0x9210
jmp 0x29e3d
movq %rax, %r14
movq %rsp, %rdi
callq 0x9130
jmp 0x29e3d
jmp 0x29e3a
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x9220
movq %r14, %rdi
callq 0x94d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/translate_to_mdp.cpp
// Function: make_concat(int, int)
mdp::command_t make_concat(int from, int to) {
    return mdp::command_t {
        make<mdp::binop_expr_t>(
                make<mdp::var_expr_t>("location"),
                make<mdp::int_expr_t>(from),
                mdp::binop_kind_t::Eq),
        {
            mdp::branch_t{
                make<mdp::int_expr_t>(1),
                make<mdp::binop_expr_t>(
                        make<mdp::var_expr_t>("location'"),
                        make<mdp::int_expr_t>(to),
                        mdp::binop_kind_t::Eq)
            }
        }
    };
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x5c(%rsp), %r14
movl %esi, (%r14)
movl %edx, 0xc(%rsp)
leaq 0x5ed4(%rip), %rsi      # 0x36144
leaq 0x40(%rsp), %rdi
callq 0x2c735
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x32736
leaq 0x58(%rsp), %rcx
movl $0x8, (%rcx)
leaq 0xa0(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x2c4a2
leaq 0xa8(%rsp), %r14
movaps -0x8(%r14), %xmm0
andq $0x0, (%r14)
andq $0x0, -0x8(%r14)
movups %xmm0, (%rbx)
leaq 0x54(%rsp), %rsi
movl $0x1, (%rsi)
leaq 0x90(%rsp), %rdi
callq 0x2c961
leaq 0x98(%rsp), %r15
movaps -0x8(%r15), %xmm0
movaps %xmm0, 0x60(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r15)
leaq 0xc190(%rip), %rsi      # 0x3c48b
leaq 0x20(%rsp), %rdi
callq 0x2cd81
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x32736
leaq 0x50(%rsp), %rcx
movl $0x8, (%rcx)
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x2c4a2
leaq 0x10(%rbx), %rdi
leaq 0x88(%rsp), %r13
movaps -0x8(%r13), %xmm0
leaq 0x60(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r13)
pushq $0x1
popq %rdx
leaq 0xb(%rsp), %rcx
callq 0x2c376
leaq 0x60(%rsp), %rdi
callq 0xa218
movq %r13, %rdi
callq 0xa248
leaq 0x18(%rsp), %rdi
callq 0xa248
leaq 0x28(%rsp), %rdi
callq 0xa248
movq %r15, %rdi
callq 0xa248
movq %r14, %rdi
callq 0xa248
leaq 0x38(%rsp), %rdi
callq 0xa248
leaq 0x48(%rsp), %rdi
callq 0xa248
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq 0x60(%rsp), %rdi
callq 0xa218
movq %r13, %rdi
callq 0xa248
xorl %ebp, %ebp
jmp 0x303e3
movq %rax, %r12
movb $0x1, %bpl
leaq 0x18(%rsp), %rdi
callq 0xa248
jmp 0x303f5
movq %rax, %r12
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0xa248
testb %bpl, %bpl
jne 0x30409
jmp 0x30413
movq %rax, %r12
leaq 0x68(%rsp), %rdi
callq 0xa248
movq %r15, %rdi
callq 0xa248
jmp 0x30420
movq %rax, %r12
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xa248
movq %r14, %rdi
callq 0xa248
leaq 0x38(%rsp), %rdi
callq 0xa248
leaq 0x48(%rsp), %rdi
callq 0xa248
movq %r12, %rdi
callq 0x94d0
movq %rax, %r12
jmp 0x30434
movq %rax, %r12
jmp 0x3043e
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/translate_to_mdp.cpp
// Function: create_binop_case(ast::expr_t const&, ast::expr_t const&, ast::expr_kind_t, environment_t<value_info_t> const&)
mdp_with_info_t create_binop_case(
        ast::expr_t const& lhs_expr,
        ast::expr_t const& rhs_expr,
        ast::expr_kind_t op,
        var_env_t const& var_env) {
    auto lhs_ = trans_impl(lhs_expr, var_env);
    auto const& lhs = lhs_.value;
    auto rhs_ = trans_impl(rhs_expr, var_env);
    auto const& rhs = rhs_.value;

    auto result_mdp = mdp::mdp_t::merge(
            std::move(lhs_.mdp),
            std::move(rhs_.mdp));

    auto result_bound = calc_binop_bound(lhs, rhs, op);

    return mdp_with_info_t {
        result_mdp, lhs_.init, rhs_.accept,
        result_bound
    };
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x138(%rsp), %rdi
movq %r8, %rdx
callq 0x30c2e
leaq 0x98(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x30c2e
leaq 0x30(%rsp), %rdi
leaq 0x138(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0x972c
leaq 0x1a8(%rsp), %rsi
leaq 0x108(%rsp), %rdx
movq %rsp, %rdi
movl %ebp, %ecx
callq 0x31565
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x324d4
movl 0x1a0(%rsp), %eax
movl %eax, 0x68(%rbx)
movl 0x104(%rsp), %eax
movl %eax, 0x6c(%rbx)
leaq 0x70(%rbx), %rdi
movq %rsp, %rsi
callq 0x32614
movq %rsp, %rdi
callq 0x9130
leaq 0x30(%rsp), %rdi
callq 0xa08a
leaq 0x98(%rsp), %rdi
callq 0x2c15c
leaq 0x138(%rsp), %rdi
callq 0x2c15c
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa08a
jmp 0x31ca3
movq %rax, %r14
movq %rsp, %rdi
callq 0x9130
jmp 0x31cb0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xa08a
jmp 0x31cbf
movq %rax, %r14
leaq 0x98(%rsp), %rdi
callq 0x2c15c
jmp 0x31cd1
movq %rax, %r14
leaq 0x138(%rsp), %rdi
callq 0x2c15c
movq %r14, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/translate_to_mdp.cpp
// Function: create_int_case(int)
mdp_with_info_t create_int_case(int n) {
    auto const_name = "c" + std::to_string(n);
    int current = translation_data::current_location();
    return mdp_with_info_t {
        mdp::mdp_t {
            "default",
            {},
            { mdp::constant_t{const_name, n} },
            {}
        },
        current, current,
        value_info_t {
            const_name, {bound_t{n, n}}
        }
    };
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xec65
leaq 0xa581(%rip), %rsi      # 0x3c505
leaq 0x30(%rsp), %rdi
movq %r14, %rdx
callq 0xb97b
leaq 0x8(%rsp), %rdi
callq 0x9130
movl 0x2a32e(%rip), %r14d    # 0x5c2d0
leaq 0xa4a9(%rip), %rsi      # 0x3c452
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0xeb2e
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
andq $0x0, 0x30(%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %ebp, %edx
callq 0x2c102
leaq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x2c122
xorps %xmm0, %xmm0
andq $0x0, 0x60(%rbx)
movups %xmm0, 0x50(%rbx)
movl %r14d, 0x68(%rbx)
movl %r14d, 0x6c(%rbx)
leaq 0x70(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0x93a0
movl %ebp, %eax
movabsq $0x100000001, %rcx      # imm = 0x100000001
imulq %rax, %rcx
movq %rcx, 0x90(%rbx)
movb $0x1, 0x98(%rbx)
leaq 0x8(%rsp), %rdi
callq 0xa326
leaq 0x30(%rsp), %rdi
callq 0x9130
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa08a
xorl %ebp, %ebp
jmp 0x3205e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0xa326
testb %bpl, %bpl
jne 0x32072
jmp 0x32088
movq %rax, %r14
leaq 0x20(%rbx), %rdi
callq 0xa12a
movq %rbx, %rdi
callq 0x9130
jmp 0x32088
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0x32097
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x9130
movq %r14, %rdi
callq 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/pfnet-research[P]pml/src/translate_to_mdp.cpp
// Function: create_bool_case(bool)
mdp_with_info_t create_bool_case(bool b) {
    auto const_name = "c" + std::to_string(b);
    int current = translation_data::current_location();
    return mdp_with_info_t {
        mdp::mdp_t {
            "default",
            {},
            { mdp::constant_t{const_name, b} },
            {}
        },
        current, current,
        value_info_t {
            const_name, util::nullopt
        }
    };
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xec65
leaq 0xa440(%rip), %rsi      # 0x3c505
leaq 0x30(%rsp), %rdi
movq %r14, %rdx
callq 0xb97b
leaq 0x8(%rsp), %rdi
callq 0x9130
movl 0x2a1ed(%rip), %r14d    # 0x5c2d0
leaq 0xa368(%rip), %rsi      # 0x3c452
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0xeb2e
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
andq $0x0, 0x30(%rbx)
movzbl %bpl, %edx
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3266e
leaq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x2c122
xorps %xmm0, %xmm0
andq $0x0, 0x60(%rbx)
movups %xmm0, 0x50(%rbx)
movl %r14d, 0x68(%rbx)
movl %r14d, 0x6c(%rbx)
leaq 0x70(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0x93a0
movb $0x0, 0x98(%rbx)
leaq 0x8(%rsp), %rdi
callq 0xa326
leaq 0x30(%rsp), %rdi
callq 0x9130
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa08a
xorl %ebp, %ebp
jmp 0x3218a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0xa326
testb %bpl, %bpl
jne 0x3219e
jmp 0x321b4
movq %rax, %r14
leaq 0x20(%rbx), %rdi
callq 0xa12a
movq %rbx, %rdi
callq 0x9130
jmp 0x321b4
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0x321c3
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x9130
movq %r14, %rdi
callq 0x94d0