// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_error
s7_pointer s7_error(s7_scheme *sc, s7_pointer type, s7_pointer info)
                {
                    bool reset_error_hook = false;
                    s7_pointer cur_code;

                    /* type is a symbol normally, and info is compatible with format: (apply format #f info) --
                     *    car(info) is the control string, cdr(info) its args
                     *    type/range errors have cadr(info)=caller, caddr(info)=offending arg number
                     *    null info can mean symbol table is locked so make-symbol uses s7_error to get out
                     *
                     * set up (owlet), look for a catch that matches 'type', if found
                     *   call its error-handler, else if *error-hook* is bound, call it,
                     *   else send out the error info ourselves.
                     */
                    sc->format_depth = -1;
                    sc->gc_off = false;             /* this is in case we were triggered from the sort function -- clumsy! */
                    sc->object_out_locked = false;  /* possible error in obj->str method after object_out has set this flag */
                    sc->has_openlets = true;        /*   same problem -- we need a cleaner way to handle this */

                    if (sc->current_safe_list > 0)
                        clear_list_in_use(sc->safe_lists[sc->current_safe_list]);
                    slot_set_value(sc->error_type, type);
                    slot_set_value(sc->error_data, info);

                    if ((unchecked_type(sc->envir) != T_LET) &&
                            (sc->envir != sc->nil))
                        sc->envir = sc->nil;          /* in the reader, the sc->envir stack entry is mostly ignored, so it can be (and usually is) garbage */

                    set_outlet(sc->owlet, sc->envir);

                    cur_code = current_code(sc);
                    slot_set_value(sc->error_code, cur_code);

#if WITH_HISTORY
                    slot_set_value(sc->error_history, sc->cur_code);
                    if (sc->cur_code != sc->history_sink)
                    {
                        sc->cur_code = (sc->using_history1) ? sc->eval_history2 : sc->eval_history1;
                        sc->using_history1 = (!sc->using_history1);
                    }
#endif

                    if (is_pair(cur_code))
                    {
                        int32_t line = -1, file;
                        if (has_line_number(cur_code))
                        {
                            line = (int32_t)pair_line_number(cur_code); /* cast to int32_t (from uint32_t) for sc->last_error_line */
                            file = (int32_t)pair_file(cur_code);
                        }
                        else
                        {
                            /* try to find a plausible line number! */
                            s7_pointer p, sp;
                            for (p = cur_code, sp = cur_code; is_pair(p); p = cdr(p), sp = cdr(sp))
                            {
                                if ((is_pair(car(p))) &&
                                        (has_line_number(car(p))))
                                {
                                    line = (int32_t)pair_line_number(car(p));
                                    file = (int32_t)pair_file(car(p));
                                    break;
                                }
                                p = cdr(p);
                                if ((!is_pair(p)) || (p == sp)) break;
                                if ((is_pair(car(p))) &&
                                        (has_line_number(car(p))))
                                {
                                    line = (int32_t)pair_line_number(car(p));
                                    file = (int32_t)pair_file(car(p));
                                    break;
                                }
                            }
                        }
                        if ((line > 0) &&
                                (line != sc->last_error_line))
                        {
                            sc->last_error_line = line;
#if S7_DEBUGGING
                            if (file > sc->file_names_top)
                            {
                                char *s;
                                fprintf(stderr, "line_number file: %d (top: %d), bits: %s\n", file, sc->file_names_top, s = describe_type_bits(sc, cur_code));
                                free(s);
                                if (sc->stop_at_error) abort();
                            }
#endif
                            if ((line > 0) &&
                                    (file >= 0) &&
                                    (file <= sc->file_names_top))
                            {
                                integer(slot_value(sc->error_line)) = line;
                                slot_set_value(sc->error_file, sc->file_names[file]);
                            }
                            else fill_error_location(sc);
                        }
                    }
                    else fill_error_location(sc);

                    { /* look for a catcher */
                        int64_t i;
                        /* top is 1 past actual top, top - 1 is op, if op = OP_CATCH, top - 4 is the cell containing the catch struct */
                        for (i = s7_stack_top(sc) - 1; i >= 3; i -= 4)
                        {
                            catch_function catcher;
                            catcher = catchers[stack_op(sc->stack, i)];
                            if ((catcher) &&
                                    (catcher(sc, i, type, info, &reset_error_hook)))
                            {
                                if (sc->longjmp_ok) longjmp(sc->goto_start, CATCH_JUMP);
                                /* all the rest of the code expects s7_error to jump, not return, so presumably if we get here, we're in trouble */
#if S7_DEBUGGING
                                fprintf(stderr, "fall through in s7_error!\n");
#endif
                            }
                        }
                    }

                    /* error not caught */
                    /* (set! *error-hook* (list (lambda (hook) (apply format #t (hook 'args))))) */

                    if ((!reset_error_hook) &&
                            (is_procedure(sc->error_hook)) &&
                            (hook_has_functions(sc->error_hook)))
                    {
                        s7_pointer error_hook_func;
                        /* (set! (hook-functions *error-hook*) (list (lambda (h) (format *stderr* "got error ~A~%" (h 'args))))) */

                        error_hook_func = sc->error_hook;
                        sc->error_hook = sc->nil;
                        /* if the *error-hook* functions trigger an error, we had better not have *error-hook* still set! */

                        push_stack(sc, OP_ERROR_HOOK_QUIT, sc->nil, error_hook_func); /* restore *error-hook* upon successful (or any!) evaluation */
                        sc->code = error_hook_func;
                        sc->args = list_2(sc, type, info);

                        /* if we drop into the longjmp below, the hook functions are not called!
                         *   OP_ERROR_HOOK_QUIT performs the longjmp, so it should be safe to go to eval.
                         */
                        eval(sc, OP_APPLY);
                    }
                    else
                    {
                        s7_int op;
                        op = sc->print_length;
                        if (op < 32) sc->print_length = 32;

                        if ((!is_output_port(sc->error_port)) || /* error-port can be #f */
                                (port_is_closed(sc->error_port)))
                            sc->error_port = sc->standard_error;
                        /* if info is not a list, send object->string to current error port,
                         *   else assume car(info) is a format control string, and cdr(info) are its args
                         * if at all possible, get some indication of where we are!
                         */
                        if ((!is_pair(info)) ||
                                (!is_string(car(info))))
                            format_to_port(sc, sc->error_port, "\n;~S ~S", set_plist_2(sc, type, info), false, 7);
                        else
                        {
                            /* it's possible that the error string is just a string -- not intended for format */
                            if ((type != sc->format_error_symbol) &&      /* avoid an infinite loop of format errors */
                                    (strchr(string_value(car(info)), '~')))
                            {
                                char *errstr;
                                block_t *b;
                                s7_int len, str_len;
                                len = string_length(car(info)) + 8;
                                b = mallocate(sc, len);
                                errstr = (char *)block_data(b);
                                str_len = catstrs_direct(errstr, "\n;", string_value(car(info)), NULL);
                                format_to_port(sc, sc->error_port, errstr, cdr(info), false, str_len);
                                liberate(sc, b);
                            }
                            else format_to_port(sc, sc->error_port, "\n;~S ~S", set_plist_2(sc, type, info), false, 7); /* 7 = ctrl str len */
                        }
                        if (op < 32) sc->print_length = op;

                        /* now display location at end */

                        if (is_string(slot_value(sc->error_file)))
                        {
                            s7_newline(sc, sc->error_port);
                            format_to_port(sc, sc->error_port, ";    ~A\n",
                                    set_plist_1(sc, object_to_truncated_string(sc, cur_code, 40)),
                                    false, 8);
                            format_to_port(sc, sc->error_port, ";    ~A, line ~D\n",
                                    set_plist_2(sc, slot_value(sc->error_file), slot_value(sc->error_line)),
                                    false, 17);
                        }
                        else
                        {
                            if ((is_input_port(sc->input_port)) &&
                                    (port_file(sc->input_port) != stdin) &&
                                    (!port_is_closed(sc->input_port)))
                            {
                                const char *filename;
                                int32_t line;

                                filename = port_filename(sc->input_port);
                                line = port_line_number(sc->input_port);

                                if (filename)
                                    format_to_port(sc, sc->error_port, "\n;  ~A[~D]",
                                            set_plist_2(sc, wrap_string(sc, filename, port_filename_length(sc->input_port)),
                                                wrap_integer3(sc, line)), false, 10);
                                else
                                {
                                    if ((line > 0) &&
                                            (integer(slot_value(sc->error_line)) > 0))
                                        format_to_port(sc, sc->error_port, "\n;  line ~D", set_plist_1(sc, wrap_integer3(sc, line)), false, 11);
                                    else
                                    {
                                        if (sc->input_port_stack_loc > 0)
                                        {
                                            s7_pointer p;
                                            p = sc->input_port_stack[sc->input_port_stack_loc - 1];
                                            if ((is_input_port(p)) &&
                                                    (port_file(p) != stdin) &&
                                                    (!port_is_closed(p)))
                                            {
                                                filename = port_filename(p);
                                                line = port_line_number(p);
                                                if (filename)
                                                    format_to_port(sc, sc->error_port, "\n;  ~A[~D]",
                                                            set_plist_2(sc, wrap_string(sc, filename, port_filename_length(sc->input_port)),
                                                                wrap_integer3(sc, line)), false, 10);
                                            }}}}
                            }
                            else
                            {
                                const char *call_name;
                                call_name = sc->s7_call_name;
                                if (call_name)
                                {
                                    sc->s7_call_name = NULL;
                                    if ((sc->s7_call_file) &&
                                            (sc->s7_call_line >= 0))
                                    {
                                        format_to_port(sc, sc->error_port, "\n;  ~A ~A[~D]",
                                                set_plist_3(sc,
                                                    s7_make_string_wrapper(sc, call_name),
                                                    s7_make_string_wrapper(sc, sc->s7_call_file),
                                                    make_integer(sc, sc->s7_call_line)),
                                                false, 13);
                                    }
                                }
                            }
                            s7_newline(sc, sc->error_port);
                        }

                        /* look for __func__ in the error environment etc */
                        if (sc->error_port != sc->F)
                        {
                            s7_pointer errp;
                            errp = stacktrace_1(sc,
                                    s7_integer(car(sc->stacktrace_defaults)),
                                    s7_integer(cadr(sc->stacktrace_defaults)),
                                    s7_integer(caddr(sc->stacktrace_defaults)),
                                    s7_integer(cadddr(sc->stacktrace_defaults)),
                                    s7_boolean(sc, s7_list_ref(sc, sc->stacktrace_defaults, 4)));
                            if (string_length(errp) > 0)
                            {
                                port_write_string(sc->error_port)(sc, string_value(errp), string_length(errp), sc->error_port);
                                port_write_character(sc->error_port)(sc, '\n', sc->error_port);
                            }
                        }
                        else
                        {
                            if (is_pair(slot_value(sc->error_code)))
                            {
                                format_to_port(sc, sc->error_port, ";    ~S", set_plist_1(sc, slot_value(sc->error_code)), false, 7);
                                s7_newline(sc, sc->error_port);
                            }
                        }

                        /* if (is_continuation(type))
                         *   go into repl here with access to continuation?  Or expect *error-handler* to deal with it?
                         */
                        sc->value = type;
                        sc->cur_op = OP_ERROR_QUIT;
                    }

                    if (sc->longjmp_ok) longjmp(sc->goto_start, ERROR_JUMP);
                    return(type);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movb %al, 0xf(%rsp)
movl $0xffffffff, 0x2188(%rdi) # imm = 0xFFFFFFFF
movb %al, 0x218(%rdi)
movw $0x100, 0x24b(%rdi)     # imm = 0x100
movslq 0x2138(%rdi), %rax
testq %rax, %rax
jle 0x38e55
movq 0x1f38(%rbx,%rax,8), %rax
andq $-0x401, (%rax)         # imm = 0xFBFF
movl $0x0, 0x2138(%rbx)
movq 0x1a0(%rbx), %rax
movq %r14, 0x10(%rax)
movq 0x1a8(%rbx), %rax
movq %r12, 0x10(%rax)
movq 0x8(%rbx), %rax
cmpb $0x1c, (%rax)
je 0x38e87
movq 0x110(%rbx), %rcx
cmpq %rcx, %rax
je 0x38e87
movq %rcx, 0x8(%rbx)
movq %rcx, %rax
movq 0x198(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x28(%rbx), %r15
movq 0x1b0(%rbx), %rax
movq %r15, 0x10(%rax)
cmpb $0x1, (%r15)
jne 0x38f22
movq (%r15), %rax
btl $0x12, %eax
movq %r15, %rcx
jb 0x38ef8
cmpb $0x1, %al
jne 0x38f2a
movq %r15, %rdx
movq %r15, %rax
movq 0x8(%rdx), %rcx
cmpb $0x1, (%rcx)
jne 0x38ecc
testb $0x4, 0x2(%rcx)
jne 0x38ef8
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
jne 0x38f2a
cmpq %rax, %rdx
je 0x38f2a
movq 0x8(%rdx), %rcx
cmpb $0x1, (%rcx)
jne 0x38ee9
testb $0x4, 0x2(%rcx)
jne 0x38ef8
movq 0x10(%rdx), %rdx
movq 0x10(%rax), %rax
cmpb $0x1, (%rdx)
je 0x38ebd
jmp 0x38f2a
movslq 0x2c(%rcx), %rax
testq %rax, %rax
jle 0x38f2a
cmpl 0x6d4(%rbx), %eax
je 0x38f2a
movl 0x28(%rcx), %ecx
movl %eax, 0x6d4(%rbx)
testl %ecx, %ecx
js 0x38f22
cmpl 0x4a4(%rbx), %ecx
jle 0x39707
movq %rbx, %rdi
callq 0x43e8e
movq %r15, 0x10(%rsp)
movq 0x50(%rbx), %r13
subq 0x48(%rbx), %r13
sarq $0x3, %r13
cmpq $0x4, %r13
jl 0x38f9f
decq %r13
leaq 0x113465(%rip), %r15    # 0x14c3b0
leaq 0xf(%rsp), %rbp
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rax
movq (%rax,%r13,8), %rax
movq (%r15,%rax,8), %rax
testq %rax, %rax
je 0x38f87
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %rbp, %r8
callq *%rax
testb %al, %al
je 0x38f87
cmpb $0x1, 0x678(%rbx)
je 0x3983e
leaq -0x4(%r13), %rax
cmpq $0x6, %r13
movq %rax, %r13
jg 0x38f50
testb $0x1, 0xf(%rsp)
jne 0x390a7
movq 0x208(%rbx), %r13
movzbl (%r13), %eax
leaq 0x11337e(%rip), %rcx    # 0x14c330
cmpb $0x0, (%rax,%rcx)
je 0x39098
movq 0x18e0(%rbx), %rsi
movq 0x18(%r13), %rdx
movq %rbx, %rdi
callq 0xbe9a
cmpb $0x1, (%rax)
jne 0x390a7
movq 0x50(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x208(%rbx)
movq %r13, (%rax)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x1f0, 0x18(%rax)      # imm = 0x1F0
addq $0x20, 0x50(%rbx)
movq %r13, (%rbx)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r15
cmpq 0x98(%rbx), %rax
ja 0x39042
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r14, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %rdx, 0x10(%rbx)
movl $0x198, %esi            # imm = 0x198
movq %rbx, %rdi
callq 0xfd85
jmp 0x396e8
cmpb $0x14, %al
jne 0x390a7
testb $0x20, 0x2(%r13)
jne 0x38fbc
movq 0x280(%rbx), %rbp
cmpq $0x1f, %rbp
jg 0x390bf
movq $0x20, 0x280(%rbx)
movq 0x190(%rbx), %r13
cmpb $0x22, (%r13)
jne 0x390d7
movq 0x8(%r13), %rax
cmpb $0x1, 0x2(%rax)
jne 0x390e5
movq 0x1d8(%rbx), %r13
movq %r13, 0x190(%rbx)
cmpb $0x1, (%r12)
jne 0x391c0
movq 0x8(%r12), %r15
cmpb $0x13, (%r15)
jne 0x391c0
cmpq %r14, 0x18f8(%rbx)
je 0x391c0
movq 0x10(%r15), %rdi
movl $0x7e, %esi
callq 0x81d0
testq %rax, %rax
je 0x391c0
movq 0x8(%r15), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x9357
movq %rax, %r13
movq (%rax), %r15
movq 0x8(%r12), %rax
movq 0x10(%rax), %rdx
leaq 0xd11ef(%rip), %rsi     # 0x10a338
movq %r15, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xc442
movq 0x190(%rbx), %rsi
cmpq %rsi, 0x120(%rbx)
je 0x39188
movq 0x10(%r12), %rcx
subq $0x8, %rsp
movq %rbx, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq %rax
pushq $0x1
callq 0x969ef
addq $0x20, %rsp
movslq 0x8(%r13), %rax
cmpq $0x11, %rax
jne 0x39435
movq (%r13), %rdi
testq %rdi, %rdi
je 0x391ac
callq 0x8050
movq $0x0, (%r13)
movl $0x0, 0x8(%r13)
leaq 0x838(%rbx), %rax
jmp 0x3943f
movq 0x708(%rbx), %rax
movq %r14, 0x8(%rax)
movq 0x710(%rbx), %rax
movq %r12, 0x8(%rax)
cmpq %r13, 0x120(%rbx)
je 0x3920c
movq 0x708(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd113f(%rip), %rdx     # 0x10a330
movq %rbx, %rdi
movq %r13, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0x7
pushq $0x1
callq 0x969ef
addq $0x20, %rsp
cmpq $0x1f, %rbp
jg 0x39219
movq %rbp, 0x280(%rbx)
movq 0x1c0(%rbx), %rax
movq 0x10(%rax), %rax
cmpb $0x13, (%rax)
jne 0x3931d
movq 0x190(%rbx), %r12
cmpq %r12, 0x120(%rbx)
je 0x3925b
movq 0x8(%r12), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
movl $0xa, %esi
movq %r12, %rdx
callq *0x8(%rax)
movq 0x190(%rbx), %r12
movq 0x10(%rsp), %rsi
movl $0x28, %edx
movq %rbx, %rdi
callq 0x43f21
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
cmpq %r12, 0x120(%rbx)
je 0x392ae
movq 0x700(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd10a8(%rip), %rdx     # 0x10a33b
movq %rbx, %rdi
movq %r12, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0x8
pushq $0x1
callq 0x969ef
addq $0x20, %rsp
movq 0x190(%rbx), %rsi
movq 0x1b8(%rbx), %rax
movq 0x1c0(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rax), %rax
movq 0x708(%rbx), %rdx
movq %rcx, 0x8(%rdx)
movq 0x710(%rbx), %rcx
movq %rax, 0x8(%rcx)
cmpq %rsi, 0x120(%rbx)
je 0x3958d
movq 0x708(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd1044(%rip), %rdx     # 0x10a344
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0x11
pushq $0x1
callq 0x969ef
addq $0x20, %rsp
jmp 0x3958d
movq 0x170(%rbx), %rax
cmpb $0x23, (%rax)
jne 0x39343
movq 0x8(%rax), %rax
movq 0x10cca4(%rip), %rcx    # 0x145fd8
movq (%rcx), %rcx
cmpq %rcx, 0x8(%rax)
je 0x39343
cmpb $0x0, 0x2(%rax)
je 0x39398
movq 0x6b8(%rbx), %rax
testq %rax, %rax
je 0x3956a
movq $0x0, 0x6b8(%rbx)
cmpq $0x0, 0x6b0(%rbx)
je 0x3956a
cmpq $0x0, 0x698(%rbx)
js 0x3956a
cmpb $0x0, (%rax)
je 0x3944e
xorl %edx, %edx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%rax,%rdx)
movq %rcx, %rdx
jne 0x39385
jmp 0x39450
movq 0x10(%rax), %rdi
movslq 0x20(%rax), %rdx
testq %rdi, %rdi
je 0x39731
movq 0x190(%rbx), %rsi
movq 0x30(%rax), %rax
movq 0x820(%rbx), %rcx
movslq 0x7dc(%rbx), %r8
movq (%rcx,%r8,8), %rcx
incl %r8d
andl $0x7, %r8d
movl %r8d, 0x7dc(%rbx)
movq %rdi, 0x10(%rcx)
movq %rax, 0x8(%rcx)
movq 0x1f10(%rbx), %rax
movq %rdx, 0x8(%rax)
movq 0x1f10(%rbx), %rax
movq 0x708(%rbx), %rdx
movq %rcx, 0x8(%rdx)
movq 0x710(%rbx), %rcx
movq %rax, 0x8(%rcx)
cmpq %rsi, 0x120(%rbx)
je 0x3956a
movq 0x708(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd0f33(%rip), %rdx     # 0x10a356
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0xa
jmp 0x3955f
leaq (%rbx,%rax,8), %rax
addq $0x838, %rax            # imm = 0x838
movq (%rax), %rcx
movq %rcx, 0x18(%r13)
movq %r13, (%rax)
jmp 0x3920c
xorl %ecx, %ecx
movq 0x190(%rbx), %r15
movq 0x820(%rbx), %rdx
movslq 0x7dc(%rbx), %rsi
movq (%rdx,%rsi,8), %r12
leal 0x1(%rsi), %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rbx)
movq %rax, 0x10(%r12)
movq %rcx, 0x8(%r12)
movq 0x6b0(%rbx), %rax
testq %rax, %rax
je 0x394a2
cmpb $0x0, (%rax)
je 0x394a2
xorl %edx, %edx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%rax,%rdx)
movq %rcx, %rdx
jne 0x39492
jmp 0x394a4
xorl %ecx, %ecx
movq 0x820(%rbx), %rdx
movslq 0x7dc(%rbx), %rsi
movq (%rdx,%rsi,8), %r13
leal 0x1(%rsi), %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rbx)
movq %rax, 0x10(%r13)
movq %rcx, 0x8(%r13)
movq 0x698(%rbx), %rbp
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0x394e7
leaq 0x10d46f(%rip), %rax    # 0x146950
movq (%rax,%rbp,8), %rax
jmp 0x39520
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x39506
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %rbp, 0x8(%rax)
movq 0x718(%rbx), %rcx
movq %r12, 0x8(%rcx)
movq 0x10(%rcx), %rdx
movq %r13, 0x8(%rdx)
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
cmpq %r15, 0x120(%rbx)
je 0x3956a
subq $0x8, %rsp
leaq 0xd0e1e(%rip), %rdx     # 0x10a36d
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0xd
pushq $0x1
callq 0x969ef
addq $0x20, %rsp
movq 0x190(%rbx), %rdx
cmpq %rdx, 0x120(%rbx)
je 0x3958d
movq 0x8(%rdx), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
movl $0xa, %esi
callq *0x8(%rax)
movq 0x120(%rbx), %rax
movq 0x190(%rbx), %rsi
cmpq %rax, %rsi
je 0x395b6
movq 0x2e0(%rbx), %rdi
movq 0x8(%rdi), %rcx
cmpb $0xb, (%rcx)
jne 0x39624
movq 0x8(%rcx), %rsi
jmp 0x39626
movq 0x1b0(%rbx), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x396dc
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
cmpq %rsi, 0x120(%rbx)
je 0x3960f
movq 0x700(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd0d8b(%rip), %rdx     # 0x10a37b
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0x7
pushq $0x1
callq 0x969ef
addq $0x20, %rsp
movq 0x120(%rbx), %rsi
movq 0x190(%rbx), %rdx
cmpq %rdx, %rsi
jne 0x396c9
jmp 0x396dc
xorl %esi, %esi
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rdx
cmpb $0xb, (%rdx)
jne 0x39639
movq 0x8(%rdx), %rdx
jmp 0x3963b
xorl %edx, %edx
movq 0x10(%rcx), %r8
movq 0x8(%r8), %rcx
cmpb $0xb, (%rcx)
jne 0x3964e
movq 0x8(%rcx), %rcx
jmp 0x39650
xorl %ecx, %ecx
movq 0x10(%r8), %r8
movq 0x8(%r8), %r8
cmpb $0xb, (%r8)
jne 0x39664
movq 0x8(%r8), %r8
jmp 0x39667
xorl %r8d, %r8d
movl $0x4, %r9d
cmpb $0x1, (%rdi)
jne 0x39686
movq 0x10(%rdi), %rdi
decq %r9
jne 0x3966d
cmpb $0x1, (%rdi)
jne 0x39686
addq $0x8, %rdi
jmp 0x3968d
leaq 0x110(%rbx), %rdi
xorl %r9d, %r9d
cmpq (%rdi), %rax
setne %r9b
movq %rbx, %rdi
callq 0x4308a
movq 0x8(%rax), %rdx
testq %rdx, %rdx
jle 0x396dc
movq 0x190(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x48(%rsi), %r8
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq *0x10(%r8)
movq 0x190(%rbx), %rdx
movq 0x8(%rdx), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
movl $0xa, %esi
callq *0x8(%rax)
movq %r14, 0x20(%rbx)
movq $0x1ed, 0x18(%rbx)      # imm = 0x1ED
cmpb $0x1, 0x678(%rbx)
je 0x39852
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1b8(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x498(%rbx), %rax
movq (%rax,%rcx,8), %rax
movq 0x1c0(%rbx), %rcx
movq %rax, 0x10(%rcx)
jmp 0x38f2a
testl %edx, %edx
jle 0x3979c
movq 0x1b8(%rbx), %rsi
movq 0x10(%rsi), %rsi
cmpq $0x0, 0x8(%rsi)
jle 0x3979c
movq 0x190(%rbx), %rsi
movq 0x1f10(%rbx), %rax
movq %rdx, 0x8(%rax)
movq 0x1f10(%rbx), %rax
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
cmpq %rsi, 0x120(%rbx)
je 0x3956a
movq 0x700(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd0bd7(%rip), %rdx     # 0x10a361
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0xb
jmp 0x3955f
movl 0x184(%rbx), %edx
testl %edx, %edx
je 0x3956a
movq 0x178(%rbx), %rsi
decl %edx
movq (%rsi,%rdx,8), %rdx
cmpb $0x23, (%rdx)
jne 0x3956a
movq 0x8(%rdx), %rdx
cmpq %rcx, 0x8(%rdx)
je 0x3956a
cmpb $0x0, 0x2(%rdx)
jne 0x3956a
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
je 0x3956a
movslq 0x20(%rdx), %rdx
movq 0x190(%rbx), %rsi
movq 0x30(%rax), %rax
movq 0x820(%rbx), %rdi
movslq 0x7dc(%rbx), %r8
movq (%rdi,%r8,8), %rdi
incl %r8d
andl $0x7, %r8d
movl %r8d, 0x7dc(%rbx)
movq %rcx, 0x10(%rdi)
movq %rax, 0x8(%rdi)
movq 0x1f10(%rbx), %rax
movq %rdx, 0x8(%rax)
movq 0x1f10(%rbx), %rax
movq 0x708(%rbx), %rcx
movq %rdi, 0x8(%rcx)
jmp 0x393f9
addq $0x5b0, %rbx            # imm = 0x5B0
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8530
addq $0x5b0, %rbx            # imm = 0x5B0
movq %rbx, %rdi
movl $0x4, %esi
callq 0x8530