// File: 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
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x2ff30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2edb3
movq -0x80(%rbp), %rdi
callq 0x2ecc0
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc190
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc420
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x2f45e
movq -0x10(%rbp), %rdi
callq 0xc420
movq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xa0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xcc80
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movl $0x5c, %edx
callq 0x1efd0
jmp 0x2edf8
leaq -0x41(%rbp), %rdi
callq 0xcfa0
movq $0x0, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc420
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jae 0x2f3c2
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movsbl (%rax), %eax
movl %eax, -0xac(%rbp)
subl $0x8, %eax
je 0x2ef33
jmp 0x2ee59
movl -0xac(%rbp), %eax
subl $0x9, %eax
je 0x2f003
jmp 0x2ee6a
movl -0xac(%rbp), %eax
subl $0xa, %eax
je 0x2ef9b
jmp 0x2ee7b
movl -0xac(%rbp), %eax
subl $0xc, %eax
je 0x2ef67
jmp 0x2ee8c
movl -0xac(%rbp), %eax
subl $0xd, %eax
je 0x2efcf
jmp 0x2ee9d
movl -0xac(%rbp), %eax
subl $0x22, %eax
je 0x2eed4
jmp 0x2eeaa
movl -0xac(%rbp), %eax
subl $0x5c, %eax
je 0x2ef22
jmp 0x2f037
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0xcfa0
jmp 0x2f467
movq -0x60(%rbp), %rsi
incq %rsi
leaq -0x40(%rbp), %rdi
callq 0xce90
movq %rax, -0xb8(%rbp)
jmp 0x2eeed
movq -0xb8(%rbp), %rax
movb $0x22, (%rax)
movq -0x60(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
jmp 0x2f3af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcfb8
jmp 0x2f467
movq -0x60(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
jmp 0x2f3af
movq -0x60(%rbp), %rsi
incq %rsi
leaq -0x40(%rbp), %rdi
callq 0xce90
movq %rax, -0xc0(%rbp)
jmp 0x2ef4c
movq -0xc0(%rbp), %rax
movb $0x62, (%rax)
movq -0x60(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
jmp 0x2f3af
movq -0x60(%rbp), %rsi
incq %rsi
leaq -0x40(%rbp), %rdi
callq 0xce90
movq %rax, -0xc8(%rbp)
jmp 0x2ef80
movq -0xc8(%rbp), %rax
movb $0x66, (%rax)
movq -0x60(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
jmp 0x2f3af
movq -0x60(%rbp), %rsi
incq %rsi
leaq -0x40(%rbp), %rdi
callq 0xce90
movq %rax, -0xd0(%rbp)
jmp 0x2efb4
movq -0xd0(%rbp), %rax
movb $0x6e, (%rax)
movq -0x60(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
jmp 0x2f3af
movq -0x60(%rbp), %rsi
incq %rsi
leaq -0x40(%rbp), %rdi
callq 0xce90
movq %rax, -0xd8(%rbp)
jmp 0x2efe8
movq -0xd8(%rbp), %rax
movb $0x72, (%rax)
movq -0x60(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
jmp 0x2f3af
movq -0x60(%rbp), %rsi
incq %rsi
leaq -0x40(%rbp), %rdi
callq 0xce90
movq %rax, -0xe0(%rbp)
jmp 0x2f01c
movq -0xe0(%rbp), %rax
movb $0x74, (%rax)
movq -0x60(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
jmp 0x2f3af
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x2f062
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movsbl (%rax), %eax
cmpl $0x1f, %eax
jle 0x2f09f
testb $0x1, -0x11(%rbp)
je 0x2f369
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x2f09f
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movsbl (%rax), %eax
cmpl $0x7f, %eax
jne 0x2f369
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movzbl (%rax), %edi
callq 0x300a0
movq %rax, -0xe8(%rbp)
jmp 0x2f0bd
movq -0xe8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $-0x1, -0x70(%rbp)
jne 0x2f118
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movb (%rax), %al
movb %al, -0xf1(%rbp)
movq -0x60(%rbp), %rsi
movq %rsi, %rax
incq %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xce90
movq %rax, -0xf0(%rbp)
jmp 0x2f104
movq -0xf0(%rbp), %rax
movb -0xf1(%rbp), %cl
movb %cl, (%rax)
jmp 0x2f3af
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc420
movq %rax, %rcx
movq -0x100(%rbp), %rax
cmpq %rcx, %rax
jae 0x2f141
jmp 0x2f160
leaq 0x6252e(%rip), %rdi     # 0x91676
leaq 0x604fa(%rip), %rsi     # 0x8f649
movl $0x1956, %edx           # imm = 0x1956
leaq 0x62530(%rip), %rcx     # 0x9168b
callq 0xc290
movl $0x0, -0x74(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpq -0x70(%rbp), %rcx
movb %al, -0x101(%rbp)
ja 0x2f185
cmpq $0x3, -0x70(%rbp)
setbe %al
movb %al, -0x101(%rbp)
movb -0x101(%rbp), %al
testb $0x1, %al
jne 0x2f191
jmp 0x2f193
jmp 0x2f1b2
leaq 0x62586(%rip), %rdi     # 0x91720
leaq 0x604a8(%rip), %rsi     # 0x8f649
movl $0x195c, %edx           # imm = 0x195C
leaq 0x624de(%rip), %rcx     # 0x9168b
callq 0xc290
movq -0x70(%rbp), %rax
movq %rax, -0x110(%rbp)
subq $0x3, %rax
ja 0x2f349
movq -0x110(%rbp), %rax
leaq 0x61547(%rip), %rcx     # 0x9071c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movsbl (%rax), %eax
andl $0xff, %eax
movl %eax, -0x74(%rbp)
jmp 0x2f349
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movsbl (%rax), %eax
andl $0x3f, %eax
shll $0x6, %eax
movl %eax, -0x114(%rbp)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x1, %rsi
callq 0xce20
movq %rax, %rcx
movl -0x114(%rbp), %eax
movsbl (%rcx), %ecx
andl $0x7f, %ecx
addl %ecx, %eax
movl %eax, -0x74(%rbp)
jmp 0x2f349
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movsbl (%rax), %eax
andl $0x1f, %eax
shll $0xc, %eax
movl %eax, -0x11c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x1, %rsi
callq 0xce20
movq %rax, %rcx
movl -0x11c(%rbp), %eax
movsbl (%rcx), %ecx
andl $0x7f, %ecx
shll $0x6, %ecx
addl %ecx, %eax
movl %eax, -0x118(%rbp)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x2, %rsi
callq 0xce20
movq %rax, %rcx
movl -0x118(%rbp), %eax
movsbl (%rcx), %ecx
andl $0x7f, %ecx
addl %ecx, %eax
movl %eax, -0x74(%rbp)
jmp 0x2f349
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movsbl (%rax), %eax
andl $0xf, %eax
shll $0x12, %eax
movl %eax, -0x128(%rbp)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x1, %rsi
callq 0xce20
movq %rax, %rcx
movl -0x128(%rbp), %eax
movsbl (%rcx), %ecx
andl $0x7f, %ecx
shll $0xc, %ecx
addl %ecx, %eax
movl %eax, -0x124(%rbp)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x2, %rsi
callq 0xce20
movq %rax, %rcx
movl -0x124(%rbp), %eax
movsbl (%rcx), %ecx
andl $0x7f, %ecx
shll $0x6, %ecx
addl %ecx, %eax
movl %eax, -0x120(%rbp)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x3, %rsi
callq 0xce20
movq %rax, %rcx
movl -0x120(%rbp), %eax
movsbl (%rcx), %ecx
andl $0x7f, %ecx
addl %ecx, %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %edi
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x30160
jmp 0x2f35b
movq -0x70(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x2f3ad
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xce20
movb (%rax), %al
movb %al, -0x131(%rbp)
movq -0x60(%rbp), %rsi
movq %rsi, %rax
incq %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xce90
movq %rax, -0x130(%rbp)
jmp 0x2f39e
movq -0x130(%rbp), %rax
movb -0x131(%rbp), %cl
movb %cl, (%rax)
jmp 0x2f3af
jmp 0x2f3b1
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x2ee11
movq -0x60(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc420
movq %rax, %rcx
movq -0x140(%rbp), %rax
cmpq %rcx, %rax
jne 0x2f3e7
jmp 0x2f406
leaq 0x6234c(%rip), %rdi     # 0x9173a
leaq 0x60254(%rip), %rsi     # 0x8f649
movl $0x198b, %edx           # imm = 0x198B
leaq 0x6228a(%rip), %rcx     # 0x9168b
callq 0xc290
movq -0x80(%rbp), %rdi
callq 0x2ecc0
movq %rax, -0x150(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0xc190
movq -0x158(%rbp), %rdi
movq %rax, -0x148(%rbp)
callq 0xc420
movq -0x150(%rbp), %rdi
movq -0x148(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x2f455
leaq -0x40(%rbp), %rdi
callq 0xcfb8
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xc8c0