LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pfnet-research[P]pml/./include/environment.hpp
// Function: environment_t<ast::expr_t>::append(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<ast::expr_t> const&) const
environment_t append(std::string const& name, ptr<element_t> const& val) const {
        auto result = *this;
        auto found = result.elems.find(name);
        if (found != result.elems.end())
            result.elems.erase(name);
        result.elems.emplace(name, val);
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x21(%rbp)
callq 0x13390
movq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x17f80
jmp 0x130e3
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x18000
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x17fd0
testb $0x1, %al
jne 0x13103
jmp 0x1312b
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18040
jmp 0x13112
jmp 0x1312b
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x13170
jmp 0x1315f
movq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x18070
jmp 0x13142
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x13155
movq -0x60(%rbp), %rdi
callq 0x13170
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xa650
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1aae0
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1ab30
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1ab80
testb $0x1, %al
jne 0x13264
jmp 0x132a4
leaq -0x28(%rbp), %rdi
callq 0x1abb0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf040
testb $0x1, %al
jne 0x13284
jmp 0x13297
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x20, %rsi
callq 0x13050
jmp 0x132b1
jmp 0x13299
leaq -0x28(%rbp), %rdi
callq 0x1ac10
jmp 0x13251
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1ac70
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x20953
jmp 0x20946
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x20998
jmp 0x209dd
leaq -0xd(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xa660
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x7af44(%rip), %rsi     # 0x9b8b3
callq 0x1dd10
jmp 0x20976
leaq -0xd(%rbp), %rdi
callq 0xa420
jmp 0x209df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0xa420
jmp 0x209e9
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xa660
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x7af03(%rip), %rsi     # 0x9b8b7
callq 0x1dd10
jmp 0x209bb
leaq -0x1d(%rbp), %rdi
callq 0xa420
jmp 0x209df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0xa420
jmp 0x209e9
ud2
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x118(%rbp)
movq %rdi, %rax
movq %rax, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x79705(%rip), %rsi     # 0x9bc14
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x1dee0
movq -0x108(%rbp), %rsi
leaq 0x793a3(%rip), %rdx     # 0x9b8d3
leaq -0x90(%rbp), %rdi
callq 0x1ddc0
jmp 0x2253e
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
leaq -0xe0(%rbp), %rdi
callq 0x20920
jmp 0x22553
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x1de10
jmp 0x2256c
leaq 0x79360(%rip), %rdx     # 0x9b8d3
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1ddc0
jmp 0x22582
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x115e0
movq %rax, %rsi
leaq -0x100(%rbp), %rdi
callq 0x213a0
jmp 0x225a0
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0x1de10
jmp 0x225b6
movq -0x118(%rbp), %rdi
leaq 0x76dee(%rip), %rdx     # 0x993b2
leaq -0x30(%rbp), %rsi
callq 0x1ddc0
jmp 0x225cf
leaq -0x30(%rbp), %rdi
callq 0xa240
leaq -0x100(%rbp), %rdi
callq 0xa240
leaq -0x50(%rbp), %rdi
callq 0xa240
leaq -0x70(%rbp), %rdi
callq 0xa240
leaq -0xe0(%rbp), %rdi
callq 0xa240
leaq -0x90(%rbp), %rdi
callq 0xa240
leaq -0xb0(%rbp), %rdi
callq 0xa240
movq -0x110(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x226f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x226ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x226e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x226d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x226cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x226c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa240
leaq -0x100(%rbp), %rdi
callq 0xa240
leaq -0x50(%rbp), %rdi
callq 0xa240
leaq -0x70(%rbp), %rdi
callq 0xa240
leaq -0xe0(%rbp), %rdi
callq 0xa240
leaq -0x90(%rbp), %rdi
callq 0xa240
leaq -0xb0(%rbp), %rdi
callq 0xa240
movq -0xb8(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa520
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2f5b3
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xa450
movsbl (%rax), %esi
leaq -0x30(%rbp), %rdi
callq 0xa250
jmp 0x2f569
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xa450
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x2f5a3
leaq 0x6c350(%rip), %rsi     # 0x9b8d5
leaq -0x30(%rbp), %rdi
callq 0xa510
jmp 0x2f590
jmp 0x2f5a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2f6ad
jmp 0x2f5a5
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2f544
movq 0xb79e6(%rip), %rdi     # 0xe6fa0
leaq -0x30(%rbp), %rsi
callq 0xa340
movq %rax, -0x78(%rbp)
jmp 0x2f5c9
movq -0x78(%rbp), %rdi
movq 0xb7984(%rip), %rsi     # 0xe6f58
callq 0xa400
jmp 0x2f5db
leaq -0x30(%rbp), %rdi
callq 0xa280
movq %rax, -0x88(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xa660
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rcx
leaq -0x68(%rbp), %rdi
movl $0x20, %edx
callq 0x1e1d0
jmp 0x2f613
movq 0xb7986(%rip), %rdi     # 0xe6fa0
leaq -0x68(%rbp), %rsi
callq 0xa340
movq %rax, -0x90(%rbp)
jmp 0x2f62c
movq -0x90(%rbp), %rdi
leaq 0x6cce7(%rip), %rsi     # 0x9c321
callq 0xa3b0
movq %rax, -0x98(%rbp)
jmp 0x2f648
movq -0x98(%rbp), %rdi
movq 0xb7902(%rip), %rsi     # 0xe6f58
callq 0xa400
jmp 0x2f65d
leaq -0x68(%rbp), %rdi
callq 0xa240
leaq -0x69(%rbp), %rdi
callq 0xa420
leaq -0x30(%rbp), %rdi
callq 0xa240
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2f6a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa240
leaq -0x69(%rbp), %rdi
callq 0xa420
leaq -0x30(%rbp), %rdi
callq 0xa240
movq -0x40(%rbp), %rdi
callq 0xa650
nop
// File: pfnet-research[P]pml/./include/result.hpp
// Function: auto result_t<std::shared_ptr<ast::expr_t>, parser::error_t>::case_of<main::$_0, main::$_1>(ok_adaptor<main::$_0> const&, error_adaptor<main::$_1> 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, 0x30(%rax)
je 0x2fa14
movq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fab0
jmp 0x2fa61
movq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2ffe0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x2fd40
jmp 0x2fa3f
leaq -0x48(%rbp), %rdi
callq 0x30020
jmp 0x2fa61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x30020
jmp 0x2fa67
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xa650
// File: 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>>>::clear()
void clear() {
        if (m_is_ok)
            m_ok.~T();
        else
            m_error.~E();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x20(%rax)
je 0x30135
movq -0x10(%rbp), %rdi
callq 0x30150
jmp 0x3013e
movq -0x10(%rbp), %rdi
callq 0xa240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30770
testb $0x1, %al
jne 0x3068f
jmp 0x3070a
movq -0x10(%rbp), %rdi
callq 0x307a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa340
movq %rax, %rdi
leaq 0x6bdbe(%rip), %rsi     # 0x9c470
callq 0xa3b0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0xa630
movq %rax, %rdi
leaq 0x71ac4(%rip), %rsi     # 0xa2190
callq 0xa3b0
movq %rax, %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0xa630
movq %rax, %rdi
leaq 0x6bd8c(%rip), %rsi     # 0x9c475
callq 0xa3b0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0xa630
movq %rax, %rdi
leaq 0x68a70(%rip), %rsi     # 0x99173
callq 0xa3b0
jmp 0x30760
movq -0x10(%rbp), %rdi
callq 0x307d0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa340
movq %rax, %rdi
leaq 0x6c0d7(%rip), %rsi     # 0x9c809
callq 0xa3b0
movq %rax, %rdi
leaq 0xbf(%rip), %rsi        # 0x30800
callq 0xa130
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0xa630
movq %rax, %rdi
leaq 0x68a18(%rip), %rsi     # 0x99173
callq 0xa3b0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pfnet-research[P]pml/src/mdp_expr.cpp
// Function: mdp::operator<<(std::ostream&, mdp::binop_kind_t)
std::ostream& operator<<(std::ostream& os, binop_kind_t kind) {
    switch (kind) {
    case binop_kind_t::Mul:
        os << "*"; break;
    case binop_kind_t::Div:
        os << "/"; break;
    case binop_kind_t::Add:
        os << "+"; break;
    case binop_kind_t::Sub:
        os << "-"; break;
    case binop_kind_t::Lt:
        os << "<"; break;
    case binop_kind_t::Leq:
        os << "<="; break;
    case binop_kind_t::Geq:
        os << ">="; break;
    case binop_kind_t::Gt:
        os << ">"; break;
    case binop_kind_t::Eq:
        os << "="; break;
    case binop_kind_t::Neq:
        os << "!="; break;
    case binop_kind_t::And:
        os << "&"; break;
    case binop_kind_t::Or:
        os << "|"; break;
    case binop_kind_t::Iff:
        os << "<=>"; break;
    case binop_kind_t::Impl:
        os << "=>"; break;
    }
    return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xd, %rax
ja 0x32250
movq -0x18(%rbp), %rax
leaq 0x6a45d(%rip), %rcx     # 0x9c598
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x69acd(%rip), %rsi     # 0x9bc1c
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x6a8ba(%rip), %rsi     # 0x9ca1e
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x66ff8(%rip), %rsi     # 0x99171
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x69a8c(%rip), %rsi     # 0x9bc1a
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x69ac6(%rip), %rsi     # 0x9bc69
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x69ab3(%rip), %rsi     # 0x9bc6b
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x69aa1(%rip), %rsi     # 0x9bc6e
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x6a83c(%rip), %rsi     # 0x9ca1b
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x6a418(%rip), %rsi     # 0x9c609
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x6a405(%rip), %rsi     # 0x9c608
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x69a50(%rip), %rsi     # 0x9bc65
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x69a40(%rip), %rsi     # 0x9bc67
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x6a3d2(%rip), %rsi     # 0x9c60b
callq 0xa3b0
jmp 0x32250
movq -0x8(%rbp), %rdi
leaq 0x6a3c1(%rip), %rsi     # 0x9c60c
callq 0xa3b0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbd80
testb $0x1, %al
jne 0x33632
jmp 0x33712
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33880
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33880
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33880
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x336a6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa340
movq %rax, %rdi
leaq 0x69173(%rip), %rsi     # 0x9c7f8
callq 0xa3b0
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0xa630
movq %rax, %rdi
leaq 0x65ad4(%rip), %rsi     # 0x99173
callq 0xa3b0
jmp 0x33710
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa340
movq %rax, %rdi
leaq 0x68db3(%rip), %rsi     # 0x9c470
callq 0xa3b0
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0xa630
movq %rax, %rdi
leaq 0x6912e(%rip), %rsi     # 0x9c805
callq 0xa3b0
movq %rax, %rdi
movl -0x20(%rbp), %esi
callq 0xa630
movq %rax, %rdi
leaq 0x68d84(%rip), %rsi     # 0x9c475
callq 0xa3b0
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0xa630
movq %rax, %rdi
leaq 0x65a68(%rip), %rsi     # 0x99173
callq 0xa3b0
jmp 0x33769
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa340
movq %rax, %rdi
leaq 0x690df(%rip), %rsi     # 0x9c808
callq 0xa3b0
movq %rax, %rdi
leaq -0x2f38(%rip), %rsi     # 0x30800
callq 0xa130
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x338a0
movq -0x30(%rbp), %rdi
movb (%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xa670
movq %rax, %rdi
leaq 0x65a0f(%rip), %rsi     # 0x99173
callq 0xa3b0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pfnet-research[P]pml/src/mdp_variable.cpp
// Function: mdp::operator==(mdp::variable_t const&, mdp::variable_t const&)
bool operator==(variable_t const& lhs, variable_t const& rhs) {
    if (lhs.is_int() != rhs.is_int())
        return false;

    if (lhs.is_int()) {
        return lhs.name == rhs.name &&
            lhs.as_int().init == rhs.as_int().init;
    } else {
        return lhs.name == rhs.name &&
            lhs.as_bool().init == rhs.as_bool().init;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbd80
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbd80
movb %al, %cl
movl -0x1c(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x337c2
movb $0x0, -0x1(%rbp)
jmp 0x33872
movq -0x10(%rbp), %rdi
callq 0xbd80
testb $0x1, %al
jne 0x337d1
jmp 0x3381d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf040
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1d(%rbp)
jne 0x337ec
jmp 0x33813
movq -0x10(%rbp), %rdi
callq 0x33880
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33880
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl 0x8(%rcx), %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x33872
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf040
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x25(%rbp)
jne 0x33838
jmp 0x3386a
movq -0x10(%rbp), %rdi
callq 0x338a0
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x338a0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movb (%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa450
movsbl (%rax), %edi
callq 0xa5e0
cmpl $0x0, %eax
je 0x35507
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa280
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jb 0x35514
movq $0x0, -0x8(%rbp)
jmp 0x35598
movq $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x20(%rbp), %rsi
callq 0xa450
movsbl (%rax), %edi
callq 0xa3e0
cmpl $0x0, %eax
jne 0x35558
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x20(%rbp), %rsi
callq 0xa450
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x5f, %ecx
movb %al, -0x29(%rbp)
jne 0x35579
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa280
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x35582
jmp 0x35590
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3551c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x355b0
movl -0x50(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x36676
movl $0x1, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x108(%rbp)
movl -0x1c(%rbp), %esi
leaq -0xe0(%rbp), %rdi
callq 0x347b0
jmp 0x36543
leaq 0x6650c(%rip), %rsi     # 0x9ca56
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
callq 0x12fb0
jmp 0x3655f
leaq 0x66575(%rip), %rdx     # 0x9cadb
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1ddc0
jmp 0x3657b
movq -0x108(%rbp), %rdi
leaq -0x40(%rbp), %rdx
leaq -0xa0(%rbp), %rsi
callq 0x40470
jmp 0x36594
movq -0x100(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x403f0
jmp 0x365a6
leaq -0x80(%rbp), %rdi
callq 0x30020
leaq -0xa0(%rbp), %rdi
callq 0xa240
leaq -0xc0(%rbp), %rdi
callq 0xa240
leaq -0xe0(%rbp), %rdi
callq 0xa240
movl $0x1, -0xf0(%rbp)
jmp 0x36692
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x366ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x36668
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x3665c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x36650
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x30020
leaq -0xa0(%rbp), %rdi
callq 0xa240
leaq -0xc0(%rbp), %rdi
callq 0xa240
leaq -0xe0(%rbp), %rdi
callq 0xa240
jmp 0x366ab
movq -0x100(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x404c0
jmp 0x36688
movl $0x1, -0xf0(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x404f0
movq -0xf8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x404f0
movq -0xe8(%rbp), %rdi
callq 0xa650
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq -0x48(%rbp), %rdi
callq 0x355b0
cmpl $0x24, -0x48(%rbp)
je 0x38d95
movq -0xc0(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x38540
jmp 0x38d78
movl $0x1, -0x58(%rbp)
jmp 0x38ede
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x38ef7
movq -0x40(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa280
movq -0xc8(%rbp), %rcx
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x38d20
jmp 0x38dd0
leaq -0x90(%rbp), %rdi
callq 0x40890
movb %al, -0xc9(%rbp)
jmp 0x38de4
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x38df0
jmp 0x38e22
movq -0xc0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x40e60
jmp 0x38e05
movl $0x1, -0x58(%rbp)
jmp 0x38ec2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x38ed0
leaq -0x90(%rbp), %rdi
callq 0x408f0
movq %rax, -0xd8(%rbp)
jmp 0x38e37
movq -0xd8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x38f10
jmp 0x38e4c
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
leaq -0xb0(%rbp), %rsi
callq 0x251b0
movq -0xc0(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0x40cc0
jmp 0x38e7b
leaq -0xa0(%rbp), %rdi
callq 0x16150
leaq -0xb0(%rbp), %rdi
callq 0x251e0
movl $0x1, -0x58(%rbp)
jmp 0x38ec2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x16150
leaq -0xb0(%rbp), %rdi
callq 0x251e0
jmp 0x38ed0
leaq -0x90(%rbp), %rdi
callq 0x40970
jmp 0x38ede
leaq -0x90(%rbp), %rdi
callq 0x40970
jmp 0x38ef7
leaq -0x48(%rbp), %rdi
callq 0x404f0
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x404f0
movq -0x50(%rbp), %rdi
callq 0xa650
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3a130
movq -0x80(%rbp), %rdi
callq 0x415e0
movb %al, -0x71(%rbp)
jmp 0x3ae86
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x3ae8f
jmp 0x3aec1
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x41600
jmp 0x3aea1
movl $0x1, -0x70(%rbp)
jmp 0x3aee9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x41650
jmp 0x3af02
movq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3a8f0
jmp 0x3aee2
movl $0x1, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x41650
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xa650
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq -0x48(%rbp), %rdi
callq 0x355b0
movl -0x48(%rbp), %eax
movl %eax, -0x5c(%rbp)
testl %eax, %eax
je 0x3bf83
jmp 0x3bf6f
movl -0x5c(%rbp), %eax
subl $0x1, %eax
je 0x3bfb6
jmp 0x3bf79
movl -0x5c(%rbp), %eax
subl $0x3, %eax
je 0x3bfd2
jmp 0x3bfee
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3b840
jmp 0x3bf96
movl $0x1, -0x58(%rbp)
jmp 0x3c008
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x404f0
jmp 0x3c01b
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3c070
jmp 0x3bfc9
movl $0x1, -0x58(%rbp)
jmp 0x3c008
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3c8e0
jmp 0x3bfe5
movl $0x1, -0x58(%rbp)
jmp 0x3c008
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3f900
jmp 0x3c001
movl $0x1, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x404f0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq -0x48(%rbp), %rdi
callq 0x355b0
cmpl $0x24, -0x48(%rbp)
je 0x3e0e5
movq -0xc0(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3cfd0
jmp 0x3e0c8
movl $0x1, -0x58(%rbp)
jmp 0x3e229
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x3e242
movq -0x40(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa280
movq -0xc8(%rbp), %rcx
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x3e070
jmp 0x3e120
leaq -0x90(%rbp), %rdi
callq 0x41dc0
movb %al, -0xc9(%rbp)
jmp 0x3e134
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x3e143
jmp 0x3e1f1
leaq -0x90(%rbp), %rdi
callq 0x419e0
movq %rax, -0xd8(%rbp)
jmp 0x3e158
movq -0xd8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x3e260
jmp 0x3e16d
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
leaq -0xb0(%rbp), %rsi
callq 0x41de0
movq -0xc0(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0x41a60
jmp 0x3e19c
leaq -0xa0(%rbp), %rdi
callq 0x13080
leaq -0xb0(%rbp), %rdi
callq 0x41e10
movl $0x1, -0x58(%rbp)
jmp 0x3e20d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x3e21b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x13080
leaq -0xb0(%rbp), %rdi
callq 0x41e10
jmp 0x3e21b
movq -0xc0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x41990
jmp 0x3e206
movl $0x1, -0x58(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2ffa0
jmp 0x3e229
leaq -0x90(%rbp), %rdi
callq 0x2ffa0
jmp 0x3e242
leaq -0x48(%rbp), %rdi
callq 0x404f0
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x404f0
movq -0x50(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: pfnet-research[P]pml/./include/result.hpp
// Function: result_t<token_t, parser::error_t>::error(parser::error_t&&)
static result_t error(error_t&& e) {
        result_t result;
        result.m_is_ok = false;
        result.assign_err(std::move(e));
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x590b0
movq -0x30(%rbp), %rdi
movb $0x0, 0x30(%rdi)
movq -0x10(%rbp), %rsi
callq 0x590c0
jmp 0x40427
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x40453
jmp 0x4044a
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x407c0
jmp 0x4045d
movq -0x30(%rbp), %rdi
callq 0x407c0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x591e0
movq -0x30(%rbp), %rdi
movb $0x0, 0x30(%rdi)
movq -0x10(%rbp), %rsi
callq 0x591f0
jmp 0x40567
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x40593
jmp 0x4058a
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x40860
jmp 0x4059d
movq -0x30(%rbp), %rdi
callq 0x40860
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: pfnet-research[P]pml/./include/result.hpp
// Function: result_t<std::shared_ptr<logic::term_t>, parser::error_t>::ok(std::shared_ptr<logic::term_t>&&)
static result_t ok(ok_t&& o) {
        result_t result;
        result.m_is_ok = true;
        result.assign_ok(std::move(o));
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x591e0
movq -0x30(%rbp), %rdi
movb $0x1, 0x30(%rdi)
movq -0x10(%rbp), %rsi
callq 0x59260
jmp 0x40727
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x40753
jmp 0x4074a
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x40860
jmp 0x4075d
movq -0x30(%rbp), %rdi
callq 0x40860
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movb 0x30(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
testb $0x1, 0x30(%rax)
je 0x4084a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59260
jmp 0x40857
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59380
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x30(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x10(%rbp), %rcx
movb 0x30(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x41578
movq -0x18(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x41569
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
jmp 0x41576
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59ec0
jmp 0x415b6
movq -0x18(%rbp), %rdi
callq 0x59b90
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x30(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
testb $0x1, 0x30(%rax)
je 0x415a7
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59bc0
jmp 0x415b4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59be0
jmp 0x415b6
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x5ba65
jmp 0x5ba5b
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x5ba86
jmp 0x5baa7
leaq -0x20(%rbp), %rdi
callq 0x5bac0
movq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5f840
leaq -0x20(%rbp), %rdi
callq 0x5f870
jmp 0x5baa9
leaq -0x30(%rbp), %rdi
callq 0x5baf0
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5f890
leaq -0x30(%rbp), %rdi
callq 0x5f8c0
jmp 0x5baa9
ud2
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5f8e0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x15bb0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x15be0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x15fd0
testb $0x1, %al
jne 0x5bb82
jmp 0x5bbe9
leaq -0x38(%rbp), %rdi
callq 0x16040
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x5ba30
jmp 0x5bb9e
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5f900
jmp 0x5bbad
leaq -0x58(%rbp), %rdi
callq 0x30150
leaq -0x38(%rbp), %rdi
callq 0x16060
jmp 0x5bb6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5bc68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x30150
jmp 0x5bc68
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x78(%rbp), %rdi
callq 0x5ba30
jmp 0x5bbfc
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x5bc80
jmp 0x5bc12
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5f930
leaq -0x88(%rbp), %rdi
callq 0x5f960
leaq -0x78(%rbp), %rdi
callq 0x30150
leaq -0x28(%rbp), %rdi
callq 0x5f980
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x30150
leaq -0x28(%rbp), %rdi
callq 0x5f980
movq -0x60(%rbp), %rdi
callq 0xa650
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x67670
testb $0x1, %al
jne 0x5ecce
jmp 0x5ecdd
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5fbc0
jmp 0x5ecf2
movq -0x10(%rbp), %rdi
callq 0x30060
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x67690
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
je 0x5efe7
movb $0x0, -0x1(%rbp)
jmp 0x5f0f8
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x2, %eax
je 0x5effe
movb $0x1, -0x1(%rbp)
jmp 0x5f0f8
movq -0x10(%rbp), %rdi
callq 0x5e340
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5e340
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x5f9e0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x5f9e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5efb0
testb $0x1, %al
jne 0x5f04f
movb $0x0, -0x1(%rbp)
jmp 0x5f0f8
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x5fae0
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x5fae0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x5f07f
movb $0x0, -0x1(%rbp)
jmp 0x5f0f8
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x5fae0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x5f0f4
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
callq 0x5fb00
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
callq 0x5fb00
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x63e70
testb $0x1, %al
jne 0x5f0e4
movb $0x0, -0x1(%rbp)
jmp 0x5f0f8
jmp 0x5f0e6
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5f087
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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>>>::result_t(result_t<std::shared_ptr<simty::type_t>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
result_t(result_t const& src) :
        m_is_ok{src.m_is_ok}
    {
        if (m_is_ok)
            assign_ok(src.m_ok);
        else
            assign_err(src.m_error);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movb 0x20(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
testb $0x1, 0x20(%rax)
je 0x5fbfa
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x67600
jmp 0x5fc07
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x67630
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x71f20
movq -0xb0(%rbp), %rax
leaq 0x78a5b(%rip), %rcx     # 0xe6988
movq %rcx, (%rax)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xa660
movq -0xa8(%rbp), %rdx
leaq 0x31d49(%rip), %rsi     # 0x9fc97
leaq -0x28(%rbp), %rdi
callq 0x1dd10
jmp 0x6df59
leaq -0x29(%rbp), %rdi
callq 0xa420
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3fc60
jmp 0x6df71
movq -0xb0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq 0x31fd2(%rip), %rdi     # 0x9ff63
leaq -0x90(%rbp), %rsi
callq 0x68560
movq %rax, -0xb8(%rbp)
jmp 0x6dfa6
movq -0xb0(%rbp), %rax
movq -0xb8(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movq %rax, -0xa0(%rbp)
leaq 0x31f9e(%rip), %rdi     # 0x9ff64
leaq -0xa0(%rbp), %rsi
callq 0x68580
movq %rax, -0xc0(%rbp)
jmp 0x6dfdb
movq -0xc0(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x7ece0
jmp 0x6dfff
leaq -0x78(%rbp), %rdi
callq 0x40970
leaq -0x28(%rbp), %rdi
callq 0xa240
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0xa420
jmp 0x6e05d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6e054
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x40970
leaq -0x28(%rbp), %rdi
callq 0xa240
movq -0xb0(%rbp), %rdi
callq 0x71f80
movq -0x38(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
nopl (%rax)