// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]brain-tools/include/json.hpp
// 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
    {
        throw_if_invalid_utf8(s);

        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]));
                        // invalid characters will be detected by throw_if_invalid_utf8
                        assert (bytes != std::string::npos);

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

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

                        // bytes is unsigned type:
                        assert(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;
                            }

                            default:
                                break;  // LCOV_EXCL_LINE
                        }

                        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
callq 0x5f50
movq %r14, %rdi
movl %ebp, %esi
callq 0x6330
testq %rax, %rax
je 0x5b46
addq 0x8(%r14), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movl $0x5c, %edx
callq 0x3270
movq $0x0, (%rsp)
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x5b06
xorl %eax, %eax
xorb $0x1, %bpl
leaq 0x371c(%rip), %r15      # 0x9064
leaq 0x36fd(%rip), %r12      # 0x904c
movq (%r14), %rcx
movb (%rcx,%rax), %sil
movzbl %sil, %edi
leal -0x8(%rdi), %r8d
cmpl $0x5, %r8d
ja 0x597e
movslq (%r12,%r8,4), %r8
addq %r12, %r8
jmpq *%r8
movq (%rsp), %rcx
movq 0x8(%rsp), %rdx
movb $0x62, 0x1(%rdx,%rcx)
jmp 0x59fb
cmpl $0x5c, %edi
je 0x59fb
cmpl $0x22, %edi
jne 0x5998
movq (%rsp), %rcx
movq 0x8(%rsp), %rdx
movb $0x22, 0x1(%rdx,%rcx)
jmp 0x59fb
cmpb $0x20, %sil
setae %r8b
cmpb $0x7f, %sil
setb %r9b
orb %bpl, %r9b
testb %r9b, %r8b
jne 0x5a1b
testb %sil, %sil
js 0x5a32
xorl %r8d, %r8d
jmp 0x5a6f
movq (%rsp), %rcx
movq 0x8(%rsp), %rdx
movb $0x74, 0x1(%rdx,%rcx)
jmp 0x59fb
movq (%rsp), %rcx
movq 0x8(%rsp), %rdx
movb $0x6e, 0x1(%rdx,%rcx)
jmp 0x59fb
movq (%rsp), %rcx
movq 0x8(%rsp), %rdx
movb $0x66, 0x1(%rdx,%rcx)
jmp 0x59fb
movq (%rsp), %rcx
movq 0x8(%rsp), %rdx
movb $0x72, 0x1(%rdx,%rcx)
addq $0x2, (%rsp)
movq %rax, %r13
incq %r13
movq 0x8(%r14), %rdx
movq %r13, %rax
cmpq %rdx, %r13
jb 0x594f
jmp 0x5b06
movq (%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rsp), %rdx
movb %sil, (%rdx,%rcx)
jmp 0x5a00
movl %esi, %r9d
andb $-0x20, %r9b
movl $0x1, %r8d
cmpb $-0x40, %r9b
je 0x5a6f
movl %esi, %r9d
andb $-0x10, %r9b
movl $0x2, %r8d
cmpb $-0x20, %r9b
je 0x5a6f
andb $-0x8, %sil
xorl %r8d, %r8d
cmpb $-0x10, %sil
sete %r8b
leaq -0x1(,%r8,4), %r8
cmpq $-0x1, %r8
je 0x5ba5
leaq (%r8,%rax), %r13
cmpq %rdx, %r13
jae 0x5b67
cmpq $0x4, %r8
jae 0x5b86
movslq (%r15,%r8,4), %rdx
addq %r15, %rdx
jmpq *%rdx
andl $0x3f, %edi
shll $0x6, %edi
movzbl 0x1(%rcx,%rax), %eax
andl $0x7f, %eax
jmp 0x5ac4
andl $0x1f, %edi
shll $0xc, %edi
movzbl 0x1(%rcx,%rax), %edx
andl $0x7f, %edx
shll $0x6, %edx
movzbl 0x2(%rcx,%rax), %eax
andl $0x7f, %eax
addl %edx, %eax
addl %edi, %eax
movl %eax, %edi
jmp 0x5af4
andl $0xf, %edi
shll $0x12, %edi
movzbl 0x1(%rcx,%rax), %edx
andl $0x7f, %edx
shll $0xc, %edx
movzbl 0x2(%rcx,%rax), %esi
andl $0x7f, %esi
shll $0x6, %esi
addl %edx, %esi
addl %edi, %esi
movzbl 0x3(%rcx,%rax), %edi
andl $0x7f, %edi
addl %esi, %edi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
callq 0x641a
jmp 0x5a03
movq 0x10(%rsp), %rdx
cmpq %rdx, (%rsp)
jne 0x5bc4
movq (%rbx), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5b37
callq 0x3200
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 0x3904(%rip), %rdi      # 0x9472
leaq 0x370d(%rip), %rsi      # 0x9282
leaq 0x3861(%rip), %rcx      # 0x93dd
movl $0x19a4, %edx           # imm = 0x19A4
callq 0x3150
leaq 0x38fa(%rip), %rdi      # 0x9487
leaq 0x36ee(%rip), %rsi      # 0x9282
leaq 0x3842(%rip), %rcx      # 0x93dd
movl $0x19ab, %edx           # imm = 0x19AB
callq 0x3150
leaq 0x3816(%rip), %rdi      # 0x93c2
leaq 0x36cf(%rip), %rsi      # 0x9282
leaq 0x3823(%rip), %rcx      # 0x93dd
movl $0x19a1, %edx           # imm = 0x19A1
callq 0x3150
leaq 0x38c7(%rip), %rdi      # 0x9492
leaq 0x36b0(%rip), %rsi      # 0x9282
leaq 0x3804(%rip), %rcx      # 0x93dd
movl $0x19dd, %edx           # imm = 0x19DD
callq 0x3150
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5bfa
callq 0x3200
movq %rbx, %rdi
callq 0x3390