// File: Konano[P]UselessDatabase/./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)
void dump_escaped(const string_t& s, const bool ensure_ascii)
    {
        std::uint32_t codepoint;
        std::uint8_t state = UTF8_ACCEPT;
        std::size_t bytes = 0;  // number of bytes written to string_buffer

        // number of bytes written at the point of the last valid byte
        std::size_t bytes_after_last_accept = 0;
        std::size_t undumped_chars = 0;

        for (std::size_t i = 0; i < s.size(); ++i)
        {
            const auto byte = static_cast<uint8_t>(s[i]);

            switch (decode(state, codepoint, byte))
            {
                case UTF8_ACCEPT:  // decode found a new code point
                {
                    switch (codepoint)
                    {
                        case 0x08: // backspace
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 'b';
                            break;
                        }

                        case 0x09: // horizontal tab
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 't';
                            break;
                        }

                        case 0x0A: // newline
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 'n';
                            break;
                        }

                        case 0x0C: // formfeed
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 'f';
                            break;
                        }

                        case 0x0D: // carriage return
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = 'r';
                            break;
                        }

                        case 0x22: // quotation mark
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = '\"';
                            break;
                        }

                        case 0x5C: // reverse solidus
                        {
                            string_buffer[bytes++] = '\\';
                            string_buffer[bytes++] = '\\';
                            break;
                        }

                        default:
                        {
                            // escape control characters (0x00..0x1F) or, if
                            // ensure_ascii parameter is used, non-ASCII characters
                            if ((codepoint <= 0x1F) or (ensure_ascii and (codepoint >= 0x7F)))
                            {
                                if (codepoint <= 0xFFFF)
                                {
                                    (std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
                                                    static_cast<std::uint16_t>(codepoint));
                                    bytes += 6;
                                }
                                else
                                {
                                    (std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
                                                    static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
                                                    static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
                                    bytes += 12;
                                }
                            }
                            else
                            {
                                // copy byte to buffer (all previous bytes
                                // been copied have in default case above)
                                string_buffer[bytes++] = s[i];
                            }
                            break;
                        }
                    }

                    // write buffer and reset index; there must be 13 bytes
                    // left, as this is the maximal number of bytes to be
                    // written ("\uxxxx\uxxxx\0") for one code point
                    if (string_buffer.size() - bytes < 13)
                    {
                        o->write_characters(string_buffer.data(), bytes);
                        bytes = 0;
                    }

                    // remember the byte position of this accept
                    bytes_after_last_accept = bytes;
                    undumped_chars = 0;
                    break;
                }

                case UTF8_REJECT:  // decode found invalid UTF-8 byte
                {
                    switch (error_handler)
                    {
                        case error_handler_t::strict:
                        {
                            std::string sn(3, '\0');
                            (std::snprintf)(&sn[0], sn.size(), "%.2X", byte);
                            JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn));
                        }

                        case error_handler_t::ignore:
                        case error_handler_t::replace:
                        {
                            // in case we saw this character the first time, we
                            // would like to read it again, because the byte
                            // may be OK for itself, but just not OK for the
                            // previous sequence
                            if (undumped_chars > 0)
                            {
                                --i;
                            }

                            // reset length buffer to the last accepted index;
                            // thus removing/ignoring the invalid characters
                            bytes = bytes_after_last_accept;

                            if (error_handler == error_handler_t::replace)
                            {
                                // add a replacement character
                                if (ensure_ascii)
                                {
                                    string_buffer[bytes++] = '\\';
                                    string_buffer[bytes++] = 'u';
                                    string_buffer[bytes++] = 'f';
                                    string_buffer[bytes++] = 'f';
                                    string_buffer[bytes++] = 'f';
                                    string_buffer[bytes++] = 'd';
                                }
                                else
                                {
                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
                                }

                                // write buffer and reset index; there must be 13 bytes
                                // left, as this is the maximal number of bytes to be
                                // written ("\uxxxx\uxxxx\0") for one code point
                                if (string_buffer.size() - bytes < 13)
                                {
                                    o->write_characters(string_buffer.data(), bytes);
                                    bytes = 0;
                                }

                                bytes_after_last_accept = bytes;
                            }

                            undumped_chars = 0;

                            // continue processing the string
                            state = UTF8_ACCEPT;
                            break;
                        }

                        default:            // LCOV_EXCL_LINE
                            assert(false);  // LCOV_EXCL_LINE
                    }
                    break;
                }

                default:  // decode found yet incomplete multi-byte code point
                {
                    if (not ensure_ascii)
                    {
                        // code point will not be escaped - copy byte to buffer
                        string_buffer[bytes++] = s[i];
                    }
                    ++undumped_chars;
                    break;
                }
            }
        }

        // we finished processing the string
        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
        {
            // write buffer
            if (bytes > 0)
            {
                o->write_characters(string_buffer.data(), bytes);
            }
        }
        else
        {
            // we finish reading, but do not accept: string was incomplete
            switch (error_handler)
            {
                case error_handler_t::strict:
                {
                    std::string sn(3, '\0');
                    (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<std::uint8_t>(s.back()));
                    JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
                }

                case error_handler_t::ignore:
                {
                    // write all accepted bytes
                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
                    break;
                }

                case error_handler_t::replace:
                {
                    // write all accepted bytes
                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
                    // add a replacement character
                    if (ensure_ascii)
                    {
                        o->write_characters("\\ufffd", 6);
                    }
                    else
                    {
                        o->write_characters("\xEF\xBF\xBD", 3);
                    }
                    break;
                }

                default:            // LCOV_EXCL_LINE
                    assert(false);  // LCOV_EXCL_LINE
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x160(%rbp)
movb $0x0, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x168(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6380
movq %rax, %rcx
movq -0x168(%rbp), %rax
cmpq %rcx, %rax
jae 0x1423f
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x6550
movb (%rax), %al
movb %al, -0x41(%rbp)
movzbl -0x41(%rbp), %edx
leaq -0x19(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x14dc0
movzbl %al, %ecx
movl %ecx, -0x16c(%rbp)
testb %al, %al
je 0x139a6
jmp 0x13992
movl -0x16c(%rbp), %eax
subl $0x1, %eax
je 0x13d82
jmp 0x141de
movl -0x18(%rbp), %eax
movl %eax, -0x170(%rbp)
subl $0x8, %eax
je 0x13a1f
jmp 0x139b6
movl -0x170(%rbp), %eax
subl $0x9, %eax
je 0x13a68
jmp 0x139c7
movl -0x170(%rbp), %eax
subl $0xa, %eax
je 0x13ab1
jmp 0x139d8
movl -0x170(%rbp), %eax
subl $0xc, %eax
je 0x13afa
jmp 0x139e9
movl -0x170(%rbp), %eax
subl $0xd, %eax
je 0x13b43
jmp 0x139fa
movl -0x170(%rbp), %eax
subl $0x22, %eax
je 0x13b8c
jmp 0x13a0b
movl -0x170(%rbp), %eax
subl $0x5c, %eax
je 0x13bd5
jmp 0x13c1e
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x5c, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb $0x62, (%rax)
jmp 0x13d14
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x5c, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb $0x74, (%rax)
jmp 0x13d14
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x5c, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb $0x6e, (%rax)
jmp 0x13d14
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x5c, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb $0x66, (%rax)
jmp 0x13d14
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x5c, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb $0x72, (%rax)
jmp 0x13d14
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x5c, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb $0x22, (%rax)
jmp 0x13d14
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x5c, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb $0x5c, (%rax)
jmp 0x13d14
cmpl $0x1f, -0x18(%rbp)
jbe 0x13c38
testb $0x1, -0x11(%rbp)
je 0x13cd6
cmpl $0x7f, -0x18(%rbp)
jb 0x13cd6
cmpl $0xffff, -0x18(%rbp)    # imm = 0xFFFF
ja 0x13c7f
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
callq 0x14ea0
movq %rax, %rdi
addq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movzwl %ax, %ecx
movl $0x7, %esi
leaq 0x6b017(%rip), %rdx     # 0x7ec81
movb $0x0, %al
callq 0x67c0
movq -0x28(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x28(%rbp)
jmp 0x13cd4
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
callq 0x14ea0
movq %rax, %rdi
addq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
shrl $0xa, %eax
addl $0xd7c0, %eax           # imm = 0xD7C0
movzwl %ax, %ecx
movl -0x18(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
addl $0xdc00, %eax           # imm = 0xDC00
movzwl %ax, %r8d
movl $0xd, %esi
leaq 0x6afba(%rip), %rdx     # 0x7ec7b
movb $0x0, %al
callq 0x67c0
movq -0x28(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x28(%rbp)
jmp 0x13d12
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x6550
movq -0x160(%rbp), %rdi
movb (%rax), %al
movb %al, -0x171(%rbp)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb -0x171(%rbp), %cl
movb %cl, (%rax)
jmp 0x13d14
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
callq 0x14ec0
subq -0x28(%rbp), %rax
cmpq $0xd, %rax
jae 0x13d6d
movq -0x160(%rbp), %rdi
callq 0x13880
movq -0x160(%rbp), %rdi
movq %rax, -0x180(%rbp)
addq $0x5a, %rdi
callq 0x14ea0
movq -0x180(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rdx
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
jmp 0x1422c
movq -0x160(%rbp), %rax
movl 0x280(%rax), %eax
movl %eax, -0x184(%rbp)
testl %eax, %eax
je 0x13db1
jmp 0x13d9b
movl -0x184(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x13f9f
jmp 0x141bd
leaq -0x69(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0x68a0
movq -0x190(%rbp), %rcx
leaq -0x68(%rbp), %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x13770
jmp 0x13dda
leaq -0x69(%rbp), %rdi
callq 0x6530
xorl %eax, %eax
movl %eax, %esi
leaq -0x68(%rbp), %rdi
callq 0x69b0
movq %rax, -0x198(%rbp)
jmp 0x13df9
leaq -0x68(%rbp), %rdi
callq 0x6380
movq -0x198(%rbp), %rdi
movq %rax, %rsi
movzbl -0x41(%rbp), %ecx
leaq 0x6ae71(%rip), %rdx     # 0x7ec88
xorl %eax, %eax
callq 0x67c0
movb $0x1, -0x101(%rbp)
movl $0x20, %edi
callq 0x62a0
movq %rax, -0x1a0(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x15110
jmp 0x13e48
leaq 0x6ae3e(%rip), %rsi     # 0x7ec8d
leaq -0xe0(%rbp), %rdi
leaq -0x100(%rbp), %rdx
callq 0x150c0
jmp 0x13e64
leaq 0x6aef0(%rip), %rdx     # 0x7ed5b
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x15070
jmp 0x13e80
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x15020
jmp 0x13e99
movq -0x1a0(%rbp), %rdi
movl $0x13c, %esi            # imm = 0x13C
leaq -0xa0(%rbp), %rdx
callq 0x14ed0
jmp 0x13eb3
movq -0x1a0(%rbp), %rdi
movb $0x0, -0x101(%rbp)
leaq 0x9ca70(%rip), %rsi     # 0xb0938
leaq 0x1321(%rip), %rdx      # 0x151f0
callq 0x6850
jmp 0x1454b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x6530
jmp 0x14542
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x13f91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x13f78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x13f6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x13f60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x13f54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x6340
leaq -0xc0(%rbp), %rdi
callq 0x6340
leaq -0xe0(%rbp), %rdi
callq 0x6340
leaq -0x100(%rbp), %rdi
callq 0x6340
testb $0x1, -0x101(%rbp)
jne 0x13f83
jmp 0x13f8f
movq -0x1a0(%rbp), %rdi
callq 0x63a0
jmp 0x13f91
leaq -0x68(%rbp), %rdi
callq 0x6340
jmp 0x14542
cmpq $0x0, -0x38(%rbp)
jbe 0x13fb2
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x160(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0x28(%rbp)
cmpl $0x1, 0x280(%rax)
jne 0x141af
testb $0x1, -0x11(%rbp)
je 0x140a9
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x5c, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x75, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x66, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x66, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movq -0x160(%rbp), %rdi
movb $0x66, (%rax)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb $0x64, (%rax)
jmp 0x1414e
movl $0xffffffef, %edi       # imm = 0xFFFFFFEF
callq 0x15210
movq -0x160(%rbp), %rdi
movb %al, -0x1a3(%rbp)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb -0x1a3(%rbp), %cl
movb %cl, (%rax)
movl $0xffffffbf, %edi       # imm = 0xFFFFFFBF
callq 0x15210
movq -0x160(%rbp), %rdi
movb %al, -0x1a2(%rbp)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb -0x1a2(%rbp), %cl
movb %cl, (%rax)
movl $0xffffffbd, %edi       # imm = 0xFFFFFFBD
callq 0x15210
movq -0x160(%rbp), %rdi
movb %al, -0x1a1(%rbp)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb -0x1a1(%rbp), %cl
movb %cl, (%rax)
movq -0x160(%rbp), %rdi
addq $0x5a, %rdi
callq 0x14ec0
subq -0x28(%rbp), %rax
cmpq $0xd, %rax
jae 0x141a7
movq -0x160(%rbp), %rdi
callq 0x13880
movq -0x160(%rbp), %rdi
movq %rax, -0x1b0(%rbp)
addq $0x5a, %rdi
callq 0x14ea0
movq -0x1b0(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rdx
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x19(%rbp)
jmp 0x141dc
leaq 0x6aaa0(%rip), %rdi     # 0x7ec64
leaq 0x6a976(%rip), %rsi     # 0x7eb41
movl $0x3793, %edx           # imm = 0x3793
leaq 0x6aad3(%rip), %rcx     # 0x7ecaa
callq 0x6350
jmp 0x1422c
testb $0x1, -0x11(%rbp)
jne 0x14220
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x6550
movq -0x160(%rbp), %rdi
movb (%rax), %al
movb %al, -0x1b1(%rbp)
addq $0x5a, %rdi
movq -0x28(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
callq 0x14e70
movb -0x1b1(%rbp), %cl
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1422e
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x13939
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x14253
jmp 0x14296
cmpq $0x0, -0x28(%rbp)
jbe 0x14291
movq -0x160(%rbp), %rdi
callq 0x13880
movq -0x160(%rbp), %rdi
movq %rax, -0x1c0(%rbp)
addq $0x5a, %rdi
callq 0x14ea0
movq -0x1c0(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rdx
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x14539
movq -0x160(%rbp), %rax
movl 0x280(%rax), %eax
movl %eax, -0x1c4(%rbp)
testl %eax, %eax
je 0x142d4
jmp 0x142af
movl -0x1c4(%rbp), %eax
subl $0x1, %eax
je 0x14495
jmp 0x142c0
movl -0x1c4(%rbp), %eax
subl $0x2, %eax
je 0x14459
jmp 0x14518
leaq -0x129(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x68a0
movq -0x1d0(%rbp), %rcx
leaq -0x128(%rbp), %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x13770
jmp 0x14303
leaq -0x129(%rbp), %rdi
callq 0x6530
xorl %eax, %eax
movl %eax, %esi
leaq -0x128(%rbp), %rdi
callq 0x69b0
movq %rax, -0x1d8(%rbp)
jmp 0x14328
leaq -0x128(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x6380
movq %rax, -0x1f0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6270
movq -0x1d8(%rbp), %rdi
movq -0x1f0(%rbp), %rsi
movzbl (%rax), %ecx
leaq 0x6a925(%rip), %rdx     # 0x7ec88
xorl %eax, %eax
callq 0x67c0
movb $0x1, -0x151(%rbp)
movl $0x20, %edi
callq 0x62a0
movq -0x1e8(%rbp), %rdx
movq %rax, -0x1e0(%rbp)
leaq 0x6a9a9(%rip), %rsi     # 0x7ed39
leaq -0x150(%rbp), %rdi
callq 0x15220
jmp 0x1439e
movq -0x1e0(%rbp), %rdi
movl $0x13c, %esi            # imm = 0x13C
leaq -0x150(%rbp), %rdx
callq 0x14ed0
jmp 0x143b8
movq -0x1e0(%rbp), %rdi
movb $0x0, -0x151(%rbp)
leaq 0x9c56b(%rip), %rsi     # 0xb0938
leaq 0xe1c(%rip), %rdx       # 0x151f0
callq 0x6850
jmp 0x1454b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x129(%rbp), %rdi
callq 0x6530
jmp 0x14542
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x14448
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x1442f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x150(%rbp), %rdi
callq 0x6340
testb $0x1, -0x151(%rbp)
jne 0x1443a
jmp 0x14446
movq -0x1e0(%rbp), %rdi
callq 0x63a0
jmp 0x14448
leaq -0x128(%rbp), %rdi
callq 0x6340
jmp 0x14542
movq -0x160(%rbp), %rdi
callq 0x13880
movq -0x160(%rbp), %rdi
movq %rax, -0x1f8(%rbp)
addq $0x5a, %rdi
callq 0x14ea0
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x14537
movq -0x160(%rbp), %rdi
callq 0x13880
movq -0x160(%rbp), %rdi
movq %rax, -0x200(%rbp)
addq $0x5a, %rdi
callq 0x14ea0
movq -0x200(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, -0x11(%rbp)
je 0x144f5
movq -0x160(%rbp), %rdi
callq 0x13880
movq %rax, %rdi
movq (%rdi), %rax
leaq 0x6a875(%rip), %rsi     # 0x7ed60
movl $0x6, %edx
callq *0x8(%rax)
jmp 0x14516
movq -0x160(%rbp), %rdi
callq 0x13880
movq %rax, %rdi
movq (%rdi), %rax
leaq 0x6a859(%rip), %rsi     # 0x7ed67
movl $0x3, %edx
callq *0x8(%rax)
jmp 0x14537
leaq 0x6a745(%rip), %rdi     # 0x7ec64
leaq 0x6a61b(%rip), %rsi     # 0x7eb41
movl $0x37d2, %edx           # imm = 0x37D2
leaq 0x6a778(%rip), %rcx     # 0x7ecaa
callq 0x6350
jmp 0x14539
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x6890
nopl (%rax,%rax)