// File: Konano[P]UselessDatabase/./json.hpp
// Function: void nlohmann::detail::serializer<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>>::dump_integer<long, 0>(long)
void dump_integer(NumberType x)
    {
        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
        {
            {
                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
            }
        };

        // special case for "0"
        if (x == 0)
        {
            o->write_character('0');
            return;
        }

        // use a pointer to fill the buffer
        auto buffer_ptr = number_buffer.begin();

        const bool is_negative = std::is_same<NumberType, number_integer_t>::value and not(x >= 0); // see issue #755
        number_unsigned_t abs_value;

        unsigned int n_chars;

        if (is_negative)
        {
            *buffer_ptr = '-';
            abs_value = remove_sign(x);

            // account one more byte for the minus sign
            n_chars = 1 + count_digits(abs_value);
        }
        else
        {
            abs_value = static_cast<number_unsigned_t>(x);
            n_chars = count_digits(abs_value);
        }

        // spare 1 byte for '\0'
        assert(n_chars < number_buffer.size() - 1);

        // jump to the end to generate the string from backward
        // so we later avoid reversing the result
        buffer_ptr += n_chars;

        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
        while (abs_value >= 100)
        {
            const auto digits_index = static_cast<unsigned>((abs_value % 100));
            abs_value /= 100;
            *(--buffer_ptr) = digits_to_99[digits_index][1];
            *(--buffer_ptr) = digits_to_99[digits_index][0];
        }

        if (abs_value >= 10)
        {
            const auto digits_index = static_cast<unsigned>(abs_value);
            *(--buffer_ptr) = digits_to_99[digits_index][1];
            *(--buffer_ptr) = digits_to_99[digits_index][0];
        }
        else
        {
            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
        }

        o->write_characters(number_buffer.data(), n_chars);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1484a
movq -0x40(%rbp), %rdi
callq 0x13880
movq %rax, %rdi
movq (%rdi), %rax
movl $0x30, %esi
callq *(%rax)
jmp 0x14a5d
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
callq 0x15ef0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
setge %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x1489d
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movb $0x2d, (%rax)
movq -0x10(%rbp), %rsi
callq 0x15f10
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x15f90
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x148b5
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x15f90
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rdi
movl -0x2c(%rbp), %eax
movq %rax, -0x48(%rbp)
addq $0x10, %rdi
callq 0x16010
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x148db
jmp 0x148fa
leaq 0x6a4a8(%rip), %rdi     # 0x7ed8a
leaq 0x6a258(%rip), %rsi     # 0x7eb41
movl $0x3836, %edx           # imm = 0x3836
leaq 0x6a4b8(%rip), %rcx     # 0x7edad
callq 0x6350
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x64, -0x28(%rbp)
jb 0x149a2
movq -0x28(%rbp), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, %esi
leaq 0x6e673(%rip), %rdi     # 0x82fb9
callq 0x16020
movq %rax, %rdi
movl $0x1, %esi
callq 0x16050
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, -0x1(%rax)
movl -0x30(%rbp), %eax
movl %eax, %esi
leaq 0x6e641(%rip), %rdi     # 0x82fb9
callq 0x16020
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x16050
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, -0x1(%rax)
jmp 0x1490a
cmpq $0xa, -0x28(%rbp)
jb 0x14a15
movq -0x28(%rbp), %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %esi
leaq 0x6e5fd(%rip), %rdi     # 0x82fb9
callq 0x16020
movq %rax, %rdi
movl $0x1, %esi
callq 0x16050
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, -0x1(%rax)
movl -0x34(%rbp), %eax
movl %eax, %esi
leaq 0x6e5cb(%rip), %rdi     # 0x82fb9
callq 0x16020
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x16050
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, -0x1(%rax)
jmp 0x14a31
movq -0x28(%rbp), %rax
addq $0x30, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, -0x1(%rax)
movq -0x40(%rbp), %rdi
callq 0x13880
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x10, %rdi
callq 0x16080
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)