LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_w_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>&, unsigned char, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool read_array_w_(T& t, bio::byte m, II& i, II e, Cx& cx) {
                switch (m & X::mnr) {
                    case 0x1C: case 0x1D: case 0x1E:    return cx/cbor::read_error::size_invalid;
                    case 0x1F:                          return imp::read_array_w_var_<X>(t, i, e, cx);
                    default:                            return imp::read_array_w_fix_<X>(t, i, e, cx);
                }
            }

// Assembly:
andl $0x1f, %esi
leal -0x1c(%rsi), %eax
cmpl $0x3, %eax
jae 0x1191d
pushq $0x6
popq %rsi
movq %r8, %rdi
jmp 0x11218
cmpl $0x1f, %esi
jne 0x11930
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
jmp 0x12142
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
jmp 0x121f4
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_b_var_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool read_array_b_var_(T& t, II& i, II e, Cx& cx) {
                bio::byte const m = bio::get(i, e) & X::mjr;
                    for (auto b = bio::peek(i, e, 0); b != X::brk; b = bio::peek(i, e, 0)) {
                        if (m != (b & X::mjr))
                            return cx/cbor::read_error::array_invalid;
                        if (!read_array_b_fix_<X>(t, i, e, cx))
                            return false;
                    }
                return bio::get(i, e, 0), true;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq (%rsi), %rcx
cmpq %rdx, %rcx
je 0x11969
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
movb (%rcx), %bpl
movq %rax, %rcx
jmp 0x1196c
movb $-0x1, %bpl
cmpq %r15, %rcx
jne 0x1199d
xorl %eax, %eax
cmpb $-0x1, %al
je 0x119a1
xorb %bpl, %al
cmpb $0x20, %al
jae 0x119b0
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x119ce
testb %al, %al
je 0x119c3
movq (%rbx), %rcx
xorl %eax, %eax
cmpq %r15, %rcx
je 0x11973
movb (%rcx), %al
jmp 0x11973
movb $0x1, %al
cmpq %r15, %rcx
je 0x119c5
incq %rcx
movq %rcx, (%rbx)
jmp 0x119c5
pushq $0x7
popq %rsi
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11218
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_b_fix_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool read_array_b_fix_(T& t, II& i, II e, Cx& cx) {
                std::size_t n;
                return  read_size_le<X>(n, t.max_size() - size_(t), i, e, cx) &&
                        cxon::cnt::reserve(t, size_(t) + n) &&
                        read_bytes_<X>(t, n, i, e, cx)
                ;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movq %rsi, %r12
pushq $-0x28
popq %rcx
cqto
idivq %rcx
movabsq $0x333333333333333, %rsi # imm = 0x333333333333333
addq %rax, %rsi
movq %rsp, %rdi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x11a56
testb %al, %al
je 0x11a48
movq 0x8(%r15), %rax
subq (%r15), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
addq (%rsp), %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x11b5e
movq (%rsp), %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x11ab6
jmp 0x11a4a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<is_dynamic_type<std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>>::value && std::integral_constant<bool, true>::value, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&>::type cxon::value::controller<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>::move_assign<std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>>(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&&)
static auto move_assign(N& n, N&& o) noexcept
                        -> enable_if_t< is_dynamic_type<T>::value &&  propagate_on_container_move_assignment::value, N&>
                    {
                        if (n.kind_ == o.kind_) {
                            destruct<T>(n), n.alloc_ = std::move(o.alloc_);
                            get<T*>(n) = get<T*>(o), o.kind_ = N::kind_default_;
                        }
                        else {
                            n.reset(), n.kind_ = o.kind_, n.alloc_ = std::move(o.alloc_);
                            get<T*>(n) = get<T*>(o), o.kind_ = N::kind_default_;
                        }
                        return n;
                    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x11f16
movq %rbx, %rdi
callq 0xe8f2
jmp 0x11f25
movq %rbx, %rdi
callq 0xe8b8
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
movl $0x7, 0x20(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<!is_dynamic_type<std::vector<unsigned char, std::allocator<unsigned char>>>::value && std::integral_constant<bool, true>::value, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>&>::type cxon::value::controller<cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>::move_assign<std::vector<unsigned char, std::allocator<unsigned char>>>(cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>&, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>&&)
static auto move_assign(N& n, N&& o) noexcept(std::is_nothrow_move_constructible<T>::value)
                        -> enable_if_t<!is_dynamic_type<T>::value &&  propagate_on_container_move_assignment::value, N&>
                    {
                        if (n.kind_ == o.kind_) {
                            get<T>(n).~T(), n.alloc_ = std::move(o.alloc_);
                            alc::uninitialized_construct_using_allocator<T>(&get<T>(n), n.alloc_, std::move(get<T>(o)));
                        }
                        else {
                            n.reset(), n.kind_ = o.kind_, n.alloc_ = std::move(o.alloc_);
                            alc::uninitialized_construct_using_allocator<T>(&get<T>(n), n.alloc_, std::move(get<T>(o)));
                        }
                        return n;
                    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x19fac
movq %rbx, %rdi
callq 0x13464
jmp 0x19fbb
movq %rbx, %rdi
callq 0x1335c
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_w_var_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool read_array_w_var_(T& t, II& i, II e, Cx& cx) {
                II const o = i;
                    for (bio::get(i, e); size_(t) < t.max_size() && bio::peek(i, e, 0) != X::brk; )
                        if (!cxon::cnt::element_read<X>(t, i, e, cx))
                            return false;
                return  (bio::get(i, e, 0) == X::brk) ||
                        (bio::rewind(i, o), cx/cbor::read_error::size_invalid)
                ;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq (%rsi), %rcx
cmpq %rdx, %rcx
je 0x12168
leaq 0x1(%rcx), %rax
movq %rax, (%r14)
movq %rcx, (%rsp)
pushq $0x28
popq %rbp
movabsq $0x333333333333332, %r13 # imm = 0x333333333333332
movq 0x8(%r12), %rax
subq (%r12), %rax
cqto
idivq %rbp
movq (%r14), %rcx
cmpq %r13, %rax
ja 0x121b2
cmpq %r15, %rcx
je 0x12199
cmpb $-0x1, (%rcx)
je 0x121b2
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1226a
testb %al, %al
jne 0x12179
xorl %eax, %eax
jmp 0x121e5
cmpq %r15, %rcx
je 0x121c3
leaq 0x1(%rcx), %rax
movq %rax, (%r14)
cmpb $-0x1, (%rcx)
je 0x121e3
movq (%rsp), %rax
movq %rax, (%r14)
pushq $0x6
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11218
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_w_fix_<cxon::CBOR<cxon::cbor::format_traits>, std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool read_array_w_fix_(T& t, II& i, II e, Cx& cx) {
                std::size_t n;
                return  read_size_le<X>(n, t.max_size() - size_(t), i, e, cx) &&
                        cxon::cnt::reserve(t, n) &&
                        read_elements_<X>(t, n, i, e, cx)
                ;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movq %rsi, %r12
pushq $-0x28
popq %rcx
cqto
idivq %rcx
movabsq $0x333333333333333, %rsi # imm = 0x333333333333333
addq %rax, %rsi
movq %rsp, %rdi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x11a56
testb %al, %al
je 0x1225c
movq (%rsp), %rsi
movq %r15, %rdi
callq 0x11b5e
movq (%rsp), %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x12293
jmp 0x1225e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: std::enable_if<!std::is_assignable<decltype(*std::begin(fp)), decltype(*fp0)>::value, bool>::type cxon::cbor::cnt::imp::read_array_<cxon::CBOR<cxon::cbor::format_traits>, std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline auto read_array_(T& t, II& i, II e, Cx& cx)
                -> enable_if_t<!std::is_assignable<decltype(*std::begin(t)), decltype(*i)>::value, bool>
            {
                auto const m = bio::peek(i, e);
                switch (m & X::mjr) {
                    case X::arr: case X::map:   return imp::read_array_w_<X>(t, m, i, e, cx);
                    default:                    return cx/cbor::read_error::array_invalid;
                }
            }

// Assembly:
movq %rcx, %r8
movq %rdx, %rcx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x12879
movq %rsi, %rdx
movzbl (%rax), %eax
movl %eax, %esi
orl $0x20, %esi
andl $0xe0, %esi
cmpl $0xa0, %esi
jne 0x12879
movzbl %al, %esi
jmp 0x12884
pushq $0x7
popq %rsi
movq %r8, %rdi
jmp 0x11218
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/imp/map.hxx
// Function: bool cxon::cbor::imp::map_element_reader_<cxon::CBOR<cxon::cbor::format_traits>, std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>>::read<char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::map<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::less<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>, std::allocator<std::pair<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>>>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool read(M& t, II& i, II e, Cx& cx) {
                    typename M::key_type    k = alc::create_using_allocator_of<typename M::key_type>(t);
                    typename M::mapped_type v = alc::create_using_allocator_of<typename M::mapped_type>(t);
                    return  read_value<X>(k, i, e, cx) &&
                            read_value<X>(cxon::cnt::emplace(t, std::move(k), std::move(v)).second, i, e, cx)
                    ;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x7
popq %rax
leaq 0x30(%rsp), %rdi
movl %eax, 0x20(%rdi)
movl %eax, 0x28(%rsp)
callq 0x10e44
testb %al, %al
je 0x12a0c
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0xdc5e
addq $0x28, %rax
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e44
movl %eax, %ebx
jmp 0x12a0e
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0xe8b8
leaq 0x30(%rsp), %rdi
callq 0xe8b8
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe8b8
leaq 0x30(%rsp), %rdi
callq 0xe8b8
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::read<cxon::CBOR<cxon::cbor::format_traits>, bool, void>::value<char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(bool&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool value(bool& t, II& i, II e, Cx& cx) {
                    II const o = i;
                        auto const b = bio::get(i, e);
                    return  ((b == X::neg || b == X::pos) && (t = bool(b - X::neg),  true)) ||
                            (bio::rewind(i, o), cx/cbor::read_error::boolean_invalid)
                    ;
                }

// Assembly:
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x12abb
leaq 0x1(%rax), %rdx
movq %rdx, (%rsi)
movb (%rax), %dl
movl %edx, %r8d
andb $-0x2, %r8b
cmpb $-0xc, %r8b
jne 0x12abb
cmpb $-0xc, %dl
setne (%rdi)
movb $0x1, %al
retq
movq %rax, (%rsi)
pushq $0x2
popq %rsi
movq %rcx, %rdi
jmp 0x11218
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lib/node.cbor.hxx
// Function: bool cxon::read<cxon::CBOR<cxon::cbor::format_traits>, cxon::cbor::simple<unsigned char>, void>::value<char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>, cxon::CBOR<cxon::cbor::format_traits>>(cxon::cbor::simple<unsigned char>&, char const*&, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool value(cbor::simple<T>& t, II& i, II e, Cx& cx) {
                    II const o = i;
                    auto const b = bio::get(i, e);
                    switch (b & Y::mjr) {
                        case Y::svn:
                            switch (b & X::mnr) {
                                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  (t = T(b & Y::mnr), true);
                                case 0x18:
                                    return  (bio::get(t.value, 1, i, e)) ||
                                            (bio::rewind(i, o), cx/cbor::read_error::unexpected)
                                    ;
                                case 0x14: case 0x15: case 0x16: case 0x17:
                                case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E: case 0x1F:
                                    break;
                            }
                    }
                    return bio::rewind(i, o), cx/cbor::read_error::unexpected;
                }

// Assembly:
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x12df7
leaq 0x1(%rax), %r8
movq %r8, (%rsi)
movzbl (%rax), %r9d
movl %r9d, %r10d
notl %r10d
testb $-0x20, %r10b
jne 0x12df7
andl $0x1f, %r9d
movl $0xfffff, %r10d         # imm = 0xFFFFF
btl %r9d, %r10d
jae 0x12deb
movb %r9b, (%rdi)
movb $0x1, %al
retq
movl $0xfef00000, %r10d      # imm = 0xFEF00000
btl %r9d, %r10d
jae 0x12e05
movq %rax, (%rsi)
pushq $0x1
popq %rsi
movq %rcx, %rdi
jmp 0x11218
cmpq %rdx, %r8
je 0x12df7
movb (%r8), %al
movb %al, (%rdi)
incq (%rsi)
jmp 0x12de8
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::operator==(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&)
bool operator ==(const basic_node& f, const basic_node& s) noexcept {
                    if (f.kind_ != s.kind_)
                        return false;
                    switch (f.kind_) {
#                       define CXON_JSON_TYPE_DEF(T)    case node_kind::T: return f.get<T>() == s.get<T>()
                            CXON_JSON_TYPE_DEF(object);
                            CXON_JSON_TYPE_DEF(array);
                            CXON_JSON_TYPE_DEF(string);
                            CXON_JSON_TYPE_DEF(real);
                            CXON_JSON_TYPE_DEF(sint);
                            CXON_JSON_TYPE_DEF(uint);
                            CXON_JSON_TYPE_DEF(boolean);
                            case node_kind::null: return true;
#                       undef CXON_JSON_TYPE_DEF
                    }
                    return false; // LCOV_EXCL_LINE
                }

// Assembly:
pushq %rax
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x12ea8
cmpl $0x7, %eax
ja 0x12ea8
movl %eax, %eax
leaq 0x28529(%rip), %rcx     # 0x3b3c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x12ee7
xorl %eax, %eax
jmp 0x12eea
popq %rax
jmp 0x12f1d
movb $0x1, %al
jmp 0x12eea
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x12eea
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x12f40
jmp 0x12eea
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x12ef4
jmp 0x12eea
movb (%rdi), %al
cmpb (%rsi), %al
sete %al
popq %rcx
retq
movq %rax, %rdi
callq 0x6ed7
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>::reset()
void reset() noexcept {
                switch (kind_) {
#                   define CXON_CBOR_TYPE_DEF(T)    case node_kind::T: value::destruct<T>(*this); 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
                }
                kind_ = node_kind::undefined;
            }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpq $0x4, %rax
ja 0x133a9
leaq 0x28088(%rip), %rcx     # 0x3b3f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x133b2
jmp 0x133a9
movq %rbx, %rdi
callq 0x4130
jmp 0x133a9
movq %rbx, %rdi
callq 0x1344a
jmp 0x133a9
movq %rbx, %rdi
callq 0x13464
jmp 0x133a9
movq %rbx, %rdi
callq 0x13434
movl $0xb, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>::basic_node(cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>&&)
basic_node(basic_node&& o)
                noexcept(value::is_nothrow_move_constructible<basic_node>::value)
            :   kind_(o.kind_), alloc_(std::move(o.alloc_))
            {
                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:
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
cmpq $0xa, %rax
ja 0x14307
leaq 0x2714b(%rip), %rcx     # 0x3b40c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
movq %rax, (%rdi)
movl $0xb, 0x20(%rsi)
retq
movb (%rsi), %al
movb %al, (%rdi)
retq
movq (%rsi), %rax
movq %rax, (%rdi)
retq
jmp 0x14312
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
retq
andq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/cxon.hxx
// Function: std::enable_if<is_back_insertable<std::vector<unsigned char, std::allocator<unsigned 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::node_traits<std::allocator<char>>>, std::vector<unsigned char, std::allocator<unsigned char>>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>(std::vector<unsigned char, std::allocator<unsigned char>>&, cxon::cbor::basic_node<cxon::cbor::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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x10e26
movq 0x8(%r14), %r13
subq (%r14), %r13
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x321e8
addq (%r14), %r13
movups (%r12), %xmm0
movups %xmm0, (%r15)
movq %r13, 0x10(%r15)
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::write_map<cxon::CBOR<cxon::cbor::format_traits>, 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::__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>>&, 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&, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool write_map(O& o, const T& t, Cx& cx) {
            auto f = std::begin(t), l = std::end(t);
            if (write_size<X>(o, X::map, std::distance(f, l), cx))
                for ( ; f != l && cxon::cnt::element_write<X, T>(o, *f, cx); ++f) ;
            return f == l;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x18(%rsi), %r14
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e1c5
movq %r12, %rdi
movl $0xa0, %esi
movq %rax, %rdx
movq %r15, %rcx
callq 0x14f13
testb %al, %al
je 0x2e1b3
cmpq %rbx, %r14
je 0x2e1b0
leaq 0x20(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x2e1ec
testb %al, %al
je 0x2e1b3
movq %r14, %rdi
callq 0x42c0
movq %rax, %r14
jmp 0x2e18b
movq %rbx, %r14
cmpq %rbx, %r14
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r14
movq %rdx, %rax
shrq $0x20, %rax
jne 0x14f4e
cmpq $0xffff, %rbx           # imm = 0xFFFF
ja 0x14f52
xorl %r12d, %r12d
cmpq $0x100, %rbx            # imm = 0x100
setae %al
cmpq $0x18, %rbx
jb 0x14f8c
movb %al, %r12b
jmp 0x14f56
pushq $0x3
jmp 0x14f54
pushq $0x2
popq %r12
movzbl %sil, %eax
addl %r12d, %eax
addl $0x18, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x4230
pushq $0x1
popq %rdx
movl %r12d, %ecx
shll %cl, %edx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x14fa8
addb %sil, %bl
movsbl %bl, %esi
movq %r14, %rdi
callq 0x4230
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x2, %edx
je 0x1509a
cmpl $0x1, %edx
je 0x1508c
testl %edx, %edx
jne 0x150a8
leaq 0x26b20(%rip), %rsi     # 0x3bba5
leaq 0xf(%rsp), %rdx
jmp 0x150b4
leaq 0x26cec(%rip), %rsi     # 0x3bd7f
leaq 0xe(%rsp), %rdx
jmp 0x150b4
leaq 0x26cf7(%rip), %rsi     # 0x3bd98
leaq 0xd(%rsp), %rdx
jmp 0x150b4
leaq 0x26baa(%rip), %rsi     # 0x3bc59
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x40e0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq %rsi, %rcx
xorl %eax, %eax
leal -0x1(%rdx), %esi
cmpl $0x7, %esi
ja 0x1513e
leaq 0x2638e(%rip), %r8      # 0x3b468
movslq (%r8,%rsi,4), %r9
addq %r8, %r9
jmpq *%r9
movq %rcx, %rax
shrq $0x38, %rax
movb %al, (%rsp)
movq %rcx, %rax
shrq $0x30, %rax
movb %al, 0x1(%rsp)
movq %rcx, %rax
shrq $0x28, %rax
movb %al, 0x2(%rsp)
movq %rcx, %rax
shrq $0x20, %rax
movb %al, 0x3(%rsp)
movl %ecx, %eax
shrl $0x18, %eax
leal -0x4(%rdx), %r8d
movb %al, (%rsp,%r8)
movl %ecx, %eax
shrl $0x10, %eax
leal -0x3(%rdx), %r8d
movb %al, (%rsp,%r8)
leal -0x2(%rdx), %eax
movb %ch, (%rsp,%rax)
movb %cl, (%rsp,%rsi)
movl %edx, %edx
movq %rsp, %rsi
callq 0x15140
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %r15
movq (%rsi), %rbx
movq 0x8(%rsi), %r12
movq %r12, %rax
subq %rbx, %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movl $0x80, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0x14f13
testb %al, %al
je 0x15205
cmpq %r12, %rbx
je 0x15202
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x14db4
testb %al, %al
je 0x15205
addq $0x28, %rbx
jmp 0x151e5
movq %r12, %rbx
cmpq %r12, %rbx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq %xmm0, %rax
bswapq %rax
movq %rsp, %rsi
movq %rax, (%rsi)
pushq $0x8
popq %rdx
callq 0x15140
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %r15
sarq $0x3f, %r15
xorq %rsi, %r15
shrq $0x3a, %rsi
andb $0x20, %sil
movq %r15, %rax
shrq $0x20, %rax
jne 0x154b2
cmpq $0xffff, %r15           # imm = 0xFFFF
ja 0x154d7
xorl %ebp, %ebp
cmpq $0x100, %r15            # imm = 0x100
setae %bpl
jmp 0x154b5
pushq $0x3
popq %rbp
cmpq $0x18, %r15
jge 0x154da
addb %r15b, %sil
movsbl %sil, %esi
movq %rbx, %rdi
callq 0x4230
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x2
popq %rbp
addb %bpl, %sil
addb $0x18, %sil
movzbl %sil, %esi
movq %rbx, %rdi
callq 0x4230
pushq $0x1
popq %rdx
movl %ebp, %ecx
shll %cl, %edx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1550c
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
shrq $0x20, %rax
jne 0x155df
cmpq $0xffff, %rbx           # imm = 0xFFFF
ja 0x155e3
xorl %r12d, %r12d
cmpq $0x100, %rbx            # imm = 0x100
setae %al
cmpq $0x18, %rbx
jb 0x15618
movb %al, %r12b
jmp 0x155e7
pushq $0x3
jmp 0x155e5
pushq $0x2
popq %r12
leal 0x18(%r12), %eax
movzbl %al, %esi
movq %r14, %rdi
callq 0x4230
pushq $0x1
popq %rdx
movl %r12d, %ecx
shll %cl, %edx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x15631
movsbl %bl, %esi
movq %r14, %rdi
callq 0x4230
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpl $0x1f, %eax
ja 0x15719
movl $0xfffff, %ecx          # imm = 0xFFFFF
btl %eax, %ecx
jae 0x156fd
addb $-0x20, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4230
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xfef00000, %ecx       # imm = 0xFEF00000
btl %eax, %ecx
jae 0x15719
pushq $0x2
popq %rsi
movq %rdx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14fc6
pushq $-0x8
popq %rsi
movq %rbx, %rdi
callq 0x4230
movsbl (%r14), %esi
jmp 0x156eb
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lib/node.json.hxx
// Function: std::enable_if<cxon::JSON<cxon::json::format_traits>::quote_unquoted_keys && std::is_floating_point<double>::value, bool>::type cxon::cio::key::write<cxon::JSON<cxon::json::format_traits>, cxon::json::basic_node<cxon::json::ordered_node_traits<std::allocator<char>>>>::write_key_<cxon::json::indenter<cxon::JSON<cxon::JSON<cxon::json::format_traits>>, std::ostreambuf_iterator<char, std::char_traits<char>>>, double, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>, cxon::JSON<cxon::json::format_traits>>(cxon::json::indenter<cxon::JSON<cxon::JSON<cxon::json::format_traits>>, std::ostreambuf_iterator<char, std::char_traits<char>>>&, double const&, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool write_number_key_(O& o, const T& t, Cx& cx) {
                if (std::isinf(t))
                    return std::signbit(t) ?
                            write_value<X>(o, "-inf", cx) : write_value<X>(o, "inf", cx)
                    ;
                if (std::isnan(t))
                    return  write_value<X>(o, "nan", cx);
                return cio::key::write_key<X>(o, t, cx);
            }

// Assembly:
movq (%rsi), %xmm0
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %r8 # imm = 0x7FF0000000000000
cmpq %r8, %rcx
jne 0x175fd
testq %rax, %rax
js 0x17608
leaq 0x246e1(%rip), %rsi     # 0x3bcd9
jmp 0x1853c
ucomisd %xmm0, %xmm0
jp 0x17614
jmp 0x18548
leaq 0x246c9(%rip), %rsi     # 0x3bcd8
jmp 0x1827e
leaq 0x24875(%rip), %rsi     # 0x3be90
jmp 0x1853c