LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/char.hxx
// Function: bool cxon::cio::chr::imp::encode_<cxon::JSON<cxon::json::format_traits>, char16_t>::value_<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char16_t const*&, char16_t const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value_(O& o, const char16_t*& i, const char16_t* e, Cx& cx) {
                            char32_t c32 = *i;
                                if (c32 >= 0xD800 && c32 <= 0xDBFF) { // surrogate
                                    ++i;                        CXON_ASSERT(i != e, "invalid surrogate");
                                    char32_t const s32 = *i;    CXON_ASSERT(s32 >= 0xDC00 && s32 <= 0xDFFF, "invalid surrogate");
                                    c32 = char32_t(0x10000 + (((c32 - 0xD800) << 10) | (s32 - 0xDC00)));
                                }
                            return encode_<X, char32_t>::value(o, c32, cx);
                        }

// Assembly:
movq %rsi, %rax
movq (%rsi), %rdx
movzwl (%rdx), %esi
movl %esi, %r8d
andl $0xfc00, %r8d           # imm = 0xFC00
cmpw $0xd800, %r8w           # imm = 0xD800
jne 0x2857f
leaq 0x2(%rdx), %r8
movq %r8, (%rax)
movzwl 0x2(%rdx), %eax
shll $0xa, %esi
addl $0xfca00000, %esi       # imm = 0xFCA00000
addl $0xffff2400, %eax       # imm = 0xFFFF2400
orl %esi, %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, %esi
movq %rcx, %rdx
jmp 0x27948
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/lib/boost/dynamic_bitset.hxx
// Function: bool cxon::json::imp::read_bits_<cxon::JSON<cxon::json::format_traits>, boost::dynamic_bitset<unsigned char, std::allocator<unsigned char>>, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>>(boost::dynamic_bitset<unsigned char, std::allocator<unsigned char>>&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
inline bool read_bits_(BS& t, II& i, II e, Cx&) {
            using st = typename BS::size_type;
            constexpr st u = sizeof(typename BS::block_type) * 8;
            st p = u;
            t.resize(t.size() + u);
            for ( ; i != e && (*i == '1' || *i == '0'); ++i) {
                if (p == 0)
                    t.resize(t.size() * 2), t <<= u, p = u;
                --p;
                if (*i == '1') t.set(p);
            }
            return t >>= p, t.resize(t.size() - p), true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
addq $0x8, %rsi
xorl %edx, %edx
callq 0x88fc2
movq (%r15), %rax
pushq $0x8
popq %r12
movq %r12, %r13
cmpq %r14, %rax
je 0x88f9a
movb (%rax), %cl
movl %ecx, %edx
andb $-0x2, %dl
cmpb $0x30, %dl
jne 0x88f9a
testq %r13, %r13
jne 0x88f70
movq 0x18(%rbx), %rsi
addq %rsi, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x88fc2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x89042
movq (%r15), %rax
movb (%rax), %cl
movq %r12, %r13
decq %r13
cmpb $0x31, %cl
jne 0x88f92
movl %r13d, %ecx
andb $0x7, %cl
movb $0x1, %al
shlb %cl, %al
movq %r13, %rcx
shrq $0x3, %rcx
movq (%rbx), %rdx
orb %al, (%rdx,%rcx)
movq (%r15), %rax
incq %rax
movq %rax, (%r15)
jmp 0x88f36
movq %rbx, %rdi
movq %r13, %rsi
callq 0x89108
movq 0x18(%rbx), %rsi
subq %r13, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x88fc2
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/enum.hxx
// Function: bool cxon::cio::enm::read_value<cxon::JSON<cxon::json::format_traits>, boost_variant2_enum, cxon::cio::enm::value<boost_variant2_enum> const*, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>>(boost_variant2_enum&, cxon::cio::enm::value<boost_variant2_enum> const*, cxon::cio::enm::value<boost_variant2_enum> const*, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
inline bool read_value(E& t, V f, V l, II& i, II e, Cx& cx) {
            if (!consume<X>(i, e, cx))
                return false;
            II const o = i;
            char id[ids_len_max::constant<napa_type<Cx>>(64)];
                if (!cxon::read_value<X>(id, i, e, cx))
                    return false;
            for ( ; f != l && std::char_traits<char>::compare(f->name, id, f->nale + 1) != 0; ++f)
                ;
            return  (f != l && (t = f->value, true)) ||
                    (rewind(i, o), cx/X::read_error::unexpected);
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
movq %rcx, %rdi
movq %r8, %rsi
callq 0x1e8e2
movq (%r14), %r15
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x8f3b2
testb %al, %al
je 0x8f381
leaq 0x10(%rsp), %rbp
cmpq %r13, %r12
je 0x8f385
movq (%r12), %rdi
movq 0x8(%r12), %rdx
incq %rdx
movq %rbp, %rsi
callq 0x1df8c
testl %eax, %eax
je 0x8f395
addq $0x18, %r12
jmp 0x8f35e
xorl %eax, %eax
jmp 0x8f3a3
movq %r15, (%r14)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1e782
jmp 0x8f3a3
movl 0x10(%r12), %eax
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/enum.hxx
// Function: bool cxon::cio::enm::write_value<cxon::JSON<cxon::json::format_traits>, boost_variant2_enum, cxon::cio::enm::value<boost_variant2_enum> const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, boost_variant2_enum, cxon::cio::enm::value<boost_variant2_enum> const*, cxon::cio::enm::value<boost_variant2_enum> const*, cxon::context<cxon::JSON<cxon::json::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 ?
                str::pointer_write<X>(o, f->name, f->nale, cx) :
                cx/X::write_error::argument_invalid
            ;
        }

// Assembly:
cmpq %rcx, %rdx
je 0x8f955
cmpl %esi, 0x10(%rdx)
je 0x8f960
addq $0x18, %rdx
jmp 0x8f945
pushq $0x2
popq %rsi
movq %r8, %rdi
jmp 0x1ffa2
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq %r8, %rcx
jmp 0x268f7
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/compound.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, int [3], void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(int (&) [3], char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(T (&t)[N], II& i, II e, Cx& cx) {
                    II const o = i;
                        std::size_t p = 0;
                    return cio::cnt::read_list<Y>(i, e, cx, [&] {
                        return (p != N || (cio::rewind(i, o), cx/json::read_error::overflow)) &&
                                read_value<Y>(t[p++], i, e, cx)
                        ;
                    });
                }

// Assembly:
subq $0x78, %rsp
leaq 0x70(%rsp), %rax
movq %rdx, (%rax)
movq (%rsi), %r8
leaq 0x60(%rsp), %r9
andq $0x0, (%r9)
leaq 0x68(%rsp), %r10
movq %r8, (%r10)
movq %r9, 0x30(%rsp)
movq %rsi, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %rdi, 0x50(%rsp)
movq %rax, 0x58(%rsp)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xb9b3e
addq $0x78, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/compound.hxx
// Function: bool cxon::read<cxon::JSON<cxon::test::input_iterator_traits<cxon::test::allow_comments_traits<cxon::json::format_traits>>>, int*, void>::value<cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::input_iterator_traits<cxon::test::allow_comments_traits<cxon::json::format_traits>>>>, cxon::JSON<cxon::test::input_iterator_traits<cxon::test::allow_comments_traits<cxon::json::format_traits>>>>(int*&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::input_iterator_traits<cxon::test::allow_comments_traits<cxon::json::format_traits>>>>&)
static bool value(T*& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<Y>(i, e, cx))
                        return false;
                    if (cio::peek(i, e) == *Y::id::nil) {
                        II const o = i;
                        return  (cio::consume<Y>(Y::id::nil, i, e) && (t = nullptr, true)) ||
                                (cio::rewind(i, o), cx/json::read_error::unexpected)
                        ;
                    }
                    auto al = alc::make_context_allocator<T>(cx);
                    T *const n = al.create();
                        if (!read_value<Y>(*n, i, e, cx))
                            return al.release(n), false;
                    return t = n, true;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rax
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movq %rcx, %rdx
callq 0xff35b
testb %al, %al
je 0x100e01
movq (%r15), %rcx
movq (%r12), %rax
cmpq %rax, %rcx
je 0x100e05
cmpb $0x6e, (%rcx)
jne 0x100e05
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xbae95(%rip), %rdi     # 0x1bbc81
movq %r15, %rsi
callq 0xff38c
testb %al, %al
je 0x100e41
andq $0x0, (%rbx)
movb $0x1, %bpl
jmp 0x100e4e
xorl %ebp, %ebp
jmp 0x100e4e
leaq 0xf(%rsp), %rdi
callq 0xbf21a
movq %rax, %r13
movq (%r12), %rax
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x100aee
movl %eax, %ebp
testb %al, %al
je 0x100e37
movq %r13, (%rbx)
jmp 0x100e4e
movq %r13, %rdi
callq 0xe2b0
jmp 0x100e4e
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xfece0
movl %eax, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/string.hxx
// Function: std::enable_if<is_char<char>::value, bool>::type cxon::cio::str::pointer_read<cxon::JSON<cxon::test::input_iterator_traits<cxon::test::allow_comments_traits<cxon::json::format_traits>>>, char, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::input_iterator_traits<cxon::test::allow_comments_traits<cxon::json::format_traits>>>>>(char*&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::input_iterator_traits<cxon::test::allow_comments_traits<cxon::json::format_traits>>>>&)
inline auto pointer_read(T*& t, II& i, II e, Cx& cx)
            -> enable_if_t<is_char<T>::value, bool>
        {
            if (!consume<X>(i, e, cx))
                return false;
            if (peek(i, e) == *X::id::nil && consume<X>(X::id::nil, i, e))
                return true;
            auto c = cxon::cnt::make_pointer_container<X, T>(cx);
            return string_read<X>(c, i, e, cx) && (c.push_back({}), t = c.release(), true);
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rax
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movq %rcx, %rdx
callq 0xff35b
testb %al, %al
je 0xff331
movq (%r15), %rcx
movq (%r12), %rax
cmpq %rax, %rcx
je 0xff2d6
cmpb $0x6e, (%rcx)
jne 0xff2d6
leaq 0x38(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xbc9ba(%rip), %rdi     # 0x1bbc81
movq %r15, %rsi
callq 0xff38c
movb $0x1, %bpl
testb %al, %al
jne 0xff333
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0xff3af
movq (%r12), %rax
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0xff3ca
movl %eax, %ebp
testb %al, %al
je 0xff325
leaq 0xf(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xbf69e
leaq 0x10(%rsp), %rdi
callq 0xbf6c2
movq %rax, (%rbx)
leaq 0x10(%rsp), %rdi
callq 0xbf6da
jmp 0xff333
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xff346
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbf6da
movq %rbx, %rdi
callq 0xe480
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/value.hxx
// Function: bool cxon::cio::val::sink_write<cxon::JSON<cxon::json::format_traits>, cxon::cnt::range_container<char*>, cxon::cio::val::sink<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, cxon::context<cxon::JSON<cxon::json::format_traits>>>(cxon::cnt::range_container<char*>&, cxon::cio::val::sink<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
inline bool sink_write(O& o, const S& s, Cx& cx) {
            for (auto e : s.value) 
                if (!cio::poke<X>(o, e, cx))
                    return false;
            return true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %r12
movq 0x8(%rsi), %r15
xorl %ecx, %ecx
movq %rcx, %r13
cmpq %rcx, %r15
je 0xc213b
movsbl (%r12,%r13), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a4b8
leaq 0x1(%r13), %rcx
testb %al, %al
jne 0xc211b
cmpq %r13, %r15
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, char, void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>>(char&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(T& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<X>(cio::str::delim_be_read<X, II>, i, e, cx)) return false;
                        II const o = i;
                            char32_t const c32 = cio::chr::utf8_to_utf32<X>(i, e, cx);
                                if (c32 == cio::chr::bad_utf32) return cio::rewind(i, o), false;
                                if (c32 >  0xFF)                return cio::rewind(i, o), cx/json::read_error::character_invalid;
                    return cio::consume<X>(cio::str::delim_en_read<X, II>, i, e, cx) && (t = char(c32), true);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xca(%rip), %rdi        # 0xe0fd6
callq 0xe0f86
testb %al, %al
je 0xe0f75
movq (%r15), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xe0fef
cmpl $-0x1, %eax
je 0xe0f50
movl %eax, %ebp
cmpl $0x100, %eax            # imm = 0x100
jb 0xe0f55
movq %r13, (%r15)
pushq $0x2
popq %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e782
movq %r13, (%r15)
jmp 0xe0f75
leaq 0xb4(%rip), %rdi        # 0xe1010
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xe0f86
testb %al, %al
je 0xe0f75
movb %bpl, (%rbx)
movb $0x1, %al
jmp 0xe0f77
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>, wchar_t, void>::value<cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>>>(wchar_t&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>>&)
static bool value(T& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<X>(cio::str::delim_be_read<X, II>, i, e, cx)) return false;
                        II const o = i;
                            char32_t const c32 = cio::chr::utf8_to_utf32<X>(i, e, cx);
                                if (c32 == cio::chr::bad_utf32) return cio::rewind(i, o), false;
                    return cio::consume<X>(cio::str::delim_en_read<X, II>, i, e, cx) && (t = T(c32), true);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rax
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
leaq -0xe8d(%rip), %rdi      # 0x18cc57
callq 0x18cbf1
testb %al, %al
je 0x18db33
movq (%r12), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movq %r14, %rdx
callq 0x18cc70
cmpl $-0x1, %eax
je 0x18db33
movl %eax, %ebp
movq (%r12), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq -0xe70(%rip), %rdi      # 0x18ccae
movq %r15, %rsi
movq %r14, %rcx
callq 0x18cbf1
testb %al, %al
je 0x18db33
movl %ebp, (%rbx)
movb $0x1, %al
jmp 0x18db35
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, char16_t, void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>>(char16_t&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(T& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<X>(cio::str::delim_be_read<X, II>, i, e, cx)) return false;
                        II const o = i;
                            char32_t const c32 = cio::chr::utf8_to_utf32<X>(i, e, cx);
                                if (c32 == cio::chr::bad_utf32) return cio::rewind(i, o), false;
                                if (c32 >  0xFFFF)              return cio::rewind(i, o), cx/json::read_error::character_invalid;
                    return cio::consume<X>(cio::str::delim_en_read<X, II>, i, e, cx) && (t = T(c32), true);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq -0xa8c(%rip), %rdi      # 0xe0fd6
callq 0xe0f86
testb %al, %al
je 0xe1acb
movq (%r15), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xe0fef
cmpl $-0x1, %eax
je 0xe1aa6
movl %eax, %ebp
cmpl $0x10000, %eax          # imm = 0x10000
jb 0xe1aab
movq %r13, (%r15)
pushq $0x2
popq %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e782
movq %r13, (%r15)
jmp 0xe1acb
leaq -0xaa2(%rip), %rdi      # 0xe1010
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xe0f86
testb %al, %al
je 0xe1acb
movw %bp, (%rbx)
movb $0x1, %al
jmp 0xe1acd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/src/json/json.core-fundamental.cxx
// Function: std::enable_if<std::is_floating_point<long double>::value, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::type cxon::test::to_string<long double>(long double)
inline auto to_string(T t)
            -> enable_if_t<std::is_floating_point<T>::value, std::string>
        {
            char s[std::numeric_limits<T>::max_digits10 * 2] = { 0 };
            std::size_t const l = sizeof(s) / sizeof(char);
            int const w = std::snprintf(s, l, fmt<T>::str, std::numeric_limits<T>::max_digits10, t);
                CXON_ASSERT(w > 0 && (std::size_t)w < l, "conversion failed");
            return s;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
fldt 0x70(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movups %xmm0, 0x1a(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
fstpt (%rsp)
leaq 0xd2d22(%rip), %rdx     # 0x1b6911
pushq $0x2a
popq %rsi
pushq $0x15
popq %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0xe420
leaq 0x1f(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe100
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/numeric.hxx
// Function: std::enable_if<std::is_integral<int>::value, bool>::type cxon::cio::num::imp::number_read__<cxon::test::input_iterator_traits<cxon::json::format_traits>, int, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::input_iterator_traits<cxon::json::format_traits>>>>(int&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::input_iterator_traits<cxon::json::format_traits>>>&)
inline auto number_read__(T& t, II& i, II e, Cx& cx)
                -> enable_if_t<std::is_integral<T>::value, bool>
            {
                constexpr auto base = integer_base::constant<napa_type<Cx>>(10);
                II const o = i;
                    char s[num_len_max::constant<napa_type<Cx>>(32)];
                    switch (number_consume_<X, T>(std::begin(s), std::end(s), i, e, is_digit<X, base>::fun)) {
                        case -1: return rewind(i, o), cx/X::read_error::overflow;
                        case  0: return rewind(i, o), cx/X::read_error::integral_invalid;
                        default: {
                            auto const r = charconv::from_chars(std::begin(s), std::end(s), t, base); CXON_ASSERT(r.ec == std::errc(), "unexpected");
                            return true;
                        }
                    }
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x30(%rsp), %r15
movq (%rdx), %rdx
leaq 0x8(%rsp), %rcx
movq %rdx, (%rcx)
leaq -0x2fba(%rip), %r8      # 0xe49de
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe79e1
testl %eax, %eax
je 0xe79b5
cmpl $-0x1, %eax
jne 0xe79c2
pushq $0x8
jmp 0xe79b7
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xbc1e2
jmp 0xe79d7
leaq 0x10(%rsp), %rdi
pushq $0xa
popq %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0x1ea15
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/numeric.hxx
// Function: std::enable_if<std::is_integral<int>::value, int>::type cxon::cio::num::imp::number_consume_<cxon::test::input_iterator_traits<cxon::json::format_traits>, int, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, bool (*)(char)>(char*, char const*, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, bool (*)(char))
inline auto number_consume_(char* f, const char* l, II& i, II e, C is_digit)
                -> enable_if_t<std::is_integral<T>::value, int>
            {
                CXON_ASSERT(f && f < l, "unexpected");
                char c = peek(i, e);
                    if (is_sign_<T>(c))     CXON_READ()
                    if (c == '0') {         CXON_NEXT()
                                            goto trap_end; }
                       if (!is_digit(c))    return 0;
                    while ( is_digit(c))    CXON_NEXT()
                trap_end:
                    return f != l ? (*f = '\0', 1) : -1;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movb $-0x1, %bpl
cmpq (%rcx), %rax
je 0xe7a4f
movb (%rax), %bpl
cmpb $0x2d, %bpl
jne 0xe7a2c
movb $0x2d, (%rbx)
movq (%r15), %rax
incq %rax
cmpq (%r13), %rax
movq %rax, (%r15)
je 0xe7a26
movb (%rax), %bpl
jmp 0xe7a29
movb $-0x1, %bpl
incq %rbx
cmpb $0x30, %bpl
jne 0xe7a4f
cmpq %r14, %rbx
je 0xe7a8d
movb $0x30, (%rbx)
incq (%r15)
incq %rbx
pushq $-0x1
popq %rax
cmpq %r14, %rbx
je 0xe7a90
movb $0x0, (%rbx)
pushq $0x1
jmp 0xe7a8f
movsbl %bpl, %edi
callq *%r12
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xe7a90
movsbl %bpl, %edi
callq *%r12
testb %al, %al
je 0xe7a40
cmpq %r14, %rbx
je 0xe7a8d
movb %bpl, (%rbx)
movq (%r15), %rax
incq %rax
cmpq (%r13), %rax
movq %rax, (%r15)
je 0xe7a85
movb (%rax), %bpl
jmp 0xe7a88
movb $-0x1, %bpl
incq %rbx
jmp 0xe7a5e
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/char.hxx
// Function: std::enable_if<cxon::JSON<cxon::test::produce_strict_javascript_traits>::produce_strict_javascript, bool>::type cxon::cio::chr::imp::encode_<cxon::JSON<cxon::test::produce_strict_javascript_traits>, char32_t>::value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::test::produce_strict_javascript_traits>>, cxon::JSON<cxon::test::produce_strict_javascript_traits>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char32_t, cxon::context<cxon::JSON<cxon::test::produce_strict_javascript_traits>>&)
static auto value(O& o, char32_t c, Cx& cx) -> enable_if_t< S::produce_strict_javascript, bool> {
                        if (c > 0x7F) {
                                if (c == 0x2028) return poke<X>(o, "\\u2028", 6, cx);
                                if (c == 0x2029) return poke<X>(o, "\\u2029", 6, cx);
                                char b[4]; int const n = utf32_to_utf8(b, c);
                                return poke<X>(o, b, n, cx);
                        }
                        else    return encode_<X, char>::value(o, char(c), cx);
                    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x80, %esi
jb 0xea452
cmpl $0x2029, %esi           # imm = 0x2029
je 0xea465
cmpl $0x2028, %esi           # imm = 0x2028
jne 0xea474
leaq 0xcc8ca(%rip), %rsi     # 0x1b6d1a
jmp 0xea46c
movsbl %sil, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xea10c
leaq 0xcc8b5(%rip), %rsi     # 0x1b6d21
pushq $0x6
popq %rdx
movq %rbx, %rdi
jmp 0xea48a
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x26270
movslq %eax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe060
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/tidy.hxx
// Function: std::enable_if<is_back_insertable<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::value, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::type cxon::json::tidy<cxon::json::format_traits, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned int, char)
inline auto tidy(II b, II e, unsigned tab, char pad) -> enable_if_t<is_back_insertable<R>::value, R> {
            R r;
                auto i = make_indenter<X>(r, tab, pad);
                for ( ; b != e && cio::poke(i, *b); ++b)
                    ;
            return r;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
andq $0x0, 0x8(%r14)
movq %rdx, %r15
andl $0x0, 0x10(%r14)
movq %rsi, %r12
movb $0x0, 0x10(%rdi)
movl %ecx, 0x14(%r14)
movb %r8b, 0x18(%r14)
cmpq %r15, %r12
je 0xf9423
movsbl (%r12), %esi
movq %r14, %rdi
callq 0xf8a1e
incq %r12
testb %al, %al
jne 0xf940a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xe150
movq %r14, %rdi
callq 0xe480
nop
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/io.hxx
// Function: cxon::cio::buffered_back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::array<char, 8ul>>::append(char const*, unsigned long)
void append(const T* t, std::size_t n) {
                if (s_ + n > b_.size()) {
                    flush();
                    if (n > b_.size())
                        return poke(c_, t, n), void();
                }
                std::copy_n(t, n, b_.data() + s_), s_ += n;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdi), %rdi
leaq (%rdi,%rdx), %rax
cmpq $0x9, %rax
jb 0x101635
movq %r14, %rdi
callq 0x1013f4
cmpq $0x8, %rbx
jbe 0x101631
movq (%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xe060
movq 0x10(%r14), %rdi
testq %rbx, %rbx
je 0x10164d
addq 0x8(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe430
movq 0x10(%r14), %rdi
addq %rbx, %rdi
movq %rdi, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/lib/std/valarray.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, std::valarray<int>, void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(std::valarray<int>&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(std::valarray<T>& t, II& i, II e, Cx& cx) { // no, it sucks
                    std::valarray<T> v(4);
                    std::size_t p = 0;
                    bool const r = cio::cnt::read_list<Y>(i, e, cx, [&] {
                        if (p >= v.size()) {
                            std::valarray<T> n(std::move(v));
                            v.resize(p + p);
                                for (std::size_t i = 0; i != p; ++i) v[i] = n[i];
                        }
                        return read_value<Y>(v[p], i, e, cx) && (++p, true);
                    });
                        if (!r) return false;
                    t.resize(p);
                        for (std::size_t j = 0; j != p; ++j) t[j] = v[j];
                    return true;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x70(%rsp), %r13
movq %rdx, (%r13)
leaq 0x38(%rsp), %rbp
movq $0x4, (%rbp)
pushq $0x10
popq %rdi
callq 0xe2c0
movq %rax, 0x8(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x30(%rsp), %rax
andq $0x0, (%rax)
movq %rax, 0x48(%rsp)
movq %rbp, 0x50(%rsp)
movq %r12, 0x58(%rsp)
movq %r13, 0x60(%rsp)
movq %r14, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x48(%rsp), %xmm0
movups 0x58(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x148df8
movl %eax, %ebp
testb %al, %al
je 0x148d78
movq 0x30(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x148da8
movq 0x30(%rsp), %rax
movq 0x40(%rsp), %rcx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
cmpq %rsi, %rax
je 0x148d78
movl (%rcx,%rsi,4), %edi
movl %edi, (%rdx,%rsi,4)
incq %rsi
jmp 0x148d68
movq 0x40(%rsp), %rdi
callq 0xe2b0
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
callq 0xe2b0
movq %rbx, %rdi
callq 0xe480
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/lib/std/valarray.hxx
// Function: bool cxon::write<cxon::JSON<cxon::json::format_traits>, std::valarray<int>, void>::value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::valarray<int> const&, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(O& o, const std::valarray<T>& t, Cx& cx) {
#                   ifdef _MSC_VER // std::begin/std::end broken for empty std::valarray
                        return (t.size() && cio::cnt::write_list<Y, std::valarray<T>>(o, std::begin(t), std::end(t), cx)) ||
                               (cio::poke<Y>(o, Y::list::beg, cx) && cio::poke<Y>(o, Y::list::end, cx))
                        ;
#                   else
                        return cio::cnt::write_list<Y, std::valarray<T>>(o, std::begin(t), std::end(t), cx);
#                   endif
                }

// Assembly:
movq %rdx, %rcx
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
testq %rax, %rax
leaq (%rsi,%rax,4), %rdx
cmoveq %rax, %rsi
cmoveq %rax, %rdx
jmp 0x149018
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/lib/std/queue.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, std::priority_queue<int, std::vector<int, std::allocator<int>>, std::less<int>>, void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(std::priority_queue<int, std::vector<int, std::allocator<int>>, std::less<int>>&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)::'lambda'()::operator()() const
static bool value(std::priority_queue<T, R...>& t, II& i, II e, Cx& cx) {
                    return cio::cnt::read_list<Y>(i, e, cx, [&] {
                        T o{};
                        return read_value<Y>(o, i, e, cx) && (t.emplace(std::move(o)), true);
                    });
                }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %rdi
andl $0x0, (%rdi)
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
movq (%rax), %rdx
movq 0x10(%rbx), %rcx
callq 0x1e978
movl %eax, %ebp
testb %al, %al
je 0x14b48f
movq 0x18(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0x14b498
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/lib/std/bitset.hxx
// Function: bool cxon::json::imp::read_bits_<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>, 8ul, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>>>(std::bitset<8ul>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>>&)
inline bool read_bits_(std::bitset<N>& t, II& i, II e, Cx& cx) {
            for (std::size_t p = N; p != 0; ) {
                char const c = cio::peek(i, e);
                    if (c != '0' && c != '1') return cx/json::read_error::unexpected;
                t.set(--p, c == '1'), ++i;
            }
            return true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
pushq $0x7
popq %rbx
cmpq $-0x1, %rbx
je 0x192c2f
movq (%r12), %rax
cmpq (%r15), %rax
je 0x192c24
movb (%rax), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x30, %cl
jne 0x192c24
xorl %edx, %edx
cmpb $0x31, %al
sete %dl
movq %r13, %rdi
movq %rbx, %rsi
callq 0x157dac
incq (%r12)
decq %rbx
jmp 0x192bee
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1877cc
cmpq $-0x1, %rbx
sete %cl
orb %al, %cl
andb $0x1, %cl
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/test/../src/cxon/lang/json/lib/std/bitset.hxx
// Function: bool cxon::json::imp::write_bits_<cxon::JSON<cxon::json::format_traits>, 8ul, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::bitset<8ul> const&, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
inline bool write_bits_(O& o, const std::bitset<N>& t, Cx& cx) {
            //char bs[N];
            //    for (std::size_t i = 0; i != N; ++i) {
            //        bs[i] = t[N - i - 1] ? '1' : '0';
            //    }
            //return cio::poke<X>(o, bs, N, cx);
            for (std::size_t p = N; p != 0; ) {
                if (!cio::poke<X>(o, t[--p] ? '1' : '0', cx)) return false;
            }
            return true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x7
popq %r15
cmpq $-0x1, %r15
je 0x157ef6
movq (%rbx), %rax
btq %r15, %rax
movl $0x0, %esi
adcl $0x30, %esi
movq %r14, %rdi
callq 0xe250
decq %r15
jmp 0x157ed4
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: getSearchValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int getSearchValue(const string &line) {
    /*
    *	Given a line read from the search query file of the form:
    *	SEARCH <VALUE>
    *	this funtion returns integer(<VALUE>)
    */
    int length = line.length();
    string number = "";
    for (int i=7; i<length; ++i)
        number += line[i];
    return stoi(number);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movslq 0x8(%rdi), %r15
leaq 0x1323(%rip), %rsi      # 0x50f4
leaq -0x48(%rbp), %r14
leaq -0x21(%rbp), %rdx
movq %r14, %rdi
callq 0x20c0
pushq $0x7
popq %r12
cmpq %r15, %r12
jge 0x3dff
movq (%rbx), %rax
movsbl (%rax,%r12), %esi
movq %r14, %rdi
callq 0x2180
incq %r12
jmp 0x3de5
leaq -0x48(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x453b
movl %eax, %ebx
leaq -0x48(%rbp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e29
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: updateFilePaths(int, char**)
void updateFilePaths(int argc, char **argv) {
    /* This file updates file paths using command line arguments */
    if (argc != 4) {
        //cout << "ERROR: command line arguments expected\n";
        exit(0);
    }
    input_file_path = argv[1];
    query_file_path = argv[2];
    output_file_path = argv[3];
}

// Assembly:
cmpl $0x4, %edi
jne 0x3e64
movq 0x8(%rsi), %rax
movq %rax, 0x436b(%rip)      # 0x81b8
movq 0x10(%rsi), %rax
movq %rax, 0x4368(%rip)      # 0x81c0
movq 0x18(%rsi), %rax
movq %rax, 0x4365(%rip)      # 0x81c8
retq
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: getLastPageNumber(FileHandler&, bool)
int getLastPageNumber(FileHandler &fh, bool keep_pinned=false) {
    /*
     *	When we call fh.LastPage().getPageNum(), it brings the last page
     *	into memory if not already in memory. By default it is pinned.
     *	Inputs:
     *		fh : file handler from wich to find the page number of last page
     *		keep_pinned : whether to keep the last page pinned or not
     *	Outputs: page number of the last page
     */
    PageHandler last_page_handler = fh.LastPage();
    int page_number = last_page_handler.GetPageNum();
    if (not keep_pinned)	fh.UnpinPage(page_number);
    return page_number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x28(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37bc
movq %r14, %rdi
callq 0x36c0
movl %eax, %r14d
testl %r15d, %r15d
jne 0x3eac
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3902
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: getLastPageHandler(FileHandler&, bool)
PageHandler getLastPageHandler(FileHandler &fh, bool keep_pinned=false) {
    /*
     *	When we call fh.LastPage().getPageNum(), it brings the last page
     *	into memory if not already in memory. By default it is pinned.
     *	Inputs:
     *		fh : file handler from wich to find the page number of last page
     *		keep_pinned : whether to keep the last page pinned or not
     *	Outputs: pagehandler of the last page
     */
    PageHandler last_page_handler = fh.LastPage();
    int page_number = last_page_handler.GetPageNum();
    if (not keep_pinned)	fh.UnpinPage(page_number);
    return last_page_handler;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x37bc
movq %rbx, %rdi
callq 0x36c0
testl %r15d, %r15d
jne 0x3ee9
movq %r14, %rdi
movl %eax, %esi
callq 0x3902
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: getFirstPageHandler(FileHandler&, bool)
PageHandler getFirstPageHandler(FileHandler &fh, bool keep_pinned=false) {
    /*
     *	When we call fh.LastPage().getPageNum(), it brings the last page
     *	into memory if not already in memory. By default it is pinned.
     *	Inputs:
     *		fh : file handler from wich to find the page number of last page
     *		keep_pinned : whether to keep the last page pinned or not
     *	Outputs: pagehandler of the last page
     */
    PageHandler first_page_handler = fh.FirstPage();
    int page_number = first_page_handler.GetPageNum();
    if (not keep_pinned)	fh.UnpinPage(page_number);
    return first_page_handler;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x371a
movq %rbx, %rdi
callq 0x36c0
testl %r15d, %r15d
jne 0x3f26
movq %r14, %rdi
movl %eax, %esi
callq 0x3902
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: getPageHandler(FileHandler&, int, bool)
PageHandler getPageHandler(FileHandler &fh, int page_number, bool keep_pinned=false) {
	/*
	 *	When we call fh.FirstPage().getPageNum(), it brings the last page
	 *	into memory if not already in memory. By default it is pinned.
	 *	Inputs:
	 *		fh : file handler from wich to find the page number of last page
	 *		keep_pinned : whether to keep the last page pinned or not
	 *	Outputs: pagehandler of the last page
	 */
	PageHandler page_handler = fh.PageAt(page_number);
	if (not keep_pinned)	fh.UnpinPage(page_number);
	return page_handler;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3858
testl %r12d, %r12d
jne 0x40f1
movq %r15, %rdi
movl %r14d, %esi
callq 0x3902
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/main/db_mkbtree.cc
// Function: main
int main(int argc, char **argv){
	if (argc <= 1 + 1){
		printUsage(argv[0]);
		return 1;
	}

	const char *input_file	= argv[1];
	const char *output_file	= argv[2];

	if (CHECK_FILE_EXISTS && fileExists(output_file)){
		printf("File %s exists. Please remove it and try again.\n", output_file);
		return 2;
	}

	using DiskTable = hm3::DiskTable;

	hm3::DiskTable list;
	list.open(input_file);

	using BTreeIndexBuilder = hm3::btreeindex::BTreeIndexBuilder<DiskTable>;

	BTreeIndexBuilder builder;

	bool const result = builder.createFromList(output_file, list);

	return result ? 0 : 100;
}

// Assembly:
pushq %rbx
subq $0x500, %rsp            # imm = 0x500
cmpl $0x2, %edi
jg 0x24d5
movq (%rsi), %rbx
leaq 0x2bfe(%rip), %rdi      # 0x5091
callq 0x2240
leaq 0x2b65(%rip), %rdi      # 0x5004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
leaq 0x2be8(%rip), %rdi      # 0x5098
callq 0x2240
leaq 0x2c0b(%rip), %rdi      # 0x50c7
callq 0x2240
leaq 0x2c13(%rip), %rdi      # 0x50db
callq 0x2240
pushq $0x1
popq %rbx
jmp 0x25c6
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rbx
xorl %ecx, %ecx
movb %cl, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movb %cl, 0x28(%rsp)
movups %xmm0, 0x30(%rsp)
andq $0x0, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
andl $0x0, 0x6c(%rsp)
movups %xmm0, 0x5c(%rsp)
movl $0x1, 0x74(%rsp)
movups %xmm0, 0x78(%rsp)
andl $0x0, 0xa4(%rsp)
movups %xmm0, 0x8c(%rsp)
andl $0x0, 0x9c(%rsp)
movb $0x1, 0xa8(%rsp)
movups %xmm0, 0xb0(%rsp)
movups %xmm0, 0xc0(%rsp)
movups %xmm0, 0xd0(%rsp)
movups %xmm0, 0xe0(%rsp)
leaq 0xf0(%rsp), %rdi
movq %rax, %rsi
callq 0x25fa
leaq 0x10(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x3368
leaq 0xf0(%rsp), %rdi
callq 0x262a
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x25fa
leaq 0xf0(%rsp), %rdi
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
callq 0x2666
xorl %ecx, %ecx
testb %al, %al
pushq $0x64
popq %rbx
cmovnel %ecx, %ebx
leaq 0xf0(%rsp), %rdi
callq 0x27a4
leaq 0x10(%rsp), %rdi
callq 0x27be
movl %ebx, %eax
addq $0x500, %rsp            # imm = 0x500
popq %rbx
retq
jmp 0x25e5
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x27a4
jmp 0x25e8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x27be
movq %rbx, %rdi
callq 0x22a0