// File: /workspace/github_cpp_makefile_star2_O2/king1600[P]cordpp/./include/json.h
// Function: 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_escaped(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) const
void dump_escaped(const string_t& s, const bool ensure_ascii) const
    {
        const auto space = extra_space(s, ensure_ascii);
        if (space == 0)
        {
            o->write_characters(s.c_str(), s.size());
            return;
        }

        // create a result string of necessary size
        string_t result(s.size() + space, '\\');
        std::size_t pos = 0;

        for (std::size_t i = 0; i < s.size(); ++i)
        {
            switch (s[i])
            {
                case '"': // quotation mark (0x22)
                {
                    result[pos + 1] = '"';
                    pos += 2;
                    break;
                }

                case '\\': // reverse solidus (0x5c)
                {
                    // nothing to change
                    pos += 2;
                    break;
                }

                case '\b': // backspace (0x08)
                {
                    result[pos + 1] = 'b';
                    pos += 2;
                    break;
                }

                case '\f': // formfeed (0x0c)
                {
                    result[pos + 1] = 'f';
                    pos += 2;
                    break;
                }

                case '\n': // newline (0x0a)
                {
                    result[pos + 1] = 'n';
                    pos += 2;
                    break;
                }

                case '\r': // carriage return (0x0d)
                {
                    result[pos + 1] = 'r';
                    pos += 2;
                    break;
                }

                case '\t': // horizontal tab (0x09)
                {
                    result[pos + 1] = 't';
                    pos += 2;
                    break;
                }

                default:
                {
                    // escape control characters (0x00..0x1F) or, if
                    // ensure_ascii parameter is used, non-ASCII characters
                    if ((0x00 <= s[i] and s[i] <= 0x1F) or
                            (ensure_ascii and (s[i] & 0x80 or s[i] == 0x7F)))
                    {
                        const auto bytes = bytes_following(static_cast<uint8_t>(s[i]));
                        if (bytes == std::string::npos)
                        {
                            // copy invalid character as is
                            result[pos++] = s[i];
                            break;
                        }

                        // check that the additional bytes are present
                        assert(i + bytes < s.size());

                        // to use \uxxxx escaping, we first need to caluclate
                        // the codepoint from the UTF-8 bytes
                        int codepoint = 0;

                        assert(0 <= bytes and bytes <= 3);
                        switch (bytes)
                        {
                            case 0:
                            {
                                codepoint = s[i] & 0xFF;
                                break;
                            }

                            case 1:
                            {
                                codepoint = ((s[i] & 0x3F) << 6)
                                            + (s[i + 1] & 0x7F);
                                break;
                            }

                            case 2:
                            {
                                codepoint = ((s[i] & 0x1F) << 12)
                                            + ((s[i + 1] & 0x7F) << 6)
                                            + (s[i + 2] & 0x7F);
                                break;
                            }

                            case 3:
                            {
                                codepoint = ((s[i] & 0xF) << 18)
                                            + ((s[i + 1] & 0x7F) << 12)
                                            + ((s[i + 2] & 0x7F) << 6)
                                            + (s[i + 3] & 0x7F);
                                break;
                            }
                        }

                        escape_codepoint(codepoint, result, pos);
                        i += bytes;
                    }
                    else
                    {
                        // all other characters are added as-is
                        result[pos++] = s[i];
                    }
                    break;
                }
            }
        }

        assert(pos == result.size());
        o->write_characters(result.c_str(), result.size());
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x146f6
testq %rax, %rax
je 0x14319
addq 0x8(%r14), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x8(%rsp), %rdi
pushq $0x5c
popq %rdx
movq %rax, %rsi
callq 0xa600
movq %rsp, %rax
andq $0x0, (%rax)
xorl %r13d, %r13d
leaq 0x1dd5f(%rip), %r15     # 0x31ebc
cmpq 0x8(%r14), %r13
jae 0x142e3
movq (%r14), %rax
movb (%rax,%r13), %al
movzbl %al, %edi
leal -0x8(%rdi), %ecx
cmpl $0x5, %ecx
ja 0x14192
movslq (%r15,%rcx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x62, 0x1(%rcx,%rax)
jmp 0x14204
cmpl $0x5c, %edi
je 0x14204
cmpl $0x22, %edi
jne 0x141ac
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x22, 0x1(%rcx,%rax)
jmp 0x14204
testb %al, %al
js 0x14217
cmpb $0x20, %al
setb %cl
cmpb $0x7f, %al
sete %dl
andb %bpl, %dl
orb %cl, %dl
jne 0x1421c
jmp 0x1426f
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x74, 0x1(%rcx,%rax)
jmp 0x14204
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x6e, 0x1(%rcx,%rax)
jmp 0x14204
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x66, 0x1(%rcx,%rax)
jmp 0x14204
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x72, 0x1(%rcx,%rax)
addq $0x2, (%rsp)
movq %r13, %r12
incq %r12
movq %r12, %r13
jmp 0x1415d
testb %bpl, %bpl
je 0x1426f
callq 0x14794
cmpq $-0x1, %rax
je 0x14268
leaq (%rax,%r13), %r12
cmpq 0x8(%r14), %r12
jae 0x1433a
cmpq $0x4, %rax
jae 0x14359
movq (%r14), %rcx
movzbl (%rcx,%r13), %edi
leaq 0x1dc86(%rip), %rdx     # 0x31ed4
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
andl $0x3f, %edi
shll $0x6, %edi
movzbl 0x1(%rcx,%r13), %eax
andl $0x7f, %eax
jmp 0x142cf
movq (%r14), %rax
movb (%rax,%r13), %al
movq (%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rsp), %rdx
movb %al, (%rdx,%rcx)
jmp 0x14209
andl $0x1f, %edi
shll $0xc, %edi
movzbl 0x1(%rcx,%r13), %eax
andl $0x7f, %eax
shll $0x6, %eax
addl %edi, %eax
movzbl 0x2(%rcx,%r13), %edi
andl $0x7f, %edi
jmp 0x142cf
andl $0xf, %edi
shll $0x12, %edi
movzbl 0x1(%rcx,%r13), %eax
andl $0x7f, %eax
shll $0xc, %eax
addl %edi, %eax
movzbl 0x2(%rcx,%r13), %edx
andl $0x7f, %edx
shll $0x6, %edx
movzbl 0x3(%rcx,%r13), %edi
andl $0x7f, %edi
addl %edx, %edi
addl %eax, %edi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
callq 0x147ca
jmp 0x1420c
movq (%rsp), %rdx
cmpq 0x10(%rsp), %rdx
jne 0x14378
movq (%rbx), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0xac38
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq (%rdi), %rax
movq 0x8(%rax), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0x1e5ad(%rip), %rdi     # 0x328ee
leaq 0x1cff0(%rip), %rsi     # 0x31338
leaq 0x1e5b4(%rip), %rcx     # 0x32903
movl $0x1956, %edx           # imm = 0x1956
callq 0xa1a0
leaq 0x1e638(%rip), %rdi     # 0x32998
leaq 0x1cfd1(%rip), %rsi     # 0x31338
leaq 0x1e595(%rip), %rcx     # 0x32903
movl $0x195c, %edx           # imm = 0x195C
callq 0xa1a0
leaq 0x1e633(%rip), %rdi     # 0x329b2
leaq 0x1cfb2(%rip), %rsi     # 0x31338
leaq 0x1e576(%rip), %rcx     # 0x32903
movl $0x198b, %edx           # imm = 0x198B
callq 0xa1a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xac38
movq %rbx, %rdi
callq 0xa6c0