// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movl %esi, (%rsp)
cmpb $0x1, 0xb0(%rdi)
je 0x56af
movq %rdx, %r14
movq %rdi, %rbx
movb (%rdx), %al
cmpb $0x8, %al
je 0x4f24
leaq 0x8(%r14), %rdi
movzbl %al, %esi
callq 0x4428
movb $0x8, (%r14)
movl 0x28(%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xd, %ecx
ja 0x5082
leaq 0x40ca(%rip), %rdx      # 0x9004
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb $0x4, (%r14)
movq $0x1, 0x8(%r14)
jmp 0x5606
movb $0x0, (%r14)
jmp 0x5606
movb $0x5, (%r14)
movq 0x90(%rbx), %rax
jmp 0x5602
movb $0x4, (%r14)
movq $0x0, 0x8(%r14)
jmp 0x5606
movb $0x7, (%r14)
movsd 0xa0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x5606
cmpb $0x1, 0xb8(%rbx)
je 0x56e3
cmpl $0x0, 0x28(%rbx)
je 0x5606
movb $0x1, 0xb0(%rbx)
movl $0x0, 0xb4(%rbx)
jmp 0x5606
cmpb $0x0, (%rsp)
je 0x503b
cmpq $0x0, 0x18(%rbx)
je 0x500e
leaq 0x8(%rbx), %rdi
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rsp), %rdx
movb $0x2, (%rdx)
movq %r14, %rcx
callq *0x20(%rbx)
movl %eax, (%rsp)
cmpq $0x0, 0x18(%rbx)
je 0x501b
cmpb $0x0, (%rsp)
je 0x503b
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x3240
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
leaq 0x30(%rbx), %r15
movq %r15, %rdi
callq 0x585a
movl %eax, 0x28(%rbx)
cmpl $0xa, %eax
jne 0x51fd
cmpq $0x0, 0x18(%rbx)
je 0x5606
leaq 0x8(%rbx), %rdi
movl (%rbx), %eax
decl %eax
movl %eax, (%rbx)
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rsp), %rdx
movb $0x3, (%rdx)
movq %r14, %rcx
callq *0x20(%rbx)
jmp 0x51df
cmpl $0x10, %eax
je 0x5606
movb $0x1, 0xb0(%rbx)
movl $0x10, 0xb4(%rbx)
cmpb $0x1, 0xb8(%rbx)
je 0x56db
cmpl $0x10, %eax
je 0x5606
jmp 0x5636
movb $0x3, (%r14)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x68(%rbx), %rcx
leaq 0x78(%rbx), %rax
cmpq %rax, %rcx
je 0x5593
movq %rcx, 0x8(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
jmp 0x559a
movb $0x6, (%r14)
movq 0x98(%rbx), %rax
jmp 0x5602
testl %eax, %eax
je 0x5606
movb $0x1, 0xb0(%rbx)
movl $0x0, 0xb4(%rbx)
cmpb $0x1, 0xb8(%rbx)
je 0x56db
testl %eax, %eax
jne 0x5636
jmp 0x5606
cmpb $0x0, (%rsp)
je 0x519b
cmpq $0x0, 0x18(%rbx)
je 0x515a
leaq 0x8(%rbx), %rdi
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rsp), %rdx
movb $0x0, (%rdx)
movq %r14, %rcx
callq *0x20(%rbx)
movl %eax, (%rsp)
cmpq $0x0, 0x18(%rbx)
je 0x5167
cmpb $0x0, (%rsp)
je 0x519b
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x3240
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x8(%r14)
leaq 0x30(%rbx), %r15
movq %r15, %rdi
callq 0x585a
movl %eax, 0x28(%rbx)
cmpl $0xb, %eax
jne 0x528f
cmpb $0x0, (%rsp)
je 0x5606
cmpq $0x0, 0x18(%rbx)
je 0x5606
leaq 0x8(%rbx), %rdi
movl (%rbx), %esi
decl %esi
movl %esi, (%rbx)
movl $0x1, %edx
movq %r14, %rcx
callq 0x6372
testb %al, %al
jne 0x5606
leaq 0x8(%r14), %rdi
movzbl (%r14), %esi
callq 0x4428
movb $0x8, (%r14)
jmp 0x5606
leaq 0x10(%rsp), %r12
movb $0x0, -0x8(%r12)
movq $0x0, (%r12)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x4386
movq %r13, %rdi
callq 0x4386
movzbl (%rsp), %ebp
movzbl 0x8(%rsp), %esi
movq %r12, %rdi
callq 0x4428
movb $0x8, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x4eea
cmpb $0x0, 0xb0(%rbx)
jne 0x5645
cmpb $0x0, (%rsp)
je 0x526e
cmpb $0x8, 0x8(%rsp)
je 0x526e
movq 0x8(%r14), %rdi
movq %r13, %rsi
callq 0x6a2a
movq %r15, %rdi
callq 0x585a
movl %eax, 0x28(%rbx)
cmpl $0xd, %eax
jne 0x552e
movq %r15, %rdi
callq 0x585a
movl %eax, 0x28(%rbx)
jmp 0x5229
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x58(%rsp), %rcx
movb %al, -0x8(%rcx)
movq %rax, (%rcx)
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x4386
movq %r12, %rdi
callq 0x4386
leaq 0x78(%rbx), %r13
leaq 0x8(%rbx), %rax
movq %rax, 0x70(%rsp)
movl (%rsp), %eax
movl %eax, %ecx
xorb $0x1, %cl
movb %cl, 0x6(%rsp)
movzbl %al, %eax
movl %eax, 0x48(%rsp)
movl 0x28(%rbx), %eax
cmpl $0x4, %eax
jne 0x545d
leaq 0x38(%rsp), %r12
movq %r12, 0x28(%rsp)
movq 0x68(%rbx), %rax
cmpq %r13, %rax
je 0x530f
movq %rax, 0x28(%rsp)
movq (%r13), %rax
movq %rax, 0x38(%rsp)
jmp 0x5319
movups (%r13), %xmm0
movups %xmm0, (%r12)
movq 0x70(%rbx), %rax
movq %rax, 0x30(%rsp)
movq %r13, 0x68(%rbx)
movq $0x0, 0x70(%rbx)
movb $0x0, 0x78(%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x32b0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x5350
callq 0x3220
movb $0x1, %r12b
cmpb $0x0, (%rsp)
je 0x53b3
cmpq $0x0, 0x18(%rbx)
je 0x53b0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6396
movl (%rbx), %eax
movl %eax, 0x4c(%rsp)
movb $0x4, 0x7(%rsp)
cmpq $0x0, 0x18(%rbx)
je 0x56ce
movq 0x70(%rsp), %rdi
leaq 0x4c(%rsp), %rsi
leaq 0x7(%rsp), %rdx
leaq 0x28(%rsp), %rbp
movq %rbp, %rcx
callq *0x20(%rbx)
movl %eax, %r12d
movq %rbp, %rdi
callq 0x4358
xorb $0x1, %r12b
jmp 0x53b3
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x585a
movl %eax, 0x28(%rbx)
cmpl $0xc, %eax
jne 0x5489
movq %r15, %rdi
callq 0x585a
movl %eax, 0x28(%rbx)
movzbl 0x50(%rsp), %esi
leaq 0x58(%rsp), %rdi
callq 0x4428
movb $0x8, 0x50(%rsp)
movq %rbx, %rdi
movl 0x48(%rsp), %esi
leaq 0x50(%rsp), %rdx
callq 0x4eea
movl $0x1, %ecx
cmpb $0x0, 0xb0(%rbx)
jne 0x5452
orb 0x6(%rsp), %r12b
jne 0x5426
cmpb $0x8, 0x50(%rsp)
je 0x5426
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x6820
movq %r15, %rdi
callq 0x585a
movl %eax, 0x28(%rbx)
cmpl $0xd, %eax
jne 0x5448
movq %r15, %rdi
callq 0x585a
movl %eax, 0x28(%rbx)
movl $0x3, %ecx
jmp 0x5452
movl $0x4, %ecx
cmpl $0xb, %eax
jne 0x54b3
cmpl $0x3, %ecx
je 0x52e0
jmp 0x54da
movb $0x1, 0xb0(%rbx)
movl $0x4, 0xb4(%rbx)
cmpb $0x1, 0xb8(%rbx)
je 0x56d3
cmpl $0x4, %eax
je 0x52ec
jmp 0x567a
movb $0x1, 0xb0(%rbx)
movl $0xc, 0xb4(%rbx)
cmpb $0x1, 0xb8(%rbx)
je 0x54d2
movl $0x1, %ecx
cmpl $0xc, %eax
je 0x53c7
jmp 0x5452
movb $0x1, 0xb0(%rbx)
movl $0xb, 0xb4(%rbx)
cmpb $0x0, 0xb8(%rbx)
movl $0x1, %ecx
je 0x5452
movq %rbx, %rdi
callq 0x6c60
cmpl $0x4, %ecx
jne 0x567f
xorl %ebp, %ebp
cmpb $0x0, (%rsp)
je 0x5686
cmpq $0x0, 0x18(%rbx)
je 0x5686
movl (%rbx), %esi
decl %esi
movl %esi, (%rbx)
movq 0x70(%rsp), %rdi
movl $0x1, %edx
movq %r14, %rcx
callq 0x6372
testb %al, %al
jne 0x5527
leaq 0x8(%r14), %rdi
movzbl (%r14), %esi
callq 0x4428
movb $0x8, (%r14)
xorl %ebp, %ebp
jmp 0x5686
movl $0x2, %ebp
cmpl $0xa, %eax
jne 0x564f
cmpl $0xa, %eax
jne 0x557f
cmpb $0x0, (%rsp)
je 0x557f
movl $0x2, %ebp
cmpq $0x0, 0x18(%rbx)
je 0x557f
leaq 0x8(%rbx), %rdi
movl (%rbx), %esi
decl %esi
movl %esi, (%rbx)
movl $0x3, %edx
movq %r14, %rcx
callq 0x6372
testb %al, %al
jne 0x557f
leaq 0x8(%r14), %rdi
movzbl (%r14), %esi
callq 0x4428
movb $0x8, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x4358
cmpl $0x1, %ebp
jne 0x5606
jmp 0x5636
movups (%rax), %xmm0
movups %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 0x55df
movq %rdx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x55e6
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r15, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rax, 0x8(%r14)
cmpb $0x0, (%rsp)
je 0x5636
cmpq $0x0, 0x18(%rbx)
je 0x5636
leaq 0x8(%rbx), %rdi
movl (%rbx), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rsp), %rdx
movb $0x5, (%rdx)
movq %r14, %rcx
callq *0x20(%rbx)
testb %al, %al
jne 0x5636
movb $0x8, (%r14)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ebp
jmp 0x557f
movb $0x1, 0xb0(%rbx)
movl $0xa, 0xb4(%rbx)
movl $0x1, %ebp
cmpb $0x1, 0xb8(%rbx)
jne 0x553c
movq %rbx, %rdi
callq 0x6c60
movl $0x1, %ecx
cmpl $0x1, %ecx
sete %bpl
leaq 0x50(%rsp), %rdi
callq 0x4358
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x56a4
callq 0x3220
testb %bpl, %bpl
je 0x5606
jmp 0x5636
leaq 0x489c(%rip), %rdi      # 0x9f52
leaq 0x3fa1(%rip), %rsi      # 0x965e
leaq 0x489a(%rip), %rcx      # 0x9f5e
movl $0xbb3, %edx            # imm = 0xBB3
callq 0x3160
callq 0x30e0
movq %rbx, %rdi
callq 0x6c60
movq %rbx, %rdi
callq 0x6c60
addq $0x30, %rbx
movl $0x20, %edi
callq 0x3130
movq %rax, %r14
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
callq 0x656c
leaq 0x48dc(%rip), %rsi      # 0x9fe4
leaq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x64fb
leaq 0x490e(%rip), %rsi      # 0xa02c
leaq 0x28(%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 0x5749
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x5756
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 0x63c2
xorl %ebp, %ebp
leaq 0x850d(%rip), %rsi      # 0xdc98
leaq 0x20ba(%rip), %rdx      # 0x784c
movq %r14, %rdi
callq 0x3370
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x57b4
callq 0x3220
jmp 0x57b4
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57cf
callq 0x3220
jmp 0x57cf
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57ea
callq 0x3220
jmp 0x57ea
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5851
movq %r14, %rdi
callq 0x31a0
jmp 0x5851
jmp 0x5821
jmp 0x5821
jmp 0x5844
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x583d
jmp 0x5851
jmp 0x5810
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4358
jmp 0x5824
jmp 0x5821
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4358
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5851
callq 0x3220
jmp 0x5851
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4358
movq %rbx, %rdi
callq 0x3390
nop