// File: alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::parser::parse_internal(bool)
basic_json parse_internal(bool keep)
        {
            auto result = basic_json(value_t::discarded);

            switch (last_token)
            {
                case lexer::token_type::begin_object:
                {
                    if (keep and (not callback or (keep = callback(depth++, parse_event_t::object_start, result))))
                    {
                        // explicitly set result to object to cope with {}
                        result.m_type = value_t::object;
                        result.m_value = json_value(value_t::object);
                    }

                    // read next token
                    get_token();

                    // closing } -> we are done
                    if (last_token == lexer::token_type::end_object)
                    {
                        get_token();
                        if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
                        {
                            result = basic_json(value_t::discarded);
                        }
                        return result;
                    }

                    // no comma is expected here
                    unexpect(lexer::token_type::value_separator);

                    // otherwise: parse key-value pairs
                    do
                    {
                        // ugly, but could be fixed with loop reorganization
                        if (last_token == lexer::token_type::value_separator)
                        {
                            get_token();
                        }

                        // store key
                        expect(lexer::token_type::value_string);
                        const auto key = m_lexer.get_string();

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

                        // parse separator (:)
                        get_token();
                        expect(lexer::token_type::name_separator);

                        // parse and add value
                        get_token();
                        auto value = parse_internal(keep);
                        if (keep and keep_tag and not value.is_discarded())
                        {
                            result[key] = std::move(value);
                        }
                    }
                    while (last_token == lexer::token_type::value_separator);

                    // closing }
                    expect(lexer::token_type::end_object);
                    get_token();
                    if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
                    {
                        result = basic_json(value_t::discarded);
                    }

                    return result;
                }

                case lexer::token_type::begin_array:
                {
                    if (keep and (not callback or (keep = callback(depth++, parse_event_t::array_start, result))))
                    {
                        // explicitly set result to object to cope with []
                        result.m_type = value_t::array;
                        result.m_value = json_value(value_t::array);
                    }

                    // read next token
                    get_token();

                    // closing ] -> we are done
                    if (last_token == lexer::token_type::end_array)
                    {
                        get_token();
                        if (callback and not callback(--depth, parse_event_t::array_end, result))
                        {
                            result = basic_json(value_t::discarded);
                        }
                        return result;
                    }

                    // no comma is expected here
                    unexpect(lexer::token_type::value_separator);

                    // otherwise: parse values
                    do
                    {
                        // ugly, but could be fixed with loop reorganization
                        if (last_token == lexer::token_type::value_separator)
                        {
                            get_token();
                        }

                        // parse value
                        auto value = parse_internal(keep);
                        if (keep and not value.is_discarded())
                        {
                            result.push_back(std::move(value));
                        }
                    }
                    while (last_token == lexer::token_type::value_separator);

                    // closing ]
                    expect(lexer::token_type::end_array);
                    get_token();
                    if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
                    {
                        result = basic_json(value_t::discarded);
                    }

                    return result;
                }

                case lexer::token_type::literal_null:
                {
                    get_token();
                    result.m_type = value_t::null;
                    break;
                }

                case lexer::token_type::value_string:
                {
                    const auto s = m_lexer.get_string();
                    get_token();
                    result = basic_json(s);
                    break;
                }

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

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

                case lexer::token_type::value_number:
                {
                    result.m_value = m_lexer.get_number();

                    // NAN is returned if token could not be translated
                    // completely
                    if (std::isnan(result.m_value.number_float))
                    {
                        throw std::invalid_argument(std::string("parse error - ") +
                                                    m_lexer.get_token() + " is not a number");
                    }

                    get_token();

                    // check if conversion loses precision (special case -0.0 always loses precision)
                    const auto int_val = static_cast<number_integer_t>(result.m_value.number_float);
                    if (result.m_value.number_float == static_cast<number_float_t>(int_val) and
                            result.m_value.number_integer != json_value(-0.0f).number_integer)
                    {
                        // we would not lose precision -> return int
                        result.m_type = value_t::number_integer;
                        result.m_value = int_val;
                    }
                    else
                    {
                        // we would lose precision -> return float
                        result.m_type = value_t::number_float;
                    }
                    break;
                }

                default:
                {
                    // the last token was unexpected
                    unexpect(last_token);
                }
            }

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

// Assembly:
subq $0x268, %rsp            # imm = 0x268
movq %rdi, 0x60(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x68(%rsp)
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
andb $0x1, %al
movb %al, 0x257(%rsp)
movq 0x258(%rsp), %rax
movq %rax, 0x70(%rsp)
movb $0x0, 0x256(%rsp)
movl $0x7, %esi
callq 0x98440
movq 0x70(%rsp), %rax
movl 0x28(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x78(%rsp)
subl $0x6, %eax
ja 0x9e620
movq 0x78(%rsp), %rax
leaq 0x464cc(%rip), %rcx     # 0xe4010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testb $0x1, 0x257(%rsp)
je 0x9dbf3
movq 0x70(%rsp), %rdi
addq $0x8, %rdi
callq 0x96070
testb $0x1, %al
jne 0x9db6f
jmp 0x9dbab
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
movl %esi, %edx
incl %edx
movl %edx, (%rax)
xorl %edx, %edx
callq 0x96da0
movb %al, 0x5f(%rsp)
jmp 0x9db95
movb 0x5f(%rsp), %al
movb %al, %cl
andb $0x1, %cl
movb %cl, 0x257(%rsp)
testb $0x1, %al
jne 0x9dbab
jmp 0x9dbf3
movq 0x60(%rsp), %rax
movb $0x1, (%rax)
leaq 0x238(%rsp), %rdi
movl $0x1, %esi
callq 0x93130
jmp 0x9dbc7
movq 0x60(%rsp), %rax
movq 0x238(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x9dbf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x248(%rsp)
movl %eax, 0x244(%rsp)
jmp 0x9e6e3
movq 0x70(%rsp), %rdi
callq 0x96e70
movq 0x70(%rsp), %rax
cmpl $0x9, 0x28(%rax)
jne 0x9dcb0
movq 0x70(%rsp), %rdi
callq 0x96e70
testb $0x1, 0x257(%rsp)
je 0x9dc98
movq 0x70(%rsp), %rdi
addq $0x8, %rdi
callq 0x96070
testb $0x1, %al
jne 0x9dc34
jmp 0x9dc98
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
decl %esi
movl %esi, (%rax)
movl $0x1, %edx
callq 0x96da0
movb %al, 0x5e(%rsp)
jmp 0x9dc5b
movb 0x5e(%rsp), %al
testb $0x1, %al
jne 0x9dc98
jmp 0x9dc65
leaq 0x228(%rsp), %rdi
movl $0x7, %esi
callq 0x98440
jmp 0x9dc79
movq 0x60(%rsp), %rdi
leaq 0x228(%rsp), %rsi
callq 0x92ce0
leaq 0x228(%rsp), %rdi
callq 0x90790
movb $0x1, 0x256(%rsp)
movl $0x1, 0x224(%rsp)
jmp 0x9e6c2
movq 0x70(%rsp), %rdi
movl $0xb, %esi
callq 0x98f90
jmp 0x9dcc1
jmp 0x9dcc3
movq 0x70(%rsp), %rax
cmpl $0xb, 0x28(%rax)
jne 0x9dcd8
movq 0x70(%rsp), %rdi
callq 0x96e70
movq 0x70(%rsp), %rdi
movl $0x4, %esi
callq 0x90420
jmp 0x9dce9
movq 0x70(%rsp), %rsi
addq $0x30, %rsi
leaq 0x200(%rsp), %rdi
callq 0x92f70
jmp 0x9dd01
movb $0x0, 0x1ff(%rsp)
testb $0x1, 0x257(%rsp)
je 0x9ddd0
movq 0x70(%rsp), %rdi
addq $0x8, %rdi
callq 0x96070
testb $0x1, %al
jne 0x9dd2e
jmp 0x9ddc6
leaq 0x1e8(%rsp), %rdi
leaq 0x200(%rsp), %rsi
callq 0x91170
jmp 0x9dd45
movq 0x70(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
movl $0x4, %edx
leaq 0x1e8(%rsp), %rcx
callq 0x96da0
movb %al, 0x5d(%rsp)
jmp 0x9dd6b
movb 0x5d(%rsp), %al
andb $0x1, %al
movb %al, 0x1ff(%rsp)
leaq 0x1e8(%rsp), %rdi
callq 0x90790
jmp 0x9ddce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x248(%rsp)
movl %eax, 0x244(%rsp)
jmp 0x9df93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x248(%rsp)
movl %eax, 0x244(%rsp)
leaq 0x1e8(%rsp), %rdi
callq 0x90790
jmp 0x9df93
movb $0x1, 0x1ff(%rsp)
jmp 0x9ddd0
movq 0x70(%rsp), %rdi
callq 0x96e70
movq 0x70(%rsp), %rdi
movl $0xa, %esi
callq 0x90420
jmp 0x9ddeb
movq 0x70(%rsp), %rdi
callq 0x96e70
movq 0x70(%rsp), %rsi
movzbl 0x257(%rsp), %edx
andl $0x1, %edx
leaq 0x1d8(%rsp), %rdi
callq 0x94220
jmp 0x9de14
testb $0x1, 0x257(%rsp)
je 0x9dec7
testb $0x1, 0x1ff(%rsp)
je 0x9dec7
leaq 0x1d8(%rsp), %rdi
callq 0x913e0
testb $0x1, %al
jne 0x9dec7
leaq 0x1c8(%rsp), %rdi
leaq 0x1d8(%rsp), %rsi
callq 0x93b30
movq 0x60(%rsp), %rdi
leaq 0x200(%rsp), %rsi
callq 0x940a0
movq %rax, 0x50(%rsp)
jmp 0x9de73
movq 0x50(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
callq 0x92ce0
leaq 0x1c8(%rsp), %rdi
callq 0x90790
jmp 0x9dec7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x248(%rsp)
movl %eax, 0x244(%rsp)
leaq 0x1c8(%rsp), %rdi
callq 0x90790
leaq 0x1d8(%rsp), %rdi
callq 0x90790
jmp 0x9df93
leaq 0x1d8(%rsp), %rdi
callq 0x90790
leaq 0x200(%rsp), %rdi
callq 0x99830
movq 0x70(%rsp), %rax
cmpl $0xb, 0x28(%rax)
je 0x9dcc3
movq 0x70(%rsp), %rdi
movl $0x9, %esi
callq 0x90420
jmp 0x9df01
movq 0x70(%rsp), %rdi
callq 0x96e70
testb $0x1, 0x257(%rsp)
je 0x9dfa5
movq 0x70(%rsp), %rdi
addq $0x8, %rdi
callq 0x96070
testb $0x1, %al
jne 0x9df2d
jmp 0x9dfa5
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
decl %esi
movl %esi, (%rax)
movl $0x1, %edx
callq 0x96da0
movb %al, 0x4f(%rsp)
jmp 0x9df54
movb 0x4f(%rsp), %al
testb $0x1, %al
jne 0x9dfa5
jmp 0x9df5e
leaq 0x1b8(%rsp), %rdi
movl $0x7, %esi
callq 0x98440
jmp 0x9df72
movq 0x60(%rsp), %rdi
leaq 0x1b8(%rsp), %rsi
callq 0x92ce0
leaq 0x1b8(%rsp), %rdi
callq 0x90790
jmp 0x9dfa5
leaq 0x200(%rsp), %rdi
callq 0x99830
jmp 0x9e6e3
movb $0x1, 0x256(%rsp)
movl $0x1, 0x224(%rsp)
jmp 0x9e6c2
testb $0x1, 0x257(%rsp)
je 0x9e04b
movq 0x70(%rsp), %rdi
addq $0x8, %rdi
callq 0x96070
testb $0x1, %al
jne 0x9dfdf
jmp 0x9e01e
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
movl %esi, %edx
incl %edx
movl %edx, (%rax)
movl $0x2, %edx
callq 0x96da0
movb %al, 0x4e(%rsp)
jmp 0x9e008
movb 0x4e(%rsp), %al
movb %al, %cl
andb $0x1, %cl
movb %cl, 0x257(%rsp)
testb $0x1, %al
jne 0x9e01e
jmp 0x9e04b
movq 0x60(%rsp), %rax
movb $0x2, (%rax)
leaq 0x1b0(%rsp), %rdi
movl $0x2, %esi
callq 0x93130
jmp 0x9e03a
movq 0x60(%rsp), %rax
movq 0x1b0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x70(%rsp), %rdi
callq 0x96e70
movq 0x70(%rsp), %rax
cmpl $0x8, 0x28(%rax)
jne 0x9e0fe
movq 0x70(%rsp), %rdi
callq 0x96e70
movq 0x70(%rsp), %rdi
addq $0x8, %rdi
callq 0x96070
testb $0x1, %al
jne 0x9e082
jmp 0x9e0e6
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
decl %esi
movl %esi, (%rax)
movl $0x3, %edx
callq 0x96da0
movb %al, 0x4d(%rsp)
jmp 0x9e0a9
movb 0x4d(%rsp), %al
testb $0x1, %al
jne 0x9e0e6
jmp 0x9e0b3
leaq 0x1a0(%rsp), %rdi
movl $0x7, %esi
callq 0x98440
jmp 0x9e0c7
movq 0x60(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
callq 0x92ce0
leaq 0x1a0(%rsp), %rdi
callq 0x90790
movb $0x1, 0x256(%rsp)
movl $0x1, 0x224(%rsp)
jmp 0x9e6c2
movq 0x70(%rsp), %rdi
movl $0xb, %esi
callq 0x98f90
jmp 0x9e10f
jmp 0x9e111
movq 0x70(%rsp), %rax
cmpl $0xb, 0x28(%rax)
jne 0x9e126
movq 0x70(%rsp), %rdi
callq 0x96e70
movq 0x70(%rsp), %rsi
movzbl 0x257(%rsp), %edx
andl $0x1, %edx
leaq 0x190(%rsp), %rdi
callq 0x94220
jmp 0x9e145
testb $0x1, 0x257(%rsp)
je 0x9e19c
leaq 0x190(%rsp), %rdi
callq 0x913e0
testb $0x1, %al
jne 0x9e19c
movq 0x60(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0x925f0
jmp 0x9e174
jmp 0x9e19c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x248(%rsp)
movl %eax, 0x244(%rsp)
leaq 0x190(%rsp), %rdi
callq 0x90790
jmp 0x9e6e3
leaq 0x190(%rsp), %rdi
callq 0x90790
movq 0x70(%rsp), %rax
cmpl $0xb, 0x28(%rax)
je 0x9e111
movq 0x70(%rsp), %rdi
movl $0x8, %esi
callq 0x90420
jmp 0x9e1c9
movq 0x70(%rsp), %rdi
callq 0x96e70
testb $0x1, 0x257(%rsp)
je 0x9e255
movq 0x70(%rsp), %rdi
addq $0x8, %rdi
callq 0x96070
testb $0x1, %al
jne 0x9e1f1
jmp 0x9e255
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
decl %esi
movl %esi, (%rax)
movl $0x3, %edx
callq 0x96da0
movb %al, 0x4c(%rsp)
jmp 0x9e218
movb 0x4c(%rsp), %al
testb $0x1, %al
jne 0x9e255
jmp 0x9e222
leaq 0x180(%rsp), %rdi
movl $0x7, %esi
callq 0x98440
jmp 0x9e236
movq 0x60(%rsp), %rdi
leaq 0x180(%rsp), %rsi
callq 0x92ce0
leaq 0x180(%rsp), %rdi
callq 0x90790
movb $0x1, 0x256(%rsp)
movl $0x1, 0x224(%rsp)
jmp 0x9e6c2
movq 0x70(%rsp), %rdi
callq 0x96e70
movq 0x60(%rsp), %rax
movb $0x0, (%rax)
jmp 0x9e631
movq 0x70(%rsp), %rsi
addq $0x30, %rsi
leaq 0x160(%rsp), %rdi
callq 0x92f70
jmp 0x9e29c
movq 0x70(%rsp), %rdi
callq 0x96e70
leaq 0x150(%rsp), %rdi
leaq 0x160(%rsp), %rsi
callq 0x91170
jmp 0x9e2bd
movq 0x60(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x92ce0
leaq 0x150(%rsp), %rdi
callq 0x90790
movl $0x2, 0x224(%rsp)
leaq 0x160(%rsp), %rdi
callq 0x99830
jmp 0x9e631
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x248(%rsp)
movl %eax, 0x244(%rsp)
leaq 0x160(%rsp), %rdi
callq 0x99830
jmp 0x9e6e3
movq 0x70(%rsp), %rdi
callq 0x96e70
movq 0x60(%rsp), %rax
movb $0x4, (%rax)
leaq 0x148(%rsp), %rdi
movl $0x1, %esi
callq 0x93820
movq 0x60(%rsp), %rax
movq 0x148(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x9e631
movq 0x70(%rsp), %rdi
callq 0x96e70
movq 0x60(%rsp), %rax
movb $0x4, (%rax)
leaq 0x140(%rsp), %rdi
xorl %esi, %esi
callq 0x93820
movq 0x60(%rsp), %rax
movq 0x140(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x9e631
movq 0x70(%rsp), %rdi
addq $0x30, %rdi
callq 0x98e60
vmovsd %xmm0, 0x40(%rsp)
jmp 0x9e3a6
vmovsd 0x40(%rsp), %xmm0
leaq 0x138(%rsp), %rdi
callq 0x96b40
movq 0x60(%rsp), %rax
movq 0x138(%rsp), %rcx
movq %rcx, 0x8(%rax)
vmovsd 0x8(%rax), %xmm0
callq 0x8d450
movb %al, 0x3f(%rsp)
jmp 0x9e3da
movb 0x3f(%rsp), %al
testb $0x1, %al
jne 0x9e3e7
jmp 0x9e56b
movb $0x1, 0xaf(%rsp)
movl $0x10, %edi
callq 0x8f970
movq %rax, 0x28(%rsp)
leaq 0xd7(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x98200
movq 0x30(%rsp), %rdx
leaq 0x46276(%rip), %rsi     # 0xe4692
leaq 0xd8(%rsp), %rdi
callq 0x95700
jmp 0x9e42b
movq 0x70(%rsp), %rsi
addq $0x30, %rsi
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x95ba0
movq 0x20(%rsp), %rdx
leaq 0xf8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x920d0
jmp 0x9e462
leaq 0x46238(%rip), %rdx     # 0xe46a1
leaq 0x118(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x8df90
jmp 0x9e480
movq 0x28(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0x97e80
jmp 0x9e494
movq 0x28(%rsp), %rdi
movb $0x0, 0xaf(%rsp)
movq 0x67ab0(%rip), %rsi     # 0x105f58
movq 0x67a49(%rip), %rdx     # 0x105ef8
callq 0x97c60
jmp 0x9e6fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x248(%rsp)
movl %eax, 0x244(%rsp)
jmp 0x9e543
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x248(%rsp)
movl %eax, 0x244(%rsp)
jmp 0x9e529
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x248(%rsp)
movl %eax, 0x244(%rsp)
jmp 0x9e51c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x248(%rsp)
movl %eax, 0x244(%rsp)
leaq 0x118(%rsp), %rdi
callq 0x99830
leaq 0xf8(%rsp), %rdi
callq 0x99830
leaq 0xb0(%rsp), %rdi
callq 0x99830
leaq 0xd8(%rsp), %rdi
callq 0x99830
leaq 0xd7(%rsp), %rdi
callq 0x938a0
testb $0x1, 0xaf(%rsp)
jne 0x9e55c
jmp 0x9e566
movq 0x28(%rsp), %rdi
callq 0x911a0
jmp 0x9e6e3
movq 0x70(%rsp), %rdi
callq 0x96e70
movq 0x60(%rsp), %rax
vcvttsd2si 0x8(%rax), %rcx
movq %rcx, 0xa0(%rsp)
vmovsd 0x8(%rax), %xmm0
vcvtsi2sdq 0xa0(%rsp), %xmm1, %xmm1
xorl %eax, %eax
vucomisd %xmm1, %xmm0
movb %al, 0x1f(%rsp)
jne 0x9e5dc
jp 0x9e5dc
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x98(%rsp), %rdi
vmovsd 0x45a3d(%rip), %xmm0    # 0xe4000
callq 0x96b40
movq 0x10(%rsp), %rax
cmpq 0x98(%rsp), %rax
setne %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x9e5e6
jmp 0x9e616
movq 0x60(%rsp), %rax
movb $0x5, (%rax)
movq 0xa0(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x96740
movq 0x60(%rsp), %rax
movq 0x90(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x9e61e
movq 0x60(%rsp), %rax
movb $0x6, (%rax)
jmp 0x9e631
movq 0x70(%rsp), %rdi
movl 0x28(%rdi), %esi
callq 0x98f90
jmp 0x9e62f
jmp 0x9e631
testb $0x1, 0x257(%rsp)
je 0x9e6af
movq 0x70(%rsp), %rdi
addq $0x8, %rdi
callq 0x96070
testb $0x1, %al
jne 0x9e64f
jmp 0x9e6af
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl (%rax), %esi
movl $0x5, %edx
callq 0x96da0
movb %al, 0xf(%rsp)
jmp 0x9e672
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x9e6af
jmp 0x9e67c
leaq 0x80(%rsp), %rdi
movl $0x7, %esi
callq 0x98440
jmp 0x9e690
movq 0x60(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x92ce0
leaq 0x80(%rsp), %rdi
callq 0x90790
movb $0x1, 0x256(%rsp)
movl $0x1, 0x224(%rsp)
testb $0x1, 0x256(%rsp)
jne 0x9e6d6
movq 0x60(%rsp), %rdi
callq 0x90790
movq 0x68(%rsp), %rax
addq $0x268, %rsp            # imm = 0x268
retq
movq 0x60(%rsp), %rdi
callq 0x90790
movq 0x248(%rsp), %rdi
callq 0x981c0
nopw (%rax,%rax)