// File: SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: 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>>::parse_internal(bool, 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>&)
void parse_internal(bool keep, BasicJsonType& result)
    {
        // never parse after a parse error was detected
        assert(not errored);

        // start with a discarded value
        if (not result.is_discarded())
        {
            result.m_value.destroy(result.m_type);
            result.m_type = value_t::discarded;
        }

        switch (last_token)
        {
            case token_type::begin_object:
            {
                if (keep)
                {
                    if (callback)
                    {
                        keep = callback(depth++, parse_event_t::object_start, result);
                    }

                    if (not callback or keep)
                    {
                        // explicitly set result to object to cope with {}
                        result.m_type = value_t::object;
                        result.m_value = value_t::object;
                    }
                }

                // read next token
                get_token();

                // closing } -> we are done
                if (last_token == token_type::end_object)
                {
                    if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
                    {
                        result.m_value.destroy(result.m_type);
                        result.m_type = value_t::discarded;
                    }
                    break;
                }

                // parse values
                std::string key;
                BasicJsonType value;
                while (true)
                {
                    // store key
                    if (not expect(token_type::value_string))
                    {
                        return;
                    }
                    key = m_lexer.move_string();

                    bool keep_tag = false;
                    if (keep)
                    {
                        if (callback)
                        {
                            BasicJsonType k(key);
                            keep_tag = callback(depth, parse_event_t::key, k);
                        }
                        else
                        {
                            keep_tag = true;
                        }
                    }

                    // parse separator (:)
                    get_token();
                    if (not expect(token_type::name_separator))
                    {
                        return;
                    }

                    // parse and add value
                    get_token();
                    value.m_value.destroy(value.m_type);
                    value.m_type = value_t::discarded;
                    parse_internal(keep, value);

                    if (JSON_UNLIKELY(errored))
                    {
                        return;
                    }

                    if (keep and keep_tag and not value.is_discarded())
                    {
                        result.m_value.object->emplace(std::move(key), std::move(value));
                    }

                    // comma -> next value
                    get_token();
                    if (last_token == token_type::value_separator)
                    {
                        get_token();
                        continue;
                    }

                    // closing }
                    if (not expect(token_type::end_object))
                    {
                        return;
                    }
                    break;
                }

                if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
                {
                    result.m_value.destroy(result.m_type);
                    result.m_type = value_t::discarded;
                }
                break;
            }

            case token_type::begin_array:
            {
                if (keep)
                {
                    if (callback)
                    {
                        keep = callback(depth++, parse_event_t::array_start, result);
                    }

                    if (not callback or keep)
                    {
                        // explicitly set result to array to cope with []
                        result.m_type = value_t::array;
                        result.m_value = value_t::array;
                    }
                }

                // read next token
                get_token();

                // closing ] -> we are done
                if (last_token == token_type::end_array)
                {
                    if (callback and not callback(--depth, parse_event_t::array_end, result))
                    {
                        result.m_value.destroy(result.m_type);
                        result.m_type = value_t::discarded;
                    }
                    break;
                }

                // parse values
                BasicJsonType value;
                while (true)
                {
                    // parse value
                    value.m_value.destroy(value.m_type);
                    value.m_type = value_t::discarded;
                    parse_internal(keep, value);

                    if (JSON_UNLIKELY(errored))
                    {
                        return;
                    }

                    if (keep and not value.is_discarded())
                    {
                        result.m_value.array->push_back(std::move(value));
                    }

                    // comma -> next value
                    get_token();
                    if (last_token == token_type::value_separator)
                    {
                        get_token();
                        continue;
                    }

                    // closing ]
                    if (not expect(token_type::end_array))
                    {
                        return;
                    }
                    break;
                }

                if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
                {
                    result.m_value.destroy(result.m_type);
                    result.m_type = value_t::discarded;
                }
                break;
            }

            case token_type::literal_null:
            {
                result.m_type = value_t::null;
                break;
            }

            case token_type::value_string:
            {
                result.m_type = value_t::string;
                result.m_value = m_lexer.move_string();
                break;
            }

            case token_type::literal_true:
            {
                result.m_type = value_t::boolean;
                result.m_value = true;
                break;
            }

            case token_type::literal_false:
            {
                result.m_type = value_t::boolean;
                result.m_value = false;
                break;
            }

            case token_type::value_unsigned:
            {
                result.m_type = value_t::number_unsigned;
                result.m_value = m_lexer.get_number_unsigned();
                break;
            }

            case token_type::value_integer:
            {
                result.m_type = value_t::number_integer;
                result.m_value = m_lexer.get_number_integer();
                break;
            }

            case token_type::value_float:
            {
                result.m_type = value_t::number_float;
                result.m_value = m_lexer.get_number_float();

                // throw in case of infinity or NAN
                if (JSON_UNLIKELY(not std::isfinite(result.m_value.number_float)))
                {
                    if (allow_exceptions)
                    {
                        JSON_THROW(out_of_range::create(406, "number overflow parsing '" +
                                                        m_lexer.get_token_string() + "'"));
                    }
                    expect(token_type::uninitialized);
                }
                break;
            }

            case token_type::parse_error:
            {
                // using "uninitialized" to avoid "expected" message
                if (not expect(token_type::uninitialized))
                {
                    return;
                }
                break; // LCOV_EXCL_LINE
            }

            default:
            {
                // the last token was unexpected; we expected a value
                if (not expect(token_type::literal_or_value))
                {
                    return;
                }
                break; // LCOV_EXCL_LINE
            }
        }

        if (keep and callback and not callback(depth, parse_event_t::value, result))
        {
            result.m_type = value_t::discarded;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x180(%rbp)
movb 0xb0(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9c34
jmp 0x9c36
jmp 0x9c55
leaq 0xcba7(%rip), %rdi      # 0x167e4
leaq 0xbdea(%rip), %rsi      # 0x15a2e
movl $0xbb3, %edx            # imm = 0xBB3
leaq 0xcba0(%rip), %rcx      # 0x167f0
callq 0x3210
movq -0x18(%rbp), %rdi
callq 0xa820
testb $0x1, %al
jne 0x9c7d
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movzbl (%rax), %esi
callq 0x4f20
movq -0x18(%rbp), %rax
movb $0x8, (%rax)
movq -0x180(%rbp), %rax
movl 0x28(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x188(%rbp)
subl $0xd, %eax
ja 0xa682
movq -0x188(%rbp), %rax
leaq 0xb37b(%rip), %rcx      # 0x15024
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testb $0x1, -0x9(%rbp)
je 0x9d34
movq -0x180(%rbp), %rdi
addq $0x8, %rdi
callq 0x99b0
testb $0x1, %al
jne 0x9cce
jmp 0x9cf5
movq -0x180(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
movl %esi, %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
xorl %edx, %edx
callq 0xc780
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x180(%rbp), %rdi
addq $0x8, %rdi
callq 0x99b0
testb $0x1, %al
jne 0x9d0b
jmp 0x9d11
testb $0x1, -0x9(%rbp)
je 0x9d32
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x6110
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x9d34
movq -0x180(%rbp), %rdi
callq 0x9bd0
movq -0x180(%rbp), %rax
cmpl $0xb, 0x28(%rax)
jne 0x9db0
testb $0x1, -0x9(%rbp)
je 0x9dab
movq -0x180(%rbp), %rdi
addq $0x8, %rdi
callq 0x99b0
testb $0x1, %al
jne 0x9d69
jmp 0x9dab
movq -0x180(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
addl $-0x1, %esi
movl %esi, (%rax)
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0xc780
testb $0x1, %al
jne 0x9dab
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movzbl (%rax), %esi
callq 0x4f20
movq -0x18(%rbp), %rax
movb $0x8, (%rax)
jmp 0xa69b
leaq -0x40(%rbp), %rdi
callq 0x33d0
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4630
jmp 0x9dc8
movq -0x180(%rbp), %rdi
movl $0x4, %esi
callq 0xa700
movb %al, -0x189(%rbp)
jmp 0x9de1
movb -0x189(%rbp), %al
testb $0x1, %al
jne 0x9e0a
jmp 0x9ded
movl $0x1, -0x60(%rbp)
jmp 0xa0a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa0c8
movq -0x180(%rbp), %rsi
addq $0x30, %rsi
leaq -0x80(%rbp), %rdi
callq 0xc7d0
jmp 0x9e20
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3360
leaq -0x80(%rbp), %rdi
callq 0x3200
movb $0x0, -0x81(%rbp)
testb $0x1, -0x9(%rbp)
je 0x9eda
movq -0x180(%rbp), %rdi
addq $0x8, %rdi
callq 0x99b0
testb $0x1, %al
jne 0x9e5d
jmp 0x9ed1
leaq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xc800
jmp 0x9e6f
movq -0x180(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
movl $0x4, %edx
leaq -0x98(%rbp), %rcx
callq 0xc780
movb %al, -0x18a(%rbp)
jmp 0x9e98
movb -0x18a(%rbp), %al
andb $0x1, %al
movb %al, -0x81(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4d80
jmp 0x9ed8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4d80
jmp 0xa0c8
movb $0x1, -0x81(%rbp)
jmp 0x9eda
movq -0x180(%rbp), %rdi
callq 0x9bd0
jmp 0x9ee8
movq -0x180(%rbp), %rdi
movl $0xc, %esi
callq 0xa700
movb %al, -0x18b(%rbp)
jmp 0x9f01
movb -0x18b(%rbp), %al
testb $0x1, %al
jne 0x9f19
jmp 0x9f0d
movl $0x1, -0x60(%rbp)
jmp 0xa0a3
movq -0x180(%rbp), %rdi
callq 0x9bd0
jmp 0x9f27
leaq -0x48(%rbp), %rdi
movzbl -0x50(%rbp), %esi
callq 0x4f20
jmp 0x9f36
movq -0x180(%rbp), %rdi
movb $0x8, -0x50(%rbp)
movzbl -0x9(%rbp), %esi
andl $0x1, %esi
leaq -0x50(%rbp), %rdx
callq 0x9c00
jmp 0x9f53
movq -0x180(%rbp), %rax
movb 0xb0(%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9f6a
jmp 0x9f76
movl $0x1, -0x60(%rbp)
jmp 0xa0a3
testb $0x1, -0x9(%rbp)
je 0x9fd0
testb $0x1, -0x81(%rbp)
je 0x9fd0
leaq -0x50(%rbp), %rdi
callq 0xa820
testb $0x1, %al
jne 0x9fd0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xc850
movb %dl, -0x199(%rbp)
movq %rax, -0x198(%rbp)
jmp 0x9fb6
movb -0x199(%rbp), %al
movq -0x198(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movb %al, -0xa0(%rbp)
movq -0x180(%rbp), %rdi
callq 0x9bd0
jmp 0x9fde
movq -0x180(%rbp), %rax
cmpl $0xd, 0x28(%rax)
jne 0x9ffe
movq -0x180(%rbp), %rdi
callq 0x9bd0
jmp 0x9ff9
jmp 0x9dc6
movq -0x180(%rbp), %rdi
movl $0xb, %esi
callq 0xa700
movb %al, -0x19a(%rbp)
jmp 0xa017
movb -0x19a(%rbp), %al
testb $0x1, %al
jne 0xa02c
jmp 0xa023
movl $0x1, -0x60(%rbp)
jmp 0xa0a3
jmp 0xa02e
testb $0x1, -0x9(%rbp)
je 0xa09c
movq -0x180(%rbp), %rdi
addq $0x8, %rdi
callq 0x99b0
testb $0x1, %al
jne 0xa04a
jmp 0xa09c
movq -0x180(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
decl %esi
movl %esi, (%rax)
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0xc780
movb %al, -0x19b(%rbp)
jmp 0xa074
movb -0x19b(%rbp), %al
testb $0x1, %al
jne 0xa09c
jmp 0xa080
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movzbl (%rax), %esi
callq 0x4f20
jmp 0xa095
movq -0x18(%rbp), %rax
movb $0x8, (%rax)
movl $0x2, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4d80
leaq -0x40(%rbp), %rdi
callq 0x3200
movl -0x60(%rbp), %eax
subl $0x1, %eax
je 0xa6e0
jmp 0xa0c3
jmp 0xa69b
leaq -0x50(%rbp), %rdi
callq 0x4d80
leaq -0x40(%rbp), %rdi
callq 0x3200
jmp 0xa6e9
testb $0x1, -0x9(%rbp)
je 0xa16e
movq -0x180(%rbp), %rdi
addq $0x8, %rdi
callq 0x99b0
testb $0x1, %al
jne 0xa0ff
jmp 0xa129
movq -0x180(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
movl %esi, %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movl $0x2, %edx
callq 0xc780
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x180(%rbp), %rdi
addq $0x8, %rdi
callq 0x99b0
testb $0x1, %al
jne 0xa13f
jmp 0xa145
testb $0x1, -0x9(%rbp)
je 0xa16c
movq -0x18(%rbp), %rax
movb $0x2, (%rax)
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
callq 0x6110
movq -0x18(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xa16e
movq -0x180(%rbp), %rdi
callq 0x9bd0
movq -0x180(%rbp), %rax
cmpl $0xa, 0x28(%rax)
jne 0xa1e4
movq -0x180(%rbp), %rdi
addq $0x8, %rdi
callq 0x99b0
testb $0x1, %al
jne 0xa19d
jmp 0xa1df
movq -0x180(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
addl $-0x1, %esi
movl %esi, (%rax)
movq -0x18(%rbp), %rcx
movl $0x3, %edx
callq 0xc780
testb $0x1, %al
jne 0xa1df
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movzbl (%rax), %esi
callq 0x4f20
movq -0x18(%rbp), %rax
movb $0x8, (%rax)
jmp 0xa69b
leaq -0xc0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4630
jmp 0xa1f6
leaq -0xb8(%rbp), %rdi
movzbl -0xc0(%rbp), %esi
callq 0x4f20
jmp 0xa20b
movq -0x180(%rbp), %rdi
movb $0x8, -0xc0(%rbp)
movzbl -0x9(%rbp), %esi
andl $0x1, %esi
leaq -0xc0(%rbp), %rdx
callq 0x9c00
jmp 0xa22e
movq -0x180(%rbp), %rax
movb 0xb0(%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xa245
jmp 0xa26e
movl $0x1, -0x60(%rbp)
jmp 0xa36f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x4d80
jmp 0xa6e9
testb $0x1, -0x9(%rbp)
je 0xa29c
leaq -0xc0(%rbp), %rdi
callq 0xa820
testb $0x1, %al
jne 0xa29c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xc8a0
jmp 0xa29a
jmp 0xa29c
movq -0x180(%rbp), %rdi
callq 0x9bd0
jmp 0xa2aa
movq -0x180(%rbp), %rax
cmpl $0xd, 0x28(%rax)
jne 0xa2ca
movq -0x180(%rbp), %rdi
callq 0x9bd0
jmp 0xa2c5
jmp 0xa1f4
movq -0x180(%rbp), %rdi
movl $0xa, %esi
callq 0xa700
movb %al, -0x19c(%rbp)
jmp 0xa2e3
movb -0x19c(%rbp), %al
testb $0x1, %al
jne 0xa2f8
jmp 0xa2ef
movl $0x1, -0x60(%rbp)
jmp 0xa36f
jmp 0xa2fa
testb $0x1, -0x9(%rbp)
je 0xa368
movq -0x180(%rbp), %rdi
addq $0x8, %rdi
callq 0x99b0
testb $0x1, %al
jne 0xa316
jmp 0xa368
movq -0x180(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
decl %esi
movl %esi, (%rax)
movq -0x18(%rbp), %rcx
movl $0x3, %edx
callq 0xc780
movb %al, -0x19d(%rbp)
jmp 0xa340
movb -0x19d(%rbp), %al
testb $0x1, %al
jne 0xa368
jmp 0xa34c
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movzbl (%rax), %esi
callq 0x4f20
jmp 0xa361
movq -0x18(%rbp), %rax
movb $0x8, (%rax)
movl $0x2, -0x60(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x4d80
movl -0x60(%rbp), %eax
subl $0x1, %eax
je 0xa6e0
jmp 0xa389
jmp 0xa69b
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
jmp 0xa69b
movq -0x180(%rbp), %rsi
movq -0x18(%rbp), %rax
movb $0x3, (%rax)
addq $0x30, %rsi
leaq -0xe8(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0xc7d0
movq -0x1a8(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0xc8d0
jmp 0xa3d4
movq -0x18(%rbp), %rax
movq -0xc8(%rbp), %rcx
movq %rcx, 0x8(%rax)
leaq -0xe8(%rbp), %rdi
callq 0x3200
jmp 0xa69b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x3200
jmp 0xa6e9
movq -0x18(%rbp), %rax
movb $0x4, (%rax)
leaq -0xf0(%rbp), %rdi
movl $0x1, %esi
callq 0xc910
movq -0x18(%rbp), %rax
movq -0xf0(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xa69b
movq -0x18(%rbp), %rax
movb $0x4, (%rax)
leaq -0xf8(%rbp), %rdi
xorl %esi, %esi
callq 0xc910
movq -0x18(%rbp), %rax
movq -0xf8(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xa69b
movq -0x180(%rbp), %rdi
movq -0x18(%rbp), %rax
movb $0x6, (%rax)
addq $0x30, %rdi
callq 0xc930
movq %rax, %rsi
leaq -0x100(%rbp), %rdi
callq 0xc950
movq -0x18(%rbp), %rax
movq -0x100(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xa69b
movq -0x180(%rbp), %rdi
movq -0x18(%rbp), %rax
movb $0x5, (%rax)
addq $0x30, %rdi
callq 0xc970
movq %rax, %rsi
leaq -0x108(%rbp), %rdi
callq 0xc990
movq -0x18(%rbp), %rax
movq -0x108(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xa69b
movq -0x180(%rbp), %rdi
movq -0x18(%rbp), %rax
movb $0x7, (%rax)
addq $0x30, %rdi
callq 0xc9b0
leaq -0x110(%rbp), %rdi
callq 0xc9d0
movq -0x18(%rbp), %rax
movq -0x110(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0xc9f0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xa529
jmp 0xa66a
movq -0x180(%rbp), %rax
testb $0x1, 0xb8(%rax)
je 0xa65c
movb $0x1, -0x171(%rbp)
movl $0x20, %edi
callq 0x3190
movq -0x180(%rbp), %rsi
movq %rax, -0x1b0(%rbp)
addq $0x30, %rsi
leaq -0x170(%rbp), %rdi
callq 0xcbd0
jmp 0xa56e
leaq 0xc301(%rip), %rsi      # 0x16876
leaq -0x150(%rbp), %rdi
leaq -0x170(%rbp), %rdx
callq 0xcb80
jmp 0xa58a
leaq 0xc639(%rip), %rdx      # 0x16bca
leaq -0x130(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0x7d70
jmp 0xa5a6
movq -0x1b0(%rbp), %rdi
movl $0x196, %esi            # imm = 0x196
leaq -0x130(%rbp), %rdx
callq 0xca30
jmp 0xa5c0
movq -0x1b0(%rbp), %rdi
movb $0x0, -0x171(%rbp)
leaq 0x17713(%rip), %rsi     # 0x21ce8
leaq 0x2894(%rip), %rdx      # 0xce70
callq 0x34b0
jmp 0xa6f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa640
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa634
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa628
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x3200
leaq -0x150(%rbp), %rdi
callq 0x3200
leaq -0x170(%rbp), %rdi
callq 0x3200
testb $0x1, -0x171(%rbp)
jne 0xa64b
jmp 0xa657
movq -0x1b0(%rbp), %rdi
callq 0x3260
jmp 0xa6e9
movq -0x180(%rbp), %rdi
xorl %esi, %esi
callq 0xa700
jmp 0xa69b
movq -0x180(%rbp), %rdi
xorl %esi, %esi
callq 0xa700
testb $0x1, %al
jne 0xa680
jmp 0xa6e0
jmp 0xa69b
movq -0x180(%rbp), %rdi
movl $0x10, %esi
callq 0xa700
testb $0x1, %al
jne 0xa699
jmp 0xa6e0
jmp 0xa69b
testb $0x1, -0x9(%rbp)
je 0xa6e0
movq -0x180(%rbp), %rdi
addq $0x8, %rdi
callq 0x99b0
testb $0x1, %al
jne 0xa6b7
jmp 0xa6e0
movq -0x180(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
movq -0x18(%rbp), %rcx
movl $0x5, %edx
callq 0xc780
testb $0x1, %al
jne 0xa6e0
movq -0x18(%rbp), %rax
movb $0x8, (%rax)
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
nopl (%rax)