LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*, 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, 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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
andl $0x1f, %esi
leal -0x1c(%rsi), %eax
cmpl $0x3, %eax
jae 0x180d9
callq 0x16fd8
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %r12
cmpl $0x1f, %esi
jne 0x18154
movq (%r14), %rcx
cmpq %r15, %rcx
je 0x180f6
leaq 0x1(%rcx), %rax
movq %rax, (%r14)
movq %rcx, 0x8(%rsp)
movabsq $0x3fffffffffffffff, %r13 # imm = 0x3FFFFFFFFFFFFFFF
xorl %ebp, %ebp
movq (%r14), %rax
cmpq %r13, 0x8(%r12)
jae 0x181e8
cmpq %r15, %rax
je 0x18123
cmpb $-0x1, (%rax)
je 0x181e8
movq %r12, %rdi
xorl %esi, %esi
callq 0x4200
movq (%r12), %rax
movq 0x8(%r12), %rcx
leaq (%rax,%rcx), %rdi
decq %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x18378
testb %al, %al
jne 0x18107
jmp 0x180c8
movq 0x8(%r12), %r13
movq (%r14), %rbp
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x177f5
testb %al, %al
je 0x18206
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
subq %r13, %rax
movq 0x10(%rsp), %r13
cmpq %rax, %r13
ja 0x18215
movq %r12, %rdi
movq %r13, %rsi
callq 0x4360
testq %r13, %r13
je 0x1821d
decq %r13
movq %r12, %rdi
xorl %esi, %esi
callq 0x4200
movq (%r12), %rax
movq 0x8(%r12), %rcx
leaq (%rax,%rcx), %rdi
decq %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x18378
movl %eax, %ebp
addq $-0x1, %r13
setb %al
testb %bpl, %bpl
je 0x180c8
testb %al, %al
jne 0x181a5
jmp 0x180c8
cmpq %r15, %rax
je 0x181f9
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
cmpb $-0x1, (%rax)
je 0x1821d
movq 0x8(%rsp), %rax
movq %rax, (%r14)
jmp 0x180b7
callq 0x16fd8
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbp, (%r14)
jmp 0x180b7
movb $0x1, %bpl
jmp 0x180c8
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rbp
movq 0x8(%rdi), %r13
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x177f5
testb %al, %al
je 0x177be
subq %rbp, %r13
sarq $0x3, %r13
movabsq $0x3333333333333333, %rax # imm = 0x3333333333333333
imulq %r13, %rax
movabsq $0x333333333333333, %rcx # imm = 0x333333333333333
addq %rax, %rcx
movq 0x10(%rsp), %r13
cmpq %rcx, %r13
ja 0x177cd
movq 0x8(%r12), %rax
subq (%r12), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0x178d6
movq (%r14), %rdx
subq %rdx, %r15
cmpq %r13, %r15
movq %r13, %rbp
cmovbq %r15, %rbp
leaq (%rdx,%rbp), %rcx
movq 0x8(%r12), %rsi
movq %r12, %rdi
callq 0x179c0
addq %rbp, (%r14)
movb $0x1, %al
cmpq %r13, %r15
jae 0x177e6
callq 0x16fd8
movl $0x1, (%rbx)
jmp 0x177e0
callq 0x16fd8
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rax
movq %rax, (%r14)
callq 0x16fd8
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::operator=(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&&)
basic_node& operator =(basic_node&& o)
                noexcept(value::is_nothrow_move_assignable<basic_node>::value)
            {
                switch (o.kind_) {
#                   define CXON_JSON_TYPE_DEF(T)    case node_kind::T: return value::move_assign<T>(*this, std::move(o))
                        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);
                        CXON_JSON_TYPE_DEF(null);
#                   undef CXON_JSON_TYPE_DEF
                }
                return *this; // LCOV_EXCL_LINE
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rsi), %eax
cmpq $0x7, %rax
ja 0x17d6d
movq %rsi, %r14
leaq 0x2c776(%rip), %rcx     # 0x44420
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17d78
cmpl $0x4, 0x20(%rbx)
je 0x17cda
movq %rbx, %rdi
callq 0x13dae
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
jmp 0x17d6d
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17e10
cmpl $0x3, 0x20(%rbx)
je 0x17d0c
movq %rbx, %rdi
callq 0x13dae
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
jmp 0x17d6d
cmpl $0x7, 0x20(%rbx)
je 0x17d2c
movq %rbx, %rdi
callq 0x13dae
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq $0x0, (%rbx)
jmp 0x17d6d
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17dc4
cmpl $0x5, 0x20(%rbx)
jne 0x17ccb
jmp 0x17cda
cmpl $0x6, 0x20(%rbx)
je 0x17d68
movq %rbx, %rdi
callq 0x13dae
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movb (%r14), %al
movb %al, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<is_dynamic_type<cxon::cbor::taggle<unsigned long long, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<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<cxon::cbor::taggle<unsigned long long, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<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
                        -> 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 0x21b8c
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x18f38
movq (%rbx), %rdi
callq 0x4220
jmp 0x21b9b
movq %rbx, %rdi
callq 0x18f38
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
movl $0xb, 0x20(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/common/node-value.hxx
// Function: std::enable_if<!is_dynamic_type<std::__cxx11::basic_string<char, std::char_traits<char>, 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::__cxx11::basic_string<char, std::char_traits<char>, 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(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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl 0x20(%rsi), %eax
jne 0x17e4c
movq (%rbx), %rdi
leaq 0x10(%rbx), %r15
cmpq %r15, %rdi
je 0x17e34
callq 0x4220
movq %r15, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rcx
leaq 0x8(%r14), %rax
cmpq %rcx, %rdx
je 0x17e8a
movq %rdx, (%rbx)
jmp 0x17e75
movq %rbx, %rdi
callq 0x13dae
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%r14), %rsi
leaq 0x10(%r14), %rcx
leaq 0x8(%r14), %rax
cmpq %rcx, %rsi
je 0x17e93
movq %rsi, (%rbx)
movq 0x8(%r14), %rdx
movq %rdx, 0x8(%rbx)
movq 0x10(%r14), %rdx
movq %rdx, 0x10(%rbx)
movq %rcx, (%r14)
jmp 0x17ea4
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x17e99
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq (%r14), %rcx
movq $0x0, (%rax)
movb $0x0, (%rcx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/cbor/common/container.hxx
// Function: bool cxon::cbor::cnt::imp::read_array_b_<cxon::CBOR<cxon::cbor::format_traits>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*, 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, 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_(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 read_array_b_var_<X>(t, i, e, cx);
                    default:                            return read_array_b_fix_<X>(t, i, e, cx);
                }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
andl $0x1f, %esi
leal -0x1c(%rsi), %eax
cmpl $0x3, %eax
jae 0x17fd4
callq 0x16fd8
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %r12
cmpl $0x1f, %esi
jne 0x18001
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18225
movq 0x8(%r12), %rbp
movq (%r14), %r13
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x177f5
testb %al, %al
je 0x18084
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
subq %rbp, %rax
movq (%rsp), %rbp
cmpq %rax, %rbp
ja 0x18093
movq 0x8(%r12), %rsi
addq %rbp, %rsi
movq %r12, %rdi
callq 0x4360
movq (%r14), %rcx
subq %rcx, %r15
cmpq %rbp, %r15
movq %rbp, %r13
cmovbq %r15, %r13
movq 0x8(%r12), %rsi
movq %r12, %rdi
xorl %edx, %edx
movq %r13, %r8
callq 0x4270
addq %r13, (%r14)
movb $0x1, %al
cmpq %rbp, %r15
jae 0x17fc5
callq 0x16fd8
movl $0x1, (%rbx)
jmp 0x17fbf
callq 0x16fd8
movl $0x6, (%rbx)
movq %rax, 0x8(%rbx)
movq %r13, (%r14)
jmp 0x17fb4
// File: /workspace/github_cpp_makefile_star2_O3/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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*, 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>>&, 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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r13
movq (%rsi), %rbx
cmpq %rdx, %rbx
je 0x1825b
leaq 0x1(%rbx), %rax
movq %rax, (%r14)
movb (%rbx), %cl
movb %cl, 0x7(%rsp)
movq %rax, %rbx
jmp 0x18260
movb $-0x1, 0x7(%rsp)
cmpq %rbp, %rbx
jne 0x18269
xorl %eax, %eax
jmp 0x18273
movb (%rbx), %al
cmpb $-0x1, %al
je 0x18309
xorb 0x7(%rsp), %al
cmpb $0x20, %al
jae 0x18318
movq 0x8(%r13), %r12
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq 0x8(%rsp), %rcx
callq 0x177f5
testb %al, %al
je 0x1832a
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
subq %r12, %rax
movq 0x10(%rsp), %r12
cmpq %rax, %r12
ja 0x1833e
movq 0x8(%r13), %rsi
addq %r12, %rsi
movq %r13, %rdi
callq 0x4360
movq (%r14), %rcx
movq %rbp, %r15
subq %rcx, %r15
cmpq %r12, %r15
movq %r12, %rbx
cmovbq %r15, %rbx
movq 0x8(%r13), %rsi
movq %r13, %rdi
xorl %edx, %edx
movq %rbx, %r8
callq 0x4270
addq (%r14), %rbx
movq %rbx, (%r14)
cmpq %r12, %r15
jb 0x18353
cmpq %rbp, %rbx
jne 0x18269
xorl %eax, %eax
jmp 0x1826b
movb $0x1, %al
cmpq %rbp, %rbx
je 0x18369
incq %rbx
movq %rbx, (%r14)
jmp 0x18369
callq 0x16fd8
movq 0x8(%rsp), %rcx
movl $0x7, (%rcx)
jmp 0x18363
callq 0x16fd8
movq 0x8(%rsp), %rcx
movl $0x6, (%rcx)
movq %rax, 0x8(%rcx)
movq %rbx, (%r14)
callq 0x16fd8
movq 0x8(%rsp), %rcx
movl $0x6, (%rcx)
jmp 0x18363
callq 0x16fd8
movq 0x8(%rsp), %rcx
movl $0x1, (%rcx)
movq %rax, 0x8(%rcx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/cbor/fundamental.hxx
// Function: bool cxon::cbor::imp::read_integral_<cxon::cbor::format_traits, char, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(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_integral_(T& t, II& i, II e, Cx& cx) {
                switch (bio::peek(i, e) & X::mjr) {
                    case 0x00:  return read_unsigned_<X>(t, i, e, cx);
                    case 0x20:  return read_signed_<X>(t, i, e, cx);
                    default:    return cx/cbor::read_error::integer_invalid;
                }
            }

// Assembly:
pushq %rbx
movq %rcx, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x18498
movzbl (%rax), %ecx
andl $-0x20, %ecx
cmpl $0x20, %ecx
je 0x18456
testl %ecx, %ecx
jne 0x18498
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
movzbl (%rax), %r8d
andl $0x1f, %r8d
cmpl $0x18, %r8d
jb 0x1846e
movl %r8d, %r9d
addl $-0x18, %r9d
cmpl $0x4, %r9d
jae 0x18495
cmpb $0x18, %r8b
setne %r8b
cmpq %rdx, %rcx
sete %dl
orb %r8b, %dl
jne 0x18495
movb (%rcx), %al
movb %al, (%rdi)
incq (%rsi)
jmp 0x18471
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
movzbl (%rax), %r8d
andl $0x1f, %r8d
cmpl $0x18, %r8d
jae 0x18475
notb %r8b
movb %r8b, (%rdi)
movb $0x1, %al
jmp 0x184a9
movl %r8d, %r9d
addl $-0x1c, %r9d
cmpl $0x4, %r9d
jb 0x18495
cmpb $0x18, %r8b
setne %r8b
cmpq %rdx, %rcx
sete %dl
orb %r8b, %dl
je 0x184ab
movq %rax, (%rsi)
callq 0x16fd8
movl $0x4, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
movb (%rcx), %al
movb %al, (%rdi)
incq (%rsi)
movb (%rdi), %r8b
jmp 0x1846b
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x7, %eax
leaq 0x30(%rsp), %rdi
movl %eax, 0x20(%rdi)
movl %eax, 0x28(%rsp)
callq 0x16b6e
testb %al, %al
je 0x186b0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x13182
addq $0x28, %rax
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x16b6e
movl %eax, %ebx
jmp 0x186b2
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x13dae
leaq 0x30(%rsp), %rdi
callq 0x13dae
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13dae
leaq 0x30(%rsp), %rdi
callq 0x13dae
movq %rbx, %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rcx, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x1871d
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
movb (%rax), %cl
movl %ecx, %edx
andb $-0x2, %dl
cmpb $-0xc, %dl
jne 0x1871d
cmpb $-0xc, %cl
setne (%rdi)
movb $0x1, %al
jmp 0x18731
movq %rax, (%rsi)
callq 0x16fd8
movl $0x2, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rcx, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x189a8
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
movzbl (%rax), %r8d
movl %r8d, %r9d
notl %r9d
testb $-0x20, %r9b
jne 0x189a8
andl $0x1f, %r8d
movl $0xfffff, %r9d          # imm = 0xFFFFF
btl %r8d, %r9d
jae 0x1899c
movb %r8b, (%rdi)
movb $0x1, %al
jmp 0x189bc
movl $0xfef00000, %r9d       # imm = 0xFEF00000
btl %r8d, %r9d
jae 0x189be
movq %rax, (%rsi)
callq 0x16fd8
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
cmpq %rdx, %rcx
je 0x189a8
movb (%rcx), %al
movb %al, (%rdi)
incq (%rsi)
jmp 0x18998
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl 0x20(%rdi), %ecx
cmpl 0x20(%rsi), %ecx
jne 0x18aa5
cmpl $0x7, %ecx
ja 0x18aa5
movb $0x1, %al
movl %ecx, %ecx
leaq 0x2ba4f(%rip), %rdx     # 0x44440
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x18a7a
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x18aa7
movb (%rdi), %al
cmpb (%rsi), %al
jmp 0x18a7a
movq (%rdi), %rcx
movq (%rsi), %rdx
movq (%rcx), %rbx
movq 0x8(%rcx), %r15
movq %r15, %rcx
subq %rbx, %rcx
movq (%rdx), %r14
movq 0x8(%rdx), %rdx
subq %r14, %rdx
cmpq %rdx, %rcx
jne 0x18aa5
cmpq %r15, %rbx
je 0x18aa7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x189cc
testb %al, %al
je 0x18aa7
addq $0x28, %rbx
addq $0x28, %r14
jmp 0x18a40
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x18aa5
testq %rdx, %rdx
je 0x18aa7
movq (%rsi), %rsi
movq (%rdi), %rdi
callq 0x4240
testl %eax, %eax
sete %al
jmp 0x18aa7
movq (%rdi), %rax
movq (%rsi), %rcx
movq 0x28(%rax), %rdx
cmpq 0x28(%rcx), %rdx
jne 0x18aa5
movq 0x18(%rax), %rdi
addq $0x8, %rax
movq 0x18(%rcx), %rdx
movq %rax, %rsi
callq 0x18ab6
jmp 0x18aa7
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x8504
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18f95
leaq 0x2b52c(%rip), %rcx     # 0x44478
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x18f9e
jmp 0x18f8d
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
jne 0x18f90
jmp 0x18f95
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x18f38
jmp 0x18f8d
movq (%rbx), %rdi
testq %rdi, %rdi
jne 0x18f90
jmp 0x18f95
movq (%rbx), %rdi
callq 0x82d0
movq (%rbx), %rdi
callq 0x4220
movl $0xb, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lib/node.json.hxx
// Function: std::enable_if<cxon::JSON<cxon::json::format_traits>::quote_unquoted_keys, bool>::type cxon::cio::key::read<cxon::JSON<cxon::json::format_traits>, cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>>::key<std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>, cxon::JSON<cxon::json::format_traits>>(cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>&, std::istreambuf_iterator<char, std::char_traits<char>>&, std::istreambuf_iterator<char, std::char_traits<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static auto key(cbor::basic_node<Tr>& t, II& i, II e, Cx& cx)
                            -> enable_if_t< Y::quote_unquoted_keys, bool>
                        {
#                           define CXON_IMBUE(T) t.template imbue<typename cbor::basic_node<Tr>::T>()
                                CXON_IF_CONSTEXPR (Y::unquote_quoted_keys) {
                                    if (!cio::consume<Y>(i, e, cx))
                                        return false;
                                    switch (cio::peek(i, e)) {
                                        case '{': { CXON_NODE_RG();     return read_key_(t, CXON_IMBUE(map),    i, e, cx); }
                                        case '[': { CXON_NODE_RG();     return read_key_(t, CXON_IMBUE(array),  i, e, cx); }
                                    }
                                }
                                return cio::key::read_key<Y>(CXON_IMBUE(text), i, e, cx);
#                           undef CXON_IMBUE
                        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpl $0x4, 0x20(%rdi)
je 0x199bf
movq %r12, %rdi
callq 0x18f38
movl $0x4, 0x20(%r12)
leaq 0x10(%r12), %rax
movq %rax, (%r12)
movq $0x0, 0x8(%r12)
movb $0x0, 0x10(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x199da
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a9df
leaq 0x29b1f(%rip), %rcx     # 0x4448c
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
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq (%rsi), %rdx
leaq 0x10(%rsi), %rax
cmpq %rax, %rdx
je 0x1a9e9
movq %rdx, (%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rdi)
movq %rax, (%rsi)
jmp 0x1a9fa
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
retq
movq $0x0, (%rdi)
retq
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq (%rsi), %rax
movq $0x0, 0x8(%rsi)
movb $0x0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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::vector<unsigned char, std::allocator<unsigned char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char, unsigned long, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
inline bool write_size(O& o, bio::byte m, std::size_t s, Cx& cx) {
            unsigned const p = cbor::imp::power_(s);
            return s > 0x17 ?
                bio::poke<X>(o, bio::byte(m + 0x18 + p), cx) && bio::poke<X>(o, s, 1 << p, cx) :
                bio::poke<X>(o, bio::byte(m + s), cx)
            ;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq %rdx, %r15
shrq $0x20, %r15
movl $0x3, %ebp
jne 0x3b00e
movl $0x2, %ebp
cmpq $0xffff, %rdx           # imm = 0xFFFF
ja 0x3b00e
xorl %ebp, %ebp
cmpq $0x100, %rdx            # imm = 0x100
setae %al
cmpq $0x18, %rdx
jb 0x3b10f
movb %al, %bpl
movq %rdx, %r12
movzbl %sil, %eax
addl %ebp, %eax
addb $0x18, %al
movb %al, 0x5(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3b02f
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3b03c
leaq 0x5(%rsp), %rdx
movq %rbx, %rdi
callq 0x3b138
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
leal -0x1(%rax), %r8d
cmpl $0x7, %r8d
ja 0x3b0fb
leaq 0xa88a(%rip), %rdx      # 0x458e4
movslq (%rdx,%r8,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movq %r12, %rdx
shrq $0x38, %rdx
movb %dl, 0x8(%rsp)
movq %r12, %rdx
shrq $0x30, %rdx
movb %dl, 0x9(%rsp)
movq %r12, %rdx
shrq $0x28, %rdx
movb %dl, 0xa(%rsp)
movb %r15b, 0xb(%rsp)
movq %r12, %rdi
movl %edi, %edx
shrl $0x18, %edx
leal -0x4(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
movl %edi, %edx
shrl $0x10, %edx
leal -0x3(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
leal -0x2(%rax), %edx
movq %r12, %rcx
movb %ch, 0x8(%rsp,%rdx)
movb %r12b, 0x8(%rsp,%r8)
movl %eax, %r15d
xorl %r12d, %r12d
leaq 0x6(%rsp), %r14
movb 0x8(%rsp,%r12), %al
movb %al, 0x6(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3b0d9
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3b0e4
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3b138
incq %r12
cmpq %r12, %r15
jne 0x3b0be
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c1ae
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
xorl %eax, %eax
jmp 0x3b0ee
addb %sil, %dl
movb %dl, 0x7(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3b128
movb %dl, (%rsi)
incq 0x8(%rbx)
jmp 0x3b0ec
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3b138
jmp 0x3b0ec
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x2, %edx
je 0x1c21f
cmpl $0x1, %edx
je 0x1c20f
testl %edx, %edx
jne 0x1c22f
leaq 0x28757(%rip), %rsi     # 0x4495d
leaq 0x28758(%rip), %rdx     # 0x44965
jmp 0x1c23d
leaq 0x28921(%rip), %rsi     # 0x44b37
leaq 0x28932(%rip), %rdx     # 0x44b4f
jmp 0x1c23d
leaq 0x2892a(%rip), %rsi     # 0x44b50
leaq 0x28933(%rip), %rdx     # 0x44b60
jmp 0x1c23d
leaq 0x287db(%rip), %rsi     # 0x44a11
leaq 0x287e1(%rip), %rdx     # 0x44a1e
movq %rbx, %rdi
callq 0x98ac
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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::vector<unsigned char, std::allocator<unsigned char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<unsigned char, std::allocator<unsigned 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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rax
sarq $0x3f, %rax
xorq %rsi, %rax
shrq $0x3a, %rsi
andb $0x20, %sil
movq %rax, %r15
shrq $0x20, %r15
movl $0x3, %ebp
jne 0x3b45f
movl $0x2, %ebp
cmpq $0xffff, %rax           # imm = 0xFFFF
ja 0x3b465
xorl %ebp, %ebp
cmpq $0x100, %rax            # imm = 0x100
setae %bpl
cmpq $0x18, %rax
jl 0x3b487
movq %rax, %r12
addb %bpl, %sil
addb $0x18, %sil
movb %sil, 0x5(%rsp)
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x3b4a9
movb %sil, (%rax)
incq 0x8(%rbx)
jmp 0x3b4b9
addb %al, %sil
movb %sil, 0x7(%rsp)
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x3b56b
movb %sil, (%rax)
incq 0x8(%rbx)
jmp 0x3b57b
leaq 0x5(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b138
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
leal -0x1(%rax), %r8d
cmpl $0x7, %r8d
ja 0x3b58a
leaq 0xa42d(%rip), %rdx      # 0x45904
movslq (%rdx,%r8,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movq %r12, %rdx
shrq $0x38, %rdx
movb %dl, 0x8(%rsp)
movq %r12, %rdx
shrq $0x30, %rdx
movb %dl, 0x9(%rsp)
movq %r12, %rdx
shrq $0x28, %rdx
movb %dl, 0xa(%rsp)
movb %r15b, 0xb(%rsp)
movq %r12, %rdi
movl %edi, %edx
shrl $0x18, %edx
leal -0x4(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
movl %edi, %edx
shrl $0x10, %edx
leal -0x3(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
leal -0x2(%rax), %edx
movq %r12, %rcx
movb %ch, 0x8(%rsp,%rdx)
movb %r12b, 0x8(%rsp,%r8)
movl %eax, %r15d
xorl %r12d, %r12d
leaq 0x6(%rsp), %r14
movb 0x8(%rsp,%r12), %al
movb %al, 0x6(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3b556
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3b561
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3b138
incq %r12
cmpq %r12, %r15
jne 0x3b53b
jmp 0x3b57b
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b138
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c1ae
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
xorl %eax, %eax
jmp 0x3b57d
// File: /workspace/github_cpp_makefile_star2_O3/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::vector<unsigned char, std::allocator<unsigned char>>, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<unsigned char, std::allocator<unsigned 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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rcx
movq %rdi, %rbx
movq %rsi, %r12
shrq $0x20, %r12
movl $0x3, %r15d
jne 0x3b5ec
movl $0x2, %r15d
cmpq $0xffff, %rcx           # imm = 0xFFFF
ja 0x3b5ec
xorl %r15d, %r15d
cmpq $0x100, %rcx            # imm = 0x100
setae %al
cmpq $0x18, %rcx
jb 0x3b6eb
movb %al, %r15b
movq %rcx, %r13
leal 0x18(%r15), %eax
movb %al, 0x5(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3b609
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3b616
leaq 0x5(%rsp), %rdx
movq %rbx, %rdi
callq 0x3b138
movl $0x1, %eax
movl %r15d, %ecx
shll %cl, %eax
leal -0x1(%rax), %r8d
cmpl $0x7, %r8d
ja 0x3b6d7
leaq 0xa2ef(%rip), %rdx      # 0x45924
movslq (%rdx,%r8,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movq %r13, %rdx
shrq $0x38, %rdx
movb %dl, 0x8(%rsp)
movq %r13, %rdx
shrq $0x30, %rdx
movb %dl, 0x9(%rsp)
movq %r13, %rdx
shrq $0x28, %rdx
movb %dl, 0xa(%rsp)
movb %r12b, 0xb(%rsp)
movq %r13, %rdi
movl %edi, %edx
shrl $0x18, %edx
leal -0x4(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
movl %edi, %edx
shrl $0x10, %edx
leal -0x3(%rax), %esi
movb %dl, 0x8(%rsp,%rsi)
leal -0x2(%rax), %edx
movq %r13, %rcx
movb %ch, 0x8(%rsp,%rdx)
movb %r13b, 0x8(%rsp,%r8)
movl %eax, %r15d
xorl %r12d, %r12d
leaq 0x6(%rsp), %r14
movb 0x8(%rsp,%r12), %al
movb %al, 0x6(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3b6b4
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3b6bf
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3b138
incq %r12
cmpq %r12, %r15
jne 0x3b699
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1c1ae
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
xorl %eax, %eax
jmp 0x3b6c9
movb %cl, 0x7(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3b701
movb %cl, (%rsi)
incq 0x8(%rbx)
jmp 0x3b6c7
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3b138
jmp 0x3b6c7
// File: /workspace/github_cpp_makefile_star2_O3/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::vector<unsigned char, std::allocator<unsigned 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::vector<unsigned char, std::allocator<unsigned 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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpl $0x1f, %eax
ja 0x3b783
movl $0xfffff, %ecx          # imm = 0xFFFFF
btl %eax, %ecx
jae 0x3b749
addb $-0x20, %al
movb %al, 0xd(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3b76a
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x3b777
movl $0xfef00000, %ecx       # imm = 0xFEF00000
btl %eax, %ecx
jae 0x3b783
movq %rdx, %r15
callq 0x1c1ae
movl $0x2, (%r15)
movq %rax, 0x8(%r15)
xorl %eax, %eax
jmp 0x3b779
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x3b138
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movb $-0x8, 0xe(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3b7a2
movb $-0x8, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3b7b3
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x3b138
movq 0x8(%rbx), %rsi
movb (%r14), %al
movb %al, 0xf(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x3b7c7
movb %al, (%rsi)
jmp 0x3b743
leaq 0xf(%rsp), %rdx
jmp 0x3b76f
// File: /workspace/github_cpp_makefile_star2_O3/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::vector<unsigned char, std::allocator<unsigned char>>, char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::vector<unsigned char, std::allocator<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 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::bstr: case X::tstr: return imp::read_array_b_<X>(t, m, i, e, cx);
                    case X::arr:                return imp::read_array_w_<X>(t, m, i, e, cx);
                    default:                    return cx/cbor::read_error::array_invalid;
                }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x20a5e
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movzbl (%rax), %esi
movl %esi, %ecx
andl $-0x20, %ecx
cmpl $0x40, %ecx
je 0x209cb
cmpl $0x80, %ecx
je 0x209e6
cmpl $0x60, %ecx
jne 0x20a5e
andl $0x1f, %esi
leal -0x1c(%rsi), %ecx
cmpl $0x3, %ecx
jae 0x209ff
callq 0x16fd8
movl $0x6, (%rbx)
jmp 0x20a69
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20a87
cmpl $0x1f, %esi
jne 0x20a17
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movb (%rax), %bpl
cmpq %r15, %rcx
jne 0x20a30
xorl %eax, %eax
jmp 0x20a36
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20b84
movb (%rcx), %al
cmpb $-0x1, %al
je 0x20a78
xorb %bpl, %al
cmpb $0x20, %al
jae 0x20a5e
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x20b84
testb %al, %al
je 0x20a6d
movq (%r14), %rcx
cmpq %r15, %rcx
jne 0x20a30
xorl %eax, %eax
jmp 0x20a32
callq 0x16fd8
movl $0x7, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
cmpq %r15, %rcx
je 0x20a6f
incq %rcx
movq %rcx, (%r14)
jmp 0x20a6f