// File: harry830622[P]floorplanner/src/./././json.hpp
// Function: void 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>::numtostr::x_write<double>(double, std::integral_constant<bool, false>)
void x_write(NumberType x, /*is_integral=*/std::false_type)
        {
            // special case for 0.0 and -0.0
            if (x == 0)
            {
                size_t i = 0;
                if (std::signbit(x))
                {
                    m_buf[i++] = '-';
                }
                m_buf[i++] = '0';
                m_buf[i++] = '.';
                m_buf[i] = '0';
                return;
            }

            // get number of digits for a text -> float -> text round-trip
            static constexpr auto d = std::numeric_limits<NumberType>::digits10;

            // the actual conversion
            const auto written_bytes = snprintf(m_buf.data(), m_buf.size(), "%.*g", d, x);

            // negative value indicates an error
            assert(written_bytes > 0);
            // check if buffer was large enough
            assert(static_cast<size_t>(written_bytes) < m_buf.size());

            // read information from locale
            const auto loc = localeconv();
            assert(loc != nullptr);
            const char thousands_sep = !loc->thousands_sep ? '\0'
                                       : loc->thousands_sep[0];

            const char decimal_point = !loc->decimal_point ? '\0'
                                       : loc->decimal_point[0];

            // erase thousands separator
            if (thousands_sep != '\0')
            {
                const auto end = std::remove(m_buf.begin(), m_buf.begin() + written_bytes, thousands_sep);
                std::fill(end, m_buf.end(), '\0');
            }

            // convert decimal point to '.'
            if (decimal_point != '\0' and decimal_point != '.')
            {
                for (auto& c : m_buf)
                {
                    if (c == decimal_point)
                    {
                        c = '.';
                        break;
                    }
                }
            }

            // determine if need to append ".0"
            size_t i = 0;
            bool value_is_int_like = true;
            for (i = 0; i < m_buf.size(); ++i)
            {
                // break when end of number is reached
                if (m_buf[i] == '\0')
                {
                    break;
                }

                // check if we find non-int character
                value_is_int_like = value_is_int_like and m_buf[i] != '.' and
                                    m_buf[i] != 'e' and m_buf[i] != 'E';
            }

            if (value_is_int_like)
            {
                // there must be 2 bytes left for ".0"
                assert((i + 2) < m_buf.size());
                // we write to the end of the number
                assert(m_buf[i] == '\0');
                assert(m_buf[i - 1] != '\0');

                // add ".0"
                m_buf[i] = '.';
                m_buf[i + 1] = '0';

                // the resulting string is properly terminated
                assert(m_buf[i + 2] == '\0');
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x474be
jp 0x474be
movq $0x0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x478d0
testb $0x1, %al
jne 0x47458
jmp 0x47473
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
callq 0x47090
movb $0x2d, (%rax)
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
callq 0x47090
movq -0x80(%rbp), %rdi
movb $0x30, (%rax)
movq -0x20(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
callq 0x47090
movq -0x80(%rbp), %rdi
movb $0x2e, (%rax)
movq -0x20(%rbp), %rsi
callq 0x47090
movb $0x30, (%rax)
jmp 0x478c4
movq -0x80(%rbp), %rdi
callq 0x47220
movq -0x80(%rbp), %rdi
movq %rax, -0x88(%rbp)
callq 0x470c0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
movsd -0x18(%rbp), %xmm0
leaq 0x4da7(%rip), %rdx      # 0x4c294
movl $0xf, %ecx
movb $0x1, %al
callq 0x97e0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x47504
jmp 0x47523
leaq 0x4d8e(%rip), %rdi      # 0x4c299
leaq 0x3f16(%rip), %rsi      # 0x4b428
movl $0x208a, %edx           # imm = 0x208A
leaq 0x4d8d(%rip), %rcx      # 0x4c2ab
callq 0x9330
movq -0x80(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x470c0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x47548
jmp 0x47567
leaq 0x4ecb(%rip), %rdi      # 0x4c41a
leaq 0x3ed2(%rip), %rsi      # 0x4b428
movl $0x208c, %edx           # imm = 0x208C
leaq 0x4d49(%rip), %rcx      # 0x4c2ab
callq 0x9330
callq 0x99d0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x47579
jmp 0x47598
leaq 0x4ecc(%rip), %rdi      # 0x4c44c
leaq 0x3ea1(%rip), %rsi      # 0x4b428
movl $0x2090, %edx           # imm = 0x2090
leaq 0x4d18(%rip), %rcx      # 0x4c2ab
callq 0x9330
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x475ad
xorl %eax, %eax
movb %al, -0x91(%rbp)
jmp 0x475bd
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movb (%rax), %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
movb %al, -0x31(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x475da
xorl %eax, %eax
movb %al, -0x92(%rbp)
jmp 0x475e9
movq -0x30(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x92(%rbp)
movb -0x92(%rbp), %al
movb %al, -0x32(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x0, %eax
je 0x4765d
movq -0x80(%rbp), %rdi
callq 0x47110
movq -0x80(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0x47110
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
movslq -0x24(%rbp), %rax
addq %rax, %rsi
leaq -0x31(%rbp), %rdx
callq 0x478f0
movq -0x80(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x47970
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
movb $0x0, -0x41(%rbp)
leaq -0x41(%rbp), %rdx
callq 0x47940
movsbl -0x32(%rbp), %eax
cmpl $0x0, %eax
je 0x476cd
movsbl -0x32(%rbp), %eax
cmpl $0x2e, %eax
je 0x476cd
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x47110
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x47970
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
je 0x476cb
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x32(%rbp), %ecx
cmpl %ecx, %eax
jne 0x476bb
movq -0x68(%rbp), %rax
movb $0x2e, (%rax)
jmp 0x476cb
jmp 0x476bd
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x47691
jmp 0x476cd
movq $0x0, -0x70(%rbp)
movb $0x1, -0x71(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x470c0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x477a2
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x47090
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x47722
jmp 0x477a2
xorl %eax, %eax
testb $0x1, -0x71(%rbp)
movb %al, -0xb1(%rbp)
je 0x47786
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x47090
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0xb1(%rbp)
je 0x47786
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x47090
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x65, %ecx
movb %al, -0xb1(%rbp)
je 0x47786
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x47090
movsbl (%rax), %eax
cmpl $0x45, %eax
setne %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
andb $0x1, %al
movb %al, -0x71(%rbp)
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x476e1
testb $0x1, -0x71(%rbp)
je 0x478c4
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xc0(%rbp)
callq 0x470c0
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jae 0x477d5
jmp 0x477f4
leaq 0x4c7f(%rip), %rdi      # 0x4c45b
leaq 0x3c45(%rip), %rsi      # 0x4b428
movl $0x20be, %edx           # imm = 0x20BE
leaq 0x4abc(%rip), %rcx      # 0x4c2ab
callq 0x9330
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x47090
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4780b
jmp 0x4782a
leaq 0x4c60(%rip), %rdi      # 0x4c472
leaq 0x3c0f(%rip), %rsi      # 0x4b428
movl $0x20c0, %edx           # imm = 0x20C0
leaq 0x4a86(%rip), %rcx      # 0x4c2ab
callq 0x9330
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
subq $0x1, %rsi
callq 0x47090
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x47845
jmp 0x47864
leaq 0x4c37(%rip), %rdi      # 0x4c483
leaq 0x3bd5(%rip), %rsi      # 0x4b428
movl $0x20c1, %edx           # imm = 0x20C1
leaq 0x4a4c(%rip), %rcx      # 0x4c2ab
callq 0x9330
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x47090
movq -0x80(%rbp), %rdi
movb $0x2e, (%rax)
movq -0x70(%rbp), %rsi
addq $0x1, %rsi
callq 0x47090
movq -0x80(%rbp), %rdi
movb $0x30, (%rax)
movq -0x70(%rbp), %rsi
addq $0x2, %rsi
callq 0x47090
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x478a3
jmp 0x478c2
leaq 0x4bee(%rip), %rdi      # 0x4c498
leaq 0x3b77(%rip), %rsi      # 0x4b428
movl $0x20c8, %edx           # imm = 0x20C8
leaq 0x49ee(%rip), %rcx      # 0x4c2ab
callq 0x9330
jmp 0x478c4
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)