// File: /workspace/github_cpp_makefile_star2_O2/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_callback_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_callback_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 $0xd8, %rsp
leaq 0xb0(%rsp), %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 0x70(%rdi), %r12
leaq 0x24bf4(%rip), %r13     # 0x3362c
movl 0x20(%r14), %eax
decl %eax
cmpl $0xd, %eax
ja 0xee0a
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0x1109c
jmp 0xeb3c
movq %rbx, %rdi
pushq $-0x1
popq %rsi
callq 0x10dac
testb %al, %al
je 0xed78
movq %r14, %rdi
callq 0xdb6c
cmpl $0xa, %eax
jne 0xec96
movq %rbx, %rdi
callq 0x10ed8
jmp 0xeb3c
movq 0x98(%r14), %rsi
movq %rbx, %rdi
callq 0x110c8
jmp 0xeb3c
movq %rbx, %rdi
callq 0x110b4
jmp 0xeb3c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1109c
jmp 0xeb3c
movq %rbx, %rdi
pushq $-0x1
popq %rsi
callq 0x10a38
testb %al, %al
je 0xed78
movq %r14, %rdi
callq 0xdb6c
cmpl $0xb, %eax
jne 0xeca6
movq %rbx, %rdi
callq 0x10b64
jmp 0xeb3c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x110de
jmp 0xeb3c
movq 0xa8(%r14), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0xf082
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11088
jmp 0xeb3c
movq 0xa0(%r14), %rsi
movq %rbx, %rdi
callq 0x110ea
testb %al, %al
je 0xed78
movq 0xb0(%rsp), %rax
cmpq 0xc0(%rsp), %rax
sete %al
cmpl $0x0, 0xc8(%rsp)
sete %bpl
andb %al, %bpl
jne 0xef49
movq %r15, %rdi
callq 0x11100
testq %rdx, (%rax)
je 0xebd3
movq %r14, %rdi
callq 0xdb6c
cmpl $0xd, %eax
je 0xec89
cmpl $0xa, 0x20(%r14)
jne 0xecec
movq %rbx, %rdi
callq 0x10ed8
testb %al, %al
je 0xef49
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 0xec28
jmp 0xf24e
movq %r14, %rdi
callq 0xdb6c
cmpl $0xd, %eax
je 0xec54
cmpl $0xb, 0x20(%r14)
jne 0xee98
movq %rbx, %rdi
callq 0x10b64
testb %al, %al
je 0xef49
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 0xf26d
subl $0x1, %ecx
movl %ecx, 0xc8(%rsp)
jae 0xeb44
movl $0x3f, 0xc8(%rsp)
addq $-0x8, %rax
movq %rax, 0xc0(%rsp)
jmp 0xeb44
movq %r14, %rdi
callq 0xdb6c
cmpl $0x4, %eax
jne 0xef6a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10cd6
testb %al, %al
je 0xed78
movq %r14, %rdi
callq 0xdb6c
cmpl $0xc, %eax
jne 0xeff6
movq %r14, %rdi
callq 0xdb6c
jmp 0xea38
movq %r15, %rdi
pushq $0x1
popq %rsi
callq 0x10498
jmp 0xea38
cmpl $0x4, 0x20(%r14)
jne 0xf136
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10cd6
testb %al, %al
je 0xed78
movq %r14, %rdi
callq 0xdb6c
cmpl $0xc, %eax
jne 0xf1c2
movq %r15, %rdi
xorl %esi, %esi
callq 0x10498
movq %r14, %rdi
callq 0xdb6c
jmp 0xea38
leaq 0x28(%r14), %rsi
movq 0x40(%r14), %r15
leaq 0x48(%rsp), %rdi
callq 0xf4a6
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x259fe(%rip), %rsi     # 0x3471e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84b8
leaq 0x28(%rsp), %rdi
pushq $0xa
popq %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
callq 0xf6e8
leaq 0x68(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x90(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0xf54e
leaq 0x48(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf39a
jmp 0xef1f
xorl %ebp, %ebp
jmp 0xef49
leaq 0x28(%r14), %rsi
movq 0x40(%r14), %r15
leaq 0x48(%rsp), %rdi
callq 0xf4a6
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x271a2(%rip), %rsi     # 0x35f55
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84b8
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0xf6e8
leaq 0x68(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x90(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0xf54e
leaq 0x48(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf39a
jmp 0xef1f
leaq 0x28(%r14), %rsi
movq 0x40(%r14), %r15
leaq 0x48(%rsp), %rdi
callq 0xf4a6
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movdqu (%rax), %xmm0
movdqa %xmm0, 0x90(%rsp)
leaq 0x27115(%rip), %rsi     # 0x35f55
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84b8
leaq 0x28(%rsp), %rdi
pushq $0x10
popq %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
callq 0xf6e8
leaq 0x68(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x90(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0xf54e
leaq 0x48(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf39a
jmp 0xef1f
leaq 0x28(%r14), %rsi
movq 0x40(%r14), %r15
leaq 0x48(%rsp), %rdi
callq 0xf4a6
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x2584b(%rip), %rsi     # 0x34717
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84b8
leaq 0x28(%rsp), %rdi
pushq $0xb
popq %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
callq 0xf6e8
leaq 0x68(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x90(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0xf54e
leaq 0x48(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf39a
movl %eax, %ebp
leaq 0x68(%rsp), %rdi
callq 0xf968
leaq 0x28(%rsp), %rdi
callq 0x5200
leaq 0x8(%rsp), %rdi
callq 0x5200
leaq 0x48(%rsp), %rdi
callq 0x5200
leaq 0xb0(%rsp), %rdi
callq 0x104d6
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%r14), %rsi
movq 0x40(%r14), %r15
leaq 0x48(%rsp), %rdi
callq 0xf4a6
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x269e4(%rip), %rsi     # 0x35982
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84b8
leaq 0x28(%rsp), %rdi
pushq $0x4
popq %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
callq 0xf6e8
leaq 0x68(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x90(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0xf54e
leaq 0x48(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf39a
jmp 0xef1f
leaq 0x28(%r14), %rsi
movq 0x40(%r14), %r15
leaq 0x48(%rsp), %rdi
callq 0xf4a6
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x26963(%rip), %rsi     # 0x3598d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84b8
leaq 0x28(%rsp), %rdi
pushq $0xc
popq %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
callq 0xf6e8
leaq 0x68(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x90(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0xf54e
leaq 0x48(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf39a
jmp 0xef1f
movq 0x40(%r14), %r15
addq $0x28, %r14
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
callq 0xf4a6
leaq 0x90(%rsp), %rdi
movq %r14, %rsi
callq 0xf4a6
leaq 0x268f0(%rip), %rsi     # 0x3599e
leaq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0xaa7f
leaq 0x275f7(%rip), %rdx     # 0x366be
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xaa60
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movl $0x196, %esi            # imm = 0x196
callq 0x10fd2
leaq 0x68(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf39a
movl %eax, %ebp
leaq 0x48(%rsp), %rdi
callq 0xf968
leaq 0x28(%rsp), %rdi
callq 0x5200
leaq 0x8(%rsp), %rdi
callq 0x5200
leaq 0x90(%rsp), %rdi
callq 0x5200
leaq 0x68(%rsp), %rdi
jmp 0xef44
leaq 0x28(%r14), %rsi
movq 0x40(%r14), %r15
leaq 0x48(%rsp), %rdi
callq 0xf4a6
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x26818(%rip), %rsi     # 0x35982
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84b8
leaq 0x28(%rsp), %rdi
pushq $0x4
popq %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
callq 0xf6e8
leaq 0x68(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x90(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0xf54e
leaq 0x48(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf39a
jmp 0xef1f
leaq 0x28(%r14), %rsi
movq 0x40(%r14), %r15
leaq 0x48(%rsp), %rdi
callq 0xf4a6
leaq 0x40(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x26797(%rip), %rsi     # 0x3598d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x84b8
leaq 0x28(%rsp), %rdi
pushq $0xc
popq %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rsi
callq 0xf6e8
leaq 0x68(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x90(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0xf54e
leaq 0x48(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf39a
jmp 0xef1f
leaq 0x26763(%rip), %rdi     # 0x359b8
leaq 0x2459e(%rip), %rsi     # 0x337fa
leaq 0x26768(%rip), %rcx     # 0x359cb
movl $0x2349, %edx           # imm = 0x2349
callq 0x52c0
leaq 0x26744(%rip), %rdi     # 0x359b8
leaq 0x2457f(%rip), %rsi     # 0x337fa
leaq 0x26749(%rip), %rcx     # 0x359cb
movl $0x2381, %edx           # imm = 0x2381
callq 0x52c0
jmp 0xf33b
jmp 0xf34a
jmp 0xf359
jmp 0xf368
jmp 0xf381
jmp 0xf33b
jmp 0xf34a
jmp 0xf359
jmp 0xf368
jmp 0xf381
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf968
jmp 0xf2d0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5200
jmp 0xf2df
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5200
jmp 0xf2ee
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x5200
jmp 0xf300
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0xf370
jmp 0xf381
jmp 0xf33b
jmp 0xf34a
jmp 0xf359
jmp 0xf368
jmp 0xf381
jmp 0xf33b
jmp 0xf34a
jmp 0xf359
jmp 0xf368
jmp 0xf381
jmp 0xf33b
jmp 0xf34a
jmp 0xf359
jmp 0xf368
jmp 0xf381
jmp 0xf33b
jmp 0xf33b
jmp 0xf34a
jmp 0xf34a
jmp 0xf359
jmp 0xf359
jmp 0xf368
jmp 0xf368
jmp 0xf381
jmp 0xf381
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf968
jmp 0xf34d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5200
jmp 0xf35c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5200
jmp 0xf36b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5200
jmp 0xf384
jmp 0xf381
jmp 0xf381
jmp 0xf381
jmp 0xf381
jmp 0xf381
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x104d6
movq %rbx, %rdi
callq 0x56f0
nop