// File: /workspace/github_cpp_makefile_star2_O3/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 $0xe8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorl %eax, %eax
leaq 0xb0(%rsp), %rdx
movq %rax, (%rdx)
movl %eax, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movl %eax, 0x18(%rdx)
movq %rax, 0x20(%rdx)
leaq 0x8(%rsi), %rax
movq %rax, 0xe0(%rsp)
leaq 0x28(%rdi), %r15
leaq 0x70(%rdi), %rax
movq %rax, 0xd8(%rsp)
leaq 0x2acf1(%rip), %r12     # 0x3c678
leaq 0x3f(%rcx), %r13
movb $0x1, %bpl
movl 0x20(%r14), %eax
decl %eax
cmpl $0xd, %eax
ja 0x11d86
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movb $0x1, 0x68(%rsp)
movq %rbx, %rdi
leaq 0x68(%rsp), %rsi
callq 0x1665a
jmp 0x11b73
movb $0x2, 0x28(%rsp)
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
callq 0x15f70
movq %rax, 0x68(%rsp)
movq 0xe0(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x160f2
movq %r15, %rdi
callq 0xf284
movl %eax, 0x20(%r14)
cmpl $0xa, %eax
je 0x11aa0
leaq 0xb0(%rsp), %rdi
movl $0x1, %esi
callq 0x126f6
jmp 0x1198e
movq 0x98(%r14), %rax
movq %rax, 0x68(%rsp)
movq %rbx, %rdi
leaq 0x68(%rsp), %rsi
callq 0x16c02
jmp 0x11b73
movq $0x0, 0x68(%rsp)
movq %rbx, %rdi
leaq 0x68(%rsp), %rsi
callq 0x16938
jmp 0x11b73
movb $0x0, 0x68(%rsp)
movq %rbx, %rdi
leaq 0x68(%rsp), %rsi
callq 0x1665a
jmp 0x11b73
movb $0x1, 0x28(%rsp)
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
callq 0x15f70
movq %rax, 0x68(%rsp)
movq 0xe0(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x160f2
movq %r15, %rdi
callq 0xf284
movl %eax, 0x20(%r14)
cmpl $0xb, %eax
jne 0x11c9b
addq $-0x8, 0x10(%rbx)
jmp 0x11b73
movq %rbx, %rdi
movq 0xd8(%rsp), %rsi
callq 0x16ee0
jmp 0x11b73
movq 0xa8(%r14), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x12124
movq %xmm0, 0x68(%rsp)
movq %rbx, %rdi
leaq 0x68(%rsp), %rsi
callq 0x16370
jmp 0x11b73
movq 0xa0(%r14), %rax
movq %rax, 0x68(%rsp)
movq %rbx, %rdi
leaq 0x68(%rsp), %rsi
callq 0x1718e
jmp 0x11b73
cmpl $0xb, %eax
jne 0x11f56
addq $-0x8, 0x10(%rbx)
movq 0xc0(%rsp), %rax
movl 0xc8(%rsp), %ecx
cmpq %rax, 0xb0(%rsp)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x123c9
subl $0x1, %ecx
movl %ecx, 0xc8(%rsp)
jae 0x11b73
movl $0x3f, 0xc8(%rsp)
addq $-0x8, %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movl 0xc8(%rsp), %ecx
cmpq %rax, 0xb0(%rsp)
sete %dl
testl %ecx, %ecx
sete %sil
testb %sil, %dl
jne 0x11e8b
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 %r13, %rcx
xorl %esi, %esi
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
cmpq %rdi, %rcx
setbe %sil
movq -0x8(%rax,%rsi,8), %rax
btq %rdx, %rax
jae 0x11c2e
movq %r15, %rdi
callq 0xf284
movl %eax, 0x20(%r14)
cmpl $0xd, %eax
je 0x11c8a
cmpl $0xa, %eax
jne 0x11ebc
addq $-0x8, 0x10(%rbx)
movq 0xc0(%rsp), %rax
movl 0xc8(%rsp), %ecx
cmpq %rax, 0xb0(%rsp)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x11b50
jmp 0x123aa
movq %r15, %rdi
callq 0xf284
movl %eax, 0x20(%r14)
cmpl $0xd, %eax
jne 0x11b15
movq %r15, %rdi
callq 0xf284
movl %eax, 0x20(%r14)
cmpl $0x4, %eax
jne 0x11ff0
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xd8(%rsp), %rsi
callq 0x14332
movq %rax, 0x20(%rbx)
movq %r15, %rdi
callq 0xf284
movl %eax, 0x20(%r14)
cmpl $0xc, %eax
jne 0x1208a
movq %r15, %rdi
callq 0xf284
movl %eax, 0x20(%r14)
jmp 0x1198e
cmpl $0x4, %eax
jne 0x1219d
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xd8(%rsp), %rsi
callq 0x14332
movq %rax, 0x20(%rbx)
movq %r15, %rdi
callq 0xf284
movl %eax, 0x20(%r14)
cmpl $0xc, %eax
jne 0x12237
leaq 0xb0(%rsp), %rdi
xorl %esi, %esi
callq 0x126f6
movq %r15, %rdi
callq 0xf284
jmp 0x11c92
movq 0x40(%r14), %r12
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10d88
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2ce65(%rip), %rsi     # 0x3eb90
leaq 0x2ce63(%rip), %rdx     # 0x3eb95
leaq 0x8(%rsp), %rdi
callq 0xa960
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0x11270
leaq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movl $0x65, %esi
callq 0x10e42
leaq 0x28(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x125b8
jmp 0x11e1d
movq 0x40(%r14), %r12
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10d88
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movdqu (%rax), %xmm0
movdqa %xmm0, 0x90(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2cdcc(%rip), %rsi     # 0x3eb90
leaq 0x2cdca(%rip), %rdx     # 0x3eb95
leaq 0x8(%rsp), %rdi
callq 0xa960
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
movl $0x10, %edx
callq 0x11270
leaq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movl $0x65, %esi
callq 0x10e42
leaq 0x28(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x125b8
movl %eax, %ebp
leaq 0x40a62(%rip), %rax     # 0x52888
leaq 0x78(%rsp), %rdi
movq %rax, -0x10(%rdi)
callq 0x53b0
leaq 0x68(%rsp), %rdi
callq 0x5720
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11e59
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53a0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x11e70
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11e8b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53a0
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x11ea8
movq 0xd0(%rsp), %rsi
subq %rdi, %rsi
callq 0x53a0
movl %ebp, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%r14), %r12
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10d88
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b5de(%rip), %rsi     # 0x3d4d6
leaq 0x2b5dc(%rip), %rdx     # 0x3d4db
leaq 0x8(%rsp), %rdi
callq 0xa960
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
movl $0xa, %edx
callq 0x11270
leaq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movl $0x65, %esi
callq 0x10e42
leaq 0x28(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x125b8
jmp 0x11e1d
movq 0x40(%r14), %r12
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10d88
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b53d(%rip), %rsi     # 0x3d4cf
leaq 0x2b53c(%rip), %rdx     # 0x3d4d5
leaq 0x8(%rsp), %rdi
callq 0xa960
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
movl $0xb, %edx
callq 0x11270
leaq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movl $0x65, %esi
callq 0x10e42
leaq 0x28(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x125b8
jmp 0x11e1d
movq 0x40(%r14), %r12
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10d88
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c591(%rip), %rsi     # 0x3e5bd
leaq 0x2c594(%rip), %rdx     # 0x3e5c7
leaq 0x8(%rsp), %rdi
callq 0xa960
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
movl $0x4, %edx
callq 0x11270
leaq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movl $0x65, %esi
callq 0x10e42
leaq 0x28(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x125b8
jmp 0x11e1d
movq 0x40(%r14), %r12
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10d88
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c502(%rip), %rsi     # 0x3e5c8
leaq 0x2c50b(%rip), %rdx     # 0x3e5d8
leaq 0x8(%rsp), %rdi
callq 0xa960
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
movl $0xc, %edx
callq 0x11270
leaq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movl $0x65, %esi
callq 0x10e42
leaq 0x28(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x125b8
jmp 0x11e1d
movq 0x40(%r14), %r14
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x10d88
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0x10d88
leaq 0x2c48d(%rip), %rsi     # 0x3e5d9
leaq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0xbd1e
leaq 0x2d194(%rip), %rsi     # 0x3f2f9
leaq 0x8(%rsp), %rdi
callq 0x5780
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x122d1
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x122da
movq 0x40(%r14), %r12
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10d88
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c3e4(%rip), %rsi     # 0x3e5bd
leaq 0x2c3e7(%rip), %rdx     # 0x3e5c7
leaq 0x8(%rsp), %rdi
callq 0xa960
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
movl $0x4, %edx
callq 0x11270
leaq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movl $0x65, %esi
callq 0x10e42
leaq 0x28(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x125b8
jmp 0x11e1d
movq 0x40(%r14), %r12
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10d88
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c355(%rip), %rsi     # 0x3e5c8
leaq 0x2c35e(%rip), %rdx     # 0x3e5d8
leaq 0x8(%rsp), %rdi
callq 0xa960
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
movl $0xc, %edx
callq 0x11270
leaq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movl $0x65, %esi
callq 0x10e42
leaq 0x28(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x125b8
jmp 0x11e1d
movdqu (%rcx), %xmm0
movdqu %xmm0, (%r15)
movq 0x8(%rax), %rsi
leaq 0x48(%rsp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x28(%rsp), %rdi
movl $0x196, %esi            # imm = 0x196
callq 0x133cc
leaq 0x68(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x125b8
movl %eax, %ebp
leaq 0x40565(%rip), %rax     # 0x52888
leaq 0x38(%rsp), %rdi
movq %rax, -0x10(%rdi)
callq 0x53b0
leaq 0x28(%rsp), %rdi
callq 0x5720
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x12352
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1236d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1238e
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x53a0
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11e8b
movq 0x78(%rsp), %rsi
jmp 0x11e83
leaq 0x2c242(%rip), %rdi     # 0x3e5f3
leaq 0x2a442(%rip), %rsi     # 0x3c7fa
leaq 0x2d002(%rip), %rcx     # 0x3f3c1
movl $0x2349, %edx           # imm = 0x2349
callq 0x5280
leaq 0x2c223(%rip), %rdi     # 0x3e5f3
leaq 0x2a423(%rip), %rsi     # 0x3c7fa
leaq 0x2cfe3(%rip), %rcx     # 0x3f3c1
movl $0x2381, %edx           # imm = 0x2381
callq 0x5280
jmp 0x12500
jmp 0x12526
jmp 0x12548
jmp 0x12566
jmp 0x12590
jmp 0x12500
jmp 0x12526
jmp 0x12548
jmp 0x12566
jmp 0x12590
movq %rax, %rbx
leaq 0x40464(%rip), %rax     # 0x52888
leaq 0x38(%rsp), %rdi
movq %rax, -0x10(%rdi)
callq 0x53b0
leaq 0x28(%rsp), %rdi
callq 0x5720
jmp 0x12441
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x1245d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x1245d
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1247d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x1247d
movq %rax, %rbx
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x124a3
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x124a3
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12593
movq 0x78(%rsp), %rsi
jmp 0x1257c
jmp 0x12590
jmp 0x12500
jmp 0x12526
jmp 0x12548
jmp 0x12566
jmp 0x12590
jmp 0x12500
jmp 0x12526
jmp 0x12548
jmp 0x12566
jmp 0x12500
jmp 0x12590
jmp 0x12526
jmp 0x12548
jmp 0x12566
jmp 0x12590
jmp 0x12500
jmp 0x12526
jmp 0x12548
jmp 0x12566
jmp 0x12590
jmp 0x12500
movq %rax, %rbx
leaq 0x4037e(%rip), %rax     # 0x52888
leaq 0x78(%rsp), %rdi
movq %rax, -0x10(%rdi)
callq 0x53b0
leaq 0x68(%rsp), %rdi
callq 0x5720
jmp 0x12529
jmp 0x12526
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1254b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x1254b
jmp 0x12548
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x12569
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x12569
jmp 0x12566
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12593
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53a0
jmp 0x12593
jmp 0x12590
jmp 0x12590
jmp 0x12590
jmp 0x12590
jmp 0x12590
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x125b0
movq 0xd0(%rsp), %rsi
subq %rdi, %rsi
callq 0x53a0
movq %rbx, %rdi
callq 0x56e0