// File: /workspace/github_cpp_makefile_star2_O2/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_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_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 $0xe8, %rsp
leaq -0x108(%rbp), %r15
andq $0x0, (%r15)
andl $0x0, 0x8(%r15)
movq %rsi, %rbx
andq $0x0, 0x10(%r15)
movq %rdi, %r14
andl $0x0, 0x18(%r15)
andq $0x0, 0x20(%r15)
leaq 0x78(%rdi), %rax
movq %rax, -0xe0(%rbp)
leaq 0x1528d(%rip), %r12     # 0x78d40
movl 0x20(%r14), %eax
decl %eax
cmpl $0xd, %eax
ja 0x63e92
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0x6902a
jmp 0x63bc1
movq %rbx, %rdi
pushq $-0x1
popq %rsi
callq 0x68e78
testb %al, %al
je 0x63dfc
movq %r14, %rdi
callq 0x61dc6
cmpl $0xa, %eax
jne 0x63d13
movq %rbx, %rdi
callq 0x68f66
jmp 0x63bc1
movq 0xa0(%r14), %rsi
movq %rbx, %rdi
callq 0x69068
jmp 0x63bc1
movq %rbx, %rdi
callq 0x6904a
jmp 0x63bc1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6902a
jmp 0x63bc1
movq %rbx, %rdi
pushq $-0x1
popq %rsi
callq 0x68cb8
testb %al, %al
je 0x63dfc
movq %r14, %rdi
callq 0x61dc6
cmpl $0xb, %eax
jne 0x63d23
movq %rbx, %rdi
callq 0x68da6
jmp 0x63bc1
movq %rbx, %rdi
movq -0xe0(%rbp), %rsi
callq 0x69aec
jmp 0x63bc9
movq 0xb0(%r14), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x64119
movq %rbx, %rdi
movq -0xe0(%rbp), %rsi
callq 0x6900c
jmp 0x63bc1
movq 0xa8(%r14), %rsi
movq %rbx, %rdi
callq 0x69088
testb %al, %al
je 0x63dfc
movq -0x108(%rbp), %rax
cmpq -0xf8(%rbp), %rax
sete %al
cmpl $0x0, -0xf0(%rbp)
sete %r13b
andb %al, %r13b
jne 0x63fda
movq %r15, %rdi
callq 0x651f6
testq %rdx, (%rax)
je 0x63c52
movq %r14, %rdi
callq 0x61dc6
cmpl $0xd, %eax
je 0x63d06
cmpl $0xa, 0x20(%r14)
jne 0x63d6d
movq %rbx, %rdi
callq 0x68f66
testb %al, %al
je 0x63fda
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 0x63ca4
jmp 0x642d5
movq %r14, %rdi
callq 0x61dc6
cmpl $0xd, %eax
je 0x63ccd
cmpl $0xb, 0x20(%r14)
jne 0x63f23
movq %rbx, %rdi
callq 0x68da6
testb %al, %al
je 0x63fda
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 0x642f4
subl $0x1, %ecx
movl %ecx, -0xf0(%rbp)
jae 0x63bc9
movl $0x3f, -0xf0(%rbp)
addq $-0x8, %rax
movq %rax, -0xf8(%rbp)
jmp 0x63bc9
movq %r14, %rdi
callq 0x61dc6
cmpl $0x4, %eax
jne 0x63ffb
movq %rbx, %rdi
movq -0xe0(%rbp), %rsi
callq 0x68e08
testb %al, %al
je 0x63dfc
movq %r14, %rdi
callq 0x61dc6
cmpl $0xc, %eax
jne 0x6408a
movq %r14, %rdi
callq 0x61dc6
jmp 0x63ab3
movq %r15, %rdi
pushq $0x1
popq %rsi
callq 0x64456
jmp 0x63ab3
cmpl $0x4, 0x20(%r14)
jne 0x641b7
movq %rbx, %rdi
movq -0xe0(%rbp), %rsi
callq 0x68e08
testb %al, %al
je 0x63dfc
movq %r14, %rdi
callq 0x61dc6
cmpl $0xc, %eax
jne 0x64246
movq %r15, %rdi
xorl %esi, %esi
callq 0x64456
movq %r14, %rdi
callq 0x61dc6
jmp 0x63ab3
leaq 0x28(%r14), %rsi
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
callq 0x63608
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
leaq 0x19f90(%rip), %rsi     # 0x7dd31
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x24210
leaq -0x70(%rbp), %rdi
pushq $0xa
popq %rdx
leaq -0x50(%rbp), %rcx
movq %r14, %rsi
callq 0x637ee
leaq -0xd8(%rbp), %rdi
pushq $0x65
popq %rsi
leaq -0xb0(%rbp), %rdx
leaq -0x70(%rbp), %rcx
xorl %r8d, %r8d
callq 0x636ac
leaq -0x90(%rbp), %rdx
leaq -0xd8(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64412
jmp 0x63fad
xorl %r13d, %r13d
jmp 0x63fda
leaq 0x28(%r14), %rsi
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
callq 0x63608
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
leaq 0x1033f(%rip), %rsi     # 0x74177
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x24210
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0x637ee
leaq -0xd8(%rbp), %rdi
pushq $0x65
popq %rsi
leaq -0xb0(%rbp), %rdx
leaq -0x70(%rbp), %rcx
xorl %r8d, %r8d
callq 0x636ac
leaq -0x90(%rbp), %rdx
leaq -0xd8(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64412
jmp 0x63fad
leaq 0x28(%r14), %rsi
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
callq 0x63608
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movdqu (%rax), %xmm0
movdqa %xmm0, -0xb0(%rbp)
leaq 0x102af(%rip), %rsi     # 0x74177
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x24210
leaq -0x70(%rbp), %rdi
pushq $0x10
popq %rdx
leaq -0x50(%rbp), %rcx
movq %r14, %rsi
callq 0x637ee
leaq -0xd8(%rbp), %rdi
pushq $0x65
popq %rsi
leaq -0xb0(%rbp), %rdx
leaq -0x70(%rbp), %rcx
xorl %r8d, %r8d
callq 0x636ac
leaq -0x90(%rbp), %rdx
leaq -0xd8(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64412
jmp 0x63fad
leaq 0x28(%r14), %rsi
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
callq 0x63608
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
leaq 0x16b53(%rip), %rsi     # 0x7aaaa
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x24210
leaq -0x70(%rbp), %rdi
pushq $0xb
popq %rdx
leaq -0x50(%rbp), %rcx
movq %r14, %rsi
callq 0x637ee
leaq -0xd8(%rbp), %rdi
pushq $0x65
popq %rsi
leaq -0xb0(%rbp), %rdx
leaq -0x70(%rbp), %rcx
xorl %r8d, %r8d
callq 0x636ac
leaq -0x90(%rbp), %rdx
leaq -0xd8(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64412
movl %eax, %r13d
leaq -0xd8(%rbp), %rdi
callq 0x6397c
leaq -0x70(%rbp), %rdi
callq 0x24ad8
leaq -0x50(%rbp), %rdi
callq 0x24ad8
leaq -0x90(%rbp), %rdi
callq 0x24ad8
leaq -0x108(%rbp), %rdi
callq 0x644a2
movl %r13d, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%r14), %rsi
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
callq 0x63608
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
leaq 0x168ea(%rip), %rsi     # 0x7a919
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x24210
leaq -0x70(%rbp), %rdi
pushq $0x4
popq %rdx
leaq -0x50(%rbp), %rcx
movq %r14, %rsi
callq 0x637ee
leaq -0xd8(%rbp), %rdi
pushq $0x65
popq %rsi
leaq -0xb0(%rbp), %rdx
leaq -0x70(%rbp), %rcx
xorl %r8d, %r8d
callq 0x636ac
leaq -0x90(%rbp), %rdx
leaq -0xd8(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64412
jmp 0x63fad
leaq 0x28(%r14), %rsi
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
callq 0x63608
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
leaq 0x16866(%rip), %rsi     # 0x7a924
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x24210
leaq -0x70(%rbp), %rdi
pushq $0xc
popq %rdx
leaq -0x50(%rbp), %rcx
movq %r14, %rsi
callq 0x637ee
leaq -0xd8(%rbp), %rdi
pushq $0x65
popq %rsi
leaq -0xb0(%rbp), %rdx
leaq -0x70(%rbp), %rcx
xorl %r8d, %r8d
callq 0x636ac
leaq -0x90(%rbp), %rdx
leaq -0xd8(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64412
jmp 0x63fad
movq 0x48(%r14), %r15
addq $0x28, %r14
leaq -0xd8(%rbp), %rdi
movq %r14, %rsi
callq 0x63608
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x63608
leaq -0xb0(%rbp), %rcx
movb $0x27, (%rcx)
leaq 0x167e8(%rip), %rsi     # 0x7a935
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x650d0
leaq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rdx
movl $0x196, %esi            # imm = 0x196
xorl %ecx, %ecx
callq 0x64fe6
leaq -0xd8(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x68fc8
movl %eax, %r13d
leaq -0x90(%rbp), %rdi
callq 0x6397c
leaq -0x70(%rbp), %rdi
callq 0x24ad8
leaq -0x50(%rbp), %rdi
callq 0x24ad8
leaq -0xd8(%rbp), %rdi
jmp 0x63fd5
leaq 0x28(%r14), %rsi
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
callq 0x63608
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
leaq 0x1672e(%rip), %rsi     # 0x7a919
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x24210
leaq -0x70(%rbp), %rdi
pushq $0x4
popq %rdx
leaq -0x50(%rbp), %rcx
movq %r14, %rsi
callq 0x637ee
leaq -0xd8(%rbp), %rdi
pushq $0x65
popq %rsi
leaq -0xb0(%rbp), %rdx
leaq -0x70(%rbp), %rcx
xorl %r8d, %r8d
callq 0x636ac
leaq -0x90(%rbp), %rdx
leaq -0xd8(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64412
jmp 0x63fad
leaq 0x28(%r14), %rsi
movq 0x48(%r14), %r15
leaq -0x90(%rbp), %rdi
callq 0x63608
leaq 0x48(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
leaq 0x166aa(%rip), %rsi     # 0x7a924
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x24210
leaq -0x70(%rbp), %rdi
pushq $0xc
popq %rdx
leaq -0x50(%rbp), %rcx
movq %r14, %rsi
callq 0x637ee
leaq -0xd8(%rbp), %rdi
pushq $0x65
popq %rsi
leaq -0xb0(%rbp), %rdx
leaq -0x70(%rbp), %rcx
xorl %r8d, %r8d
callq 0x636ac
leaq -0x90(%rbp), %rdx
leaq -0xd8(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64412
jmp 0x63fad
leaq 0x16673(%rip), %rdi     # 0x7a94f
leaq 0x14d7b(%rip), %rsi     # 0x7905e
leaq 0x17443(%rip), %rcx     # 0x7b72d
movl $0x30d0, %edx           # imm = 0x30D0
callq 0x24390
leaq 0x16654(%rip), %rdi     # 0x7a94f
leaq 0x14d5c(%rip), %rsi     # 0x7905e
leaq 0x17424(%rip), %rcx     # 0x7b72d
movl $0x3106, %edx           # imm = 0x3106
callq 0x24390
jmp 0x643b2
jmp 0x643c3
jmp 0x643d1
jmp 0x643df
jmp 0x643fa
jmp 0x643b2
jmp 0x643c3
jmp 0x643d1
jmp 0x643df
jmp 0x643fa
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x6397c
jmp 0x64359
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x24ad8
jmp 0x64367
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x24ad8
jmp 0x64375
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
jmp 0x643e9
jmp 0x643fa
jmp 0x643b2
jmp 0x643c3
jmp 0x643d1
jmp 0x643df
jmp 0x643fa
jmp 0x643b2
jmp 0x643c3
jmp 0x643d1
jmp 0x643df
jmp 0x643fa
jmp 0x643b2
jmp 0x643c3
jmp 0x643d1
jmp 0x643df
jmp 0x643fa
jmp 0x643b2
jmp 0x643b2
jmp 0x643c3
jmp 0x643c3
jmp 0x643d1
jmp 0x643d1
jmp 0x643df
jmp 0x643df
jmp 0x643fa
jmp 0x643fa
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0x6397c
jmp 0x643c6
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x24ad8
jmp 0x643d4
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x24ad8
jmp 0x643e2
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x24ad8
jmp 0x643fd
jmp 0x643fa
jmp 0x643fa
jmp 0x643fa
jmp 0x643fa
jmp 0x643fa
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x644a2
movq %rbx, %rdi
callq 0x24950
nop