// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq 0x10(%rdi), %rcx
movq 0x48(%rdi), %rax
testq %rcx, %rcx
je 0x185d6
cmpq (%r15), %rax
jne 0x18779
addq %rax, %rcx
cmpq %rcx, 0x68(%rbx)
jne 0x18798
movq 0x50(%rbx), %r14
cmpq %r14, %rax
ja 0x186de
movq 0x60(%rbx), %r13
cmpq %r13, %r14
ja 0x186fd
movq 0x68(%rbx), %rdx
cmpq %rdx, %r13
ja 0x1871c
movq 0x58(%rbx), %rbp
cmpq %rdx, %rbp
ja 0x1873b
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x18666
movq (%rcx), %rsi
movq -0x18(%rsi), %rsi
testb $0x2, 0x20(%rcx,%rsi)
jne 0x18666
movq %r14, %rdx
subq %rax, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x989b0
andq $0x0, 0x30(%rbx)
leaq 0x28(%rbx), %r12
movq 0x28(%rbx), %rax
movb $0x0, (%rax)
movq (%rbx), %rdi
pushq $0xa
popq %rdx
movq %r12, %rsi
callq 0x1d9b0
movq %r15, %rdi
movq %r12, %rsi
callq 0x998b0
movq %r15, %rdi
pushq $0xa
popq %rsi
callq 0x98830
jmp 0x18694
movq %r15, %rdi
movq %r14, %rsi
callq 0x187b8
pushq $0x1
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x98c00
testq %r12, %r12
je 0x18694
decq %r12
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x98c00
movq 0x8(%rbx), %rax
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x1875a
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 0xb2329(%rip), %rdi     # 0xcaa0e
leaq 0xb1c19(%rip), %rsi     # 0xca305
leaq 0xb218b(%rip), %rcx     # 0xca87e
movl $0x2ab6, %edx           # imm = 0x2AB6
callq 0x13130
leaq 0xb231f(%rip), %rdi     # 0xcaa23
leaq 0xb1bfa(%rip), %rsi     # 0xca305
leaq 0xb216c(%rip), %rcx     # 0xca87e
movl $0x2ab7, %edx           # imm = 0x2AB7
callq 0x13130
leaq 0xb2314(%rip), %rdi     # 0xcaa37
leaq 0xb1bdb(%rip), %rsi     # 0xca305
leaq 0xb214d(%rip), %rcx     # 0xca87e
movl $0x2ab8, %edx           # imm = 0x2AB8
callq 0x13130
leaq 0xb2309(%rip), %rdi     # 0xcaa4b
leaq 0xb1bbc(%rip), %rsi     # 0xca305
leaq 0xb212e(%rip), %rcx     # 0xca87e
movl $0x2ab9, %edx           # imm = 0x2AB9
callq 0x13130
leaq 0xb1dfd(%rip), %rdi     # 0xca55e
leaq 0xb1b9d(%rip), %rsi     # 0xca305
leaq 0xb210f(%rip), %rcx     # 0xca87e
movl $0x2ae1, %edx           # imm = 0x2AE1
callq 0x13130
leaq 0xb209c(%rip), %rdi     # 0xca81c
leaq 0xb1b7e(%rip), %rsi     # 0xca305
leaq 0xb20f0(%rip), %rcx     # 0xca87e
movl $0x2aaf, %edx           # imm = 0x2AAF
callq 0x13130
leaq 0xb222a(%rip), %rdi     # 0xca9c9
leaq 0xb1b5f(%rip), %rsi     # 0xca305
leaq 0xb20d1(%rip), %rcx     # 0xca87e
movl $0x2ab3, %edx           # imm = 0x2AB3
callq 0x13130
nop