LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: oknenavin[P]cxon/test/src/cbor/../test.hxx
// Function: bool cxon::test::verify_read_<cxon::CBOR<cxon::cbor::format_traits>, (anonymous namespace)::Struct11, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>>((anonymous namespace)::Struct11 const&, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>> const&)
static bool verify_read_(const T& ref, const C& sbj) {
            T res{};
                auto const r = from_string<X>(res, sbj);
                clean<T> clean__(res);
            return r && r.end == std::end(sbj) && match<T>::values(res, ref);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x35ec0
movq -0x98(%rbp), %rdx
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x169650
jmp 0x169757
leaq -0x58(%rbp), %rdi
callq 0x190150
movq -0x10(%rbp), %rdx
leaq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x169860
jmp 0x169773
leaq -0x81(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x169890
jmp 0x169785
leaq -0x80(%rbp), %rdi
callq 0x2c140
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x99(%rbp)
jne 0x16979f
jmp 0x169805
leaq -0x80(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2c1a0
movq -0xa8(%rbp), %rdi
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x2c160
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x99(%rbp)
jne 0x1697e2
jmp 0x169805
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1698a0
movb %al, -0xa9(%rbp)
jmp 0x1697f7
movb -0xa9(%rbp), %al
movb %al, -0x99(%rbp)
jmp 0x169805
movb -0x99(%rbp), %al
movb %al, -0xaa(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x169690
movb -0xaa(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x190150
jmp 0x169857
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x169690
movq -0x60(%rbp), %rdi
callq 0x7690
// File: oknenavin[P]cxon/test/src/cbor/../test.hxx
// Function: bool cxon::test::verify_read_<cxon::CBOR<cxon::cbor::format_traits>, (anonymous namespace)::Struct11, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>, cxon::cbor::read_error>((anonymous namespace)::Struct11 const&, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>> const&, cxon::cbor::read_error, int)
static bool verify_read_(const T&, const C& sbj, E err, int pos) {
            T res{};
                auto const r = from_string<X>(res, sbj);
                clean<T> clean__(res);
            return r.ec.value() == (int)err && (pos == -1 || std::distance(std::begin(sbj), r.end) == pos);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x35ec0
movq -0xa8(%rbp), %rdx
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x169650
jmp 0x16a7bd
leaq -0x60(%rbp), %rdi
callq 0x190150
movq -0x10(%rbp), %rdx
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x169860
jmp 0x16a7dc
leaq -0x89(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x169890
jmp 0x16a7ee
leaq -0x88(%rbp), %rdi
callq 0x53120
movl %eax, %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0xa9(%rbp)
jne 0x16a871
movb $0x1, %al
cmpl $-0x1, -0x18(%rbp)
movb %al, -0xaa(%rbp)
je 0x16a865
movq -0x10(%rbp), %rdi
callq 0x2c360
movq %rax, -0x98(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x53130
movq %rax, -0xb8(%rbp)
jmp 0x16a84e
movq -0xb8(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq %rcx, %rax
sete %al
movb %al, -0xaa(%rbp)
movb -0xaa(%rbp), %al
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
movb %al, -0xb9(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x169690
movb -0xb9(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x190150
jmp 0x16a8c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x169690
movq -0x68(%rbp), %rdi
callq 0x7690
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::read_array<cxon::CBOR<cxon::cbor::format_traits>, boost::container::vec_iterator<int*, false>, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(boost::container::vec_iterator<int*, false>, boost::container::vec_iterator<int*, false>, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool read_array(FI f, FI l, II& i, II e, Cx& cx) {
            typename X::tag_type tag;
            if (!tag::read<X>(tag, i, e, cx))
                return false;
            return read_array<X>(f, l, tag, i, e, cx);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x2c6f0
testb $0x1, %al
jne 0x4bfb3
movb $0x0, -0x1(%rbp)
jmp 0x4bfef
movq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x4c140
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x4c140
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4c0c0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::write<cxon::CBOR<cxon::cbor::format_traits>, wchar_t, void>::value<std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>&, wchar_t, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
static bool value(O& o, T t, Cx& cx) {
                    using Q = typename std::make_unsigned<T>::type;
                    auto const p = cbor::imp::power_(t);
                    return Q(t) > 0x17 ?
                        bio::poke<X>(o, bio::byte(X::pint + 0x18 + p), cx) && bio::poke<X>(o, Q(t), 1 << p, cx) :
                        bio::poke<X>(o, bio::byte(X::pint + Q(t)), cx)
                    ;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x75750
movl %eax, -0x1c(%rbp)
cmpl $0x17, -0xc(%rbp)
jbe 0x7571d
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x18, %eax
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x37210
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1d(%rbp)
jne 0x756f8
jmp 0x75715
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x18(%rbp), %rcx
callq 0x757a0
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
movb %al, -0x1e(%rbp)
jmp 0x75736
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x0, %eax
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x37210
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: std::enable_if<std::is_integral<char16_t>::value && sizeof (char16_t) == 2, bool>::type cxon::bio::imp::put_<char16_t, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>>(std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>&, char16_t, unsigned int)
inline auto put_(O& o, T t, unsigned n)
                -> enable_if_t<std::is_integral<T>::value && sizeof(T) == 2, bool>
            {
                byte bs[sizeof(T)];
                    switch (n) {
                        default:    CXON_ASSERT(0, "unexpected");   // LCOV_EXCL_LINE
                                    return false;                   // LCOV_EXCL_LINE
                        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 $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x1, %eax
je 0x79a48
jmp 0x79a23
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0x79a33
jmp 0x79a2d
movb $0x0, -0x1(%rbp)
jmp 0x79a72
movzwl -0x12(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movl -0x18(%rbp), %eax
subl $0x2, %eax
movl %eax, %eax
movb %cl, -0x1a(%rbp,%rax)
movzwl -0x12(%rbp), %eax
sarl $0x0, %eax
movb %al, %cl
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movb %cl, -0x1a(%rbp,%rax)
movq -0x10(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x36e30
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/compound.hxx
// Function: bool cxon::cbor::imp::read_pointer_t_<cxon::CBOR<cxon::cbor::format_traits>, boost::container::basic_string<char, std::char_traits<char>, void>, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(boost::container::basic_string<char, std::char_traits<char>, void>*&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool read_pointer_t_(T*& t, II& i, II e, Cx& cx) {
                if (bio::peek(i, e) == X::nil)
                    return bio::get(i, e), t = nullptr, true;
                auto al = alc::make_context_allocator<T>(cx);
                T *const v = al.create();
                    if (!v || !read_value<X>(*v, i, e, cx))
                        return al.release(v), false;
                return t = v, true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xff, %edx
callq 0x2c880
movzbl %al, %eax
cmpl $0xf6, %eax
jne 0x7e26a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xff, %edx
callq 0x2c8c0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7e30e
movq -0x28(%rbp), %rsi
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x7e330
movq -0x58(%rbp), %rdi
callq 0x7fee0
movq %rax, -0x50(%rbp)
jmp 0x7e28a
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x7e2bc
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6e820
movb %al, -0x59(%rbp)
jmp 0x7e2b3
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x7e2ef
jmp 0x7e2bc
movq -0x38(%rbp), %rsi
leaq -0x29(%rbp), %rdi
callq 0x7ff40
jmp 0x7e2cb
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x7e305
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x7e490
jmp 0x7e319
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x7e490
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x7690
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/container.hxx
// Function: cxon::cnt::pointer_container<boost::container::basic_string<char, std::char_traits<char>, void>, cxon::alc::basic_allocator<boost::container::basic_string<char, std::char_traits<char>, void>, std::allocator<char>>>::resize(unsigned long)
void resize(std::size_t n) {
                    CXON_ASSERT(n != 0 && n >= std::size_t(e_ - f_), "unexpected");
                    auto const p = a_.create(n);
                        std::move(f_, e_, p);
                        a_.release(f_, l_ - f_);
                    e_ = p + (e_ - f_), l_ = p + n, f_ = p;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7e68d
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x18(%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
setae %al
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7e730
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rdi
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x7e7b0
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rdx
callq 0x7e7f0
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq 0x18(%rdx), %rax
movq 0x8(%rdx), %rdx
subq %rdx, %rax
movl $0x18, %esi
cqto
idivq %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rax
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
imulq $0x18, -0x10(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/allocator.hxx
// Function: cxon::alc::basic_allocator<boost::container::basic_string<char, std::char_traits<char>, void>, std::allocator<char>>::create(unsigned long)
T* create(std::size_t n) {
                auto p = tr::allocate(al_, n);
                    if (p) for (T *t = p, *te = t + n; t != te; ++t)
                        construct(t);
                return p;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x7e870
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7e79b
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x7e799
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7e8a0
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x7e774
jmp 0x7e79b
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/allocator.hxx
// Function: cxon::alc::basic_allocator<boost::container::basic_string<char, std::char_traits<char>, void>, std::allocator<char>>::release(boost::container::basic_string<char, std::char_traits<char>, void>*, unsigned long)
void release(T* p, std::size_t n) {
                if (p) {
                    for (T *t = p, *te = t + n; t != te; ++t)
                        destroy(t);
                    tr::deallocate(al_, p, n);
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7e861
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x7e850
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7efe0
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x7e82b
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7f010
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/boost/dynamic_bitset.hxx
// Function: bool cxon::cbor::imp::write_bitset_<cxon::CBOR<cxon::cbor::format_traits>, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>, unsigned char, std::allocator<unsigned char>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>&, boost::dynamic_bitset<unsigned char, std::allocator<unsigned char>> const&, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool write_bitset_(O& o, const boost::dynamic_bitset<B, A>& t, Cx& cx) {
                auto const N = t.size() / 8 + (t.size() % 8 ? 1 : 0);
                if (!cbor::cnt::write_size<X>(o, X::bstr, N + 1, cx))
                    return false;
                if (!bio::poke<X>(o, bio::byte(N * 8 - t.size()), cx))
                    return false;
                bio::byte b = 0;
                for (std::size_t i = t.size(); i != 0; --i) {
                    b |= t[i - 1] << ((i - 1) % 8);
                    if ((i - 1) % 8 == 0) {
                        if (!bio::poke<X>(o, b, cx))
                            return false;
                        b = 0;
                    }
                }
                return true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x130300
shrq $0x3, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x130300
movq %rax, %rsi
movq -0x40(%rbp), %rax
andq $0x7, %rsi
xorl %ecx, %ecx
movl $0x1, %edx
cmpq $0x0, %rsi
cmovnel %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
movq -0x20(%rbp), %rcx
movl $0x40, %esi
callq 0x364b0
testb $0x1, %al
jne 0x132938
movb $0x0, -0x1(%rbp)
jmp 0x132a0a
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x130300
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq %rcx, %rax
movq -0x20(%rbp), %rdx
movzbl %al, %esi
callq 0x36680
testb $0x1, %al
jne 0x13297c
movb $0x0, -0x1(%rbp)
jmp 0x132a0a
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rdi
callq 0x130300
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x132a06
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
subq $0x1, %rsi
callq 0x132a20
andb $0x1, %al
movzbl %al, %eax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
andq $0x7, %rcx
shll %cl, %eax
movl %eax, %ecx
movzbl -0x29(%rbp), %eax
orl %ecx, %eax
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rax
subq $0x1, %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x1329f6
movq -0x10(%rbp), %rdi
movb -0x29(%rbp), %al
movq -0x20(%rbp), %rdx
movzbl %al, %esi
callq 0x36680
testb $0x1, %al
jne 0x1329f2
movb $0x0, -0x1(%rbp)
jmp 0x132a0a
movb $0x0, -0x29(%rbp)
jmp 0x1329f8
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x13298d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: oknenavin[P]cxon/test/../src/cxon/cxon.hxx
// Function: cxon::to_bytes_result<unsigned char*> cxon::interface::to_bytes<cxon::CBOR<cxon::cbor::format_traits>, boost::dynamic_bitset<unsigned char, std::allocator<unsigned char>>, unsigned char*>(unsigned char*, unsigned char*, boost::dynamic_bitset<unsigned char, std::allocator<unsigned char>> const&)
inline auto to_bytes(FI b, FI e, const T& t, NaPa&&... p) -> to_bytes_result<FI> {
                auto cx = make_context<X>(std::forward<NaPa>(p)...);
                    auto c = cnt::make_range_container(b, e);
                    bool const r = write_value<X>(c, t, cx); CXON_ASSERT(!r != !cx.ec, "result discrepant");
                return { cx.ec, c.end() };
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2c550
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x132c00
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x132c30
andb $0x1, %al
movb %al, -0x49(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2c5b0
movq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
leaq -0x48(%rbp), %rdi
callq 0x132c60
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x10(%rdi)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/enum.hxx
// Function: bool cxon::cbor::enm::read_value<cxon::CBOR<cxon::cbor::format_traits>, (anonymous namespace)::Enum1, cxon::cbor::enm::value<(anonymous namespace)::Enum1> const*, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>((anonymous namespace)::Enum1&, cxon::cbor::enm::value<(anonymous namespace)::Enum1> const*, cxon::cbor::enm::value<(anonymous namespace)::Enum1> const*, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool read_value(E& t, V f, V l, II& i, II e, Cx& cx) {
            II const o = i;
            typename value<E>::type alias;
                if (!cxon::read_value<X>(alias, i, e, cx))
                    return false;
            for ( ; f != l && f->alias != alias; ++f)
                ;
            return  (f != l && (t = f->value, true)) ||
                    (bio::rewind(i, o), cx/cbor::read_error::unexpected)
            ;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq -0x44(%rbp), %rdi
callq 0x17a6b0
testb $0x1, %al
jne 0x1551fa
movb $0x0, -0x1(%rbp)
jmp 0x155279
jmp 0x1551fc
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x45(%rbp)
je 0x15521a
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x44(%rbp), %eax
setne %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x155223
jmp 0x155233
jmp 0x155225
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x1551fc
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x155253
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, %al
testb $0x1, %al
movb %al, -0x46(%rbp)
jne 0x155271
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2c9c0
movq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x2c9e0
movb %al, -0x46(%rbp)
movb -0x46(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/enum.hxx
// Function: bool cxon::cbor::enm::write_value<cxon::CBOR<cxon::cbor::format_traits>, (anonymous namespace)::Enum1, cxon::cbor::enm::value<(anonymous namespace)::Enum1> const*, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>&, (anonymous namespace)::Enum1, cxon::cbor::enm::value<(anonymous namespace)::Enum1> const*, cxon::cbor::enm::value<(anonymous namespace)::Enum1> const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool write_value(O& o, E t, V f, V l, Cx& cx) {
            for ( ; f != l && t != f->value; ++f)
                ;
            return f != l ?
                cxon::write_value<X>(o, f->alias, cx) :
                cx/cbor::write_error::argument_invalid
            ;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x29(%rbp)
je 0x1554ca
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1554d3
jmp 0x1554e3
jmp 0x1554d5
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x1554ab
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x155503
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x17b5a0
movb %al, -0x2a(%rbp)
jmp 0x155514
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x36750
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/class.hxx
// Function: bool cxon::cbor::cls::read_fields<cxon::CBOR<cxon::cbor::format_traits>, (anonymous namespace)::Struct1, cxon::cbor::cls::field<int (anonymous namespace)::Struct1::*, cxon::cbor::cls::default_false<(anonymous namespace)::Struct1>>, cxon::cbor::cls::field<(anonymous namespace)::Enum1 (anonymous namespace)::Struct1::*, cxon::cbor::cls::default_false<(anonymous namespace)::Struct1>>, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>((anonymous namespace)::Struct1&, std::tuple<cxon::cbor::cls::field<int (anonymous namespace)::Struct1::*, cxon::cbor::cls::default_false<(anonymous namespace)::Struct1>>, cxon::cbor::cls::field<(anonymous namespace)::Enum1 (anonymous namespace)::Struct1::*, cxon::cbor::cls::default_false<(anonymous namespace)::Struct1>>> const&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool read_fields(T& t, const fields<Fs...>& fs, II& i, II e, Cx& cx) {
            std::size_t n;
            if (cbor::cnt::read_size_le<X>(n, sizeof...(Fs), i, e, cx)) {
                int st[sizeof...(Fs)] = {0};
                for (char id[bio::ids_len_max::constant<napa_type<Cx>>(64)]; n; --n) {
                    II const o = i;
                        if (!read_value<X>(id, i, e, cx))
                            return false;
                        if (!imp::read_field_<X>(t, id, fs, st, i, e, cx))
                            return cx && (bio::rewind(i, o), cx/cbor::read_error::unexpected);
                }
            }
            return n == 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0x2d920
testb $0x1, %al
jne 0x155fc2
jmp 0x156096
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x7230
cmpq $0x0, -0x38(%rbp)
je 0x156094
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x80(%rbp), %rdi
callq 0x18f120
testb $0x1, %al
jne 0x15600d
movb $0x0, -0x1(%rbp)
jmp 0x1560a3
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
leaq -0x40(%rbp), %rcx
movq %rax, (%rsp)
callq 0x1560c0
testb $0x1, %al
jne 0x156081
movq -0x30(%rbp), %rdi
callq 0x18f160
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x89(%rbp)
jne 0x156050
jmp 0x156074
movq -0x20(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x2c9c0
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x2c9e0
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1560a3
jmp 0x156083
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x155fd2
jmp 0x156096
cmpq $0x0, -0x38(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/class.hxx
// Function: bool cxon::cbor::cls::write_fields<cxon::CBOR<cxon::cbor::format_traits>, (anonymous namespace)::Struct1, cxon::cbor::cls::field<int (anonymous namespace)::Struct1::*, cxon::cbor::cls::default_false<(anonymous namespace)::Struct1>>, cxon::cbor::cls::field<(anonymous namespace)::Enum1 (anonymous namespace)::Struct1::*, cxon::cbor::cls::default_false<(anonymous namespace)::Struct1>>, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>&, (anonymous namespace)::Struct1 const&, std::tuple<cxon::cbor::cls::field<int (anonymous namespace)::Struct1::*, cxon::cbor::cls::default_false<(anonymous namespace)::Struct1>>, cxon::cbor::cls::field<(anonymous namespace)::Enum1 (anonymous namespace)::Struct1::*, cxon::cbor::cls::default_false<(anonymous namespace)::Struct1>>> const&, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool write_fields(O& o, const T& t, const fields<Fs...>& fs, Cx& cx) {
            int st[sizeof...(Fs)] = {0};
                auto const ct = imp::field_state_<sizeof...(Fs)>(t, fs, st);
            return  cbor::cnt::write_size<X>(o, X::map, ct, cx) &&
                    imp::write_fields_<X>(o, t, fs, st, cx)
            ;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x7230
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x1567f0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %edx
movq -0x20(%rbp), %rcx
movl $0xa0, %esi
callq 0x364b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x2d(%rbp)
jne 0x1567c1
jmp 0x1567dd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r8
leaq -0x28(%rbp), %rcx
callq 0x156820
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/sink.hxx
// Function: bool cxon::cbor::imp::sink_reader_<cxon::CBOR<cxon::cbor::format_traits>, cxon::cbor::sink<void> const>::read_element<unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>, cxon::CBOR<cxon::cbor::format_traits>>(cxon::cbor::sink<void> const&, unsigned char, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
static bool read_element(S& s, bio::byte m, II& i, II e, Cx& cx) {
                    switch (m) {
                        case Y::map:    return  sink_read<Y>(s, i, e, cx) &&
                                                sink_read<Y>(s, i, e, cx);
                        case Y::arr:    return  sink_read<Y>(s, i, e, cx);
                        default:        return  CXON_ASSERT(0, "unexpected"), false; // LCOV_EXCL_LINE
                    }
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movzbl -0x11(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x80, %eax
je 0x18faff
jmp 0x18faae
movl -0x34(%rbp), %eax
subl $0xa0, %eax
jne 0x18fb1b
jmp 0x18faba
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x18f230
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x35(%rbp)
jne 0x18fadd
jmp 0x18faf5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x18f230
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x18fb1f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x18f230
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x18fb1f
movb $0x0, -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/cbor/common/sink.hxx
// Function: bool cxon::cbor::sink_write<cxon::CBOR<cxon::cbor::format_traits>, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>, cxon::cbor::sink<std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>&, cxon::cbor::sink<std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>> const&, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool sink_write(O& o, const S& s, Cx& cx) {
            for (auto e : s.value) 
                if (!bio::poke<X>(o, e, cx))
                    return false;
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x34a10
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x34b30
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x191340
testb $0x1, %al
jne 0x1912f9
jmp 0x191331
leaq -0x30(%rbp), %rdi
callq 0x191380
movb (%rax), %al
movb %al, -0x39(%rbp)
movq -0x10(%rbp), %rdi
movb -0x39(%rbp), %al
movq -0x20(%rbp), %rdx
movzbl %al, %esi
callq 0x36680
testb $0x1, %al
jne 0x191324
movb $0x0, -0x1(%rbp)
jmp 0x191335
jmp 0x191326
leaq -0x30(%rbp), %rdi
callq 0x34aa0
jmp 0x1912e6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/bio/io.hxx
// Function: bool cxon::bio::imp::put_<std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>>(std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>&, float)
inline bool put_(O& o, float t) {
                union { unsigned long i; float f; } u; u.f = t;
                byte bs[sizeof(float)];
                    bs[0] = byte(u.i >> 24), bs[1] = byte(u.i >> 16),
                    bs[2] = byte(u.i >>  8), bs[3] = byte(u.i >>  0);
                return poke_(o, bs, sizeof(bs));
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x18(%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 -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0x1360d0
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/src/cbor/cbor.core-main.cxx
// Function: main
int main() {
    using cxon::test::suite;
    for (auto& c : suite::info::get()) {
        for (auto s : c.second.suites)
            s->test();
        std::fprintf(stdout, "cxon/cbor%-12s: %u of %4u failed\n", c.first.c_str(), suite::info::errors(c.first.c_str()), suite::info::count(c.first.c_str())); std::fflush(stdout);
    }
    return suite::info::errors();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
callq 0x29990
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b08a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a230
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1b08d0
testb $0x1, %al
jne 0x1ae128
jmp 0x1ae20d
leaq -0x18(%rbp), %rdi
callq 0x2a2b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2b680
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2b510
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1b0900
testb $0x1, %al
jne 0x1ae16e
jmp 0x1ae192
leaq -0x38(%rbp), %rdi
callq 0x1b0940
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq -0x38(%rbp), %rdi
callq 0x1b0960
jmp 0x1ae15b
movq 0x13dde7(%rip), %rax    # 0x2ebf80
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7160
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7160
movq %rax, %rdi
callq 0x2bc70
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7160
movq %rax, %rdi
callq 0x2baa0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
movl -0x4c(%rbp), %ecx
movl (%rax), %r8d
leaq 0x891f7(%rip), %rsi     # 0x2373e0
movb $0x0, %al
callq 0x7560
movq 0x13dd89(%rip), %rax    # 0x2ebf80
movq (%rax), %rdi
callq 0x7490
leaq -0x18(%rbp), %rdi
callq 0x2b1b0
jmp 0x1ae112
callq 0x1b0980
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/bitset.hxx
// Function: bool cxon::cbor::imp::write_bitset_<cxon::CBOR<cxon::cbor::format_traits>, std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>, 32ul, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>&, std::bitset<32ul> const&, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline bool write_bitset_(O& o, const std::bitset<N>& t, Cx& cx) {
                auto const M = N / 8 + (N % 8 ? 1 : 0);
                if (!cbor::cnt::write_size<X>(o, X::bstr, M + 1, cx))
                    return false;
                if (!bio::poke<X>(o, bio::byte(M * 8 - N), cx))
                    return false;
                bio::byte b = 0;
                for (std::size_t i = N; i != 0; --i) {
                    b |= t[i - 1] << ((i - 1) % 8);
                    if ((i - 1) % 8 == 0) {
                        if (!bio::poke<X>(o, b, cx))
                            return false;
                        b = 0;
                    }
                }
                return true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x4, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl $0x40, %esi
movl $0x5, %edx
callq 0x364b0
testb $0x1, %al
jne 0x1ebd80
movb $0x0, -0x1(%rbp)
jmp 0x1ebe25
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x36680
testb $0x1, %al
jne 0x1ebd9c
movb $0x0, -0x1(%rbp)
jmp 0x1ebe25
movb $0x0, -0x29(%rbp)
movq $0x20, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1ebe21
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
subq $0x1, %rsi
callq 0x1ebe30
andb $0x1, %al
movzbl %al, %eax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
andq $0x7, %rcx
shll %cl, %eax
movl %eax, %ecx
movzbl -0x29(%rbp), %eax
orl %ecx, %eax
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rax
subq $0x1, %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x1ebe11
movq -0x10(%rbp), %rdi
movb -0x29(%rbp), %al
movq -0x20(%rbp), %rdx
movzbl %al, %esi
callq 0x36680
testb $0x1, %al
jne 0x1ebe0d
movb $0x0, -0x1(%rbp)
jmp 0x1ebe25
movb $0x0, -0x29(%rbp)
jmp 0x1ebe13
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1ebda8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/bitset.hxx
// Function: std::enable_if<1ul < 8, bool>::type cxon::cbor::imp::read_bitset_<cxon::CBOR<cxon::cbor::format_traits>, 1ul, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>>(std::bitset<1ul>&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
inline auto read_bitset_(std::bitset<N>& t, II& i, II e, Cx& cx) -> enable_if_t<N  < 8, bool> {
                switch (bio::peek(i, e) & X::mjr) {
                    case X::bstr: {
                        auto const M = N / 8 + std::size_t(!!(N % 8));
                        if (!cbor::cnt::read_size_eq<X>(M + 1, i, e, cx))
                            return false;
                        if (i == e)
                            return cx/cbor::read_error::unexpected;
                        if (M * 8 - bio::byte(*i) != N)
                            return cx/cbor::read_error::size_invalid;
                        if (++i == e)
                            return cx/cbor::read_error::unexpected;
                        return t |= std::bitset<N> {*i}, ++i, true;
                    }
                    default:
                        return cx/cbor::read_error::unexpected;
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xff, %edx
callq 0x2c880
movzbl %al, %eax
andl $0xe0, %eax
subl $0x40, %eax
jne 0x1ec26b
jmp 0x1ec18d
movq $0x1, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x2, %edi
callq 0x133920
testb $0x1, %al
jne 0x1ec1b8
movb $0x0, -0x1(%rbp)
jmp 0x1ec27e
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x1ec1dd
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x2c9e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1ec27e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movl %eax, %ecx
movl $0x8, %eax
subq %rcx, %rax
cmpq $0x1, %rax
je 0x1ec20c
movq -0x28(%rbp), %rdi
movl $0x6, %esi
callq 0x2c9e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1ec27e
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
addq $0x1, %rax
movq %rax, (%rcx)
cmpq -0x20(%rbp), %rax
jne 0x1ec235
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x2c9e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1ec27e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x1ea7b0
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1ec290
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1ec27e
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x2c9e0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/complex.hxx
// Function: bool cxon::read<cxon::CBOR<cxon::cbor::format_traits>, std::complex<float>, void>::value<unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>, cxon::CBOR<cxon::cbor::format_traits>>(std::complex<float>&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
static bool value(std::complex<T>& t, II& i, II e, Cx& cx) {
                    T rl, mg;
                    return  cbor::tag::read<Y>(i, e, cx) &&
                            cbor::cnt::read_size_eq<Y>(2, i, e, cx) &&
                                read_value<Y>(rl, i, e, cx) &&
                                read_value<Y>(mg, i, e, cx) &&
                            (t.real(rl), t.imag(mg), true)
                    ;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x12fe50
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x1f5f4a
jmp 0x1f5fd5
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x2, %edi
callq 0x133920
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x1f5f6e
jmp 0x1f5fd5
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %rdi
callq 0x1ad340
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x1f5f91
jmp 0x1f5fd5
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %rdi
callq 0x1ad340
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x1f5fb4
jmp 0x1f5fd5
movq -0x8(%rbp), %rdi
movss -0x24(%rbp), %xmm0
callq 0x1f5fe0
movq -0x8(%rbp), %rdi
movss -0x28(%rbp), %xmm0
callq 0x1f6000
movb $0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: oknenavin[P]cxon/test/src/cbor/../test.hxx
// Function: cxon::test::match<std::priority_queue<int, std::vector<int, std::allocator<int>>, std::less<int>>>::values(std::priority_queue<int, std::vector<int, std::allocator<int>>, std::less<int>> const&, std::priority_queue<int, std::vector<int, std::allocator<int>>, std::less<int>> const&)
static bool values(const std::priority_queue<T>& t0, const std::priority_queue<T>& t1) {
                auto r0 = t0, r1 = t1;
                    while (!r0.empty() && !r1.empty()) {
                        if (!match<T>::values(r0.top(), r1.top())) return false;
                        r0.pop(); r1.pop();
                    }
                return r0.empty() && r1.empty();
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2160d0
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x2160d0
jmp 0x213f6f
jmp 0x213f71
leaq -0x38(%rbp), %rdi
callq 0x216100
movb %al, -0x69(%rbp)
jmp 0x213f7f
movb -0x69(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x6a(%rbp)
jne 0x213fa4
jmp 0x213f8e
leaq -0x58(%rbp), %rdi
callq 0x216100
movb %al, -0x6b(%rbp)
jmp 0x213f9c
movb -0x6b(%rbp), %al
xorb $-0x1, %al
movb %al, -0x6a(%rbp)
movb -0x6a(%rbp), %al
testb $0x1, %al
jne 0x213fb0
jmp 0x214045
leaq -0x38(%rbp), %rdi
callq 0x216120
movq %rax, -0x78(%rbp)
jmp 0x213fbf
leaq -0x58(%rbp), %rdi
callq 0x216120
movq %rax, -0x80(%rbp)
jmp 0x213fce
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x17c780
movb %al, -0x81(%rbp)
jmp 0x213fe3
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x21402a
jmp 0x213fef
movb $0x0, -0x1(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x21409c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2140bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x213d50
jmp 0x2140bc
leaq -0x38(%rbp), %rdi
callq 0x216140
jmp 0x214035
leaq -0x58(%rbp), %rdi
callq 0x216140
jmp 0x214040
jmp 0x213f71
leaq -0x38(%rbp), %rdi
callq 0x216100
movb %al, -0x82(%rbp)
jmp 0x214056
movb -0x82(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x83(%rbp)
jne 0x21406b
jmp 0x21408a
leaq -0x58(%rbp), %rdi
callq 0x216100
movb %al, -0x84(%rbp)
jmp 0x21407c
movb -0x84(%rbp), %al
movb %al, -0x83(%rbp)
jmp 0x21408a
movb -0x83(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x68(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x213d50
leaq -0x38(%rbp), %rdi
callq 0x213d50
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x213d50
movq -0x60(%rbp), %rdi
callq 0x7690
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/utility.hxx
// Function: bool cxon::read<cxon::CBOR<cxon::cbor::format_traits>, std::pair<int, float>, void>::value<unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>, cxon::CBOR<cxon::cbor::format_traits>>(std::pair<int, float>&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
static bool value(std::pair<F, S>& t, II& i, II e, Cx& cx) {
                    return  cbor::tag::read<Y>(i, e, cx) &&
                            cbor::cnt::read_size_eq<Y>(2, i, e, cx) &&
                                read_value<Y>(t.first, i, e, cx) &&
                                read_value<Y>(t.second, i, e, cx)
                    ;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x12fe50
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x21b217
jmp 0x21b27a
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x2, %edi
callq 0x133920
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x21b23b
jmp 0x21b27a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x33910
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x21b25e
jmp 0x21b27a
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1ad340
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop