// File: /workspace/github_cpp_makefile_star2_O1/Konano[P]UselessDatabase/./json.hpp
// Function: bool nlohmann::detail::parser<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>>::sax_parse_internal<nlohmann::detail::json_sax_dom_parser<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>>>(nlohmann::detail::json_sax_dom_parser<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>>*)
bool sax_parse_internal(SAX* sax)
    {
        // stack to remember the hierarchy of structured values we are parsing
        // true = array; false = object
        std::vector<bool> states;
        // value to avoid a goto (see comment where set to true)
        bool skip_to_state_evaluation = false;

        while (true)
        {
            if (not skip_to_state_evaluation)
            {
                // invariant: get_token() was called before each iteration
                switch (last_token)
                {
                    case token_type::begin_object:
                    {
                        if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
                        {
                            return false;
                        }

                        // closing } -> we are done
                        if (get_token() == token_type::end_object)
                        {
                            if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
                            {
                                return false;
                            }
                            break;
                        }

                        // parse key
                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                        {
                            return sax->parse_error(m_lexer.get_position(),
                                                    m_lexer.get_token_string(),
                                                    parse_error::create(101, m_lexer.get_position(),
                                                            exception_message(token_type::value_string, "object key")));
                        }
                        if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
                        {
                            return false;
                        }

                        // parse separator (:)
                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                        {
                            return sax->parse_error(m_lexer.get_position(),
                                                    m_lexer.get_token_string(),
                                                    parse_error::create(101, m_lexer.get_position(),
                                                            exception_message(token_type::name_separator, "object separator")));
                        }

                        // remember we are now inside an object
                        states.push_back(false);

                        // parse values
                        get_token();
                        continue;
                    }

                    case token_type::begin_array:
                    {
                        if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
                        {
                            return false;
                        }

                        // closing ] -> we are done
                        if (get_token() == token_type::end_array)
                        {
                            if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
                            {
                                return false;
                            }
                            break;
                        }

                        // remember we are now inside an array
                        states.push_back(true);

                        // parse values (no need to call get_token)
                        continue;
                    }

                    case token_type::value_float:
                    {
                        const auto res = m_lexer.get_number_float();

                        if (JSON_HEDLEY_UNLIKELY(not std::isfinite(res)))
                        {
                            return sax->parse_error(m_lexer.get_position(),
                                                    m_lexer.get_token_string(),
                                                    out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
                        }

                        if (JSON_HEDLEY_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
                        {
                            return false;
                        }

                        break;
                    }

                    case token_type::literal_false:
                    {
                        if (JSON_HEDLEY_UNLIKELY(not sax->boolean(false)))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::literal_null:
                    {
                        if (JSON_HEDLEY_UNLIKELY(not sax->null()))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::literal_true:
                    {
                        if (JSON_HEDLEY_UNLIKELY(not sax->boolean(true)))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::value_integer:
                    {
                        if (JSON_HEDLEY_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::value_string:
                    {
                        if (JSON_HEDLEY_UNLIKELY(not sax->string(m_lexer.get_string())))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::value_unsigned:
                    {
                        if (JSON_HEDLEY_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
                        {
                            return false;
                        }
                        break;
                    }

                    case token_type::parse_error:
                    {
                        // using "uninitialized" to avoid "expected" message
                        return sax->parse_error(m_lexer.get_position(),
                                                m_lexer.get_token_string(),
                                                parse_error::create(101, m_lexer.get_position(),
                                                        exception_message(token_type::uninitialized, "value")));
                    }

                    default: // the last token was unexpected
                    {
                        return sax->parse_error(m_lexer.get_position(),
                                                m_lexer.get_token_string(),
                                                parse_error::create(101, m_lexer.get_position(),
                                                        exception_message(token_type::literal_or_value, "value")));
                    }
                }
            }
            else
            {
                skip_to_state_evaluation = false;
            }

            // we reached this line after we successfully parsed a value
            if (states.empty())
            {
                // empty stack: we reached the end of the hierarchy: done
                return true;
            }

            if (states.back())  // array
            {
                // comma -> next value
                if (get_token() == token_type::value_separator)
                {
                    // parse a new value
                    get_token();
                    continue;
                }

                // closing ]
                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
                {
                    if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
                    {
                        return false;
                    }

                    // We are done with this array. Before we can parse a
                    // new value, we need to evaluate the new state first.
                    // By setting skip_to_state_evaluation to false, we
                    // are effectively jumping to the beginning of this if.
                    assert(not states.empty());
                    states.pop_back();
                    skip_to_state_evaluation = true;
                    continue;
                }

                return sax->parse_error(m_lexer.get_position(),
                                        m_lexer.get_token_string(),
                                        parse_error::create(101, m_lexer.get_position(),
                                                exception_message(token_type::end_array, "array")));
            }
            else  // object
            {
                // comma -> next value
                if (get_token() == token_type::value_separator)
                {
                    // parse key
                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
                    {
                        return sax->parse_error(m_lexer.get_position(),
                                                m_lexer.get_token_string(),
                                                parse_error::create(101, m_lexer.get_position(),
                                                        exception_message(token_type::value_string, "object key")));
                    }

                    if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
                    {
                        return false;
                    }

                    // parse separator (:)
                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                    {
                        return sax->parse_error(m_lexer.get_position(),
                                                m_lexer.get_token_string(),
                                                parse_error::create(101, m_lexer.get_position(),
                                                        exception_message(token_type::name_separator, "object separator")));
                    }

                    // parse values
                    get_token();
                    continue;
                }

                // closing }
                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
                {
                    if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
                    {
                        return false;
                    }

                    // We are done with this object. Before we can parse a
                    // new value, we need to evaluate the new state first.
                    // By setting skip_to_state_evaluation to false, we
                    // are effectively jumping to the beginning of this if.
                    assert(not states.empty());
                    states.pop_back();
                    skip_to_state_evaluation = true;
                    continue;
                }

                return sax->parse_error(m_lexer.get_position(),
                                        m_lexer.get_token_string(),
                                        parse_error::create(101, m_lexer.get_position(),
                                                exception_message(token_type::end_object, "object")));
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r14
movq %rdi, %r15
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
xorl %r13d, %r13d
leaq 0xb8(%rsp), %rcx
movq %r13, (%rcx)
movl %r13d, 0x8(%rcx)
movq %r13, 0x10(%rcx)
movl %r13d, 0x18(%rcx)
movq %r13, 0x20(%rcx)
leaq 0x8(%rsi), %rbx
leaq 0x28(%rdi), %r12
leaq 0x70(%rdi), %rcx
movq %rcx, 0xe0(%rsp)
addq $0x3f, %rax
movq %rax, 0xf0(%rsp)
leaq 0x2b770(%rip), %rbp     # 0x3d678
testb $0x1, %r13b
jne 0x11fb4
movl 0x20(%r15), %eax
decl %eax
cmpl $0xd, %eax
ja 0x124c3
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movb $0x2, 0x20(%rsp)
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
callq 0x16618
movq %rax, 0x60(%rsp)
movq %rbx, %rdi
leaq 0x60(%rsp), %rsi
callq 0x1679a
movq %r12, %rdi
callq 0xf658
movl %eax, 0x20(%r15)
cmpl $0xa, %eax
je 0x11fad
leaq 0xb8(%rsp), %rdi
movl $0x1, %esi
callq 0x12d56
jmp 0x11f08
movb $0x1, 0x20(%rsp)
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
callq 0x16618
movq %rax, 0x60(%rsp)
movq %rbx, %rdi
leaq 0x60(%rsp), %rsi
callq 0x1679a
movq %r12, %rdi
callq 0xf658
movl %eax, 0x20(%r15)
cmpl $0xb, %eax
jne 0x120e9
addq $-0x8, 0x10(%r14)
jmp 0x11fb7
xorl %r13d, %r13d
movq 0xc8(%rsp), %rax
movl 0xd0(%rsp), %ecx
cmpq %rax, 0xb8(%rsp)
sete %dl
testl %ecx, %ecx
sete %sil
testb %sil, %dl
jne 0x1241b
movl %ecx, %ecx
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
movq %rdx, %rcx
andq 0xf0(%rsp), %rcx
xorl %esi, %esi
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
cmpq %rdi, %rcx
setbe %sil
movq -0x8(%rax,%rsi,8), %rax
btq %rdx, %rax
jae 0x12040
movq %r12, %rdi
callq 0xf658
movl %eax, 0x20(%r15)
cmpl $0xd, %eax
jne 0x120a9
movq %r12, %rdi
callq 0xf658
jmp 0x1213b
movq %r12, %rdi
callq 0xf658
movl %eax, 0x20(%r15)
cmpl $0xd, %eax
jne 0x12144
movq %r12, %rdi
callq 0xf658
movl %eax, 0x20(%r15)
cmpl $0x4, %eax
jne 0x128a1
movq 0x10(%r14), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xe0(%rsp), %rsi
callq 0x149a0
movq %rax, 0x20(%r14)
movq %r12, %rdi
callq 0xf658
movl %eax, 0x20(%r15)
cmpl $0xc, %eax
jne 0x1293f
movq %r12, %rdi
callq 0xf658
jmp 0x1213b
cmpl $0xa, %eax
jne 0x12629
addq $-0x8, 0x10(%r14)
movq 0xc8(%rsp), %rax
movl 0xd0(%rsp), %ecx
cmpq %rax, 0xb8(%rsp)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x1217f
jmp 0x129dd
cmpl $0x4, %eax
jne 0x126c7
movq 0x10(%r14), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xe0(%rsp), %rsi
callq 0x149a0
movq %rax, 0x20(%r14)
movq %r12, %rdi
callq 0xf658
movl %eax, 0x20(%r15)
cmpl $0xc, %eax
jne 0x12765
leaq 0xb8(%rsp), %rdi
xorl %esi, %esi
callq 0x12d56
movq %r12, %rdi
callq 0xf658
movl %eax, 0x20(%r15)
jmp 0x11f08
cmpl $0xb, %eax
jne 0x12803
addq $-0x8, 0x10(%r14)
movq 0xc8(%rsp), %rax
movl 0xd0(%rsp), %ecx
cmpq %rax, 0xb8(%rsp)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x129fc
movb $0x1, %r13b
subl $0x1, %ecx
movl %ecx, 0xd0(%rsp)
jae 0x11f08
movl $0x3f, 0xd0(%rsp)
addq $-0x8, %rax
movq %rax, 0xc8(%rsp)
jmp 0x11f08
movq 0x98(%r15), %rax
movq %rax, 0x60(%rsp)
movq %r14, %rdi
leaq 0x60(%rsp), %rsi
callq 0x17318
jmp 0x11fb7
movq 0xa8(%r15), %xmm0
movq %xmm0, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq %rcx, 0xe8(%rsp)
cmpq %rax, %rcx
jge 0x122a9
movq %xmm0, 0x60(%rsp)
movq %r14, %rdi
leaq 0x60(%rsp), %rsi
callq 0x16a2e
movq 0xe8(%rsp), %rcx
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
cmpq %rax, %rcx
jl 0x11fb7
jmp 0x125c9
movq 0xa0(%r15), %rax
movq %rax, 0x60(%rsp)
movq %r14, %rdi
leaq 0x60(%rsp), %rsi
callq 0x178be
jmp 0x11fb7
movb $0x0, 0x60(%rsp)
movq %r14, %rdi
leaq 0x60(%rsp), %rsi
callq 0x16d58
jmp 0x11fb7
movb $0x1, 0x60(%rsp)
movq %r14, %rdi
leaq 0x60(%rsp), %rsi
callq 0x16d58
jmp 0x11fb7
movq %r14, %rdi
movq 0xe0(%rsp), %rsi
callq 0x17616
jmp 0x11fb7
movq $0x0, 0x60(%rsp)
movq %r14, %rdi
leaq 0x60(%rsp), %rsi
callq 0x17056
jmp 0x11fb7
movq 0x40(%r15), %rax
movq %rax, 0x88(%rsp)
leaq 0x60(%rsp), %rdi
movq %r12, %rsi
callq 0x11306
leaq 0x90(%rsp), %rdi
movq %r12, %rsi
callq 0x11306
leaq 0x40(%rsp), %rdi
leaq 0x2d2fe(%rip), %rsi     # 0x3f5dc
leaq 0x90(%rsp), %rdx
callq 0xc0ee
leaq 0x40(%rsp), %rdi
leaq 0x2e005(%rip), %rsi     # 0x402fc
callq 0x5780
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x12322
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x1232f
movdqu (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movdqu %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x20(%rsp), %rdi
movl $0x196, %esi            # imm = 0x196
movq %rsp, %rdx
callq 0x139ba
movq %r14, %rdi
movq 0x88(%rsp), %rsi
leaq 0x60(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x12c18
movb %al, 0x88(%rsp)
leaq 0x41507(%rip), %rax     # 0x53888
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x53b0
leaq 0x20(%rsp), %rdi
callq 0x5720
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x123b5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53a0
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x123d1
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53a0
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x123f6
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x53a0
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x1220d
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x1220d
movb $0x1, 0x88(%rsp)
jmp 0x125c9
movq 0x40(%r15), %rbx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x11306
leaq 0x40(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movdqu (%rax), %xmm0
movdqa %xmm0, 0x90(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %r12
movq %r12, (%rdi)
leaq 0x2d729(%rip), %rsi     # 0x3fb93
leaq 0x2d727(%rip), %rdx     # 0x3fb98
callq 0xaccc
movq %rsp, %rdi
leaq 0x40(%rsp), %rcx
movq %r15, %rsi
xorl %edx, %edx
callq 0x117f0
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movq %rsp, %rcx
movl $0x65, %esi
callq 0x113c0
leaq 0x20(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12c18
movb %al, 0x88(%rsp)
jmp 0x1255c
movq 0x40(%r15), %rbx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x11306
leaq 0x40(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movdqu (%rax), %xmm0
movdqa %xmm0, 0x90(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %r12
movq %r12, (%rdi)
leaq 0x2d68e(%rip), %rsi     # 0x3fb93
leaq 0x2d68c(%rip), %rdx     # 0x3fb98
callq 0xaccc
movq %rsp, %rdi
leaq 0x40(%rsp), %rcx
movq %r15, %rsi
movl $0x10, %edx
callq 0x117f0
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movq %rsp, %rcx
movl $0x65, %esi
callq 0x113c0
leaq 0x20(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12c18
movb %al, 0x88(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x41320(%rip), %rax     # 0x53888
movq %rax, -0x10(%rdi)
callq 0x53b0
leaq 0x60(%rsp), %rdi
callq 0x5720
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x12596
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53a0
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x125ad
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53a0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x125c9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53a0
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x1260e
movq 0xd8(%rsp), %rsi
subq %rdi, %rsi
callq 0x53a0
xorl %eax, %eax
movq %rax, 0xb8(%rsp)
movl %eax, 0xc0(%rsp)
movq %rax, 0xc8(%rsp)
movl %eax, 0xd0(%rsp)
movq %rax, 0xd8(%rsp)
movb 0x88(%rsp), %al
andb $0x1, %al
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%r15), %rbx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x11306
leaq 0x40(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movdqu (%rax), %xmm0
movdqa %xmm0, 0x90(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %r12
movq %r12, (%rdi)
leaq 0x2be6e(%rip), %rsi     # 0x3e4d9
leaq 0x2be6c(%rip), %rdx     # 0x3e4de
callq 0xaccc
movq %rsp, %rdi
leaq 0x40(%rsp), %rcx
movq %r15, %rsi
movl $0xa, %edx
callq 0x117f0
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movq %rsp, %rcx
movl $0x65, %esi
callq 0x113c0
leaq 0x20(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12c18
movb %al, 0x88(%rsp)
jmp 0x1255c
movq 0x40(%r15), %rbx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x11306
leaq 0x40(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movdqu (%rax), %xmm0
movdqa %xmm0, 0x90(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %r12
movq %r12, (%rdi)
leaq 0x2ceb7(%rip), %rsi     # 0x3f5c0
leaq 0x2ceba(%rip), %rdx     # 0x3f5ca
callq 0xaccc
movq %rsp, %rdi
leaq 0x40(%rsp), %rcx
movq %r15, %rsi
movl $0x4, %edx
callq 0x117f0
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movq %rsp, %rcx
movl $0x65, %esi
callq 0x113c0
leaq 0x20(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12c18
movb %al, 0x88(%rsp)
jmp 0x1255c
movq 0x40(%r15), %rbx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x11306
leaq 0x40(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movdqu (%rax), %xmm0
movdqa %xmm0, 0x90(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %r12
movq %r12, (%rdi)
leaq 0x2ce24(%rip), %rsi     # 0x3f5cb
leaq 0x2ce2d(%rip), %rdx     # 0x3f5db
callq 0xaccc
movq %rsp, %rdi
leaq 0x40(%rsp), %rcx
movq %r15, %rsi
movl $0xc, %edx
callq 0x117f0
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movq %rsp, %rcx
movl $0x65, %esi
callq 0x113c0
leaq 0x20(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12c18
movb %al, 0x88(%rsp)
jmp 0x1255c
movq 0x40(%r15), %rbx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x11306
leaq 0x40(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movdqu (%rax), %xmm0
movdqa %xmm0, 0x90(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %r12
movq %r12, (%rdi)
leaq 0x2bc8d(%rip), %rsi     # 0x3e4d2
leaq 0x2bc8c(%rip), %rdx     # 0x3e4d8
callq 0xaccc
movq %rsp, %rdi
leaq 0x40(%rsp), %rcx
movq %r15, %rsi
movl $0xb, %edx
callq 0x117f0
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movq %rsp, %rcx
movl $0x65, %esi
callq 0x113c0
leaq 0x20(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12c18
movb %al, 0x88(%rsp)
jmp 0x1255c
movq 0x40(%r15), %rbx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x11306
leaq 0x40(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movdqu (%rax), %xmm0
movdqa %xmm0, 0x90(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %r12
movq %r12, (%rdi)
leaq 0x2ccdd(%rip), %rsi     # 0x3f5c0
leaq 0x2cce0(%rip), %rdx     # 0x3f5ca
callq 0xaccc
movq %rsp, %rdi
leaq 0x40(%rsp), %rcx
movq %r15, %rsi
movl $0x4, %edx
callq 0x117f0
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movq %rsp, %rcx
movl $0x65, %esi
callq 0x113c0
leaq 0x20(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12c18
movb %al, 0x88(%rsp)
jmp 0x1255c
movq 0x40(%r15), %rbx
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x11306
leaq 0x40(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movdqu (%rax), %xmm0
movdqa %xmm0, 0x90(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %r12
movq %r12, (%rdi)
leaq 0x2cc4a(%rip), %rsi     # 0x3f5cb
leaq 0x2cc53(%rip), %rdx     # 0x3f5db
callq 0xaccc
movq %rsp, %rdi
leaq 0x40(%rsp), %rcx
movq %r15, %rsi
movl $0xc, %edx
callq 0x117f0
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movq %rsp, %rcx
movl $0x65, %esi
callq 0x113c0
leaq 0x20(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12c18
movb %al, 0x88(%rsp)
jmp 0x1255c
leaq 0x2cc12(%rip), %rdi     # 0x3f5f6
leaq 0x2ae12(%rip), %rsi     # 0x3d7fd
leaq 0x2d9d2(%rip), %rcx     # 0x403c4
movl $0x2349, %edx           # imm = 0x2349
callq 0x5280
leaq 0x2cbf3(%rip), %rdi     # 0x3f5f6
leaq 0x2adf3(%rip), %rsi     # 0x3d7fd
leaq 0x2d9b3(%rip), %rcx     # 0x403c4
movl $0x2381, %edx           # imm = 0x2381
callq 0x5280
movq %rax, %r14
leaq 0x30(%rsp), %rdi
leaq 0x40e5e(%rip), %rax     # 0x53888
movq %rax, -0x10(%rdi)
callq 0x53b0
leaq 0x20(%rsp), %rdi
callq 0x5720
jmp 0x12a42
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x12a62
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x12a62
movq %rax, %r14
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x12a83
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x12a83
movq %rax, %r14
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x12aad
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x12aad
movq %rax, %r14
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x12bcb
movq 0x70(%rsp), %rsi
jmp 0x12bb6
jmp 0x12bc8
jmp 0x12b34
jmp 0x12b5a
jmp 0x12b7c
jmp 0x12b9f
jmp 0x12bc8
jmp 0x12b34
jmp 0x12b5a
jmp 0x12b7c
jmp 0x12b34
jmp 0x12b9f
jmp 0x12b5a
jmp 0x12bc8
jmp 0x12b7c
jmp 0x12b9f
jmp 0x12bc8
jmp 0x12b34
jmp 0x12b5a
jmp 0x12b7c
jmp 0x12b9f
jmp 0x12bc8
jmp 0x12b34
jmp 0x12b5a
jmp 0x12b7c
jmp 0x12b9f
jmp 0x12bc8
jmp 0x12b34
jmp 0x12b5a
jmp 0x12b7c
jmp 0x12b9f
jmp 0x12bc8
jmp 0x12b34
movq %rax, %r14
leaq 0x70(%rsp), %rdi
leaq 0x40d45(%rip), %rax     # 0x53888
movq %rax, -0x10(%rdi)
callq 0x53b0
leaq 0x60(%rsp), %rdi
callq 0x5720
jmp 0x12b5d
jmp 0x12b5a
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x12b7f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x12b7f
jmp 0x12b7c
movq %rax, %r14
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x12ba2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x12ba2
jmp 0x12b9f
movq %rax, %r14
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x12bcb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x12bcb
jmp 0x12bc8
jmp 0x12bc8
jmp 0x12bc8
jmp 0x12bc8
movq %rax, %r14
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x12c10
movq 0xd8(%rsp), %rsi
subq %rdi, %rsi
callq 0x53a0
xorl %eax, %eax
movq %rax, 0xb8(%rsp)
movl %eax, 0xc0(%rsp)
movq %rax, 0xc8(%rsp)
movl %eax, 0xd0(%rsp)
movq %rax, 0xd8(%rsp)
movq %r14, %rdi
callq 0x56e0