// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: bool nlohmann::json_abi_v3_11_2::detail::parser<nlohmann::json_abi_v3_11_2::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::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::sax_parse_internal<nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::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::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>(nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::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::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*)
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 (!skip_to_state_evaluation)
            {
                // invariant: get_token() was called before each iteration
                switch (last_token)
                {
                    case token_type::begin_object:
                    {
                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
                        {
                            return false;
                        }

                        // closing } -> we are done
                        if (get_token() == token_type::end_object)
                        {
                            if (JSON_HEDLEY_UNLIKELY(!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"), nullptr));
                        }
                        if (JSON_HEDLEY_UNLIKELY(!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"), nullptr));
                        }

                        // 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(!sax->start_array(static_cast<std::size_t>(-1))))
                        {
                            return false;
                        }

                        // closing ] -> we are done
                        if (get_token() == token_type::end_array)
                        {
                            if (JSON_HEDLEY_UNLIKELY(!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(!std::isfinite(res)))
                        {
                            return sax->parse_error(m_lexer.get_position(),
                                                    m_lexer.get_token_string(),
                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
                        }

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

                        break;
                    }

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

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

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

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

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

                    case token_type::value_unsigned:
                    {
                        if (JSON_HEDLEY_UNLIKELY(!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"), nullptr));
                    }

                    case token_type::uninitialized:
                    case token_type::end_array:
                    case token_type::end_object:
                    case token_type::name_separator:
                    case token_type::value_separator:
                    case token_type::end_of_input:
                    case token_type::literal_or_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"), nullptr));
                    }
                }
            }
            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(!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.
                    JSON_ASSERT(!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"), nullptr));
            }

            // states.back() is false -> 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"), nullptr));
                }

                if (JSON_HEDLEY_UNLIKELY(!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"), nullptr));
                }

                // parse values
                get_token();
                continue;
            }

            // closing }
            if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
            {
                if (JSON_HEDLEY_UNLIKELY(!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.
                JSON_ASSERT(!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"), nullptr));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorl %eax, %eax
leaq -0xf8(%rbp), %rdx
movq %rax, (%rdx)
movl %eax, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movl %eax, 0x18(%rdx)
movq %rax, 0x20(%rdx)
leaq 0x28(%rdi), %r12
leaq 0x78(%rdi), %rax
movq %rax, -0x100(%rbp)
leaq 0x3f(%rcx), %r13
movl 0x20(%r14), %eax
decl %eax
cmpl $0xd, %eax
ja 0x6701d
leaq 0x19141(%rip), %rcx     # 0x7fd68
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x50(%rbp)
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x6bf8c
jmp 0x66d74
movq %rbx, %rdi
movq $-0x1, %rsi
callq 0x69284
testb %al, %al
je 0x67137
movq %r12, %rdi
callq 0x65e78
movl %eax, 0x20(%r14)
cmpl $0xa, %eax
jne 0x66f1f
movq %rbx, %rdi
callq 0x69424
jmp 0x66d04
movq 0xa0(%r14), %rax
movq %rax, -0x50(%rbp)
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x6c618
jmp 0x66d74
movq $0x0, -0x50(%rbp)
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x6c2f0
jmp 0x66d74
movb $0x0, -0x50(%rbp)
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x6bf8c
jmp 0x66d74
movq %rbx, %rdi
movq $-0x1, %rsi
callq 0x68db6
testb %al, %al
je 0x67137
movq %r12, %rdi
callq 0x65e78
movl %eax, 0x20(%r14)
cmpl $0xb, %eax
jne 0x66f35
movq %rbx, %rdi
callq 0x68f56
testb %al, %al
jne 0x66d74
jmp 0x67137
movq %rbx, %rdi
movq -0x100(%rbp), %rsi
xorl %edx, %edx
callq 0x6c978
jmp 0x66d74
movq 0xb0(%r14), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x673b4
movq %xmm0, -0x50(%rbp)
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x6bc24
jmp 0x66d74
movq 0xa8(%r14), %rax
movq %rax, -0x50(%rbp)
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x6cc9a
movq -0xe8(%rbp), %rax
movl -0xe0(%rbp), %ecx
cmpq %rax, -0xf8(%rbp)
sete %dl
testl %ecx, %ecx
sete %sil
movb $0x1, %r15b
testb %sil, %dl
jne 0x67111
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 0x66e33
movq %r12, %rdi
callq 0x65e78
movl %eax, 0x20(%r14)
cmpl $0xd, %eax
je 0x66f0e
cmpl $0xa, %eax
jne 0x6713c
movq %rbx, %rdi
callq 0x69424
testb %al, %al
je 0x67137
movq -0xe8(%rbp), %rax
movl -0xe0(%rbp), %ecx
cmpq %rax, -0xf8(%rbp)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x66e8b
jmp 0x675b4
movq %r12, %rdi
callq 0x65e78
movl %eax, 0x20(%r14)
cmpl $0xd, %eax
je 0x66ecd
cmpl $0xb, %eax
jne 0x671da
movq %rbx, %rdi
callq 0x68f56
testb %al, %al
je 0x67137
movq -0xe8(%rbp), %rax
movl -0xe0(%rbp), %ecx
cmpq %rax, -0xf8(%rbp)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x675d3
subl $0x1, %ecx
movl %ecx, -0xe0(%rbp)
jae 0x66eab
movl $0x3f, -0xe0(%rbp)
addq $-0x8, %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movl -0xe0(%rbp), %ecx
cmpq %rax, -0xf8(%rbp)
sete %dl
testl %ecx, %ecx
sete %sil
jmp 0x66d94
movq %r12, %rdi
callq 0x65e78
movl %eax, 0x20(%r14)
cmpl $0x4, %eax
jne 0x67278
movq %rbx, %rdi
movq -0x100(%rbp), %rsi
callq 0x69176
testb %al, %al
je 0x67137
movq %r12, %rdi
callq 0x65e78
movl %eax, 0x20(%r14)
cmpl $0xc, %eax
jne 0x67316
movq %r12, %rdi
callq 0x65e78
movl %eax, 0x20(%r14)
jmp 0x66c11
leaq -0xf8(%rbp), %rdi
movl $0x1, %esi
callq 0x689a2
jmp 0x66c11
cmpl $0x4, %eax
jne 0x67478
movq %rbx, %rdi
movq -0x100(%rbp), %rsi
callq 0x69176
testb %al, %al
je 0x67137
movq %r12, %rdi
callq 0x65e78
movl %eax, 0x20(%r14)
cmpl $0xc, %eax
jne 0x67516
leaq -0xf8(%rbp), %rdi
xorl %esi, %esi
callq 0x689a2
movq %r12, %rdi
callq 0x65e78
jmp 0x66f16
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
callq 0x677a4
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xc0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xd0(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x141e1(%rip), %rsi     # 0x7b19f
leaq 0x141df(%rip), %rdx     # 0x7b1a4
leaq -0x70(%rbp), %rdi
callq 0x431c8
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0x67a0c
leaq -0x50(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x6785c
leaq -0x90(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6775c
jmp 0x670b8
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
callq 0x677a4
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xc0(%rbp)
movdqu (%rax), %xmm0
movdqa %xmm0, -0xd0(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x14144(%rip), %rsi     # 0x7b19f
leaq 0x14142(%rip), %rdx     # 0x7b1a4
leaq -0x70(%rbp), %rdi
callq 0x431c8
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rsi
movl $0x10, %edx
callq 0x67a0c
leaq -0x50(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x6785c
leaq -0x90(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6775c
movl %eax, %r15d
leaq 0x428ee(%rip), %rax     # 0xa99b0
addq $0x10, %rax
leaq -0x40(%rbp), %rdi
movq %rax, -0x10(%rdi)
callq 0x1ba70
leaq -0x50(%rbp), %rdi
callq 0x1b950
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x670f1
callq 0x1b4d0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x670ff
callq 0x1b4d0
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67111
callq 0x1b4d0
movq -0xf8(%rbp), %rdi
testq %rdi, %rdi
je 0x67122
callq 0x1b4d0
movl %r15d, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x67111
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
callq 0x677a4
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xc0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xd0(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1d52d(%rip), %rsi     # 0x846a5
leaq 0x1d52b(%rip), %rdx     # 0x846aa
leaq -0x70(%rbp), %rdi
callq 0x431c8
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rsi
movl $0xa, %edx
callq 0x67a0c
leaq -0x50(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x6785c
leaq -0x90(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6775c
jmp 0x670b8
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
callq 0x677a4
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xc0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xd0(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a728(%rip), %rsi     # 0x8193e
leaq 0x1a727(%rip), %rdx     # 0x81944
leaq -0x70(%rbp), %rdi
callq 0x431c8
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rsi
movl $0xb, %edx
callq 0x67a0c
leaq -0x50(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x6785c
leaq -0x90(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6775c
jmp 0x670b8
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
callq 0x677a4
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xc0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xd0(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a4f9(%rip), %rsi     # 0x817ad
leaq 0x1a4fc(%rip), %rdx     # 0x817b7
leaq -0x70(%rbp), %rdi
callq 0x431c8
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rsi
movl $0x4, %edx
callq 0x67a0c
leaq -0x50(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x6785c
leaq -0x90(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6775c
jmp 0x670b8
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
callq 0x677a4
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xc0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xd0(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a466(%rip), %rsi     # 0x817b8
leaq 0x1a46f(%rip), %rdx     # 0x817c8
leaq -0x70(%rbp), %rdi
callq 0x431c8
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rsi
movl $0xc, %edx
callq 0x67a0c
leaq -0x50(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x6785c
leaq -0x90(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6775c
jmp 0x670b8
movq 0x48(%r14), %r14
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0x677a4
leaq -0x70(%rbp), %rdi
movq %r12, %rsi
callq 0x677a4
leaq -0xd0(%rbp), %rcx
movb $0x27, (%rcx)
leaq 0x1a3e8(%rip), %rsi     # 0x817c9
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x6974f
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
movl $0x196, %esi            # imm = 0x196
xorl %ecx, %ecx
callq 0x695b2
leaq -0x50(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6956a
movl %eax, %r15d
leaq 0x42585(%rip), %rax     # 0xa99b0
addq $0x10, %rax
leaq -0x80(%rbp), %rdi
movq %rax, -0x10(%rdi)
callq 0x1ba70
leaq -0x90(%rbp), %rdi
callq 0x1b950
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6745d
callq 0x1b4d0
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6746f
callq 0x1b4d0
leaq -0x40(%rbp), %rax
jmp 0x67103
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
callq 0x677a4
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xc0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xd0(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a2f9(%rip), %rsi     # 0x817ad
leaq 0x1a2fc(%rip), %rdx     # 0x817b7
leaq -0x70(%rbp), %rdi
callq 0x431c8
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rsi
movl $0x4, %edx
callq 0x67a0c
leaq -0x50(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x6785c
leaq -0x90(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6775c
jmp 0x670b8
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
callq 0x677a4
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xc0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xd0(%rbp)
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a266(%rip), %rsi     # 0x817b8
leaq 0x1a26f(%rip), %rdx     # 0x817c8
leaq -0x70(%rbp), %rdi
callq 0x431c8
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rcx
movq %r14, %rsi
movl $0xc, %edx
callq 0x67a0c
leaq -0x50(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x6785c
leaq -0x90(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6775c
jmp 0x670b8
leaq 0x1a228(%rip), %rdi     # 0x817e3
leaq 0x18aed(%rip), %rsi     # 0x800af
leaq 0x1a22a(%rip), %rcx     # 0x817f3
movl $0x30d0, %edx           # imm = 0x30D0
callq 0x1b320
leaq 0x1a209(%rip), %rdi     # 0x817e3
leaq 0x18ace(%rip), %rsi     # 0x800af
leaq 0x1a20b(%rip), %rcx     # 0x817f3
movl $0x3106, %edx           # imm = 0x3106
callq 0x1b320
jmp 0x676c5
jmp 0x676ed
jmp 0x67709
jmp 0x6771e
jmp 0x6773f
jmp 0x676c5
jmp 0x676ed
jmp 0x67709
jmp 0x6771e
jmp 0x6773f
movq %rax, %rbx
leaq 0x42382(%rip), %rax     # 0xa99b0
addq $0x10, %rax
leaq -0x80(%rbp), %rdi
movq %rax, -0x10(%rdi)
callq 0x1ba70
leaq -0x90(%rbp), %rdi
callq 0x1b950
jmp 0x67650
movq %rax, %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6766a
callq 0x1b4d0
jmp 0x6766a
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67681
callq 0x1b4d0
jmp 0x67681
movq %rax, %rbx
leaq -0x40(%rbp), %rax
jmp 0x67725
jmp 0x6773f
jmp 0x676c5
jmp 0x676ed
jmp 0x67709
jmp 0x6771e
jmp 0x6773f
jmp 0x676c5
jmp 0x676ed
jmp 0x67709
jmp 0x6771e
jmp 0x6773f
jmp 0x676c5
jmp 0x676ed
jmp 0x67709
jmp 0x6771e
jmp 0x6773f
jmp 0x676c5
jmp 0x676ed
jmp 0x67709
jmp 0x6771e
jmp 0x6773f
jmp 0x676c5
movq %rax, %rbx
leaq 0x422e1(%rip), %rax     # 0xa99b0
addq $0x10, %rax
leaq -0x40(%rbp), %rdi
movq %rax, -0x10(%rdi)
callq 0x1ba70
leaq -0x50(%rbp), %rdi
callq 0x1b950
jmp 0x676f0
jmp 0x676ed
movq %rax, %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6770c
callq 0x1b4d0
jmp 0x6770c
jmp 0x67709
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x67721
callq 0x1b4d0
jmp 0x67721
jmp 0x6771e
movq %rax, %rbx
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67742
callq 0x1b4d0
jmp 0x67742
jmp 0x6773f
jmp 0x6773f
jmp 0x6773f
jmp 0x6773f
jmp 0x6773f
movq %rax, %rbx
movq -0xf8(%rbp), %rdi
testq %rdi, %rdi
je 0x67753
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop