// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::parser<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>>::parse_internal(bool, 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>&)
void parse_internal(bool keep, BasicJsonType& result)
    {
        // never parse after a parse error was detected
        assert(not errored);

        // start with a discarded value
        if (not result.is_discarded())
        {
            result.m_value.destroy(result.m_type);
            result.m_type = value_t::discarded;
        }

        switch (last_token)
        {
            case token_type::begin_object:
            {
                if (keep)
                {
                    if (callback)
                    {
                        keep = callback(depth++, parse_event_t::object_start, result);
                    }

                    if (not callback or keep)
                    {
                        // explicitly set result to object to cope with {}
                        result.m_type = value_t::object;
                        result.m_value = value_t::object;
                    }
                }

                // read next token
                get_token();

                // closing } -> we are done
                if (last_token == token_type::end_object)
                {
                    if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
                    {
                        result.m_value.destroy(result.m_type);
                        result.m_type = value_t::discarded;
                    }
                    break;
                }

                // parse values
                std::string key;
                BasicJsonType value;
                while (true)
                {
                    // store key
                    if (not expect(token_type::value_string))
                    {
                        return;
                    }
                    key = m_lexer.move_string();

                    bool keep_tag = false;
                    if (keep)
                    {
                        if (callback)
                        {
                            BasicJsonType k(key);
                            keep_tag = callback(depth, parse_event_t::key, k);
                        }
                        else
                        {
                            keep_tag = true;
                        }
                    }

                    // parse separator (:)
                    get_token();
                    if (not expect(token_type::name_separator))
                    {
                        return;
                    }

                    // parse and add value
                    get_token();
                    value.m_value.destroy(value.m_type);
                    value.m_type = value_t::discarded;
                    parse_internal(keep, value);

                    if (JSON_UNLIKELY(errored))
                    {
                        return;
                    }

                    if (keep and keep_tag and not value.is_discarded())
                    {
                        result.m_value.object->emplace(std::move(key), std::move(value));
                    }

                    // comma -> next value
                    get_token();
                    if (last_token == token_type::value_separator)
                    {
                        get_token();
                        continue;
                    }

                    // closing }
                    if (not expect(token_type::end_object))
                    {
                        return;
                    }
                    break;
                }

                if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
                {
                    result.m_value.destroy(result.m_type);
                    result.m_type = value_t::discarded;
                }
                break;
            }

            case token_type::begin_array:
            {
                if (keep)
                {
                    if (callback)
                    {
                        keep = callback(depth++, parse_event_t::array_start, result);
                    }

                    if (not callback or keep)
                    {
                        // explicitly set result to array to cope with []
                        result.m_type = value_t::array;
                        result.m_value = value_t::array;
                    }
                }

                // read next token
                get_token();

                // closing ] -> we are done
                if (last_token == token_type::end_array)
                {
                    if (callback and not callback(--depth, parse_event_t::array_end, result))
                    {
                        result.m_value.destroy(result.m_type);
                        result.m_type = value_t::discarded;
                    }
                    break;
                }

                // parse values
                BasicJsonType value;
                while (true)
                {
                    // parse value
                    value.m_value.destroy(value.m_type);
                    value.m_type = value_t::discarded;
                    parse_internal(keep, value);

                    if (JSON_UNLIKELY(errored))
                    {
                        return;
                    }

                    if (keep and not value.is_discarded())
                    {
                        result.m_value.array->push_back(std::move(value));
                    }

                    // comma -> next value
                    get_token();
                    if (last_token == token_type::value_separator)
                    {
                        get_token();
                        continue;
                    }

                    // closing ]
                    if (not expect(token_type::end_array))
                    {
                        return;
                    }
                    break;
                }

                if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
                {
                    result.m_value.destroy(result.m_type);
                    result.m_type = value_t::discarded;
                }
                break;
            }

            case token_type::literal_null:
            {
                result.m_type = value_t::null;
                break;
            }

            case token_type::value_string:
            {
                result.m_type = value_t::string;
                result.m_value = m_lexer.move_string();
                break;
            }

            case token_type::literal_true:
            {
                result.m_type = value_t::boolean;
                result.m_value = true;
                break;
            }

            case token_type::literal_false:
            {
                result.m_type = value_t::boolean;
                result.m_value = false;
                break;
            }

            case token_type::value_unsigned:
            {
                result.m_type = value_t::number_unsigned;
                result.m_value = m_lexer.get_number_unsigned();
                break;
            }

            case token_type::value_integer:
            {
                result.m_type = value_t::number_integer;
                result.m_value = m_lexer.get_number_integer();
                break;
            }

            case token_type::value_float:
            {
                result.m_type = value_t::number_float;
                result.m_value = m_lexer.get_number_float();

                // throw in case of infinity or NAN
                if (JSON_UNLIKELY(not std::isfinite(result.m_value.number_float)))
                {
                    if (allow_exceptions)
                    {
                        JSON_THROW(out_of_range::create(406, "number overflow parsing '" +
                                                        m_lexer.get_token_string() + "'"));
                    }
                    expect(token_type::uninitialized);
                }
                break;
            }

            case token_type::parse_error:
            {
                // using "uninitialized" to avoid "expected" message
                if (not expect(token_type::uninitialized))
                {
                    return;
                }
                break; // LCOV_EXCL_LINE
            }

            default:
            {
                // the last token was unexpected; we expected a value
                if (not expect(token_type::literal_or_value))
                {
                    return;
                }
                break; // LCOV_EXCL_LINE
            }
        }

        if (keep and callback and not callback(depth, parse_event_t::value, result))
        {
            result.m_type = value_t::discarded;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
cmpb $0x1, 0xb0(%rdi)
je 0x576f
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movb (%rdx), %al
cmpb $0x8, %al
je 0x500e
leaq 0x8(%r14), %rdi
movzbl %al, %esi
callq 0x4518
movb $0x8, (%r14)
movl 0x28(%rbx), %eax
decl %eax
cmpl $0xf, %eax
ja 0x56e3
leaq 0x3fe1(%rip), %rcx      # 0x9004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x4, (%r14)
movq $0x1, 0x8(%r14)
jmp 0x5230
movb $0x7, (%r14)
movq 0xa0(%rbx), %xmm0
movq %xmm0, %rax
movq %xmm0, 0x8(%r14)
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x5230
cmpb $0x1, 0xb8(%rbx)
je 0x5793
cmpl $0x0, 0x28(%rbx)
je 0x5230
movb $0x1, 0xb0(%rbx)
movl $0x0, 0xb4(%rbx)
jmp 0x5230
movb $0x6, (%r14)
movq 0x98(%rbx), %rax
jmp 0x522c
movb $0x5, (%r14)
movq 0x90(%rbx), %rax
jmp 0x522c
testb %bpl, %bpl
je 0x51be
cmpq $0x0, 0x18(%rbx)
je 0x5271
leaq 0x8(%rbx), %rdi
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x38(%rsp), %rdx
movb $0x0, (%rdx)
movq %r14, %rcx
callq *0x20(%rbx)
movl %eax, %ebp
testb %al, %al
jne 0x5274
cmpq $0x0, 0x18(%rbx)
jne 0x52a4
jmp 0x5274
movb $0x3, (%r14)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x68(%rbx), %rcx
leaq 0x78(%rbx), %rax
cmpq %rax, %rcx
je 0x51cc
movq %rcx, 0x8(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
jmp 0x51d5
movb $0x1, 0xb0(%rbx)
movl $0x0, 0xb4(%rbx)
cmpb $0x1, 0xb8(%rbx)
jne 0x525f
movq %rbx, %rdi
callq 0x6c20
movb $0x0, (%r14)
jmp 0x5230
testb %bpl, %bpl
je 0x51c5
cmpq $0x0, 0x18(%rbx)
je 0x5568
leaq 0x8(%rbx), %rdi
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x38(%rsp), %rdx
movb $0x2, (%rdx)
movq %r14, %rcx
callq *0x20(%rbx)
movl %eax, %ebp
testb %al, %al
jne 0x556b
cmpq $0x0, 0x18(%rbx)
jne 0x558d
jmp 0x556b
movb $0x4, (%r14)
movq $0x0, 0x8(%r14)
jmp 0x5230
xorl %ebp, %ebp
jmp 0x52a4
xorl %ebp, %ebp
jmp 0x558d
movdqu (%rax), %xmm0
movdqu %xmm0, (%r15)
movq 0x70(%rbx), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x68(%rbx)
movq $0x0, 0x70(%rbx)
movb $0x0, 0x78(%rbx)
movl $0x20, %edi
callq 0x3240
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rdx
cmpq %r15, %rdx
je 0x521a
movq %rdx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x5223
movdqu (%r15), %xmm0
movdqu %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r14)
testb %bpl, %bpl
je 0x525f
cmpq $0x0, 0x18(%rbx)
je 0x525f
leaq 0x8(%rbx), %rdi
movl (%rbx), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x38(%rsp), %rdx
movb $0x5, (%rdx)
movq %r14, %rcx
callq *0x20(%rbx)
testb %al, %al
jne 0x525f
movb $0x8, (%r14)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %bpl
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x3240
leaq 0x8(%rax), %rcx
pxor %xmm0, %xmm0
movdqu %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rax, 0x8(%r14)
leaq 0x30(%rbx), %r15
movq %r15, %rdi
callq 0x5920
movl %eax, 0x28(%rbx)
cmpl $0xb, %eax
jne 0x52e8
testb %bpl, %bpl
je 0x5230
cmpq $0x0, 0x18(%rbx)
je 0x5230
leaq 0x8(%rbx), %rdi
movl (%rbx), %esi
decl %esi
movl %esi, (%rbx)
movl $0x1, %edx
movq %r14, %rcx
callq 0x6334
jmp 0x55cb
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x60(%rsp), %r12
movb %al, (%r12)
movq %rax, 0x8(%r12)
movq %r12, %rdi
callq 0x4476
movq %r12, %rdi
callq 0x4476
cmpl $0x4, 0x28(%rbx)
jne 0x54c8
leaq 0x48(%rsp), %r12
leaq 0x78(%rbx), %rcx
leaq 0x8(%rbx), %rax
movq %rax, 0x80(%rsp)
movl %ebp, %eax
xorb $0x1, %al
movb %al, 0x30(%rsp)
leaq 0x8(%r14), %rax
movq %rax, 0x88(%rsp)
movzbl %bpl, %eax
movl %eax, 0x2c(%rsp)
movq %rcx, 0x90(%rsp)
movq %r12, 0x38(%rsp)
movq 0x68(%rbx), %rax
cmpq %rcx, %rax
je 0x5377
movq %rax, 0x38(%rsp)
movq (%rcx), %rax
movq %rax, 0x48(%rsp)
jmp 0x5381
movdqu (%rcx), %xmm0
movdqu %xmm0, (%r12)
movq 0x70(%rbx), %rax
movq %rax, 0x40(%rsp)
movq %rcx, 0x68(%rbx)
movq $0x0, 0x70(%rbx)
movb $0x0, 0x78(%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x32b0
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x53b8
callq 0x3220
movb $0x1, %r12b
testb %bpl, %bpl
je 0x541b
cmpq $0x0, 0x18(%rbx)
je 0x5418
leaq 0x38(%rsp), %r12
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x6358
movl (%rbx), %eax
movl %eax, 0x5c(%rsp)
movb $0x4, 0x7(%rsp)
cmpq $0x0, 0x18(%rbx)
je 0x578e
movq 0x80(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
leaq 0x7(%rsp), %rdx
movq %r12, %rcx
callq *0x20(%rbx)
movq %r12, %rdi
movl %eax, %r12d
callq 0x4448
xorb $0x1, %r12b
jmp 0x541b
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x5920
movl %eax, 0x28(%rbx)
cmpl $0xc, %eax
jne 0x56f9
movq %r15, %rdi
callq 0x5920
movl %eax, 0x28(%rbx)
movzbl 0x60(%rsp), %esi
leaq 0x68(%rsp), %rdi
callq 0x4518
movb $0x8, 0x60(%rsp)
movq %rbx, %rdi
movl 0x2c(%rsp), %esi
leaq 0x60(%rsp), %rdx
callq 0x4fd2
movb $0x1, %r13b
cmpb $0x0, 0xb0(%rbx)
jne 0x553c
orb 0x30(%rsp), %r12b
jne 0x5497
cmpb $0x8, 0x60(%rsp)
je 0x5497
movq 0x88(%rsp), %rax
movq (%rax), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x67e0
movq %r15, %rdi
callq 0x5920
movl %eax, 0x28(%rbx)
cmpl $0xd, %eax
jne 0x54ed
movq %r15, %rdi
callq 0x5920
movl %eax, 0x28(%rbx)
cmpl $0x4, %eax
leaq 0x48(%rsp), %r12
movq 0x90(%rsp), %rcx
je 0x535a
movb $0x1, 0xb0(%rbx)
movl $0x4, 0xb4(%rbx)
movb $0x1, %r13b
cmpb $0x1, 0xb8(%rbx)
jne 0x553c
movq %rbx, %rdi
callq 0x6c20
cmpl $0xb, %eax
jne 0x5749
xorl %r13d, %r13d
testb %bpl, %bpl
je 0x553c
cmpq $0x0, 0x18(%rbx)
je 0x553c
movl (%rbx), %esi
decl %esi
movl %esi, (%rbx)
movq 0x80(%rsp), %rdi
movl $0x1, %edx
movq %r14, %rcx
callq 0x6334
testb %al, %al
jne 0x5539
movzbl (%r14), %esi
movq 0x88(%rsp), %rdi
callq 0x4518
movb $0x8, (%r14)
xorl %r13d, %r13d
leaq 0x60(%rsp), %rdi
callq 0x4448
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x555a
callq 0x3220
testb %r13b, %r13b
je 0x5230
jmp 0x525f
movb $0x1, %bpl
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x3240
pxor %xmm0, %xmm0
movdqu %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
leaq 0x30(%rbx), %r12
movq %r12, %rdi
callq 0x5920
movl %eax, 0x28(%rbx)
cmpl $0xa, %eax
jne 0x55e9
cmpq $0x0, 0x18(%rbx)
je 0x5230
leaq 0x8(%rbx), %rdi
movl (%rbx), %eax
decl %eax
movl %eax, (%rbx)
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x38(%rsp), %rdx
movb $0x3, (%rdx)
movq %r14, %rcx
callq *0x20(%rbx)
testb %al, %al
jne 0x5230
leaq 0x8(%r14), %rdi
movzbl (%r14), %esi
callq 0x4518
movb $0x8, (%r14)
jmp 0x5230
leaq 0x10(%rsp), %r15
movb $0x0, -0x8(%r15)
movq $0x0, (%r15)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x4476
movq %r13, %rdi
callq 0x4476
leaq 0x8(%r14), %rax
movq %rax, 0x30(%rsp)
movzbl %bpl, %eax
movl %eax, 0x2c(%rsp)
movzbl 0x8(%rsp), %esi
movq %r15, %r13
movq %r15, %rdi
callq 0x4518
leaq 0x8(%rsp), %r15
movb $0x8, 0x8(%rsp)
movq %rbx, %rdi
movl 0x2c(%rsp), %esi
movq %r15, %rdx
callq 0x4fd2
cmpb $0x1, 0xb0(%rbx)
je 0x573a
testb %bpl, %bpl
je 0x5672
cmpb $0x8, 0x8(%rsp)
je 0x5672
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq %r15, %rsi
callq 0x69ea
movq %r12, %rdi
callq 0x5920
movl %eax, 0x28(%rbx)
cmpl $0xd, %eax
jne 0x5692
movq %r12, %rdi
callq 0x5920
movl %eax, 0x28(%rbx)
movq %r13, %r15
jmp 0x5620
cmpl $0xa, %eax
jne 0x571c
testb %bpl, %bpl
je 0x56d4
cmpq $0x0, 0x18(%rbx)
je 0x56d4
leaq 0x8(%rbx), %rdi
movl (%rbx), %esi
decl %esi
movl %esi, (%rbx)
movl $0x3, %edx
movq %r14, %rcx
callq 0x6334
testb %al, %al
jne 0x56d4
movzbl (%r14), %esi
movq 0x30(%rsp), %rdi
callq 0x4518
movb $0x8, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x4448
jmp 0x5230
movb $0x1, 0xb0(%rbx)
movl $0x10, 0xb4(%rbx)
jmp 0x5148
movb $0x1, 0xb0(%rbx)
movl $0xc, 0xb4(%rbx)
movb $0x1, %r13b
cmpb $0x1, 0xb8(%rbx)
jne 0x553c
jmp 0x5767
movb $0x1, 0xb0(%rbx)
movl $0xa, 0xb4(%rbx)
cmpb $0x1, 0xb8(%rbx)
je 0x57fb
leaq 0x8(%rsp), %rdi
callq 0x4448
jmp 0x525f
movb $0x1, 0xb0(%rbx)
movl $0xb, 0xb4(%rbx)
cmpb $0x0, 0xb8(%rbx)
je 0x553c
movq %rbx, %rdi
callq 0x6c20
leaq 0x47dc(%rip), %rdi      # 0x9f52
leaq 0x3ee1(%rip), %rsi      # 0x965e
leaq 0x47da(%rip), %rcx      # 0x9f5e
movl $0xbb3, %edx            # imm = 0xBB3
callq 0x3160
callq 0x30e0
addq $0x30, %rbx
movl $0x20, %edi
callq 0x3130
movq %rax, %r14
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
callq 0x652e
leaq 0x482c(%rip), %rsi      # 0x9fe4
leaq 0x38(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x64bd
leaq 0x485e(%rip), %rsi      # 0xa02c
leaq 0x38(%rsp), %rdi
callq 0x33e0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x5803
movdqu (%rcx), %xmm0
movdqu %xmm0, (%r15)
jmp 0x5810
movq %rbx, %rdi
callq 0x6c20
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
movl $0x196, %esi            # imm = 0x196
callq 0x6384
xorl %ebp, %ebp
leaq 0x8453(%rip), %rsi      # 0xdc98
leaq 0x1f98(%rip), %rdx      # 0x77e4
movq %r14, %rdi
callq 0x3370
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x586e
callq 0x3220
jmp 0x586e
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5881
callq 0x3220
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5894
callq 0x3220
testb %bpl, %bpl
jne 0x58b6
jmp 0x5918
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58b6
callq 0x3220
jmp 0x58b6
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
jmp 0x5918
jmp 0x58f7
jmp 0x58e8
jmp 0x58c6
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4448
jmp 0x58fa
jmp 0x58f7
jmp 0x58f7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x5913
jmp 0x5918
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4448
jmp 0x5918
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x4448
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5918
callq 0x3220
movq %rbx, %rdi
callq 0x3390