// File: /workspace/github_cpp_makefile_star2_O1/mattn[P]wandbox-run/./json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::fill_line_buffer(unsigned long)
void fill_line_buffer(size_t n = 0)
        {
            // if line buffer is used, m_content points to its data
            assert(m_line_buffer.empty()
                   or m_content == reinterpret_cast<const lexer_char_t*>(m_line_buffer.data()));

            // if line buffer is used, m_limit is set past the end of its data
            assert(m_line_buffer.empty()
                   or m_limit == m_content + m_line_buffer.size());

            // pointer relationships
            assert(m_content <= m_start);
            assert(m_start <= m_cursor);
            assert(m_cursor <= m_limit);
            assert(m_marker == nullptr or m_marker  <= m_limit);

            // number of processed characters (p)
            const auto num_processed_chars = static_cast<size_t>(m_start - m_content);
            // offset for m_marker wrt. to m_start
            const auto offset_marker = (m_marker == nullptr) ? 0 : m_marker - m_start;
            // number of unprocessed characters (u)
            const auto offset_cursor = m_cursor - m_start;

            // no stream is used or end of file is reached
            if (m_stream == nullptr or m_stream->eof())
            {
                // m_start may or may not be pointing into m_line_buffer at
                // this point. We trust the standard library to do the right
                // thing. See http://stackoverflow.com/q/28142011/266378
                m_line_buffer.assign(m_start, m_limit);

                // append n characters to make sure that there is sufficient
                // space between m_cursor and m_limit
                m_line_buffer.append(1, '\x00');
                if (n > 0)
                {
                    m_line_buffer.append(n - 1, '\x01');
                }
            }
            else
            {
                // delete processed characters from line buffer
                m_line_buffer.erase(0, num_processed_chars);
                // read next line from input stream
                m_line_buffer_tmp.clear();
                std::getline(*m_stream, m_line_buffer_tmp, '\n');

                // add line with newline symbol to the line buffer
                m_line_buffer += m_line_buffer_tmp;
                m_line_buffer.push_back('\n');
            }

            // set pointers
            m_content = reinterpret_cast<const lexer_char_t*>(m_line_buffer.data());
            assert(m_content != nullptr);
            m_start  = m_content;
            m_marker = m_start + offset_marker;
            m_cursor = m_start + offset_cursor;
            m_limit  = m_start + m_line_buffer.size();
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
je 0x19128
movq 0x48(%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x192f5
testq %rdx, %rdx
je 0x19128
movq 0x48(%rbx), %rax
addq %rdx, %rax
cmpq %rax, 0x68(%rbx)
jne 0x19314
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %r14
cmpq %r14, %rax
ja 0x1925a
movq 0x60(%rbx), %r13
cmpq %r13, %r14
ja 0x19279
movq 0x68(%rbx), %r8
cmpq %r8, %r13
ja 0x19298
movq 0x58(%rbx), %rbp
cmpq %r8, %rbp
ja 0x192b7
leaq 0x8(%rbx), %r12
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x191c9
movq (%rcx), %rsi
movq -0x18(%rsi), %rsi
testb $0x2, 0x20(%rcx,%rsi)
jne 0x191c9
movq %r14, %rdx
subq %rax, %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x99840
leaq 0x28(%rbx), %rsi
movq $0x0, 0x30(%rbx)
movq 0x28(%rbx), %rax
movb $0x0, (%rax)
movq (%rbx), %rdi
movl $0xa, %edx
callq 0x1e840
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq %r12, %rdi
callq 0x9a6a0
movq %r12, %rdi
movl $0xa, %esi
callq 0x996c0
jmp 0x19210
movq 0x8(%rbx), %rsi
addq %rsi, %rdx
movq %r12, %rdi
movq %r14, %rcx
callq 0x19334
movq 0x10(%rbx), %rsi
movl $0x1, %ecx
movq %r12, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x99970
testq %r15, %r15
je 0x19210
decq %r15
movq 0x10(%rbx), %rsi
movq %r12, %rdi
xorl %edx, %edx
movq %r15, %rcx
movl $0x1, %r8d
callq 0x99970
movq 0x8(%rbx), %rax
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x192d6
movq %rbp, %rcx
subq %r14, %rcx
testq %rbp, %rbp
cmoveq %rbp, %rcx
subq %r14, %r13
movq %rax, 0x50(%rbx)
addq %rax, %rcx
movq %rcx, 0x58(%rbx)
addq %rax, %r13
movq %r13, 0x60(%rbx)
addq 0x10(%rbx), %rax
movq %rax, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb27ad(%rip), %rdi     # 0xcba0e
leaq 0xb209d(%rip), %rsi     # 0xcb305
leaq 0xb260f(%rip), %rcx     # 0xcb87e
movl $0x2ab6, %edx           # imm = 0x2AB6
callq 0x13130
leaq 0xb27a3(%rip), %rdi     # 0xcba23
leaq 0xb207e(%rip), %rsi     # 0xcb305
leaq 0xb25f0(%rip), %rcx     # 0xcb87e
movl $0x2ab7, %edx           # imm = 0x2AB7
callq 0x13130
leaq 0xb2798(%rip), %rdi     # 0xcba37
leaq 0xb205f(%rip), %rsi     # 0xcb305
leaq 0xb25d1(%rip), %rcx     # 0xcb87e
movl $0x2ab8, %edx           # imm = 0x2AB8
callq 0x13130
leaq 0xb278d(%rip), %rdi     # 0xcba4b
leaq 0xb2040(%rip), %rsi     # 0xcb305
leaq 0xb25b2(%rip), %rcx     # 0xcb87e
movl $0x2ab9, %edx           # imm = 0x2AB9
callq 0x13130
leaq 0xb2281(%rip), %rdi     # 0xcb55e
leaq 0xb2021(%rip), %rsi     # 0xcb305
leaq 0xb2593(%rip), %rcx     # 0xcb87e
movl $0x2ae1, %edx           # imm = 0x2AE1
callq 0x13130
leaq 0xb2520(%rip), %rdi     # 0xcb81c
leaq 0xb2002(%rip), %rsi     # 0xcb305
leaq 0xb2574(%rip), %rcx     # 0xcb87e
movl $0x2aaf, %edx           # imm = 0x2AAF
callq 0x13130
leaq 0xb26ae(%rip), %rdi     # 0xcb9c9
leaq 0xb1fe3(%rip), %rsi     # 0xcb305
leaq 0xb2555(%rip), %rcx     # 0xcb87e
movl $0x2ab3, %edx           # imm = 0x2AB3
callq 0x13130
nop