LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: vssense[P]Compiler/src/shlang/main.cpp
// Function: CallFrontEnd(FlagInfo*)
void CallFrontEnd(FlagInfo* info)
{
    assert(info);

    char front_end_call[syscall_size] = "";
    int len = 0;

    sprintf(front_end_call, "build/front-end %s %d %d %d %d%n", info->input_file,
            info->parser_dump_required, info->tree_dump_required,
            info->emit_tree_requiered, info->emit_code_requiered, &len);

    if ((info->emit_tree_requiered || info->emit_code_requiered) &&
         info->output_file != nullptr)
    {
        sprintf(front_end_call + len, " %s", info->output_file);
    }

    system(front_end_call);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11a8
jmp 0x11c7
leaq 0xe55(%rip), %rdi       # 0x2004
leaq 0xe53(%rip), %rsi       # 0x2009
movl $0x7, %edx
leaq 0xe5b(%rip), %rcx       # 0x201d
callq 0x1060
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x1050
movl $0x0, -0x94(%rbp)
leaq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movb 0x12(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movb 0x13(%rax), %al
andb $0x1, %al
movzbl %al, %r8d
movq -0x8(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %r9d
movq -0x8(%rbp), %rax
movb 0x11(%rax), %al
andb $0x1, %al
movzbl %al, %r10d
leaq 0xe0f(%rip), %rsi       # 0x203b
leaq -0x94(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x1257
movq -0x8(%rbp), %rax
testb $0x1, 0x11(%rax)
je 0x1289
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1289
leaq -0x90(%rbp), %rdi
movslq -0x94(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xdda(%rip), %rsi       # 0x205c
movb $0x0, %al
callq 0x1040
leaq -0x90(%rbp), %rdi
callq 0x1070
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: vssense[P]Compiler/src/shlang/main.cpp
// Function: CallBackEnd(FlagInfo*)
void CallBackEnd(FlagInfo* info)
{
    assert(info);

    char back_end_call[syscall_size] = "";

    int len = 0;

    sprintf(back_end_call, "build/back-end %d %d %d %d%n", info->nametable_dump_required,
            info->asm_listing_required, info->speed_optimization_required,
            info->memory_optimization_required, &len);

    if (info->output_file != nullptr)
    {
        sprintf(back_end_call + len, " %s", info->output_file);
    }

    system(back_end_call);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12b8
jmp 0x12d7
leaq 0xd45(%rip), %rdi       # 0x2004
leaq 0xd43(%rip), %rsi       # 0x2009
movl $0x1b, %edx
leaq 0xd8e(%rip), %rcx       # 0x2060
callq 0x1060
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x1050
movl $0x0, -0x94(%rbp)
leaq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rax
movb 0x14(%rax), %al
andb $0x1, %al
movzbl %al, %edx
movq -0x8(%rbp), %rax
movb 0x15(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movb 0x16(%rax), %al
andb $0x1, %al
movzbl %al, %r8d
movq -0x8(%rbp), %rax
movb 0x17(%rax), %al
andb $0x1, %al
movzbl %al, %r9d
leaq 0xd49(%rip), %rsi       # 0x207d
leaq -0x94(%rbp), %rax
movq %rax, (%rsp)
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1378
leaq -0x90(%rbp), %rdi
movslq -0x94(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xceb(%rip), %rsi       # 0x205c
movb $0x0, %al
callq 0x1040
leaq -0x90(%rbp), %rdi
callq 0x1070
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/shlang/main.cpp
// Function: main
int main(int argc, char const* argv[])
{
    FlagInfo info = {};
    GetFlagInfo(argc, argv, &info);

    if (info.input_file == nullptr)
    {
        printf("error: no input file\n");
        return 0;
    }

    CallFrontEnd(&info);

    if (info.emit_tree_requiered || info.emit_code_requiered)
    {
        return 0;
    }

    if (info.speed_optimization_required)
    {
        system("build/middle-end");
    }

    CallBackEnd(&info);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movb $0x0, -0x18(%rbp)
movb $0x0, -0x17(%rbp)
movb $0x0, -0x16(%rbp)
movb $0x0, -0x15(%rbp)
movb $0x0, -0x14(%rbp)
movb $0x0, -0x13(%rbp)
movb $0x0, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x16d0
cmpq $0x0, -0x28(%rbp)
jne 0x1404
leaq 0xca6(%rip), %rdi       # 0x209a
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x1444
leaq -0x28(%rbp), %rdi
callq 0x1190
testb $0x1, -0x18(%rbp)
jne 0x1419
testb $0x1, -0x17(%rbp)
je 0x1422
movl $0x0, -0x4(%rbp)
jmp 0x1444
testb $0x1, -0x12(%rbp)
je 0x1434
leaq 0xc81(%rip), %rdi       # 0x20b0
callq 0x1070
leaq -0x28(%rbp), %rdi
callq 0x12a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/shlang/flag_manager.cpp
// Function: GetFlagInfo(int, char const**, FlagInfo*)
void GetFlagInfo(const int argc, const char** argv, FlagInfo* info)
{
    assert(argv);
    assert(info);

    for (int i = 1; i < argc; ++i)
    {
        if (argv[i][0] == '-')
        {
            GetFlag(argv, info, &i);
        }
        else
        {
            if (info->input_file != nullptr)
            {
                printf("error : more than one input files\n");
                return;
            }

            info->input_file = argv[i];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16ec
jmp 0x170b
leaq 0xe0f(%rip), %rdi       # 0x2502
leaq 0xe0d(%rip), %rsi       # 0x2507
movl $0x4c, %edx
leaq 0xe75(%rip), %rcx       # 0x257b
callq 0x1060
cmpq $0x0, -0x18(%rbp)
je 0x1714
jmp 0x1733
leaq 0x8e9(%rip), %rdi       # 0x2004
leaq 0xde5(%rip), %rsi       # 0x2507
movl $0x4d, %edx
leaq 0xe4d(%rip), %rcx       # 0x257b
callq 0x1060
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x17a3
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1769
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x1450
jmp 0x1796
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1783
leaq 0xe38(%rip), %rdi       # 0x25b2
movb $0x0, %al
callq 0x1030
jmp 0x17a3
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1798
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x173a
addq $0x20, %rsp
popq %rbp
retq
// File: oknenavin[P]cxon/test/src/cbor/../utility.hxx
// Function: double test::measure<test::kind::time(std::vector<test::fixture, std::allocator<test::fixture>> const&)::$_0>(test::kind::time(std::vector<test::fixture, std::allocator<test::fixture>> const&)::$_0)
inline double measure(B block) {
            using clock = std::chrono::steady_clock;
            using ns = std::chrono::nanoseconds;
            std::vector<ns> sl;
            {   ns  rt = ns {0}, rm = ns {std::chrono::milliseconds {CXON_TIME_RUN_FOR}} ;
                do {
                    auto const s = clock::now();
                        block();
                    sl.emplace_back(std::chrono::duration_cast<ns>(clock::now() - s));
                    rt += sl.back();
                }   while (rt < rm || sl.size() < 17);
            }
            auto const md = imp::median_(sl);
            return std::chrono::duration<double, std::milli>(md).count();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x51000
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x5210
movq 0xb7d55(%rip), %rax     # 0xc1058
movq %rax, -0x28(%rbp)
callq 0x54c0
movq -0x70(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x9cb0
jmp 0x931b
callq 0x54c0
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x510c0
movq %rax, -0x78(%rbp)
jmp 0x9337
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x51090
movq %rax, -0x80(%rbp)
jmp 0x934e
movq -0x80(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x51020
jmp 0x9365
leaq -0x18(%rbp), %rdi
callq 0x51110
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x51150
jmp 0x937c
jmp 0x937e
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x51190
movb %al, -0x81(%rbp)
jmp 0x9393
movb -0x81(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x82(%rbp)
jne 0x93be
jmp 0x93a8
leaq -0x18(%rbp), %rdi
callq 0x511f0
cmpq $0x11, %rax
setb %al
movb %al, -0x82(%rbp)
movb -0x82(%rbp), %al
testb $0x1, %al
jne 0x9307
leaq -0x18(%rbp), %rdi
callq 0x51210
movq %rax, -0x90(%rbp)
jmp 0x93de
movq -0x90(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x51300
jmp 0x93f8
leaq -0x68(%rbp), %rdi
callq 0x51340
movsd %xmm0, -0x98(%rbp)
jmp 0x940b
leaq -0x18(%rbp), %rdi
callq 0x51360
movsd -0x98(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x51360
movq -0x38(%rbp), %rdi
callq 0x5660
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/../charconv.hxx
// Function: cxon::charconv::imp::from_chars_result cxon::charconv::imp::(anonymous namespace)::number_from_chars_<double, double (*)(char const*, char**)>(char const*, char const*, double (*)(char const*, char**), double&, cxon::charconv::imp::chars_format)
inline from_chars_result number_from_chars_(const char* first, const char*, Cv convert, T& value, chars_format) noexcept {
                    if (is_sign_invalid_<T>(*first)) return { first, std::errc::invalid_argument };
                char* end;
                errno = 0; auto const v = convert(first, &end);
                return { end, end != first ? errno != ERANGE ? (value = v, std::errc{}) : std::errc::result_out_of_range : std::errc::invalid_argument };
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x9760
testb $0x1, %al
jne 0x969e
jmp 0x96b2
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x16, -0x8(%rbp)
jmp 0x973d
callq 0x5060
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq *%rax
movsd %xmm0, -0x50(%rbp)
jmp 0x96d2
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x972a
callq 0x5060
cmpl $0x22, (%rax)
je 0x9718
movsd -0x48(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
movl %eax, -0x5c(%rbp)
jmp 0x9722
movl $0x22, %eax
movl %eax, -0x5c(%rbp)
jmp 0x9722
movl -0x5c(%rbp), %eax
movl %eax, -0x60(%rbp)
jmp 0x9734
movl $0x16, %eax
movl %eax, -0x60(%rbp)
jmp 0x9734
movq -0x58(%rbp), %rax
movl -0x60(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xc1f0
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lib/node.json.hxx
// Function: bool cxon::imp::read_string_value_extract_nans_<cxon::JSON<test::kind::unquoted_keys_traits>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*, cxon::context<cxon::JSON<test::kind::unquoted_keys_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>, cxon::napa::imp::cst<cxon::node::json::extract_nans, bool, true>>>(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*&, char const*, cxon::context<cxon::JSON<test::kind::unquoted_keys_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>, cxon::napa::imp::cst<cxon::node::json::extract_nans, bool, true>>&)
static bool read_string_value_extract_nans_(N& n, S& s, II& i, II e, Cx& cx) {
                if (read_value<X>(s, i, e, cx)) {
                    using real = typename N::real;
                    using symbol = typename S::value_type;
                         if (s == nmst_<symbol>::pinf) n.template imbue<real>() =  std::numeric_limits<real>::infinity();
                    else if (s == nmst_<symbol>::ninf) n.template imbue<real>() = -std::numeric_limits<real>::infinity();
                    else if (s == nmst_<symbol>::nan ) n.template imbue<real>() =  std::numeric_limits<real>::quiet_NaN();
                    return true;
                }
                return false;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x2dac0
testb $0x1, %al
jne 0x97ba
jmp 0x9878
movq -0x18(%rbp), %rdi
leaq 0xb941a(%rip), %rsi     # 0xc2bdf
callq 0xac50
testb $0x1, %al
jne 0x97d0
jmp 0x97f1
callq 0x2a830
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21fe0
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x9872
movq -0x18(%rbp), %rdi
leaq 0xb93e2(%rip), %rsi     # 0xc2bde
callq 0xac50
testb $0x1, %al
jne 0x9807
jmp 0x983c
callq 0x2a830
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21fe0
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x9870
movq -0x18(%rbp), %rdi
leaq 0xb9579(%rip), %rsi     # 0xc2dc0
callq 0xac50
testb $0x1, %al
jne 0x9852
jmp 0x986e
callq 0x2a840
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21fe0
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x9870
jmp 0x9872
movb $0x1, -0x1(%rbp)
jmp 0x987c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/../charconv.hxx
// Function: std::enable_if<std::is_integral<long long>::value, cxon::charconv::imp::to_chars_result>::type cxon::charconv::imp::(anonymous namespace)::number_to_chars_<long long>(char*, char*, long long, int)
inline auto number_to_chars_(char* first, char* last, T value, int base) noexcept
                 -> typename std::enable_if<std::is_integral<T>::value, to_chars_result>::type
            {
                CXON_ASSERT(base >= 2 && base <= 36, "invalid base");
                CXON_ASSERT(last > first && std::size_t(last - first) >= std::numeric_limits<T>::digits10 + 1, "buffer too small");
                unsigned const w = itoa_(first, value, base);
                return { first + w, std::errc{} };
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
cmpl $0x2, -0x2c(%rbp)
jl 0x9934
cmpl $0x24, -0x2c(%rbp)
setle %al
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x9950
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
cmpq $0x13, %rax
setae %al
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x9990
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl -0x30(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/../charconv.hxx
// Function: std::enable_if<std::is_signed<long long>::value, unsigned int>::type cxon::charconv::imp::(anonymous namespace)::itoa_<long long>(char*, long long, int)
inline auto itoa_(char* b, T t, int base) noexcept -> typename std::enable_if<std::is_signed<T>::value, unsigned>::type {
                using U = typename std::make_unsigned<T>::type;
                return t < 0 ?
                    *b = '-', itoa_<U>(++b, -t, base) + 1 :
                              itoa_<U>(  b,  t, base)
                ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x99d5
movq -0x8(%rbp), %rax
movb $0x2d, (%rax)
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %esi
subq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x9a00
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x99e8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x9a00
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/../charconv.hxx
// Function: std::enable_if<std::is_unsigned<unsigned long long>::value, unsigned int>::type cxon::charconv::imp::(anonymous namespace)::itoa_<unsigned long long>(char*, unsigned long long, int)
inline auto itoa_(char* b, T t, int base) noexcept -> typename std::enable_if<std::is_unsigned<T>::value, unsigned>::type {
                char    *p = b;
                do      *p = "0123456789abcdefghijklmnopqrstuvwxyz"[t % (T)base], ++p;
                while   (t /= (T)base);
                return  std::reverse(b, p), unsigned(p - b);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
xorl %edx, %edx
divq %rcx
leaq 0xb939a(%rip), %rax     # 0xc2dc9
movb (%rax,%rdx), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x9a1b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4e520
jmp 0x9a6a
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xc1f0
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lib/node.json.hxx
// Function: bool cxon::imp::write_number_key_<cxon::JSON<cxon::cio::key::unquoted_traits<cxon::json::format_traits>>, cxon::json::indenter<cxon::JSON<cxon::JSON<cxon::json::format_traits>>, std::ostreambuf_iterator<char, std::char_traits<char>>>, double, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(cxon::json::indenter<cxon::JSON<cxon::JSON<cxon::json::format_traits>>, std::ostreambuf_iterator<char, std::char_traits<char>>>&, double const&, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool write_number_key_(O& o, const T& t, Cx& cx) {
                if (std::isinf(t))
                    return std::signbit(t) ?
                            write_value<X>(o, "-inf", cx) : write_value<X>(o, "inf", cx)
                    ;
                if (std::isnan(t))
                    return  write_value<X>(o, "nan", cx);
                return cio::key::write_key<X>(o, t, cx);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x4e2e0
testb $0x1, %al
jne 0x9b37
jmp 0x9b84
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x4e370
testb $0x1, %al
jne 0x9b4a
jmp 0x9b63
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xb9085(%rip), %rsi     # 0xc2bde
callq 0x4e930
movb %al, -0x21(%rbp)
jmp 0x9b7a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xb906d(%rip), %rsi     # 0xc2bdf
callq 0x4e960
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9bc8
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x4e990
testb $0x1, %al
jne 0x9b97
jmp 0x9bb2
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xb921a(%rip), %rsi     # 0xc2dc0
callq 0x4e960
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9bc8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4e9b0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/src/cbor/../utility.hxx
// Function: test::get_directory[abi:cxx11](char const*)
inline std::string get_directory(const char* fpth) {
        std::string s = fpth;
        auto l = s.rfind('/');
#       ifdef _WIN32
            if (l == std::string::npos) l = s.rfind('\\');
#       endif
        return l != std::string::npos ? s.substr(0, l + 1) : "";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5670
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x54f0
jmp 0xa1f6
leaq -0x31(%rbp), %rdi
callq 0x53f0
leaq -0x30(%rbp), %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x56f0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movb $0x0, -0x52(%rbp)
cmpq $-0x1, %rax
je 0xa242
movq -0x78(%rbp), %rdi
movq -0x50(%rbp), %rcx
incq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rsi
callq 0x53c0
jmp 0xa240
jmp 0xa26b
leaq -0x51(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5670
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rdx
movb $0x1, -0x52(%rbp)
leaq 0xb9b65(%rip), %rsi     # 0xc3dc7
callq 0x54f0
jmp 0xa269
jmp 0xa26b
testb $0x1, -0x52(%rbp)
jne 0xa273
jmp 0xa27c
leaq -0x51(%rbp), %rdi
callq 0x53f0
leaq -0x30(%rbp), %rdi
callq 0x5260
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x53f0
jmp 0xa2df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa2d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x52(%rbp)
jne 0xa2cb
jmp 0xa2d4
leaq -0x51(%rbp), %rdi
callq 0x53f0
jmp 0xa2d6
leaq -0x30(%rbp), %rdi
callq 0x5260
movq -0x40(%rbp), %rdi
callq 0x5660
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::operator=(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&)
basic_node& operator =(const basic_node& o)
                noexcept(value::is_nothrow_copy_assignable<basic_node>::value)
            {
                switch (o.kind_) {
#                   define CXON_JSON_TYPE_DEF(T)    case node_kind::T: return value::copy_assign<T>(*this, o)
                        CXON_JSON_TYPE_DEF(object);
                        CXON_JSON_TYPE_DEF(array);
                        CXON_JSON_TYPE_DEF(string);
                        CXON_JSON_TYPE_DEF(real);
                        CXON_JSON_TYPE_DEF(sint);
                        CXON_JSON_TYPE_DEF(uint);
                        CXON_JSON_TYPE_DEF(boolean);
                        CXON_JSON_TYPE_DEF(null);
#                   undef CXON_JSON_TYPE_DEF
                }
                return *this; // LCOV_EXCL_LINE
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0xadfc
movq -0x20(%rbp), %rax
leaq 0xb6308(%rip), %rcx     # 0xc1060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2fa20
movq %rax, -0x8(%rbp)
jmp 0xae04
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2fa50
movq %rax, -0x8(%rbp)
jmp 0xae04
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2fa80
movq %rax, -0x8(%rbp)
jmp 0xae04
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2fab0
movq %rax, -0x8(%rbp)
jmp 0xae04
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2fae0
movq %rax, -0x8(%rbp)
jmp 0xae04
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2fb10
movq %rax, -0x8(%rbp)
jmp 0xae04
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2fb40
movq %rax, -0x8(%rbp)
jmp 0xae04
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2fb70
movq %rax, -0x8(%rbp)
jmp 0xae04
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>::basic_node(cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>> const&)
basic_node(const basic_node& o)
                noexcept(value::is_nothrow_copy_constructible<basic_node>::value)
            :   kind_(o.kind_), alloc_(std::allocator_traits<allocator_type>::select_on_container_copy_construction(o.alloc_))
            {
                switch (o.kind_) {
#                   define CXON_CBOR_TYPE_DEF(T)    case node_kind::T: value::copy_construct<T>(*this, o); break
                        CXON_CBOR_TYPE_DEF(map);
                        CXON_CBOR_TYPE_DEF(array);
                        CXON_CBOR_TYPE_DEF(tag);
                        CXON_CBOR_TYPE_DEF(bytes);
                        CXON_CBOR_TYPE_DEF(text);
                        CXON_CBOR_TYPE_DEF(real);
                        CXON_CBOR_TYPE_DEF(sint);
                        CXON_CBOR_TYPE_DEF(uint);
                        CXON_CBOR_TYPE_DEF(simple);
                        CXON_CBOR_TYPE_DEF(boolean);
                        CXON_CBOR_TYPE_DEF(null);
                        CXON_CBOR_TYPE_DEF(undefined);
#                   undef CXON_CBOR_TYPE_DEF
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x20(%rdi)
addq $0x24, %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
addq $0x24, %rsi
callq 0x599f0
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x28(%rbp)
subq $0xb, %rax
ja 0xb9df
movq -0x28(%rbp), %rax
leaq 0xb5789(%rip), %rcx     # 0xc1080
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59a20
jmp 0xb90f
jmp 0xb9df
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x38940
jmp 0xb9e5
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59a50
jmp 0xb93d
jmp 0xb9df
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59a80
jmp 0xb951
jmp 0xb9df
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59ab0
jmp 0xb965
jmp 0xb9df
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59ae0
jmp 0xb976
jmp 0xb9df
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59b10
jmp 0xb9df
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59b40
jmp 0xb9df
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59b70
jmp 0xb9df
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59ba0
jmp 0xb9df
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59bd0
jmp 0xb9df
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59c00
jmp 0xb9df
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59c30
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5660
nop
// File: oknenavin[P]cxon/test/src/cbor/cbor.node-main.cxx
// Function: test::kind::test::hex2bin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string hex2bin(const std::string& hex) {
            static constexpr unsigned char hex_[256] = {
                /*  0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                /* 16*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                /* 32*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                /* 48*/ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0,
                /* 64*/ 0,10,11,12,13,14,15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                /* 80*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                /* 96*/ 0,10,11,12,13,14,15, 0, 0, 0, 0, 0, 0, 0, 0, 0
            };
            CXON_ASSERT(hex.length() % 2 == 0, "invalid input");
            std::string bin;
                for (std::size_t i = 0, is = hex.length(); i != is; i += 2) {
                    char const b = char((hex_[(unsigned)hex[i]] << 4) + hex_[(unsigned)hex[i + 1]]);
                    bin += b;
                }
            return bin;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5580
movq -0x48(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x5510
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5580
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x10f85
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5410
movsbl (%rax), %eax
leaq 0xb22e5(%rip), %rcx     # 0xc3200
movq %rcx, -0x60(%rbp)
movzbl (%rax,%rcx), %eax
shll $0x4, %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x5410
movq -0x60(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl -0x54(%rbp), %eax
movsbl (%rcx), %ecx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %esi
callq 0x5270
jmp 0x10f5e
jmp 0x10f60
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x10ef6
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x5260
jmp 0x10fa2
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x10f98
movq -0x48(%rbp), %rdi
callq 0x5260
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5660
nopl (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/cxon.hxx
// Function: cxon::from_bytes_result<decltype(std::begin(fp0))> cxon::interface::from_bytes<cxon::JSON<cxon::cxcf::format_traits>, test::config, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(test::config&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline auto from_bytes(T& t, const I& i, NaPa&&... p) -> from_bytes_result<decltype(std::begin(i))> {
                auto const c = cnt::continuous<I>::range(i);
                auto const r = interface::from_bytes<X>(t, c.first, c.second, std::forward<NaPa>(p)...);
                auto b = std::begin(i); std::advance(b, std::distance(c.first, r.end));
                return { r.ec, b };
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x117f0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x11820
movq -0x10(%rbp), %rdi
callq 0xa180
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x118e0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x11890
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rdi)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/io.hxx
// Function: std::enable_if<cxon::JSON<cxon::cio::key::simple_traits<cxon::cxcf::format_traits>>::allow_comments, bool>::type cxon::cio::imp::consume_<cxon::JSON<cxon::cio::key::simple_traits<cxon::cxcf::format_traits>>, char const*>(char const*&, char const*)
inline auto consume_(II& i, II e) -> enable_if_t< X::allow_comments, bool> {
                consume_ws_<X>(i, e);
                if (peek(i, e) == '/') {
                    switch (next(i, e)) {
                        case '*':
                            for (++i; i != e; )
                                     if (        *i != '*') { ++i; continue; }
                                else if (next(i, e) == '/') { ++i; break;    }
                            break;
                        case '/':
                            while (++i != e && *i != '\n')
                                ;
                            break;
                        default:
                            return false;
                    }
                    consume_<X>(i, e);
                }
                return true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x121f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x12250
movsbl %al, %eax
cmpl $0x2f, %eax
jne 0x121d3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12280
movsbl %al, %eax
movl %eax, -0x1c(%rbp)
subl $0x2a, %eax
je 0x12120
jmp 0x12113
movl -0x1c(%rbp), %eax
subl $0x2f, %eax
je 0x12185
jmp 0x121c0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x12183
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
je 0x1215a
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1212e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12280
movsbl %al, %eax
cmpl $0x2f, %eax
jne 0x1217f
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x12183
jmp 0x12181
jmp 0x1212e
jmp 0x121c6
jmp 0x12187
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x1d(%rbp)
je 0x121b3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x121bc
jmp 0x121be
jmp 0x12187
jmp 0x121c6
movb $0x0, -0x1(%rbp)
jmp 0x121d7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x120c0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/string.hxx
// Function: std::enable_if<has_traits<cxon::JSON<cxon::cio::str::raw_traits<cxon::cio::key::quoted_traits<cxon::cxcf::format_traits>>>, cxon::cio::str::raw_traits>::value, bool>::type cxon::cio::str::imp::imp::string_read_tail_<cxon::JSON<cxon::cio::str::raw_traits<cxon::cio::key::quoted_traits<cxon::cxcf::format_traits>>>, cxon::cnt::range_container<char*>, char const*, cxon::context<cxon::JSON<cxon::cxcf::format_traits>>, char>(cxon::cnt::range_container<char*>&, char const*&, char const*, cxon::context<cxon::JSON<cxon::cxcf::format_traits>>&)
inline auto string_read_tail_(C& c, II& i, II e, Cx& cx)
                    -> enable_if_t< has_traits<X, str::raw_traits>::value, bool>
                {
                    II l = i;
                        for ( ; i != e; ++i) {
                            if (delim_en_check<X>(*i)) {
                                if (l == i || cxon::cnt::append(c, l, i))
                                    return delim_en_read<X>(i, e);
                                return rewind(i, l), cx/X::read_error::overflow;
                            }
                        }
                    return cx/X::read_error::unexpected;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %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), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
je 0x12afb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x12b20
testb $0x1, %al
jne 0x12a89
jmp 0x12ae6
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0x12ab0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x12b60
testb $0x1, %al
jne 0x12ab0
jmp 0x12ac4
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12b90
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12b0e
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x12050
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x12080
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12b0e
jmp 0x12ae8
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x12a63
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x12080
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/common/container.hxx
// Function: std::enable_if<is_random_access_iterator<char const*>::value, bool>::type cxon::cnt::range_container<char*>::append<char const*>(char const*, char const*)
auto append(II f, II l) noexcept
                    -> enable_if_t<is_random_access_iterator<II>::value, bool>
                {
#                   if defined(__GNUC__) && __GNUC__ >= 7 && !defined(__clang__)
#                       pragma GCC diagnostic push
                        // if f == l we have this with -O3 and seems it's only for unsigned char
#                       pragma GCC diagnostic ignored "-Wstringop-overflow"
#                   endif
                        auto const s = std::distance(f, l);
                        return s <= std::distance(e_, l_) && (std::copy(f, l, e_), e_ += s, true);
#                   if defined(__GNUC__) && __GNUC__ >= 7 && !defined(__clang__)
#                       pragma GCC diagnostic pop
#                   endif
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x118e0
movq %rax, -0x28(%rbp)
jmp 0x12c3f
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdi
callq 0x12cc0
movq %rax, -0x38(%rbp)
jmp 0x12c66
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x41(%rbp)
jg 0x12ca4
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rax), %rdx
callq 0x12d00
jmp 0x12c8f
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movb $0x1, %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xc1f0
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/json/lib/std/imp/map.hxx
// Function: bool cxon::json::imp::map_element_reader_<cxon::JSON<cxon::cxcf::format_traits>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, test::fixture, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, test::fixture>>>>::read<char const*, cxon::context<cxon::JSON<cxon::cxcf::format_traits>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, test::fixture, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, test::fixture>>>&, char const*&, char const*, cxon::context<cxon::JSON<cxon::cxcf::format_traits>>&)
static bool read(M& t, II& i, II e, Cx& cx) {
                    typename M::key_type    k = alc::create_using_allocator_of<typename M::key_type>(t);
                    typename M::mapped_type v = alc::create_using_allocator_of<typename M::mapped_type>(t);
                    return  cio::read_map_key<X>(k, i, e, cx) &&
                            cio::read_map_val<X>(cnt::emplace(t, std::move(k), std::move(v)).second, i, e, cx)
                    ;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x13b20
movq -0x8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x13b50
jmp 0x13a1a
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x13b80
movb %al, -0xb5(%rbp)
jmp 0x13a37
movb -0xb5(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xb6(%rbp)
jne 0x13a4c
jmp 0x13a9b
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x13c20
movq %rax, -0xc0(%rbp)
jmp 0x13a69
movq -0xc0(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x13be0
movb %al, -0xc1(%rbp)
jmp 0x13a8d
movb -0xc1(%rbp), %al
movb %al, -0xb6(%rbp)
jmp 0x13a9b
movb -0xb6(%rbp), %al
movb %al, -0xc2(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xd960
leaq -0x40(%rbp), %rdi
callq 0x5260
movb -0xc2(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x13aff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xd960
leaq -0x40(%rbp), %rdi
callq 0x5260
movq -0xb0(%rbp), %rdi
callq 0x5660
nopw %cs:(%rax,%rax)
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/char.hxx
// Function: char32_t cxon::cio::chr::esc_to_utf32<cxon::JSON<cxon::cio::key::quoted_traits<cxon::cxcf::format_traits>>, char const*, cxon::context<cxon::JSON<cxon::cxcf::format_traits>>>(char const*&, char const*, cxon::context<cxon::JSON<cxon::cxcf::format_traits>>&)
inline char32_t esc_to_utf32(II& i, II e, Cx& cx) {
            char32_t const c32 = imp::esc_to_utf32_<X>(i, e);
                if (c32 == bad_utf32) return cx/X::read_error::escape_invalid, bad_utf32;
            if (c32 < 0xD800 || c32 > 0xDBFF) return c32;
            // surrogate
                if (peek(i, e) != '\\') return cx/X::read_error::surrogate_invalid, bad_utf32;
            char32_t const s32 = (++i, imp::esc_to_utf32_<X>(i, e));
                if (s32 < 0xDC00 || s32 > 0xDFFF)
                    return (s32 == bad_utf32 ? cx/X::read_error::escape_invalid : cx/X::read_error::surrogate_invalid), bad_utf32;
            return char32_t(0x10000 + (((c32 - 0xD800) << 10) | (s32 - 0xDC00)));
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15290
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x14fc4
movq -0x20(%rbp), %rdi
movl $0x6, %esi
callq 0x12080
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1508b
cmpl $0xd800, -0x24(%rbp)    # imm = 0xD800
jb 0x14fd6
cmpl $0xdbff, -0x24(%rbp)    # imm = 0xDBFF
jbe 0x14fe1
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1508b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x12250
movsbl %al, %eax
cmpl $0x5c, %eax
je 0x15010
movq -0x20(%rbp), %rdi
movl $0x7, %esi
callq 0x12080
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1508b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15290
movl %eax, -0x28(%rbp)
cmpl $0xdc00, -0x28(%rbp)    # imm = 0xDC00
jb 0x15040
cmpl $0xdfff, -0x28(%rbp)    # imm = 0xDFFF
jbe 0x1506d
cmpl $-0x1, -0x28(%rbp)
jne 0x15056
movq -0x20(%rbp), %rdi
movl $0x6, %esi
callq 0x12080
jmp 0x15064
movq -0x20(%rbp), %rdi
movl $0x7, %esi
callq 0x12080
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1508b
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, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/char.hxx
// Function: std::enable_if<is_random_access_iterator<char const*>::value, char32_t>::type cxon::cio::chr::imp::u_to_<cxon::JSON<cxon::cio::key::quoted_traits<cxon::cxcf::format_traits>>>::dec<char const*>(char const*&, char const*)
static auto dec(II& i, II e) -> enable_if_t< is_random_access_iterator<II>::value, char32_t> {
                        if (e - i < 5 || !is<X>::digit16(i[1]) || !is<X>::digit16(i[2]) || !is<X>::digit16(i[3]) || !is<X>::digit16(i[4]))
                            return bad_utf32;
                        char32_t const c =  (hex_to_dec_[(unsigned char)i[1]] << 12) |
                                            (hex_to_dec_[(unsigned char)i[2]] <<  8) |
                                            (hex_to_dec_[(unsigned char)i[3]] <<  4) |
                                            (hex_to_dec_[(unsigned char)i[4]] <<  0)
                        ;
                        return i += 5, c;
                    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x5, %rax
jl 0x1548a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %edi
callq 0x15530
testb $0x1, %al
jne 0x1544a
jmp 0x1548a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %edi
callq 0x15530
testb $0x1, %al
jne 0x15460
jmp 0x1548a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x3(%rax), %edi
callq 0x15530
testb $0x1, %al
jne 0x15476
jmp 0x1548a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x4(%rax), %edi
callq 0x15530
testb $0x1, %al
jne 0x15496
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1551b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x1(%rax), %eax
movl %eax, %ecx
leaq 0xadb96(%rip), %rax     # 0xc3040
movl (%rax,%rcx,4), %eax
shll $0xc, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x2(%rcx), %ecx
movl %ecx, %edx
leaq 0xadb7c(%rip), %rcx     # 0xc3040
movl (%rcx,%rdx,4), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x3(%rcx), %ecx
movl %ecx, %edx
leaq 0xadb60(%rip), %rcx     # 0xc3040
movl (%rcx,%rdx,4), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x4(%rcx), %ecx
movl %ecx, %edx
leaq 0xadb44(%rip), %rcx     # 0xc3040
movl (%rcx,%rdx,4), %ecx
shll $0x0, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x5, %rcx
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: oknenavin[P]cxon/test/src/cbor/../utility.hxx
// Function: std::enable_if<!std::is_same<std::iterator_traits<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::iterator_category, std::input_iterator_tag>::value, std::pair<unsigned long, unsigned long>>::type test::imp::position_<__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>>>)
inline auto position_(II b, II e)
                -> typename std::enable_if<!std::is_same<typename std::iterator_traits<II>::iterator_category, std::input_iterator_tag>::value, std::pair<std::size_t, std::size_t>>::type
            {
                std::size_t l = 1, c = 1;
                for ( ; b != e; ++b, ++c)
                    if (*b == '\n')
                        ++l, c = 0;
                return std::make_pair(l, c);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq $0x1, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1aef0
testb $0x1, %al
jne 0x1ada3
jmp 0x1ade1
leaq -0x18(%rbp), %rdi
callq 0x1af30
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1adc8
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
jmp 0x1adca
leaq -0x18(%rbp), %rdi
callq 0x1ace0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1ad90
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1af50
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop