LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0xd800, -0x24(%rbp)    # imm = 0xD800
jb 0x62883
cmpl $0xdbff, -0x24(%rbp)    # imm = 0xDBFF
ja 0x62883
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0xdc00, -0x28(%rbp)    # imm = 0xDC00
jb 0x62865
cmpl $0xdfff, -0x28(%rbp)    # imm = 0xDFFF
setbe %al
movl -0x24(%rbp), %eax
subl $0xd800, %eax           # imm = 0xD800
shll $0xa, %eax
movl -0x28(%rbp), %ecx
subl $0xdc00, %ecx           # imm = 0xDC00
orl %ecx, %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x5fcf0
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x8, -0x28(%rbp)
movq $0x8, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13eb00
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
xorl %edx, %edx
callq 0x13ea20
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x39(%rbp)
je 0x13e94a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x31, %ecx
movb %al, -0x3a(%rbp)
je 0x13e944
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
sete %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x13e956
jmp 0x13e9d7
cmpq $0x0, -0x30(%rbp)
jne 0x13e995
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13eb00
movq -0x48(%rbp), %rdi
movq %rax, %rsi
shlq %rsi
xorl %edx, %edx
callq 0x13ea20
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x13eb20
movq $0x8, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x13e9c2
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x13ecc0
jmp 0x13e9c4
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x13e90b
movq -0x30(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x13ed30
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13eb00
movq -0x50(%rbp), %rdi
movq %rax, %rsi
subq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x13ea20
movb $0x1, %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x3ca80
testb $0x1, %al
jne 0x15aa21
movb $0x0, -0x1(%rbp)
jmp 0x15aaf5
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq -0x80(%rbp), %rdi
callq 0x15ab40
testb $0x1, %al
jne 0x15aa4e
movb $0x0, -0x1(%rbp)
jmp 0x15aaf5
jmp 0x15aa50
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x81(%rbp)
je 0x15aa8a
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0x80(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
addq $0x1, %rdx
callq 0x44cc0
cmpl $0x0, %eax
setne %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x15aa96
jmp 0x15aaa6
jmp 0x15aa98
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x15aa50
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x15aac9
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, %al
testb $0x1, %al
movb %al, -0x82(%rbp)
jne 0x15aaea
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x49b90
movq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x3cb90
movb %al, -0x82(%rbp)
movb -0x82(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x29(%rbp)
je 0x15c6aa
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x15c6b3
jmp 0x15c6c3
jmp 0x15c6b5
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x15c68b
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x15c6ee
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0x5beb0
movb %al, -0x2a(%rbp)
jmp 0x15c6ff
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x44340
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/value.hxx
// Function: bool cxon::cio::val::sink_write<cxon::JSON<(anonymous namespace)::lima_ws_sep_traits>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::cio::val::sink<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, cxon::context<cxon::JSON<(anonymous namespace)::lima_ws_sep_traits>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, cxon::cio::val::sink<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, cxon::context<cxon::JSON<(anonymous namespace)::lima_ws_sep_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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x11140
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x11570
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x21a770
testb $0x1, %al
jne 0x207f89
jmp 0x207fc1
leaq -0x30(%rbp), %rdi
callq 0x21a7b0
movb (%rax), %al
movb %al, -0x39(%rbp)
movq -0x10(%rbp), %rdi
movb -0x39(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0x207fd0
testb $0x1, %al
jne 0x207fb4
movb $0x0, -0x1(%rbp)
jmp 0x207fc5
jmp 0x207fb6
leaq -0x30(%rbp), %rdi
callq 0x43060
jmp 0x207f76
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/numeric.hxx
// Function: std::enable_if<std::is_floating_point<double>::value && (anonymous namespace)::strict_number_traits::number::strict, bool>::type cxon::cio::num::imp::number_read_<(anonymous namespace)::strict_number_traits, double, cxon::context<cxon::JSON<(anonymous namespace)::strict_number_traits>>>(double&, char const*&, char const*, cxon::context<cxon::JSON<(anonymous namespace)::strict_number_traits>>&)
inline auto number_read_(T& t, const char*& i, const char* e, Cx& cx)
                -> enable_if_t<std::is_floating_point<T>::value &&  X::number::strict, bool>
            {
                auto const b = i;
                if (!number_consume_<X, T>(i, e))
                    return i = b, cx/X::read_error::floating_point_invalid;
                if (i - b == 1)
                    return t = T(*b - '0'), true;
                auto const r = from_chars_<X>(b, i, t); CXON_ASSERT(r.ec == std::errc() && r.ptr == i, "unexpected");
                return true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x260210
cmpl $0x0, %eax
jne 0x260195
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0x260070
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2601f8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jne 0x2601c5
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cvtsi2sd %eax, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2601f8
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x260500
movq %rax, -0x40(%rbp)
movl %edx, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jne 0x2601f4
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/numeric.hxx
// Function: std::enable_if<std::is_integral<int>::value && (anonymous namespace)::strict_number_traits::number::strict, bool>::type cxon::cio::num::imp::number_read__<(anonymous namespace)::strict_number_traits, int, cxon::context<cxon::JSON<(anonymous namespace)::strict_number_traits>>>(int&, char const*&, char const*, cxon::context<cxon::JSON<(anonymous namespace)::strict_number_traits>>&)
inline auto number_read__(T& t, const char*& i, const char* e, Cx& cx)
                -> enable_if_t<std::is_integral<T>::value && X::number::strict, bool>
            {
                constexpr auto base = integer_base::constant<napa_type<Cx>>(10);
                auto const b = i;
                if (!number_consume_<X, T>(i, e, is_digit<X, base>::fun))
                    return i = b, cx/X::read_error::integral_invalid;
                if (i - b == 1)
                    return t = *b - '0', true;
                auto const r = charconv::from_chars(b, i, t, base); CXON_ASSERT(r.ec == std::errc() && r.ptr == i, "unexpected");
                return true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0xa, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x699(%rip), %rdx      # 0x2607e0
callq 0x260f10
cmpl $0x0, %eax
jne 0x260ea3
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
movl $0x3, %esi
callq 0x260070
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x260f05
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jne 0x260ecd
movq -0x38(%rbp), %rax
movsbl (%rax), %ecx
subl $0x30, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x260f05
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
movl $0xa, %ecx
callq 0x3d550
movq %rax, -0x48(%rbp)
movl %edx, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jne 0x260f01
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
// File: 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_<(anonymous namespace)::strict_number_traits, int, bool (*)(char)>(char const*&, char const*, bool (*)(char))
inline auto number_consume_(const char*& i, const char* e, C is_digit)
                -> enable_if_t<std::is_integral<T>::value, int>
            {
                char c = *i;
                    if (is_sign_<T>(c)) goto trap_neg;
                // trap_pos
                    if (c == '0') return ++i, 1;
                       if (!is_digit(c)) return 0;
                    while ( is_digit(c)) c = next(i, e);
                    goto trap_end;
                trap_neg:
                    c = next(i, e);
                       if (!is_digit(c)) return 0;
                    while ( is_digit(c)) c = next(i, e);
                trap_end:
                    return 1;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x286a70
testb $0x1, %al
jne 0x260f3f
jmp 0x260f41
jmp 0x260fa1
movsbl -0x21(%rbp), %eax
cmpl $0x30, %eax
jne 0x260f64
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x260ff5
movq -0x20(%rbp), %rax
movsbl -0x21(%rbp), %edi
callq *%rax
testb $0x1, %al
jne 0x260f7b
movl $0x0, -0x4(%rbp)
jmp 0x260ff5
jmp 0x260f7d
movq -0x20(%rbp), %rax
movsbl -0x21(%rbp), %edi
callq *%rax
testb $0x1, %al
jne 0x260f8d
jmp 0x260f9f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15ff50
movb %al, -0x21(%rbp)
jmp 0x260f7d
jmp 0x260fee
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15ff50
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movsbl -0x21(%rbp), %edi
callq *%rax
testb $0x1, %al
jne 0x260fc8
movl $0x0, -0x4(%rbp)
jmp 0x260ff5
jmp 0x260fca
movq -0x20(%rbp), %rax
movsbl -0x21(%rbp), %edi
callq *%rax
testb $0x1, %al
jne 0x260fda
jmp 0x260fec
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15ff50
movb %al, -0x21(%rbp)
jmp 0x260fca
jmp 0x260fee
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x145(%rip), %rdi       # 0x276640
callq 0x2765c0
testb $0x1, %al
jne 0x27650d
movb $0x0, -0x1(%rbp)
jmp 0x2765ae
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x276690
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x276545
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x49b90
movb $0x0, -0x1(%rbp)
jmp 0x2765ae
cmpl $0xff, -0x34(%rbp)
jbe 0x276570
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x49b90
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x3cb90
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2765ae
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x17d(%rip), %rdi       # 0x276700
callq 0x2765c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x35(%rbp)
jne 0x276596
jmp 0x2765a6
movl -0x34(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movb $0x1, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, wchar_t, void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>>(wchar_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;
                    return cio::consume<X>(cio::str::delim_en_read<X, II>, i, e, cx) && (t = T(c32), true);
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x157b(%rip), %rdi     # 0x276640
callq 0x2765c0
testb $0x1, %al
jne 0x277bca
movb $0x0, -0x1(%rbp)
jmp 0x277c3e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x276690
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x277c02
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x49b90
movb $0x0, -0x1(%rbp)
jmp 0x277c3e
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x1515(%rip), %rdi     # 0x276700
callq 0x2765c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x35(%rbp)
jne 0x277c28
jmp 0x277c36
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x1a4b(%rip), %rdi     # 0x276640
callq 0x2765c0
testb $0x1, %al
jne 0x27809d
movb $0x0, -0x1(%rbp)
jmp 0x278140
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x276690
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x2780d5
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x49b90
movb $0x0, -0x1(%rbp)
jmp 0x278140
cmpl $0xffff, -0x34(%rbp)    # imm = 0xFFFF
jbe 0x278100
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x49b90
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x3cb90
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x278140
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x1a13(%rip), %rdi     # 0x276700
callq 0x2765c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x35(%rbp)
jne 0x278126
jmp 0x278138
movl -0x34(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movb $0x1, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/src/json/json.core-fundamental.cxx
// Function: std::enable_if<std::is_floating_point<float>::value, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::type cxon::test::to_string<float>(float)
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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x12, %edx
callq 0x11180
movq $0x12, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movl $0x12, %esi
leaq 0x2a6692(%rip), %rdx    # 0x52354f
movl $0x9, %ecx
movb $0x1, %al
callq 0x11280
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x27cedd
movslq -0x2c(%rbp), %rax
cmpq $0x12, %rax
setb %al
leaq -0x2d(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x11510
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x11470
jmp 0x27cefd
leaq -0x2d(%rbp), %rdi
callq 0x11600
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x11600
movq -0x38(%rbp), %rdi
callq 0x11310
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x7f, -0x14(%rbp)
jbe 0x28d6e6
cmpl $0x2028, -0x14(%rbp)    # imm = 0x2028
jne 0x28d692
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
leaq 0x29b061(%rip), %rsi    # 0x5286e2
movl $0x6, %edx
callq 0x28ce70
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x28d6fe
cmpl $0x2029, -0x14(%rbp)    # imm = 0x2029
jne 0x28d6bb
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
leaq 0x29b03f(%rip), %rsi    # 0x5286e9
movl $0x6, %edx
callq 0x28ce70
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x28d6fe
movl -0x14(%rbp), %esi
leaq -0x24(%rbp), %rdi
callq 0x5b010
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movslq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x28ce70
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x28d6fe
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0x28cd20
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
movb $0x0, -0x1e(%rbp)
callq 0x111a0
movq -0x58(%rbp), %rsi
movl -0x1c(%rbp), %edx
movsbl -0x1d(%rbp), %ecx
leaq -0x40(%rbp), %rdi
callq 0x2b95e0
jmp 0x2bdf47
jmp 0x2bdf49
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x21a770
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x61(%rbp)
jne 0x2bdf64
jmp 0x2bdf86
leaq -0x10(%rbp), %rdi
callq 0x21a7b0
movsbl (%rax), %esi
leaq -0x40(%rbp), %rdi
callq 0x2bba90
movb %al, -0x62(%rbp)
jmp 0x2bdf7e
movb -0x62(%rbp), %al
movb %al, -0x61(%rbp)
jmp 0x2bdf86
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x2bdf8f
jmp 0x2bdfb3
jmp 0x2bdf91
leaq -0x10(%rbp), %rdi
callq 0x43060
jmp 0x2bdf49
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x113b0
jmp 0x2bdfd0
movb $0x1, -0x1e(%rbp)
testb $0x1, -0x1e(%rbp)
jne 0x2bdfc6
movq -0x58(%rbp), %rdi
callq 0x113b0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x11310
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rax), %rcx
addq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0x2d63f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x2d713f
movq -0x28(%rbp), %rdi
callq 0x2d6400
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rdi
callq 0x2d63f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jbe 0x2d713d
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5cbb0
jmp 0x2d7184
jmp 0x2d713f
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rdi
callq 0x2d6480
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rax
addq 0x10(%rax), %rdx
callq 0x2d7190
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x4, %esi
callq 0x3c8bd0
movq -0x98(%rbp), %rax
movq $0x0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x40(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x3c8c30
movb %al, -0x89(%rbp)
jmp 0x3c8ad6
movb -0x89(%rbp), %al
andb $0x1, %al
movb %al, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x3c8b11
movb $0x0, -0x1(%rbp)
movl $0x1, -0x80(%rbp)
jmp 0x3c8ba9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3c8710
jmp 0x3c8bc0
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
xorl %edx, %edx
callq 0x3c8cb0
jmp 0x3c8b22
movq $0x0, -0x88(%rbp)
movq -0x88(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x3c8b9e
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3c8d40
movq %rax, -0xa0(%rbp)
jmp 0x3c8b53
movq -0xa0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xac(%rbp)
movq -0x10(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x3c8d40
movq %rax, -0xa8(%rbp)
jmp 0x3c8b7b
movq -0xa8(%rbp), %rax
movl -0xac(%rbp), %ecx
movl %ecx, (%rax)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x3c8b2d
movb $0x1, -0x1(%rbp)
movl $0x1, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3c8710
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x11310
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rcx
movq (%rcx), %rdx
movq 0x10(%rax), %rcx
leaq -0xc(%rbp), %rdi
callq 0x3d280
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xd(%rbp)
jne 0x3cf520
jmp 0x3cf536
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0xc(%rbp), %rsi
callq 0x3cf550
movb $0x1, %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/json/lib/std/bitset.hxx
// Function: bool cxon::json::imp::read_bits_<cxon::JSON<cxon::json::format_traits>, 8ul, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>>(std::bitset<8ul>&, char const*&, char const*, cxon::context<cxon::JSON<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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x8, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3fd246
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x589e0
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x30, %eax
je 0x3fd211
movsbl -0x31(%rbp), %eax
cmpl $0x31, %eax
je 0x3fd211
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x3cb90
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3fd24a
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $-0x1, %rsi
movq %rsi, -0x30(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x31, %eax
sete %al
movzbl %al, %edx
andl $0x1, %edx
callq 0x3fd260
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3fd1d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x8, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3fd686
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $-0x1, %rsi
movq %rsi, -0x28(%rbp)
callq 0x3fd6a0
movb %al, %cl
movb $0x31, %al
movb $0x30, %dl
movb %dl, -0x2a(%rbp)
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x3fd667
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rdi
movb -0x29(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0x441e0
testb $0x1, %al
jne 0x3fd684
movb $0x0, -0x1(%rbp)
jmp 0x3fd68a
jmp 0x3fd62c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22b0
movl %eax, -0xc(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2330
movq -0x50(%rbp), %rdx
leaq 0x1a68(%rip), %rsi      # 0x90f8
leaq -0x30(%rbp), %rdi
callq 0x2260
jmp 0x769b
leaq -0x31(%rbp), %rdi
callq 0x2200
movl $0x7, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7709
movq -0x8(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x2210
movsbl (%rax), %esi
leaq -0x30(%rbp), %rdi
callq 0x2150
jmp 0x76ce
jmp 0x76d0
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x76ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x2200
jmp 0x7732
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2140
jmp 0x7732
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
movl $0xa, %edx
callq 0x8320
movl %eax, -0x54(%rbp)
jmp 0x7720
leaq -0x30(%rbp), %rdi
callq 0x2140
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2320
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x4(%rbp)
je 0x775c
xorl %edi, %edi
callq 0x2220
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x6aa5(%rip)      # 0xe210
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x6a9e(%rip)      # 0xe218
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x6a97(%rip)      # 0xe220
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x6ac0
leaq -0x20(%rbp), %rdi
callq 0x68e0
movl %eax, -0x24(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x77cf
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x6d10
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x6ac0
movq -0x20(%rbp), %rdi
callq 0x68e0
movl %eax, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7829
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x6d10
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x69b0
movq -0x20(%rbp), %rdi
callq 0x68e0
movl %eax, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7889
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x6d10
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x6be0
testb $0x1, -0x15(%rbp)
jne 0x7aef
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6d10
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0x558, %rsp            # imm = 0x558
movl $0x0, 0x554(%rsp)
movl %edi, 0x550(%rsp)
movq %rsi, 0x548(%rsp)
cmpl $0x2, 0x550(%rsp)
jg 0x257b
movq 0x548(%rsp), %rax
movq (%rax), %rdi
callq 0x26c0
movl $0x1, 0x554(%rsp)
jmp 0x269e
movq 0x548(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x540(%rsp)
movq 0x548(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x538(%rsp)
leaq 0x458(%rsp), %rdi
movl $0x1, %esi
callq 0x2800
movq 0x540(%rsp), %rsi
leaq 0x448(%rsp), %rdi
callq 0x2930
jmp 0x25cc
leaq 0x458(%rsp), %rdi
leaq 0x448(%rsp), %rsi
callq 0x5ee0
jmp 0x25e3
leaq 0x28(%rsp), %rdi
callq 0x2980
jmp 0x25ef
movq 0x538(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2930
jmp 0x2603
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x458(%rsp), %rdx
callq 0x29f0
movb %al, 0xf(%rsp)
jmp 0x2620
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %dl
movl $0x64, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x554(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2c10
leaq 0x458(%rsp), %rdi
callq 0x2c40
jmp 0x269e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x440(%rsp)
movl %eax, 0x43c(%rsp)
jmp 0x268f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x440(%rsp)
movl %eax, 0x43c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2c10
leaq 0x458(%rsp), %rdi
callq 0x2c40
jmp 0x26ad
movl 0x554(%rsp), %eax
addq $0x558, %rsp            # imm = 0x558
retq
movq 0x440(%rsp), %rdi
callq 0x2300
nopw (%rax,%rax)