// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/rapidjson/include/rapidjson/internal/itoa.h
// Function: rapidjson::internal::u64toa(unsigned long, char*)
inline char* u64toa(uint64_t value, char* buffer) {
    RAPIDJSON_ASSERT(buffer != 0);
    const char* cDigitsLut = GetDigitsLut();
    const uint64_t  kTen8 = 100000000;
    const uint64_t  kTen9 = kTen8 * 10;
    const uint64_t kTen10 = kTen8 * 100;
    const uint64_t kTen11 = kTen8 * 1000;
    const uint64_t kTen12 = kTen8 * 10000;
    const uint64_t kTen13 = kTen8 * 100000;
    const uint64_t kTen14 = kTen8 * 1000000;
    const uint64_t kTen15 = kTen8 * 10000000;
    const uint64_t kTen16 = kTen8 * kTen8;

    if (value < kTen8) {
        uint32_t v = static_cast<uint32_t>(value);
        if (v < 10000) {
            const uint32_t d1 = (v / 100) << 1;
            const uint32_t d2 = (v % 100) << 1;

            if (v >= 1000)
                *buffer++ = cDigitsLut[d1];
            if (v >= 100)
                *buffer++ = cDigitsLut[d1 + 1];
            if (v >= 10)
                *buffer++ = cDigitsLut[d2];
            *buffer++ = cDigitsLut[d2 + 1];
        }
        else {
            // value = bbbbcccc
            const uint32_t b = v / 10000;
            const uint32_t c = v % 10000;

            const uint32_t d1 = (b / 100) << 1;
            const uint32_t d2 = (b % 100) << 1;

            const uint32_t d3 = (c / 100) << 1;
            const uint32_t d4 = (c % 100) << 1;

            if (value >= 10000000)
                *buffer++ = cDigitsLut[d1];
            if (value >= 1000000)
                *buffer++ = cDigitsLut[d1 + 1];
            if (value >= 100000)
                *buffer++ = cDigitsLut[d2];
            *buffer++ = cDigitsLut[d2 + 1];

            *buffer++ = cDigitsLut[d3];
            *buffer++ = cDigitsLut[d3 + 1];
            *buffer++ = cDigitsLut[d4];
            *buffer++ = cDigitsLut[d4 + 1];
        }
    }
    else if (value < kTen16) {
        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);

        const uint32_t b0 = v0 / 10000;
        const uint32_t c0 = v0 % 10000;

        const uint32_t d1 = (b0 / 100) << 1;
        const uint32_t d2 = (b0 % 100) << 1;

        const uint32_t d3 = (c0 / 100) << 1;
        const uint32_t d4 = (c0 % 100) << 1;

        const uint32_t b1 = v1 / 10000;
        const uint32_t c1 = v1 % 10000;

        const uint32_t d5 = (b1 / 100) << 1;
        const uint32_t d6 = (b1 % 100) << 1;

        const uint32_t d7 = (c1 / 100) << 1;
        const uint32_t d8 = (c1 % 100) << 1;

        if (value >= kTen15)
            *buffer++ = cDigitsLut[d1];
        if (value >= kTen14)
            *buffer++ = cDigitsLut[d1 + 1];
        if (value >= kTen13)
            *buffer++ = cDigitsLut[d2];
        if (value >= kTen12)
            *buffer++ = cDigitsLut[d2 + 1];
        if (value >= kTen11)
            *buffer++ = cDigitsLut[d3];
        if (value >= kTen10)
            *buffer++ = cDigitsLut[d3 + 1];
        if (value >= kTen9)
            *buffer++ = cDigitsLut[d4];

        *buffer++ = cDigitsLut[d4 + 1];
        *buffer++ = cDigitsLut[d5];
        *buffer++ = cDigitsLut[d5 + 1];
        *buffer++ = cDigitsLut[d6];
        *buffer++ = cDigitsLut[d6 + 1];
        *buffer++ = cDigitsLut[d7];
        *buffer++ = cDigitsLut[d7 + 1];
        *buffer++ = cDigitsLut[d8];
        *buffer++ = cDigitsLut[d8 + 1];
    }
    else {
        const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
        value %= kTen16;

        if (a < 10)
            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
        else if (a < 100) {
            const uint32_t i = a << 1;
            *buffer++ = cDigitsLut[i];
            *buffer++ = cDigitsLut[i + 1];
        }
        else if (a < 1000) {
            *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));

            const uint32_t i = (a % 100) << 1;
            *buffer++ = cDigitsLut[i];
            *buffer++ = cDigitsLut[i + 1];
        }
        else {
            const uint32_t i = (a / 100) << 1;
            const uint32_t j = (a % 100) << 1;
            *buffer++ = cDigitsLut[i];
            *buffer++ = cDigitsLut[i + 1];
            *buffer++ = cDigitsLut[j];
            *buffer++ = cDigitsLut[j + 1];
        }

        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);

        const uint32_t b0 = v0 / 10000;
        const uint32_t c0 = v0 % 10000;

        const uint32_t d1 = (b0 / 100) << 1;
        const uint32_t d2 = (b0 % 100) << 1;

        const uint32_t d3 = (c0 / 100) << 1;
        const uint32_t d4 = (c0 % 100) << 1;

        const uint32_t b1 = v1 / 10000;
        const uint32_t c1 = v1 % 10000;

        const uint32_t d5 = (b1 / 100) << 1;
        const uint32_t d6 = (b1 % 100) << 1;

        const uint32_t d7 = (c1 / 100) << 1;
        const uint32_t d8 = (c1 % 100) << 1;

        *buffer++ = cDigitsLut[d1];
        *buffer++ = cDigitsLut[d1 + 1];
        *buffer++ = cDigitsLut[d2];
        *buffer++ = cDigitsLut[d2 + 1];
        *buffer++ = cDigitsLut[d3];
        *buffer++ = cDigitsLut[d3 + 1];
        *buffer++ = cDigitsLut[d4];
        *buffer++ = cDigitsLut[d4 + 1];
        *buffer++ = cDigitsLut[d5];
        *buffer++ = cDigitsLut[d5 + 1];
        *buffer++ = cDigitsLut[d6];
        *buffer++ = cDigitsLut[d6 + 1];
        *buffer++ = cDigitsLut[d7];
        *buffer++ = cDigitsLut[d7 + 1];
        *buffer++ = cDigitsLut[d8];
        *buffer++ = cDigitsLut[d8 + 1];
    }

    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0xe2dc
cmpq $0x5f5e0ff, %rdi        # imm = 0x5F5E0FF
ja 0xdd98
cmpq $0x270f, %rdi           # imm = 0x270F
ja 0xde79
pushq $0x64
popq %rcx
movl %edi, %eax
xorl %edx, %edx
divl %ecx
addq %rax, %rax
addl %edx, %edx
cmpq $0x3e8, %rdi            # imm = 0x3E8
jb 0xdf21
movq 0xb1dd(%rip), %rcx      # 0x18f68
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
incq %rsi
jmp 0xdf2b
movabsq $0x2386f26fc0ffff, %rax # imm = 0x2386F26FC0FFFF
cmpq %rax, %rdi
ja 0xdee7
movl $0x5f5e100, %ecx        # imm = 0x5F5E100
movq %rdi, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r8
movq %rdx, %rcx
movl $0x2710, %ebx           # imm = 0x2710
xorl %edx, %edx
divl %ebx
movl %eax, %r9d
movl %edx, %r10d
movl $0xf4240, %r12d         # imm = 0xF4240
movl %r8d, %eax
xorl %edx, %edx
divl %r12d
movl %eax, %r8d
movw $0x64, %r15w
movl %r9d, %eax
xorl %edx, %edx
divw %r15w
movl %edx, %r9d
movl %r10d, %eax
xorl %edx, %edx
divw %r15w
movl %edx, %r10d
movl %eax, %r11d
movl %ecx, %eax
xorl %edx, %edx
divl %ebx
movl %edx, %ebx
movl %eax, %r14d
movl %ecx, %eax
xorl %edx, %edx
divl %r12d
movl %eax, %ecx
movl %r14d, %eax
xorl %edx, %edx
divw %r15w
movl %edx, %r14d
movl %ebx, %eax
xorl %edx, %edx
divw %r15w
addl %r8d, %r8d
movzwl %r9w, %ebx
addl %ebx, %ebx
movzwl %r11w, %r11d
addl %r11d, %r11d
movzwl %r10w, %r10d
addl %r10d, %r10d
addl %ecx, %ecx
movzwl %r14w, %r9d
addl %r9d, %r9d
movzwl %ax, %eax
addl %eax, %eax
movzwl %dx, %edx
addl %edx, %edx
movabsq $0x38d7ea4c68000, %r14  # imm = 0x38D7EA4C68000
cmpq %r14, %rdi
jb 0xdf63
movq 0xb0fe(%rip), %rdi      # 0x18f68
movb (%rdi,%r8), %dil
movb %dil, (%rsi)
incq %rsi
jmp 0xdf76
movl $0x2710, %ecx           # imm = 0x2710
movl %edi, %eax
xorl %edx, %edx
divl %ecx
movl %eax, %r8d
movl %edx, %r9d
movl $0xf4240, %ecx          # imm = 0xF4240
movl %edi, %eax
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movw $0x64, %r10w
movl %r8d, %eax
xorl %edx, %edx
divw %r10w
movl %edx, %r8d
movl %r9d, %eax
xorl %edx, %edx
divw %r10w
addl %ecx, %ecx
movzwl %r8w, %r8d
addl %r8d, %r8d
movzwl %ax, %eax
addl %eax, %eax
movzwl %dx, %edx
addl %edx, %edx
cmpq $0x989680, %rdi         # imm = 0x989680
jb 0xe04e
movq 0xb090(%rip), %rdi      # 0x18f68
movb (%rdi,%rcx), %dil
movb %dil, (%rsi)
incq %rsi
jmp 0xe05b
movabsq $0x2386f26fc10000, %rcx # imm = 0x2386F26FC10000
movq %rdi, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r8
movq %rdx, %rcx
movabsq $0x16345785d89ffff, %rax # imm = 0x16345785D89FFFF
cmpq %rax, %rdi
ja 0xe0b7
orb $0x30, %r8b
movb %r8b, (%rsi)
incq %rsi
jmp 0xe1f1
cmpq $0x64, %rdi
jb 0xe0f0
movl %eax, %eax
movq 0xb034(%rip), %rcx      # 0x18f68
movb 0x1(%rcx,%rax), %al
movb %al, (%rsi)
incq %rsi
movq 0xb024(%rip), %rax      # 0x18f68
movb (%rax,%rdx), %al
movb %al, (%rsi)
incq %rsi
movl %edx, %eax
movq 0xb013(%rip), %rcx      # 0x18f68
movb 0x1(%rcx,%rax), %al
movb %al, (%rsi)
incq %rsi
jmp 0xe2d0
movabsq $0x5af3107a4000, %r14   # imm = 0x5AF3107A4000
cmpq %r14, %rdi
jb 0xe0ff
movl %r8d, %edi
movq 0xafe8(%rip), %r8       # 0x18f68
movb 0x1(%r8,%rdi), %dil
movb %dil, (%rsi)
incq %rsi
movq 0xafd6(%rip), %rdi      # 0x18f68
movb (%rdi,%rbx), %dil
movb %dil, (%rsi)
incq %rsi
movzwl %bx, %edi
movq 0xafc2(%rip), %r8       # 0x18f68
movb 0x1(%r8,%rdi), %dil
movb %dil, (%rsi)
incq %rsi
movq 0xafb0(%rip), %rdi      # 0x18f68
movb (%rdi,%r11), %dil
movb %dil, (%rsi)
incq %rsi
movzwl %r11w, %edi
movq 0xaf9b(%rip), %r8       # 0x18f68
movb 0x1(%r8,%rdi), %dil
movb %dil, (%rsi)
incq %rsi
movq 0xaf89(%rip), %rdi      # 0x18f68
movb (%rdi,%r10), %dil
movb %dil, (%rsi)
incq %rsi
movzwl %r10w, %edi
movq 0xaf74(%rip), %r8       # 0x18f68
movb 0x1(%r8,%rdi), %dil
movb %dil, (%rsi)
movb (%r8,%rcx), %dil
movb %dil, 0x1(%rsi)
movl %ecx, %ecx
movb 0x1(%r8,%rcx), %cl
movb %cl, 0x2(%rsi)
movb (%r8,%r9), %cl
movb %cl, 0x3(%rsi)
movzwl %r9w, %ecx
movb 0x1(%r8,%rcx), %cl
movb %cl, 0x4(%rsi)
movb (%r8,%rax), %cl
movb %cl, 0x5(%rsi)
movzwl %ax, %eax
movb 0x1(%r8,%rax), %al
movb %al, 0x6(%rsi)
movb (%r8,%rdx), %al
movb %al, 0x7(%rsi)
movzwl %dx, %eax
movb 0x1(%r8,%rax), %al
movb %al, 0x8(%rsi)
addq $0x9, %rsi
jmp 0xe2d0
cmpq $0xf4240, %rdi          # imm = 0xF4240
jb 0xe161
movl %ecx, %ecx
movq 0xaf04(%rip), %rdi      # 0x18f68
movb 0x1(%rdi,%rcx), %cl
movb %cl, (%rsi)
incq %rsi
movq 0xaef4(%rip), %rcx      # 0x18f68
movb (%rcx,%r8), %cl
movb %cl, (%rsi)
incq %rsi
movzwl %r8w, %ecx
movq 0xaee0(%rip), %rdi      # 0x18f68
movb 0x1(%rdi,%rcx), %cl
movb %cl, (%rsi)
movb (%rdi,%rax), %cl
movb %cl, 0x1(%rsi)
movzwl %ax, %eax
movb 0x1(%rdi,%rax), %al
movb %al, 0x2(%rsi)
movb (%rdi,%rdx), %al
movb %al, 0x3(%rsi)
movzwl %dx, %eax
movb 0x1(%rdi,%rax), %al
movb %al, 0x4(%rsi)
addq $0x5, %rsi
jmp 0xe2d0
movabsq $0xde0b6b3a763ffff, %rax # imm = 0xDE0B6B3A763FFFF
cmpq %rax, %rdi
ja 0xe173
movl %r8d, %eax
movq 0xae94(%rip), %rdx      # 0x18f68
movb (%rdx,%rax,2), %dil
addq %rax, %rax
movb %dil, (%rsi)
movl %eax, %eax
movb 0x1(%rdx,%rax), %al
movb %al, 0x1(%rsi)
addq $0x2, %rsi
jmp 0xe1f1
cmpq $0xa, %rdi
jae 0xdf3d
jmp 0xdf4c
movq %rdi, %r8
shrq $0xd, %r8
cmpq $0x48c27395, %r8        # imm = 0x48C27395
jae 0xdf8b
movq %rdi, %r8
shrq $0xc, %r8
cmpq $0xe8d4a51, %r8         # imm = 0xE8D4A51
jae 0xdf9c
movq %rdi, %r8
shrq $0xb, %r8
cmpq $0x2e90edd, %r8         # imm = 0x2E90EDD
jae 0xdfb1
movq %rdi, %r8
shrq $0xa, %r8
cmpq $0x9502f9, %r8          # imm = 0x9502F9
jae 0xdfc2
cmpq $0x3b9aca00, %rdi       # imm = 0x3B9ACA00
jae 0xdfd8
jmp 0xdfe9
cmpq $0x186a0, %rdi          # imm = 0x186A0
jae 0xe06d
jmp 0xe07d
movw $0x64, %r9w
movl %r8d, %eax
xorl %edx, %edx
divw %r9w
movabsq $-0x7538dcfb76180001, %r10 # imm = 0x8AC7230489E7FFFF
cmpq %r10, %rdi
ja 0xe1b5
addb $0x30, %al
movb %al, (%rsi)
movl %r8d, %eax
xorl %edx, %edx
divw %r9w
movzwl %dx, %eax
movq 0xadc1(%rip), %rdx      # 0x18f68
movzwl (%rdx,%rax,2), %eax
movw %ax, 0x1(%rsi)
addq $0x3, %rsi
jmp 0xe1f1
movzwl %ax, %eax
addl %eax, %eax
movzwl %dx, %edx
addl %edx, %edx
movq 0xada2(%rip), %rdi      # 0x18f68
movb (%rdi,%rax), %r8b
movb %r8b, (%rsi)
movl $0xffff, %r8d           # imm = 0xFFFF
andq %r8, %rax
movb 0x1(%rdi,%rax), %al
movb %al, 0x1(%rsi)
movb (%rdi,%rdx), %al
movb %al, 0x2(%rsi)
andq %r8, %rdx
movb 0x1(%rdi,%rdx), %al
movb %al, 0x3(%rsi)
addq $0x4, %rsi
movl $0x5f5e100, %edi        # imm = 0x5F5E100
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
movq %rax, %rcx
movq %rdx, %rdi
movl $0x2710, %r11d          # imm = 0x2710
xorl %edx, %edx
divl %r11d
movl %eax, %r8d
movl %edx, %r9d
movl $0xf4240, %r15d         # imm = 0xF4240
movl %ecx, %eax
xorl %edx, %edx
divl %r15d
movl %eax, %ecx
movw $0x64, %r14w
movl %r8d, %eax
xorl %edx, %edx
divw %r14w
movl %edx, %r8d
movl %r9d, %eax
xorl %edx, %edx
divw %r14w
movl %edx, %r9d
movl %eax, %r10d
movl %edi, %eax
xorl %edx, %edx
divl %r11d
movl %edx, %r11d
movl %eax, %ebx
movl %edi, %eax
xorl %edx, %edx
divl %r15d
movl %eax, %edi
movl %ebx, %eax
xorl %edx, %edx
divw %r14w
movl %edx, %ebx
movl %r11d, %eax
xorl %edx, %edx
divw %r14w
movzwl %r8w, %r8d
movzwl %r10w, %r10d
movzwl %r9w, %r9d
movzwl %bx, %r11d
movzwl %ax, %eax
movzwl %dx, %edx
movq 0xacdf(%rip), %rbx      # 0x18f68
movzwl (%rbx,%rcx,2), %ecx
movw %cx, (%rsi)
movzwl (%rbx,%r8,2), %ecx
movw %cx, 0x2(%rsi)
movzwl (%rbx,%r10,2), %ecx
movw %cx, 0x4(%rsi)
movzwl (%rbx,%r9,2), %ecx
movw %cx, 0x6(%rsi)
movzwl (%rbx,%rdi,2), %ecx
movw %cx, 0x8(%rsi)
movzwl (%rbx,%r11,2), %ecx
movw %cx, 0xa(%rsi)
movzwl (%rbx,%rax,2), %eax
movw %ax, 0xc(%rsi)
movzwl (%rbx,%rdx,2), %eax
movw %ax, 0xe(%rsi)
addq $0x10, %rsi
movq %rsi, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3e08(%rip), %rdi      # 0x120eb
leaq 0x3e0d(%rip), %rsi      # 0x120f7
leaq 0x3ecc(%rip), %rcx      # 0x121bd
pushq $0x7f
popq %rdx
callq 0x9380
nop