// File: /workspace/github_cpp_makefile_star2_O1/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 $0xf8, %rsp
movq %rsi, %r14
movq %rdi, %r12
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
xorl %r15d, %r15d
leaq -0x108(%rbp), %rcx
movq %r15, (%rcx)
movl %r15d, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movl %r15d, 0x18(%rcx)
movq %r15, 0x20(%rcx)
leaq 0x28(%rdi), %r13
leaq 0x78(%rdi), %rcx
movq %rcx, -0x110(%rbp)
addq $0x3f, %rax
movq %rax, -0x120(%rbp)
leaq 0x43f5e(%rip), %rax     # 0xab9b0
addq $0x10, %rax
movq %rax, -0x38(%rbp)
leaq 0x19337(%rip), %rbx     # 0x80d98
movl %eax, -0x30(%rbp)
testb $0x1, %r15b
jne 0x67b05
movl 0x20(%r12), %eax
decl %eax
cmpl $0xd, %eax
ja 0x67fb5
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
movq %r14, %rdi
movq $-0x1, %rsi
callq 0x6a27a
testb %al, %al
je 0x680f6
movq %r13, %rdi
callq 0x66bbe
movl %eax, 0x20(%r12)
cmpl $0xa, %eax
je 0x67e1f
leaq -0x108(%rbp), %rdi
movl $0x1, %esi
callq 0x699fe
jmp 0x67a64
movq %r14, %rdi
movq $-0x1, %rsi
callq 0x69e12
testb %al, %al
je 0x680f6
movq %r13, %rdi
callq 0x66bbe
movl %eax, 0x20(%r12)
cmpl $0xb, %eax
jne 0x67c3c
movq %r14, %rdi
callq 0x69fa6
testb %al, %al
jne 0x67b08
jmp 0x680f6
xorl %r15d, %r15d
movq -0xf8(%rbp), %rax
movl -0xf0(%rbp), %ecx
cmpq %rax, -0x108(%rbp)
sete %dl
testl %ecx, %ecx
sete %sil
testb %sil, %dl
jne 0x67f0b
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 -0x120(%rbp), %rcx
xorl %esi, %esi
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
cmpq %rdi, %rcx
setbe %sil
movq -0x8(%rax,%rsi,8), %rax
btq %rdx, %rax
jae 0x67b8e
movq %r13, %rdi
callq 0x66bbe
movl %eax, 0x20(%r12)
cmpl $0xd, %eax
jne 0x67bf4
movq %r13, %rdi
callq 0x66bbe
jmp 0x67c88
movq %r13, %rdi
callq 0x66bbe
movl %eax, 0x20(%r12)
cmpl $0xd, %eax
jne 0x67c92
movq %r13, %rdi
callq 0x66bbe
movl %eax, 0x20(%r12)
cmpl $0x4, %eax
jne 0x6838b
movq %r14, %rdi
movq -0x110(%rbp), %rsi
callq 0x6a16c
testb %al, %al
je 0x680f6
movq %r13, %rdi
callq 0x66bbe
movl %eax, 0x20(%r12)
cmpl $0xc, %eax
jne 0x6842e
movq %r13, %rdi
callq 0x66bbe
jmp 0x67c88
cmpl $0xa, %eax
jne 0x680ff
movq %r14, %rdi
callq 0x6a40e
testb %al, %al
je 0x680f6
movq -0xf8(%rbp), %rax
movl -0xf0(%rbp), %ecx
cmpq %rax, -0x108(%rbp)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x67cd5
jmp 0x684d1
cmpl $0x4, %eax
jne 0x681a2
movq %r14, %rdi
movq -0x110(%rbp), %rsi
callq 0x6a16c
testb %al, %al
je 0x680f6
movq %r13, %rdi
callq 0x66bbe
movl %eax, 0x20(%r12)
cmpl $0xc, %eax
jne 0x68245
leaq -0x108(%rbp), %rdi
xorl %esi, %esi
callq 0x699fe
movq %r13, %rdi
callq 0x66bbe
movl %eax, 0x20(%r12)
jmp 0x67a64
cmpl $0xb, %eax
jne 0x682e8
movq %r14, %rdi
callq 0x69fa6
testb %al, %al
je 0x680f6
movq -0xf8(%rbp), %rax
movl -0xf0(%rbp), %ecx
cmpq %rax, -0x108(%rbp)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x684f0
movb $0x1, %r15b
subl $0x1, %ecx
movl %ecx, -0xf0(%rbp)
jae 0x67a64
movl $0x3f, -0xf0(%rbp)
addq $-0x8, %rax
movq %rax, -0xf8(%rbp)
jmp 0x67a64
movq 0xa0(%r12), %rax
movq %rax, -0xc0(%rbp)
movq %r14, %rdi
leaq -0xc0(%rbp), %rsi
xorl %edx, %edx
callq 0x6d6c6
jmp 0x67b08
movq 0xb0(%r12), %xmm0
movq %xmm0, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq %rcx, -0x118(%rbp)
cmpq %rax, %rcx
jge 0x67e2c
movq %xmm0, -0xc0(%rbp)
movq %r14, %rdi
leaq -0xc0(%rbp), %rsi
xorl %edx, %edx
callq 0x6ccc6
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
cmpq %rax, -0x118(%rbp)
jl 0x67b08
jmp 0x680ab
movq 0xa8(%r12), %rax
movq %rax, -0xc0(%rbp)
movq %r14, %rdi
leaq -0xc0(%rbp), %rsi
xorl %edx, %edx
callq 0x6dd48
jmp 0x67b08
movb $0x0, -0xc0(%rbp)
movq %r14, %rdi
leaq -0xc0(%rbp), %rsi
xorl %edx, %edx
callq 0x6d03a
jmp 0x67b08
movb $0x1, -0xc0(%rbp)
movq %r14, %rdi
leaq -0xc0(%rbp), %rsi
xorl %edx, %edx
callq 0x6d03a
jmp 0x67b08
movq %r14, %rdi
movq -0x110(%rbp), %rsi
xorl %edx, %edx
callq 0x6da26
jmp 0x67b08
movq $0x0, -0xc0(%rbp)
movq %r14, %rdi
leaq -0xc0(%rbp), %rsi
xorl %edx, %edx
callq 0x6d39e
jmp 0x67b08
movq %r14, %rdi
callq 0x6a40e
jmp 0x67afc
movq 0x48(%r12), %rax
movq %rax, -0x30(%rbp)
leaq -0xc0(%rbp), %rdi
movq %r13, %rsi
callq 0x686e8
leaq -0x78(%rbp), %rdi
movq %r13, %rsi
callq 0x686e8
movb $0x27, -0xe0(%rbp)
leaq -0x98(%rbp), %rdi
leaq 0x1a994(%rip), %rsi     # 0x827f9
leaq -0x78(%rbp), %rdx
leaq -0xe0(%rbp), %rcx
callq 0x6a73f
leaq -0x58(%rbp), %rdi
movl $0x196, %esi            # imm = 0x196
leaq -0x98(%rbp), %rdx
xorl %ecx, %ecx
callq 0x6a5a2
movq %r14, %rdi
movq -0x30(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x6a55a
movl %eax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1ba70
leaq -0x58(%rbp), %rdi
callq 0x1b950
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x67ed8
callq 0x1b4d0
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x67eea
callq 0x1b4d0
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rax
cmpq %rax, %rdi
je 0x67d6d
callq 0x1b4d0
jmp 0x67d6d
movb $0x1, %al
movl %eax, -0x30(%rbp)
jmp 0x680ab
movq 0x48(%r12), %rbx
leaq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x686e8
leaq 0x48(%r12), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xd0(%rbp)
movdqu (%rax), %xmm0
movdqa %xmm0, -0xe0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %r15
movq %r15, (%rdi)
leaq 0x1424b(%rip), %rsi     # 0x7c19f
leaq 0x14249(%rip), %rdx     # 0x7c1a4
callq 0x43438
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rcx
movq %r12, %rsi
xorl %edx, %edx
callq 0x68950
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
leaq -0x98(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x687a0
leaq -0x58(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x686a0
movl %eax, -0x30(%rbp)
jmp 0x68053
movq 0x48(%r12), %rbx
leaq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x686e8
leaq 0x48(%r12), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xd0(%rbp)
movdqu (%rax), %xmm0
movdqa %xmm0, -0xe0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %r15
movq %r15, (%rdi)
leaq 0x141ab(%rip), %rsi     # 0x7c19f
leaq 0x141a9(%rip), %rdx     # 0x7c1a4
callq 0x43438
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rcx
movq %r12, %rsi
movl $0x10, %edx
callq 0x68950
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
leaq -0x98(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x687a0
leaq -0x58(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x686a0
movl %eax, -0x30(%rbp)
leaq -0xb0(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rdi)
callq 0x1ba70
leaq -0xc0(%rbp), %rdi
callq 0x1b950
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x6808b
callq 0x1b4d0
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x68099
callq 0x1b4d0
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x680ab
callq 0x1b4d0
movq -0x108(%rbp), %rdi
testq %rdi, %rdi
je 0x680df
callq 0x1b4d0
xorl %eax, %eax
movq %rax, -0x108(%rbp)
movl %eax, -0x100(%rbp)
movq %rax, -0xf8(%rbp)
movl %eax, -0xf0(%rbp)
movq %rax, -0xe8(%rbp)
movl -0x30(%rbp), %eax
andb $0x1, %al
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, -0x30(%rbp)
jmp 0x680ab
movq 0x48(%r12), %rbx
leaq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x686e8
leaq 0x48(%r12), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xd0(%rbp)
movdqu (%rax), %xmm0
movdqa %xmm0, -0xe0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %r15
movq %r15, (%rdi)
leaq 0x1d597(%rip), %rsi     # 0x856d5
leaq 0x1d595(%rip), %rdx     # 0x856da
callq 0x43438
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rcx
movq %r12, %rsi
movl $0xa, %edx
callq 0x68950
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
leaq -0x98(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x687a0
leaq -0x58(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x686a0
movl %eax, -0x30(%rbp)
jmp 0x68053
movq 0x48(%r12), %rbx
leaq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x686e8
leaq 0x48(%r12), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xd0(%rbp)
movdqu (%rax), %xmm0
movdqa %xmm0, -0xe0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %r15
movq %r15, (%rdi)
leaq 0x1a5fc(%rip), %rsi     # 0x827dd
leaq 0x1a5ff(%rip), %rdx     # 0x827e7
callq 0x43438
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rcx
movq %r12, %rsi
movl $0x4, %edx
callq 0x68950
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
leaq -0x98(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x687a0
leaq -0x58(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x686a0
movl %eax, -0x30(%rbp)
jmp 0x68053
movq 0x48(%r12), %rbx
leaq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x686e8
leaq 0x48(%r12), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xd0(%rbp)
movdqu (%rax), %xmm0
movdqa %xmm0, -0xe0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %r15
movq %r15, (%rdi)
leaq 0x1a564(%rip), %rsi     # 0x827e8
leaq 0x1a56d(%rip), %rdx     # 0x827f8
callq 0x43438
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rcx
movq %r12, %rsi
movl $0xc, %edx
callq 0x68950
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
leaq -0x98(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x687a0
leaq -0x58(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x686a0
movl %eax, -0x30(%rbp)
jmp 0x68053
movq 0x48(%r12), %rbx
leaq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x686e8
leaq 0x48(%r12), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xd0(%rbp)
movdqu (%rax), %xmm0
movdqa %xmm0, -0xe0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %r15
movq %r15, (%rdi)
leaq 0x1a647(%rip), %rsi     # 0x8296e
leaq 0x1a646(%rip), %rdx     # 0x82974
callq 0x43438
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rcx
movq %r12, %rsi
movl $0xb, %edx
callq 0x68950
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
leaq -0x98(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x687a0
leaq -0x58(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x686a0
movl %eax, -0x30(%rbp)
jmp 0x68053
movq 0x48(%r12), %rbx
leaq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x686e8
leaq 0x48(%r12), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xd0(%rbp)
movdqu (%rax), %xmm0
movdqa %xmm0, -0xe0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %r15
movq %r15, (%rdi)
leaq 0x1a413(%rip), %rsi     # 0x827dd
leaq 0x1a416(%rip), %rdx     # 0x827e7
callq 0x43438
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rcx
movq %r12, %rsi
movl $0x4, %edx
callq 0x68950
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
leaq -0x98(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x687a0
leaq -0x58(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x686a0
movl %eax, -0x30(%rbp)
jmp 0x68053
movq 0x48(%r12), %rbx
leaq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x686e8
leaq 0x48(%r12), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xd0(%rbp)
movdqu (%rax), %xmm0
movdqa %xmm0, -0xe0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %r15
movq %r15, (%rdi)
leaq 0x1a37b(%rip), %rsi     # 0x827e8
leaq 0x1a384(%rip), %rdx     # 0x827f8
callq 0x43438
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rcx
movq %r12, %rsi
movl $0xc, %edx
callq 0x68950
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
leaq -0x98(%rbp), %rcx
movl $0x65, %esi
xorl %r8d, %r8d
callq 0x687a0
leaq -0x58(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x686a0
movl %eax, -0x30(%rbp)
jmp 0x68053
leaq 0x1a33b(%rip), %rdi     # 0x82813
leaq 0x18c00(%rip), %rsi     # 0x810df
leaq 0x1a33d(%rip), %rcx     # 0x82823
movl $0x30d0, %edx           # imm = 0x30D0
callq 0x1b320
leaq 0x1a31c(%rip), %rdi     # 0x82813
leaq 0x18be1(%rip), %rsi     # 0x810df
leaq 0x1a31e(%rip), %rcx     # 0x82823
movl $0x3106, %edx           # imm = 0x3106
callq 0x1b320
movq %rax, %r14
leaq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rdi)
callq 0x1ba70
leaq -0x58(%rbp), %rdi
callq 0x1b950
jmp 0x68531
movq %rax, %r14
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x6854e
callq 0x1b4d0
jmp 0x6854e
movq %rax, %r14
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x68565
callq 0x1b4d0
jmp 0x68565
movq %rax, %r14
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rax
jmp 0x6864c
jmp 0x68660
jmp 0x685e2
jmp 0x68609
jmp 0x68628
jmp 0x68641
jmp 0x68660
jmp 0x685e2
jmp 0x68609
jmp 0x68628
jmp 0x685e2
jmp 0x68641
jmp 0x68660
jmp 0x68609
jmp 0x68628
jmp 0x68641
jmp 0x68660
jmp 0x685e2
jmp 0x68609
jmp 0x68628
jmp 0x68641
jmp 0x68660
jmp 0x685e2
jmp 0x68609
jmp 0x68628
jmp 0x68641
jmp 0x68660
jmp 0x685e2
jmp 0x68609
jmp 0x68628
jmp 0x68641
jmp 0x68660
jmp 0x685e2
movq %rax, %r14
leaq -0xb0(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rdi)
callq 0x1ba70
leaq -0xc0(%rbp), %rdi
callq 0x1b950
jmp 0x6860c
jmp 0x68609
movq %rax, %r14
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x6862b
callq 0x1b4d0
jmp 0x6862b
jmp 0x68628
movq %rax, %r14
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x68644
callq 0x1b4d0
jmp 0x68644
jmp 0x68641
movq %rax, %r14
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x68663
callq 0x1b4d0
jmp 0x68663
jmp 0x68660
jmp 0x68660
jmp 0x68660
jmp 0x68660
movq %rax, %r14
movq -0x108(%rbp), %rdi
testq %rdi, %rdi
je 0x68697
callq 0x1b4d0
xorl %eax, %eax
movq %rax, -0x108(%rbp)
movl %eax, -0x100(%rbp)
movq %rax, -0xf8(%rbp)
movl %eax, -0xf0(%rbp)
movq %rax, -0xe8(%rbp)
movq %r14, %rdi
callq 0x1b910
nop