// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1ff7d
jp 0x1ff7d
movq %xmm0, %rax
testq %rax, %rax
js 0x1ffc9
xorl %eax, %eax
jmp 0x1ffd1
leaq 0x25f3(%rip), %rdx      # 0x22577
movl $0x40, %esi
movq %rbx, %rdi
movl $0xf, %ecx
movb $0x1, %al
callq 0x6570
testl %eax, %eax
jle 0x200bb
movl %eax, %ebp
cmpl $0x40, %eax
jae 0x200da
callq 0x66f0
testq %rax, %rax
je 0x200f9
movq 0x8(%rax), %rcx
xorl %r14d, %r14d
testq %rcx, %rcx
je 0x1ffe1
movb (%rcx), %cl
jmp 0x1ffe3
movb $0x2d, (%rbx)
movl $0x1, %eax
movw $0x2e30, (%rbx,%rax)    # imm = 0x2E30
movb $0x30, 0x2(%rbx,%rax)
jmp 0x200b2
xorl %ecx, %ecx
movb %cl, 0xf(%rsp)
movq (%rax), %rax
testq %rax, %rax
je 0x1fff3
movsbl (%rax), %r14d
testb %cl, %cl
je 0x2001c
movl %ebp, %esi
addq %rbx, %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x20194
leaq 0x40(%rbx), %rdx
subq %rax, %rdx
je 0x2001c
movq %rax, %rdi
xorl %esi, %esi
callq 0x61e0
testl %r14d, %r14d
je 0x20041
cmpl $0x2e, %r14d
je 0x20041
xorl %eax, %eax
movsbl (%rbx,%rax), %ecx
cmpl %ecx, %r14d
je 0x2003d
incq %rax
cmpq $0x40, %rax
jne 0x20029
jmp 0x20041
movb $0x2e, (%rbx,%rax)
movb $0x1, %dl
xorl %eax, %eax
movabsq $0x7fffffff7ffffe, %rsi # imm = 0x7FFFFFFF7FFFFE
movb (%rbx,%rax), %cl
testb %cl, %cl
je 0x2007d
testb $0x1, %dl
je 0x2006d
addb $-0x2e, %cl
movb $0x1, %dl
cmpb $0x37, %cl
ja 0x2006f
movq %rsi, %rdx
shrq %cl, %rdx
jmp 0x2006f
xorl %edx, %edx
incq %rax
cmpq $0x40, %rax
jne 0x2004f
movl $0x40, %eax
testb $0x1, %dl
je 0x200b2
cmpq $0x3e, %rax
jae 0x20118
cmpb $0x0, (%rbx,%rax)
jne 0x20137
cmpb $0x0, -0x1(%rax,%rbx)
je 0x20156
movw $0x302e, (%rbx,%rax)    # imm = 0x302E
cmpb $0x0, 0x2(%rbx,%rax)
jne 0x20175
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x24ba(%rip), %rdi      # 0x2257c
leaq 0x17f1(%rip), %rsi      # 0x218ba
leaq 0x24be(%rip), %rcx      # 0x2258e
movl $0x208a, %edx           # imm = 0x208A
callq 0x6240
leaq 0x261c(%rip), %rdi      # 0x226fd
leaq 0x17d2(%rip), %rsi      # 0x218ba
leaq 0x249f(%rip), %rcx      # 0x2258e
movl $0x208c, %edx           # imm = 0x208C
callq 0x6240
leaq 0x262f(%rip), %rdi      # 0x2272f
leaq 0x17b3(%rip), %rsi      # 0x218ba
leaq 0x2480(%rip), %rcx      # 0x2258e
movl $0x2090, %edx           # imm = 0x2090
callq 0x6240
leaq 0x261f(%rip), %rdi      # 0x2273e
leaq 0x1794(%rip), %rsi      # 0x218ba
leaq 0x2461(%rip), %rcx      # 0x2258e
movl $0x20be, %edx           # imm = 0x20BE
callq 0x6240
leaq 0x2617(%rip), %rdi      # 0x22755
leaq 0x1775(%rip), %rsi      # 0x218ba
leaq 0x2442(%rip), %rcx      # 0x2258e
movl $0x20c0, %edx           # imm = 0x20C0
callq 0x6240
leaq 0x2609(%rip), %rdi      # 0x22766
leaq 0x1756(%rip), %rsi      # 0x218ba
leaq 0x2423(%rip), %rcx      # 0x2258e
movl $0x20c1, %edx           # imm = 0x20C1
callq 0x6240
leaq 0x25ff(%rip), %rdi      # 0x2277b
leaq 0x1737(%rip), %rsi      # 0x218ba
leaq 0x2404(%rip), %rcx      # 0x2258e
movl $0x20c8, %edx           # imm = 0x20C8
callq 0x6240