LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: oknenavin[P]cxon/test/../src/cxon/cxon.hxx
// Function: std::enable_if<is_back_insertable<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::value, cxon::to_bytes_result<decltype(std::begin(fp))>>::type cxon::interface::to_bytes<cxon::CBOR<cxon::cbor::format_traits>, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>> const&, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>&&)
inline auto to_bytes(I& i, const T& t, NaPa&&... p) -> enable_if_t<is_back_insertable<I>::value, to_bytes_result<decltype(std::begin(i))>> {
                auto cx = make_context<X>(std::forward<NaPa>(p)...);
                    auto const s = std::distance(std::begin(i), std::end(i));
                    bool const r = write_value<X>(i, t, cx); CXON_ASSERT(!r != !cx.ec, "result discrepant");
                    auto b = std::begin(i); std::advance(b, s);
                return { cx.ec, b };
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x30440
movq -0x8(%rbp), %rdi
callq 0x40360
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40390
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x40320
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x403c0
andb $0x1, %al
movb %al, -0x49(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x11a80
movq -0x8(%rbp), %rdi
callq 0x40360
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x403f0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x58(%rbp), %rcx
movq %rcx, 0x10(%rdi)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::write_size<cxon::CBOR<cxon::cbor::format_traits>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned char, unsigned long, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool write_size(O& o, bio::byte m, std::size_t s, Cx& cx) {
            unsigned const p = cbor::imp::power_(s);
            return s > 0x17 ?
                bio::poke<X>(o, bio::byte(m + 0x18 + p), cx) && bio::poke<X>(o, s, 1 << p, cx) :
                bio::poke<X>(o, bio::byte(m + s), cx)
            ;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41130
movl %eax, -0x24(%rbp)
cmpq $0x17, -0x18(%rbp)
jbe 0x40f4b
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %eax
addl $0x18, %eax
addl -0x24(%rbp), %eax
movq -0x20(%rbp), %rdx
movzbl %al, %esi
callq 0x411a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x25(%rbp)
jne 0x40f25
jmp 0x40f43
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x20(%rbp), %rcx
callq 0x411f0
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
movb %al, -0x26(%rbp)
jmp 0x40f66
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %eax
addq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdx
movzbl %al, %esi
callq 0x411a0
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/error.hxx
// Function: cxon::cbor::write_error_category::message[abi:cxx11](int) const
std::string message(int ev) const override {
            switch (static_cast<write_error>(ev)) {
                case write_error::ok:               return "no error";
                case write_error::output_failure:   return "output cannot be written";
                case write_error::argument_invalid: return "invalid argument";
                default:                            return "unknown error";
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x414e5
jmp 0x414ca
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x41530
jmp 0x414d4
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x4157b
jmp 0x415c0
leaq -0x15(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x5670
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x815aa(%rip), %rsi     # 0xc2aab
callq 0x54f0
jmp 0x41508
leaq -0x15(%rbp), %rdi
callq 0x53f0
jmp 0x41605
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x53f0
jmp 0x4160f
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5670
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x81739(%rip), %rsi     # 0xc2c85
callq 0x54f0
jmp 0x41553
leaq -0x25(%rbp), %rdi
callq 0x53f0
jmp 0x41605
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x53f0
jmp 0x4160f
leaq -0x26(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5670
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x81707(%rip), %rsi     # 0xc2c9e
callq 0x54f0
jmp 0x4159e
leaq -0x26(%rbp), %rdi
callq 0x53f0
jmp 0x41605
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x53f0
jmp 0x4160f
leaq -0x27(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5670
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x81583(%rip), %rsi     # 0xc2b5f
callq 0x54f0
jmp 0x415e3
leaq -0x27(%rbp), %rdi
callq 0x53f0
jmp 0x41605
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x27(%rbp), %rdi
callq 0x53f0
jmp 0x4160f
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5660
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: std::enable_if<std::is_integral<unsigned long>::value && sizeof (unsigned long) == 8, bool>::type cxon::bio::imp::put_<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long, unsigned int)
inline auto put_(O& o, T t, unsigned n)
                -> enable_if_t<std::is_integral<T>::value && sizeof(T) == 8, bool>
            {
                byte bs[sizeof(T)];
                    switch (n) {
                        default:    CXON_ASSERT(0, "unexpected");   // LCOV_EXCL_LINE
                                    return false;                   // LCOV_EXCL_LINE
                        case 8:     bs[n - 8] = byte(t >> 56);
                                    bs[n - 7] = byte(t >> 48);
                                    bs[n - 6] = byte(t >> 40);
                                    bs[n - 5] = byte(t >> 32); CXON_FALLTHROUGH;
                        case 4:     bs[n - 4] = byte(t >> 24);
                                    bs[n - 3] = byte(t >> 16); CXON_FALLTHROUGH;
                        case 2:     bs[n - 2] = byte(t >>  8); CXON_FALLTHROUGH;
                        case 1:     bs[n - 1] = byte(t >>  0);
                    }
                return poke_(o, bs, n);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x7, %eax
ja 0x41657
movq -0x30(%rbp), %rax
leaq 0x80b6e(%rip), %rcx     # 0xc21bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x1(%rbp)
jmp 0x41725
movq -0x18(%rbp), %rax
shrq $0x38, %rax
movb %al, %cl
movl -0x1c(%rbp), %eax
subl $0x8, %eax
movl %eax, %eax
movb %cl, -0x24(%rbp,%rax)
movq -0x18(%rbp), %rax
shrq $0x30, %rax
movb %al, %cl
movl -0x1c(%rbp), %eax
subl $0x7, %eax
movl %eax, %eax
movb %cl, -0x24(%rbp,%rax)
movq -0x18(%rbp), %rax
shrq $0x28, %rax
movb %al, %cl
movl -0x1c(%rbp), %eax
subl $0x6, %eax
movl %eax, %eax
movb %cl, -0x24(%rbp,%rax)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movl -0x1c(%rbp), %eax
subl $0x5, %eax
movl %eax, %eax
movb %cl, -0x24(%rbp,%rax)
movq -0x18(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movl -0x1c(%rbp), %eax
subl $0x4, %eax
movl %eax, %eax
movb %cl, -0x24(%rbp,%rax)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movl -0x1c(%rbp), %eax
subl $0x3, %eax
movl %eax, %eax
movb %cl, -0x24(%rbp,%rax)
movq -0x18(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, %eax
movb %cl, -0x24(%rbp,%rax)
movq -0x18(%rbp), %rax
shrq $0x0, %rax
movb %al, %cl
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movb %cl, -0x24(%rbp,%rax)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x41730
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: std::enable_if<sizeof (cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>) != 1 || std::is_same<cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>, bool>::value, bool>::type cxon::cbor::cnt::imp::write_array_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>, std::allocator<cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>, std::allocator<cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>> const&, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline auto write_array_(O& o, const C& t, Cx& cx)
                -> enable_if_t<sizeof(T) != 1 ||  std::is_same<T, bool>::value, bool>
            {
                auto f = std::begin(t), l = std::end(t);
                if (write_size<X>(o, X::arr, std::distance(f, l), cx))
                    for ( ; f != l && cxon::cnt::element_write<X, C>(o, *f, cx); ++f) ;
                return f == l;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41af0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41b20
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x41b50
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movl $0x80, %esi
callq 0x40ed0
testb $0x1, %al
jne 0x41a7e
jmp 0x41ad7
jmp 0x41a80
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41b90
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x41a9b
jmp 0x41abf
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x41c00
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x41bd0
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x41ac8
jmp 0x41ad5
jmp 0x41aca
leaq -0x20(%rbp), %rdi
callq 0x41c20
jmp 0x41a80
jmp 0x41ad7
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41c40
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: bool cxon::bio::imp::put_<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, double)
inline bool put_(O& o, double t) {
                union { unsigned long long i; double f; } u; u.f = t;
                byte bs[sizeof(double)];
                    bs[0] = byte(u.i >> 56), bs[1] = byte(u.i >> 48),
                    bs[2] = byte(u.i >> 40), bs[3] = byte(u.i >> 32),
                    bs[4] = byte(u.i >> 24), bs[5] = byte(u.i >> 16),
                    bs[6] = byte(u.i >>  8), bs[7] = byte(u.i >>  0);
                return poke_(o, bs, sizeof(bs));
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x38, %rax
movb %al, -0x20(%rbp)
movq -0x18(%rbp), %rax
shrq $0x30, %rax
movb %al, -0x1f(%rbp)
movq -0x18(%rbp), %rax
shrq $0x28, %rax
movb %al, -0x1e(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movb %al, -0x1d(%rbp)
movq -0x18(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x1c(%rbp)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x1b(%rbp)
movq -0x18(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
shrq $0x0, %rax
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x8, %edx
callq 0x42d40
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::write<cxon::CBOR<cxon::cbor::format_traits>, long long, void>::value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, long long, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool value(O& o, T t, Cx& cx) {
                auto const m = t < 0 ? (t = -1 - t, X::nint) : X::pint;
                auto const p = cbor::imp::power_(t);
                return t > 0x17 ?
                    bio::poke<X>(o, bio::byte(m + 0x18 + p), cx) && bio::poke<X>(o, t, 1 << p, cx) :
                    bio::poke<X>(o, bio::byte(m + t), cx)
                ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x42e01
movq $-0x1, %rax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x20, %al
movb %al, -0x21(%rbp)
jmp 0x42e08
xorl %eax, %eax
movb %al, -0x21(%rbp)
jmp 0x42e08
movb -0x21(%rbp), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42ea0
movl %eax, -0x20(%rbp)
cmpq $0x17, -0x10(%rbp)
jle 0x42e6f
movq -0x8(%rbp), %rdi
movzbl -0x19(%rbp), %eax
addl $0x18, %eax
addl -0x20(%rbp), %eax
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x42c10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x22(%rbp)
jne 0x42e49
jmp 0x42e67
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x18(%rbp), %rcx
callq 0x42f10
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x23(%rbp)
jmp 0x42e8a
movq -0x8(%rbp), %rdi
movzbl -0x19(%rbp), %eax
addq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x42c10
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::write<cxon::CBOR<cxon::cbor::format_traits>, unsigned long long, void>::value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long long, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool value(O& o, T t, Cx& cx) {
                    auto const p = cbor::imp::power_(t);
                    return t > 0x17 ?
                        bio::poke<X>(o, bio::byte(X::pint + 0x18 + p), cx) && bio::poke<X>(o, t, 1 << p, cx) :
                        bio::poke<X>(o, bio::byte(X::pint + t), cx)
                    ;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43140
movl %eax, -0x1c(%rbp)
cmpq $0x17, -0x10(%rbp)
jbe 0x43111
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x18, %eax
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x42c10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1d(%rbp)
jne 0x430eb
jmp 0x43109
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x18(%rbp), %rcx
callq 0x431b0
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
movb %al, -0x1e(%rbp)
jmp 0x4312c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x0, %rax
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x42c10
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lib/node.cbor.hxx
// Function: bool cxon::write<cxon::CBOR<cxon::cbor::format_traits>, cxon::cbor::simple<unsigned char>, void>::value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>, cxon::CBOR<cxon::cbor::format_traits>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, cxon::cbor::simple<unsigned char> const&, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool value(O& o, const cbor::simple<T>& t, Cx& cx) {
                    switch (t) {
                        case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: case 0x08: case 0x09:
                        case 0x0A: case 0x0B: case 0x0C: case 0x0D: case 0x0E: case 0x0F: case 0x10: case 0x11: case 0x12: case 0x13:
                            return  bio::poke<Y>(o, bio::byte(X::svn + t), cx);
                        default:
                            CXON_ASSERT(t <= 255, "invalid simple value");
                            return  bio::poke<Y>(o, bio::byte(X::svn + 0x18), cx) && bio::poke<Y>(o, t.value, 1, cx);
                        case 0x14: case 0x15: case 0x16: case 0x17:
                        case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E: case 0x1F:
                            return  cx/cbor::write_error::argument_invalid;
                    }
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30ec0
movzbl %al, %ecx
movl %ecx, -0x24(%rbp)
subb $0x14, %al
jb 0x4338b
jmp 0x43369
movl -0x24(%rbp), %eax
addl $-0x14, %eax
subl $0x4, %eax
jb 0x4340c
jmp 0x4337a
movl -0x24(%rbp), %eax
addl $-0x19, %eax
subl $0x7, %eax
jb 0x4340c
jmp 0x433bb
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30ec0
movq -0x30(%rbp), %rdi
movzbl %al, %eax
addl $0xe0, %eax
movq -0x20(%rbp), %rdx
movzbl %al, %esi
callq 0x411a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4341f
movq -0x18(%rbp), %rdi
callq 0x30ec0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xf8, %esi
callq 0x411a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x433e4
jmp 0x43402
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movb (%rax), %al
movq -0x20(%rbp), %rcx
movl $0x1, %edx
movzbl %al, %esi
callq 0x43430
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4341f
movq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x41270
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/numeric.hxx
// Function: std::enable_if<std::is_integral<long long>::value, bool>::type cxon::cio::num::imp::number_write_<cxon::cio::key::unquoted_traits<cxon::json::format_traits>, long long, cxon::json::indenter<cxon::JSON<cxon::JSON<cxon::json::format_traits>>, std::ostreambuf_iterator<char, std::char_traits<char>>>, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(cxon::json::indenter<cxon::JSON<cxon::JSON<cxon::json::format_traits>>, std::ostreambuf_iterator<char, std::char_traits<char>>>&, long long, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline auto number_write_(O& o, T t, Cx& cx) -> enable_if_t<std::is_integral<T>::value, bool> {
#               if __cplusplus >= 202002L && defined(__GNUC__) && __GNUC__ >= 11 && !defined(__clang__)
#                   pragma GCC diagnostic push
#                   pragma GCC diagnostic ignored "-Wrestrict" // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100366
#                   pragma GCC diagnostic ignored "-Warray-bounds"
#               endif
                    char s[std::numeric_limits<T>::digits10 + 3];
                        constexpr auto base = integer_base::constant<napa_type<Cx>>(10);
                        auto const r = charconv::to_chars(std::begin(s), std::end(s), t, base); CXON_ASSERT(r.ec == std::errc(), "unexpected");
                    return poke<X>(o, s, r.ptr, cx);
#               if __cplusplus >= 202002L && defined(__GNUC__) && __GNUC__ >= 11 && !defined(__clang__)
#                   pragma GCC diagnostic pop
#               endif
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xa, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4e4f0
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4e500
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
movl $0xa, %ecx
callq 0x4e4b0
movq %rax, -0x48(%rbp)
movl %edx, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x4e280
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>::operator=(cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>&&)
basic_node& operator =(basic_node&& o)
                noexcept(value::is_nothrow_move_assignable<basic_node>::value)
            {
                switch (o.kind_) {
#                   define CXON_CBOR_TYPE_DEF(T)    case node_kind::T: return value::move_assign<T>(*this, std::move(o))
                        CXON_CBOR_TYPE_DEF(map);
                        CXON_CBOR_TYPE_DEF(array);
                        CXON_CBOR_TYPE_DEF(tag);
                        CXON_CBOR_TYPE_DEF(bytes);
                        CXON_CBOR_TYPE_DEF(text);
                        CXON_CBOR_TYPE_DEF(real);
                        CXON_CBOR_TYPE_DEF(sint);
                        CXON_CBOR_TYPE_DEF(uint);
                        CXON_CBOR_TYPE_DEF(simple);
                        CXON_CBOR_TYPE_DEF(boolean);
                        CXON_CBOR_TYPE_DEF(null);
                        CXON_CBOR_TYPE_DEF(undefined);
#                   undef CXON_CBOR_TYPE_DEF
                }
                return *this; // LCOV_EXCL_LINE
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0xb, %rax
ja 0x55ad4
movq -0x20(%rbp), %rax
leaq 0x6ce80(%rip), %rcx     # 0xc2858
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55af0
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55b20
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55b50
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55b80
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55bb0
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55be0
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55c10
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55c40
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55c70
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55ca0
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55cd0
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55d00
movq %rax, -0x8(%rbp)
jmp 0x55adc
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>::operator=(cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>> const&)
basic_node& operator =(const basic_node& o)
                noexcept(value::is_nothrow_copy_assignable<basic_node>::value)
            {
                switch (o.kind_) {
#                   define CXON_CBOR_TYPE_DEF(T)    case node_kind::T: return value::copy_assign<T>(*this, o)
                        CXON_CBOR_TYPE_DEF(map);
                        CXON_CBOR_TYPE_DEF(array);
                        CXON_CBOR_TYPE_DEF(tag);
                        CXON_CBOR_TYPE_DEF(bytes);
                        CXON_CBOR_TYPE_DEF(text);
                        CXON_CBOR_TYPE_DEF(real);
                        CXON_CBOR_TYPE_DEF(sint);
                        CXON_CBOR_TYPE_DEF(uint);
                        CXON_CBOR_TYPE_DEF(simple);
                        CXON_CBOR_TYPE_DEF(boolean);
                        CXON_CBOR_TYPE_DEF(null);
                        CXON_CBOR_TYPE_DEF(undefined);
#                   undef CXON_CBOR_TYPE_DEF
                }
                return *this; // LCOV_EXCL_LINE
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0xb, %rax
ja 0x7c114
movq -0x20(%rbp), %rax
leaq 0x4761c(%rip), %rcx     # 0xc3634
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9ee10
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9ee40
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9ee70
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9eea0
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9eed0
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9ef00
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9ef30
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9ef60
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9ef90
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9efc0
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9eff0
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9f020
movq %rax, -0x8(%rbp)
jmp 0x7c11c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>::basic_node(cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>&&, std::allocator<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>> const&)
basic_node(basic_node&& o, const allocator_type& al)
                noexcept(value::is_nothrow_move_constructible<basic_node>::value)
            :   kind_(o.kind_), alloc_(al)
            {
                switch (o.kind_) {
#                   define CXON_CBOR_TYPE_DEF(T)    case node_kind::T: value::move_construct<T>(*this, std::move(o)); break
                        CXON_CBOR_TYPE_DEF(map);
                        CXON_CBOR_TYPE_DEF(array);
                        CXON_CBOR_TYPE_DEF(tag);
                        CXON_CBOR_TYPE_DEF(bytes);
                        CXON_CBOR_TYPE_DEF(text);
                        CXON_CBOR_TYPE_DEF(real);
                        CXON_CBOR_TYPE_DEF(sint);
                        CXON_CBOR_TYPE_DEF(uint);
                        CXON_CBOR_TYPE_DEF(simple);
                        CXON_CBOR_TYPE_DEF(boolean);
                        CXON_CBOR_TYPE_DEF(null);
                        CXON_CBOR_TYPE_DEF(undefined);
#                   undef CXON_CBOR_TYPE_DEF
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x20(%rdi)
addq $0x24, %rdi
movq -0x18(%rbp), %rsi
callq 0x81a30
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0xb, %rax
ja 0x7c2e7
movq -0x20(%rbp), %rax
leaq 0x47441(%rip), %rcx     # 0xc3664
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81a60
jmp 0x7c2e7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81a90
jmp 0x7c2e7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81ac0
jmp 0x7c2e7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81af0
jmp 0x7c2e7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81b20
jmp 0x7c2e7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81b50
jmp 0x7c2e7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81b80
jmp 0x7c2e7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81bb0
jmp 0x7c2e7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81be0
jmp 0x7c2e7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81c10
jmp 0x7c2e7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81c40
jmp 0x7c2e7
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81c70
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>::basic_node(cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>> const&, std::allocator<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>> const&)
basic_node(const basic_node& o, const allocator_type& al)
                noexcept(value::is_nothrow_copy_constructible<basic_node>::value)
            :   kind_(o.kind_), alloc_(al)
            {
                switch (o.kind_) {
#                   define CXON_CBOR_TYPE_DEF(T)    case node_kind::T: value::copy_construct<T>(*this, o); break
                        CXON_CBOR_TYPE_DEF(map);
                        CXON_CBOR_TYPE_DEF(array);
                        CXON_CBOR_TYPE_DEF(tag);
                        CXON_CBOR_TYPE_DEF(bytes);
                        CXON_CBOR_TYPE_DEF(text);
                        CXON_CBOR_TYPE_DEF(real);
                        CXON_CBOR_TYPE_DEF(sint);
                        CXON_CBOR_TYPE_DEF(uint);
                        CXON_CBOR_TYPE_DEF(simple);
                        CXON_CBOR_TYPE_DEF(boolean);
                        CXON_CBOR_TYPE_DEF(null);
                        CXON_CBOR_TYPE_DEF(undefined);
#                   undef CXON_CBOR_TYPE_DEF
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x20(%rdi)
addq $0x24, %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x81a30
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x30(%rbp)
subq $0xb, %rax
ja 0x7cf4f
movq -0x30(%rbp), %rax
leaq 0x4685d(%rip), %rcx     # 0xc36c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9dcc0
jmp 0x7ce7f
jmp 0x7cf4f
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7a7c0
jmp 0x7cf55
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9dcf0
jmp 0x7cead
jmp 0x7cf4f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9dd20
jmp 0x7cec1
jmp 0x7cf4f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9dd50
jmp 0x7ced5
jmp 0x7cf4f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9dd80
jmp 0x7cee6
jmp 0x7cf4f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9ddb0
jmp 0x7cf4f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9dde0
jmp 0x7cf4f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9de10
jmp 0x7cf4f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9de40
jmp 0x7cf4f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9de70
jmp 0x7cf4f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9dea0
jmp 0x7cf4f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9ded0
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5660
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>::operator=(std::initializer_list<cxon::cbor::basic_node<test::kind::unordered_node_traits<std::allocator<char>>>>)
basic_node& operator =(std::initializer_list<basic_node> l) {
                    bool const obj = l.size() == 0 || std::all_of(l.begin(), l.end(), [&](const basic_node& e) {
                        return e.template is<array>() && e.template get<array>().size() == 2;
                    });
                    if (obj) {
                        auto& o = imbue<map>();
                        for (auto& e : l) {
                            auto& a = e.template get<array>();
                            cxon::cnt::append(o, {a[0], a[1]});
                        }
                    }
                    else
                        imbue<array>() = l;
                    return *this;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xafa10
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0xc1(%rbp)
je 0x7e60a
leaq -0x10(%rbp), %rdi
callq 0xafa70
movq %rax, -0xd8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xafa90
movq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0xafa30
movb %al, -0xc1(%rbp)
movb -0xc1(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x7e712
movq -0xd0(%rbp), %rdi
callq 0xafad0
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xafa70
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xafa90
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x7e710
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xafb20
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xafb80
movq %rax, -0xf0(%rbp)
movq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0xafb80
movq -0xf0(%rbp), %rsi
movq %rax, %rdx
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xafba0
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0xafb50
jmp 0x7e6d3
leaq -0xa0(%rbp), %rdi
callq 0xaef40
movq -0x38(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x38(%rbp)
jmp 0x7e651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xaef40
jmp 0x7e75a
jmp 0x7e74a
movq -0xd0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0xafc00
movq %rax, %rdi
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
callq 0xafc50
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x5660
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::hash<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>>::operator()(cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>> const&) const
std::size_t operator ()(const cbor::basic_node<Tr>& n) const noexcept {
                switch (n.kind()) {
#                   define CXON_CBOR_TYPE_DEF(T)            case cbor::node_kind::T: return make_hash(cbor::get<typename cbor::basic_node<Tr>::T>(n))
                        CXON_CBOR_TYPE_DEF(map);
                        CXON_CBOR_TYPE_DEF(array);
                        CXON_CBOR_TYPE_DEF(tag);
                        CXON_CBOR_TYPE_DEF(bytes);
                        CXON_CBOR_TYPE_DEF(text);
                        CXON_CBOR_TYPE_DEF(real);
                        CXON_CBOR_TYPE_DEF(sint);
                        CXON_CBOR_TYPE_DEF(uint);
                        CXON_CBOR_TYPE_DEF(simple);
                        CXON_CBOR_TYPE_DEF(boolean);
                        CXON_CBOR_TYPE_DEF(null);
                        CXON_CBOR_TYPE_DEF(undefined);
#                   undef CXON_CBOR_TYPE_DEF
                }
                return 0; // LCOV_EXCL_LINE
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8c1b0
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xb, %eax
ja 0xabf12
movq -0x20(%rbp), %rax
leaq 0x17cb1(%rip), %rcx     # 0xc3a94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0xabf50
movq %rax, %rdi
callq 0xabf30
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq -0x18(%rbp), %rdi
callq 0xabf90
movq %rax, %rdi
callq 0xabf70
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq -0x18(%rbp), %rdi
callq 0xabfd0
movq %rax, %rdi
callq 0xabfb0
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq -0x18(%rbp), %rdi
callq 0xac010
movq %rax, %rdi
callq 0xabff0
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq -0x18(%rbp), %rdi
callq 0xac050
movq %rax, %rdi
callq 0xac030
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq -0x18(%rbp), %rdi
callq 0xac090
movq %rax, %rdi
callq 0xac070
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq -0x18(%rbp), %rdi
callq 0xac0d0
movq %rax, %rdi
callq 0xac0b0
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq -0x18(%rbp), %rdi
callq 0xac110
movq %rax, %rdi
callq 0xac0f0
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq -0x18(%rbp), %rdi
callq 0xac150
movq %rax, %rdi
callq 0xac130
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq -0x18(%rbp), %rdi
callq 0xac190
movq %rax, %rdi
callq 0xac170
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq -0x18(%rbp), %rdi
callq 0xac1d0
movq %rax, %rdi
callq 0xac1b0
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq -0x18(%rbp), %rdi
callq 0xac210
movq %rax, %rdi
callq 0xac1f0
movq %rax, -0x8(%rbp)
jmp 0xabf1a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/hash.hxx
// Function: std::enable_if<is_iterable_<std::map<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>, cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>, std::less<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>> const, cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>>>>>::value, unsigned long>::type cxon::imp::make_hash_<std::map<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>, cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>, std::less<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>> const, cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>>>>>(std::map<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>, cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>, std::less<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>> const, cxon::cbor::basic_node<cxon::cbor::node_traits<std::allocator<char>>>>>> const&)
inline auto make_hash_(const T& t) noexcept -> enable_if_t< is_iterable_<T>::value, std::size_t> {
                hash<typename T::value_type> hs;
                std::size_t s = 0;
                for (auto& v: t)
                    s = make_hash(s, hs(v));
                return s;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8c470
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8c4a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x85ca0
testb $0x1, %al
jne 0xac2d9
jmp 0xac31b
leaq -0x28(%rbp), %rdi
callq 0x85e10
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x9(%rbp), %rdi
callq 0xac360
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0xac330
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x85d40
jmp 0xac2c6
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: chiku[P]cmatrix/demo/io_demo.cpp
// Function: main
int main()
{
    int size = 5;
    cmatrix::Matrix<double> matrix(size, size);
    matrix.fillByPosition(new testFunctionoid, size/2, size/2, 1.0/size, 1.0/size);
    std::cout << matrix << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x5, -0x4(%rbp)
movslq -0x4(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movq %rdx, %rsi
callq 0x24e0
movl $0x1, %edi
callq 0x2180
movq %rax, -0x48(%rbp)
jmp 0x244f
movq -0x48(%rbp), %rsi
movl -0x4(%rbp), %eax
movl %eax, %edx
shrl $0x1f, %edx
movl %eax, %ecx
addl %edx, %ecx
sarl %ecx
movslq %ecx, %rcx
cvtsi2sd %eax, %xmm0
movsd 0x1b98(%rip), %xmm1     # 0x4008
divsd %xmm0, %xmm1
leaq -0x30(%rbp), %rdi
movq %rcx, %rdx
movaps %xmm1, %xmm0
callq 0x2530
jmp 0x2485
movq 0x4b4c(%rip), %rdi      # 0x6fd8
leaq -0x30(%rbp), %rsi
callq 0x2620
movq %rax, -0x50(%rbp)
jmp 0x249b
movq -0x50(%rbp), %rdi
movq 0x4b22(%rip), %rsi      # 0x6fc8
callq 0x21a0
jmp 0x24ad
leaq -0x30(%rbp), %rdi
callq 0x2850
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2850
movq -0x38(%rbp), %rdi
callq 0x2270
nopl (%rax)
// File: chiku[P]cmatrix/src/impl/matrix/functionoid.cpp
// Function: cmatrix::Matrix<double>& cmatrix::Matrix<double>::fillByPosition<testFunctionoid*>(testFunctionoid*, long, long, double, double)
Matrix<Type>& Matrix<Type>::fillByPosition(FunctObj function, long int xShift, long int yShift, Type xScale, Type yScale)
{
    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            access(i, j) = (*function)((i - xShift) * xScale, (j - yShift) * yScale);
        }
    }

    return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x2b80
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jge 0x260d
movl $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x2ba0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jge 0x25fd
movq -0x10(%rbp), %rdi
movslq -0x34(%rbp), %rax
subq -0x18(%rbp), %rax
cvtsi2sd %rax, %xmm0
mulsd -0x28(%rbp), %xmm0
movslq -0x38(%rbp), %rax
subq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm1
mulsd -0x30(%rbp), %xmm1
callq 0x3a90
movq -0x40(%rbp), %rdi
movsd %xmm0, -0x58(%rbp)
movslq -0x34(%rbp), %rsi
movslq -0x38(%rbp), %rdx
callq 0x3ae0
movsd -0x58(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2589
jmp 0x25ff
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2561
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chiku[P]cmatrix/src/impl/matrix/io/stream.cpp
// Function: std::ostream& cmatrix::operator<<<double>(std::ostream&, cmatrix::Matrix<double> const&)
std::ostream& operator << (std::ostream& outputStream, const Matrix<Type>& matrix)
{
    for (int i = 0; i < matrix.rows(); i++) {
        for (int j = 0; j< matrix.columns(); j++) {
            outputStream << std::setiosflags(std::ios::fixed) << std::setprecision(4) << matrix.access(i, j) << std::string("\t");
        }

        outputStream << std::string("\n");
    }

    return outputStream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b80
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jge 0x282b
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ba0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jge 0x2797
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl $0x4, %edi
movl %edi, -0xb4(%rbp)
callq 0x3b80
movq -0xc0(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x22c0
movl -0xb4(%rbp), %edi
movq %rax, -0xb0(%rbp)
callq 0x3ba0
movq -0xb0(%rbp), %rdi
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x2240
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x3bc0
movq -0xa8(%rbp), %rdi
callq 0x22b0
movq %rax, -0xa0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2280
movq -0x98(%rbp), %rdx
leaq 0x19cc(%rip), %rsi      # 0x40f5
leaq -0x40(%rbp), %rdi
callq 0x3bf0
jmp 0x2734
movq -0xa0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2150
jmp 0x2746
leaq -0x40(%rbp), %rdi
callq 0x20b0
leaq -0x41(%rbp), %rdi
callq 0x21c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2668
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2789
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x20b0
leaq -0x41(%rbp), %rdi
callq 0x21c0
jmp 0x2838
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x2280
movq -0xc8(%rbp), %rdx
leaq 0x1937(%rip), %rsi      # 0x40f7
leaq -0x78(%rbp), %rdi
callq 0x3bf0
jmp 0x27cb
movq -0xd0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2150
jmp 0x27dd
leaq -0x78(%rbp), %rdi
callq 0x20b0
leaq -0x79(%rbp), %rdi
callq 0x21c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x263a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2820
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x20b0
leaq -0x79(%rbp), %rdi
callq 0x21c0
jmp 0x2838
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)