// File: mattn[P]wandbox-run/./json.hpp
// Function: 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>::serializer::dump_escaped(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void dump_escaped(const string_t& s) const
        {
            const auto space = extra_space(s);
            if (space == 0)
            {
                o.write(s.c_str(), static_cast<std::streamsize>(s.size()));
                return;
            }

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

            for (const auto& c : s)
            {
                switch (c)
                {
                    // quotation mark (0x22)
                    case '"':
                    {
                        result[pos + 1] = '"';
                        pos += 2;
                        break;
                    }

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

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

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

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

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

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

                    case 0x00:
                    case 0x01:
                    case 0x02:
                    case 0x03:
                    case 0x04:
                    case 0x05:
                    case 0x06:
                    case 0x07:
                    case 0x0b:
                    case 0x0e:
                    case 0x0f:
                    case 0x10:
                    case 0x11:
                    case 0x12:
                    case 0x13:
                    case 0x14:
                    case 0x15:
                    case 0x16:
                    case 0x17:
                    case 0x18:
                    case 0x19:
                    case 0x1a:
                    case 0x1b:
                    case 0x1c:
                    case 0x1d:
                    case 0x1e:
                    case 0x1f:
                    {
                        // convert a number 0..15 to its hex representation
                        // (0..f)
                        static const char hexify[16] =
                        {
                            '0', '1', '2', '3', '4', '5', '6', '7',
                            '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
                        };

                        // print character c as \uxxxx
                        for (const char m :
                    { 'u', '0', '0', hexify[c >> 4], hexify[c & 0x0f]
                        })
                        {
                            result[++pos] = m;
                        }

                        ++pos;
                        break;
                    }

                    default:
                    {
                        // all other characters are added as-is
                        result[pos++] = c;
                        break;
                    }
                }
            }

            assert(pos == s.size() + space);
            o.write(result.c_str(), static_cast<std::streamsize>(result.size()));
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23c00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x22e47
movq -0xb8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa3e10
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa25f0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq %rax, %rdx
callq 0x91840
jmp 0x23283
movq -0x10(%rbp), %rdi
callq 0xa25f0
movq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xd8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x26cc0
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x5c, %edx
callq 0x22cf0
jmp 0x22e8c
leaq -0x39(%rbp), %rdi
callq 0x26ce0
movq $0x0, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0xa2510
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0xa2530
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x18470
testb $0x1, %al
jne 0x22ed5
jmp 0x231e6
leaq -0x68(%rbp), %rdi
callq 0x18530
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
movl %eax, %ecx
movq %rcx, -0xe0(%rbp)
subl $0x5c, %eax
ja 0x2319b
movq -0xe0(%rbp), %rax
leaq 0xb1343(%rip), %rcx     # 0xd424c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x26ce0
jmp 0x2328c
movq -0x58(%rbp), %rsi
incq %rsi
leaq -0x38(%rbp), %rdi
callq 0xa2910
movq %rax, -0xe8(%rbp)
jmp 0x22f45
movq -0xe8(%rbp), %rax
movb $0x22, (%rax)
movq -0x58(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x58(%rbp)
jmp 0x231d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa23d0
jmp 0x2328c
movq -0x58(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x58(%rbp)
jmp 0x231d6
movq -0x58(%rbp), %rsi
incq %rsi
leaq -0x38(%rbp), %rdi
callq 0xa2910
movq %rax, -0xf0(%rbp)
jmp 0x22fa4
movq -0xf0(%rbp), %rax
movb $0x62, (%rax)
movq -0x58(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x58(%rbp)
jmp 0x231d6
movq -0x58(%rbp), %rsi
incq %rsi
leaq -0x38(%rbp), %rdi
callq 0xa2910
movq %rax, -0xf8(%rbp)
jmp 0x22fd8
movq -0xf8(%rbp), %rax
movb $0x66, (%rax)
movq -0x58(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x58(%rbp)
jmp 0x231d6
movq -0x58(%rbp), %rsi
incq %rsi
leaq -0x38(%rbp), %rdi
callq 0xa2910
movq %rax, -0x100(%rbp)
jmp 0x2300c
movq -0x100(%rbp), %rax
movb $0x6e, (%rax)
movq -0x58(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x58(%rbp)
jmp 0x231d6
movq -0x58(%rbp), %rsi
incq %rsi
leaq -0x38(%rbp), %rdi
callq 0xa2910
movq %rax, -0x108(%rbp)
jmp 0x23040
movq -0x108(%rbp), %rax
movb $0x72, (%rax)
movq -0x58(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x58(%rbp)
jmp 0x231d6
movq -0x58(%rbp), %rsi
incq %rsi
leaq -0x38(%rbp), %rdi
callq 0xa2910
movq %rax, -0x110(%rbp)
jmp 0x23074
movq -0x110(%rbp), %rax
movb $0x74, (%rax)
movq -0x58(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x58(%rbp)
jmp 0x231d6
movb $0x75, -0x95(%rbp)
movb $0x30, -0x94(%rbp)
movb $0x30, -0x93(%rbp)
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0xb4228(%rip), %rax     # 0xd72e0
movb (%rax,%rcx), %al
movb %al, -0x92(%rbp)
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0xb420b(%rip), %rax     # 0xd72e0
movb (%rax,%rcx), %al
movb %al, -0x91(%rbp)
leaq -0x95(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x5, -0x88(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x23c50
movq %rax, -0xa0(%rbp)
movq -0x80(%rbp), %rdi
callq 0x23c70
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rax
cmpq -0xa8(%rbp), %rax
je 0x2318d
movq -0xa0(%rbp), %rax
movb (%rax), %al
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
movb %al, -0x119(%rbp)
movq -0x58(%rbp), %rsi
incq %rsi
movq %rsi, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa2910
movq %rax, -0x118(%rbp)
jmp 0x2316a
movq -0x118(%rbp), %rax
movb -0x119(%rbp), %cl
movb %cl, (%rax)
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0x23122
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x231d6
movq -0x78(%rbp), %rax
movb (%rax), %al
movb %al, -0x129(%rbp)
movq -0x58(%rbp), %rsi
movq %rsi, %rax
incq %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa2910
movq %rax, -0x128(%rbp)
jmp 0x231c7
movq -0x128(%rbp), %rax
movb -0x129(%rbp), %cl
movb %cl, (%rax)
jmp 0x231d8
leaq -0x68(%rbp), %rdi
callq 0x18580
jmp 0x22ebf
movq -0x58(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa25f0
movq %rax, %rcx
movq -0x138(%rbp), %rax
addq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2320f
jmp 0x2322e
leaq 0xb3999(%rip), %rdi     # 0xd6baf
leaq 0xb14c4(%rip), %rsi     # 0xd46e1
movl $0x19bb, %edx           # imm = 0x19BB
leaq 0xb399e(%rip), %rcx     # 0xd6bc7
callq 0x13130
movq -0xb8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x148(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0xa3e10
movq -0x150(%rbp), %rdi
movq %rax, -0x140(%rbp)
callq 0xa25f0
movq -0x148(%rbp), %rdi
movq -0x140(%rbp), %rsi
movq %rax, %rdx
callq 0x91840
jmp 0x2327a
leaq -0x38(%rbp), %rdi
callq 0xa23d0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xd1250
nopw %cs:(%rax,%rax)
nop