// File: mattn[P]wandbox-run/./json.hpp
// Function: 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>::lexer::strtonum::parse<double>(double&, std::integral_constant<bool, false>) const
bool parse(T& value, /*is_integral=*/std::false_type) const
            {
                // replace decimal separator with locale-specific version,
                // when necessary; data will point to either the original
                // string, or buf, or tempstr containing the fixed string.
                std::string tempstr;
                std::array<char, 64> buf;
                const size_t len = static_cast<size_t>(m_end - m_start);

                // lexer will reject empty numbers
                assert(len > 0);

                // since dealing with strtod family of functions, we're
                // getting the decimal point char from the C locale facilities
                // instead of C++'s numpunct facet of the current std::locale
                const auto loc = localeconv();
                assert(loc != nullptr);
                const char decimal_point_char = (loc->decimal_point == nullptr) ? '.' : loc->decimal_point[0];

                const char* data = m_start;

                if (decimal_point_char != '.')
                {
                    const size_t ds_pos = static_cast<size_t>(std::find(m_start, m_end, '.') - m_start);

                    if (ds_pos != len)
                    {
                        // copy the data into the local buffer or tempstr, if
                        // buffer is too small; replace decimal separator, and
                        // update data to point to the modified bytes
                        if ((len + 1) < buf.size())
                        {
                            std::copy(m_start, m_end, buf.begin());
                            buf[len] = 0;
                            buf[ds_pos] = decimal_point_char;
                            data = buf.data();
                        }
                        else
                        {
                            tempstr.assign(m_start, m_end);
                            tempstr[ds_pos] = decimal_point_char;
                            data = tempstr.c_str();
                        }
                    }
                }

                char* endptr = nullptr;
                value = 0;
                // this calls appropriate overload depending on T
                strtof(value, data, &endptr);

                // parsing was successful iff strtof parsed exactly the number
                // of characters determined by the lexer (len)
                const bool ok = (endptr == (data + len));

                if (ok and (value == static_cast<T>(0.0)) and (*data == '-'))
                {
                    // some implementations forget to negate the zero
                    value = -0.0;
                }

                return ok;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa22c0
movq -0xd0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jbe 0x20e05
jmp 0x20e24
leaq 0xb4d7a(%rip), %rdi     # 0xd5b86
leaq 0xb38ce(%rip), %rsi     # 0xd46e1
movl $0x2bdb, %edx           # imm = 0x2BDB
leaq 0xb4d6f(%rip), %rcx     # 0xd5b8e
callq 0x13130
callq 0x130b0
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x88(%rbp)
je 0x20e3c
jmp 0x20e5b
leaq 0xb4eb5(%rip), %rdi     # 0xd5cf8
leaq 0xb3897(%rip), %rsi     # 0xd46e1
movl $0x2be1, %edx           # imm = 0x2BE1
leaq 0xb4d38(%rip), %rcx     # 0xd5b8e
callq 0x13130
movq -0x88(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x20e72
movb $0x2e, %al
movb %al, -0xd1(%rbp)
jmp 0x20e84
movq -0x88(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0xd1(%rbp)
movq -0xd0(%rbp), %rax
movb -0xd1(%rbp), %cl
movb %cl, -0x89(%rbp)
movq (%rax), %rax
movq %rax, -0x98(%rbp)
movsbl -0x89(%rbp), %eax
cmpl $0x2e, %eax
je 0x21036
movq -0xd0(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movb $0x2e, -0xa1(%rbp)
leaq -0xa1(%rbp), %rdx
callq 0x21100
movq %rax, -0xe0(%rbp)
jmp 0x20edb
movq -0xe0(%rbp), %rax
movq -0xd0(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
cmpq -0x80(%rbp), %rax
je 0x21034
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xe8(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x21150
movq %rax, %rcx
movq -0xe8(%rbp), %rax
cmpq %rcx, %rax
jae 0x20fd5
movq -0xd0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0xf8(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0xf0(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x211a0
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
movq %rax, %rdx
callq 0x21160
jmp 0x20f6f
movq -0x80(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x211c0
movb $0x0, (%rax)
movb -0x89(%rbp), %al
movb %al, -0xf9(%rbp)
movq -0xa0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x211c0
movb -0xf9(%rbp), %cl
movb %cl, (%rax)
leaq -0x78(%rbp), %rdi
callq 0x211f0
movq %rax, -0x98(%rbp)
jmp 0x21032
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa23d0
jmp 0x210e6
movq -0xd0(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq -0x38(%rbp), %rdi
callq 0x21210
jmp 0x20fee
movb -0x89(%rbp), %al
movb %al, -0x109(%rbp)
movq -0xa0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xa2910
movq %rax, -0x108(%rbp)
jmp 0x21013
movq -0x108(%rbp), %rax
movb -0x109(%rbp), %cl
movb %cl, (%rax)
leaq -0x38(%rbp), %rdi
callq 0xa3e10
movq %rax, -0x98(%rbp)
jmp 0x21034
jmp 0x21036
movq $0x0, -0xc0(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rdi
movq -0x98(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x21280
jmp 0x21065
movq -0xc0(%rbp), %rax
movq -0x98(%rbp), %rcx
addq -0x80(%rbp), %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, -0xc1(%rbp)
testb $0x1, -0xc1(%rbp)
je 0x210c0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x210c0
jp 0x210c0
movq -0x98(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x210c0
movq -0x18(%rbp), %rax
movsd 0xb3154(%rip), %xmm0    # 0xd4210
movsd %xmm0, (%rax)
movb -0xc1(%rbp), %al
movb %al, -0x10a(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa23d0
movb -0x10a(%rbp), %al
andb $0x1, %al
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0xd1250
nopw %cs:(%rax,%rax)
nopl (%rax)