// File: /workspace/github_cpp_makefile_star2_O2/Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::operator<(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, std::vector<unsigned char, std::allocator<unsigned char>>> const&, 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, std::vector<unsigned char, std::allocator<unsigned char>>> const&)
friend bool operator<(const_reference lhs, const_reference rhs) noexcept
    {
        const auto lhs_type = lhs.type();
        const auto rhs_type = rhs.type();

        if (lhs_type == rhs_type)
        {
            switch (lhs_type)
            {
                case value_t::array:
                    // note parentheses are necessary, see
                    // https://github.com/nlohmann/json/issues/1530
                    return (*lhs.m_value.array) < (*rhs.m_value.array);

                case value_t::object:
                    return (*lhs.m_value.object) < (*rhs.m_value.object);

                case value_t::null:
                    return false;

                case value_t::string:
                    return (*lhs.m_value.string) < (*rhs.m_value.string);

                case value_t::boolean:
                    return (lhs.m_value.boolean) < (rhs.m_value.boolean);

                case value_t::number_integer:
                    return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);

                case value_t::number_unsigned:
                    return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);

                case value_t::number_float:
                    return (lhs.m_value.number_float) < (rhs.m_value.number_float);

                case value_t::binary:
                    return (*lhs.m_value.binary) < (*rhs.m_value.binary);

                default:
                    return false;
            }
        }
        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
        {
            return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
        }
        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
        {
            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
        }
        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
        {
            return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
        }
        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
        {
            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
        }
        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
        {
            return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
        }
        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
        {
            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
        }

        // We only reach this line if we cannot compare values. In that case,
        // we compare types. Note we have to call the operator explicitly,
        // because MSVC has problems otherwise.
        return operator<(lhs_type, rhs_type);
    }

// Assembly:
pushq %rax
movzbl (%rdi), %eax
movb (%rsi), %cl
cmpb %cl, %al
jne 0x2ae1e
decl %eax
cmpl $0x7, %eax
ja 0x2af23
leaq 0x1ab01(%rip), %rcx     # 0x45904
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x2c3ed
jmp 0x2af21
movl %eax, %edx
xorb $0x5, %dl
movl %ecx, %r8d
xorb $0x7, %r8b
orb %r8b, %dl
jne 0x2ae43
cvtsi2sdq 0x8(%rdi), %xmm0
movsd 0x8(%rsi), %xmm1
ucomisd %xmm0, %xmm1
jmp 0x2af1e
movl %eax, %r9d
xorb $0x7, %r9b
movl %ecx, %edx
xorb $0x5, %dl
orb %dl, %r9b
jne 0x2ae5f
cvtsi2sdq 0x8(%rsi), %xmm0
jmp 0x2af19
movl %eax, %r9d
xorb $0x6, %r9b
orb %r8b, %r9b
jne 0x2ae99
movsd 0x8(%rdi), %xmm0
unpcklps 0x1a1e9(%rip), %xmm0    # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1a1f1(%rip), %xmm0    # 0x45070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8(%rsi), %xmm0
ucomisd %xmm1, %xmm0
jmp 0x2af1e
movl %eax, %r9d
xorb $0x7, %r9b
movl %ecx, %r8d
xorb $0x6, %r8b
orb %r8b, %r9b
jne 0x2af27
movsd 0x8(%rsi), %xmm0
unpcklps 0x1a1a8(%rip), %xmm0    # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1a1b0(%rip), %xmm0    # 0x45070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
ucomisd 0x8(%rdi), %xmm1
jmp 0x2af1e
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
popq %rax
jmp 0x10a78
movb 0x8(%rdi), %al
cmpb 0x8(%rsi), %al
jmp 0x2af0f
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x2c340
jmp 0x2af21
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x2c327
jmp 0x2af21
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
setb %al
jmp 0x2af21
movsd 0x8(%rsi), %xmm0
ucomisd 0x8(%rdi), %xmm0
seta %al
popq %rcx
retq
xorl %eax, %eax
jmp 0x2af21
movl %eax, %r9d
xorb $0x5, %r9b
orb %r8b, %r9b
je 0x2af3f
movl %eax, %r8d
xorb $0x6, %r8b
orb %dl, %r8b
jne 0x2af4c
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
setl %al
jmp 0x2af21
movzbl %cl, %esi
movl %eax, %edi
popq %rax
jmp 0x2c359
movq %rax, %rdi
callq 0xc99e