// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movb %al, 0xf(%rsp)
orl $-0x1, 0x2188(%rdi)
movb %al, 0x218(%rdi)
movw $0x100, 0x24b(%rdi)     # imm = 0x100
movslq 0x2138(%rdi), %rax
testq %rax, %rax
jle 0x2ce15
movq 0x1f38(%rbx,%rax,8), %rax
andq $-0x401, (%rax)         # imm = 0xFBFF
andl $0x0, 0x2138(%rbx)
movq 0x1a0(%rbx), %rax
movq %r14, 0x10(%rax)
movq 0x1a8(%rbx), %rax
movq %r15, 0x10(%rax)
movq 0x8(%rbx), %rax
cmpb $0x1c, (%rax)
je 0x2ce47
movq 0x110(%rbx), %rcx
cmpq %rcx, %rax
je 0x2ce47
movq %rcx, 0x8(%rbx)
movq %rcx, %rax
movq 0x198(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x28(%rbx), %r12
movq 0x1b0(%rbx), %rax
movq %r12, 0x10(%rax)
cmpb $0x1, (%r12)
jne 0x2cee4
movq (%r12), %rsi
btl $0x12, %esi
movq %r12, %rcx
jb 0x2ceba
movq %r12, %rax
movq %r12, %rdx
cmpb $0x1, %sil
jne 0x2ceec
movq 0x8(%rdx), %rcx
cmpb $0x1, (%rcx)
jne 0x2ce90
testb $0x4, 0x2(%rcx)
jne 0x2ceba
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
jne 0x2ceec
cmpq %rax, %rdx
je 0x2ceec
movq 0x8(%rdx), %rcx
cmpb $0x1, (%rcx)
jne 0x2cead
testb $0x4, 0x2(%rcx)
jne 0x2ceba
movq 0x10(%rdx), %rdx
movq 0x10(%rax), %rax
movb (%rdx), %sil
jmp 0x2ce7b
movslq 0x2c(%rcx), %rax
testq %rax, %rax
jle 0x2ceec
cmpl 0x6d4(%rbx), %eax
je 0x2ceec
movl 0x28(%rcx), %ecx
movl %eax, 0x6d4(%rbx)
testl %ecx, %ecx
js 0x2cee4
cmpl 0x4a4(%rbx), %ecx
jle 0x2d504
movq %rbx, %rdi
callq 0x35fb7
movq %r12, 0x10(%rsp)
movq 0x50(%rbx), %r13
subq 0x48(%rbx), %r13
sarq $0x3, %r13
decq %r13
leaq 0xee4a9(%rip), %r12     # 0x11b3b0
leaq 0xf(%rsp), %rbp
cmpq $0x3, %r13
jl 0x2cf4f
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rax
movq (%rax,%r13,8), %rax
movq (%r12,%rax,8), %rax
testq %rax, %rax
je 0x2cf49
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %rbp, %r8
callq *%rax
testb %al, %al
je 0x2cf49
cmpb $0x1, 0x678(%rbx)
je 0x2d61f
addq $-0x4, %r13
jmp 0x2cf0c
cmpb $0x0, 0xf(%rsp)
jne 0x2d05a
movq 0x208(%rbx), %r13
movzbl (%r13), %eax
leaq 0xee3c3(%rip), %rcx     # 0x11b330
cmpb $0x0, (%rax,%rcx)
je 0x2d04b
movq %rbx, %rdi
movq %r13, %rsi
callq 0x97c7
cmpb $0x1, (%rax)
jne 0x2d05a
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), %r12
cmpq 0x98(%rbx), %rax
ja 0x2cff5
movq %rbx, %rdi
callq 0x9c27
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 %r15, 0x8(%rax)
movq %r12, 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 0xe1a8
jmp 0x2d4e5
cmpb $0x14, %al
jne 0x2d05a
testb $0x20, 0x2(%r13)
jne 0x2cf77
movq 0x280(%rbx), %rbp
cmpq $0x1f, %rbp
jg 0x2d072
movq $0x20, 0x280(%rbx)
movq 0x190(%rbx), %r13
cmpb $0x22, (%r13)
jne 0x2d08a
movq 0x8(%r13), %rax
cmpb $0x1, 0x2(%rax)
jne 0x2d098
movq 0x1d8(%rbx), %r13
movq %r13, 0x190(%rbx)
cmpb $0x1, (%r15)
jne 0x2d11c
movq 0x8(%r15), %r12
cmpb $0x13, (%r12)
jne 0x2d11c
cmpq %r14, 0x18f8(%rbx)
je 0x2d11c
movq 0x10(%r12), %rdi
pushq $0x7e
popq %rsi
callq 0x81d0
testq %rax, %rax
je 0x2d11c
movq 0x8(%r12), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x9037
movq %rax, %r12
movq (%rax), %r13
movq 0x8(%r15), %rax
movq 0x10(%rax), %rdx
leaq 0xa91ee(%rip), %rsi     # 0xd62d8
movq %r13, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xb3a5
movq 0x190(%rbx), %rsi
movq 0x10(%r15), %rcx
movq %rbx, %rdi
movq %r13, %rdx
movq %rax, %r8
callq 0x36047
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9439
jmp 0x2d14f
movq 0x708(%rbx), %rax
movq %r14, 0x8(%rax)
movq 0x710(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x708(%rbx), %rcx
leaq 0xa9190(%rip), %rdx     # 0xd62d0
pushq $0x7
popq %r8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x36047
cmpq $0x1f, %rbp
jg 0x2d15c
movq %rbp, 0x280(%rbx)
movq 0x1c0(%rbx), %rax
movq 0x10(%rax), %rax
cmpb $0x13, (%rax)
jne 0x2d210
movq 0x190(%rbx), %rsi
movq %rbx, %rdi
callq 0x2c000
movq 0x190(%rbx), %r15
pushq $0x28
popq %rdx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x36076
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rcx
leaq 0xa912c(%rip), %rdx     # 0xd62db
pushq $0x8
popq %r8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x36047
movq 0x1c0(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x190(%rbx), %rsi
movq 0x1b8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x708(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq 0x710(%rbx), %rax
movq %rcx, 0x8(%rax)
movq 0x708(%rbx), %rcx
leaq 0xa90e5(%rip), %rdx     # 0xd62e4
pushq $0x11
popq %r8
movq %rbx, %rdi
callq 0x36047
jmp 0x2d3ae
movq 0x170(%rbx), %rax
cmpb $0x23, (%rax)
jne 0x2d236
movq 0x8(%rax), %rax
movq 0xe7db1(%rip), %rcx     # 0x114fd8
movq (%rcx), %rcx
cmpq %rcx, 0x8(%rax)
je 0x2d236
cmpb $0x0, 0x2(%rax)
je 0x2d2b2
movq 0x6b8(%rbx), %rsi
testq %rsi, %rsi
je 0x2d39f
andq $0x0, 0x6b8(%rbx)
cmpq $0x0, 0x6b0(%rbx)
je 0x2d39f
cmpq $0x0, 0x698(%rbx)
js 0x2d39f
movq 0x190(%rbx), %r15
movq %rbx, %rdi
callq 0xd1ba
movq %rax, %r12
movq 0x6b0(%rbx), %rsi
movq %rbx, %rdi
callq 0xd1ba
movq %rax, %r13
movq 0x698(%rbx), %rbp
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0x2d335
leaq 0xe86a7(%rip), %rax     # 0x115950
movq (%rax,%rbp,8), %rax
jmp 0x2d36e
movq 0x10(%rax), %rdi
movslq 0x20(%rax), %rdx
testq %rdi, %rdi
je 0x2d52e
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)
movq 0x708(%rbx), %rcx
leaq 0xa8fca(%rip), %rdx     # 0xd62f6
pushq $0xa
popq %r8
movq %rbx, %rdi
jmp 0x2d39a
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x2d354
movq %rbx, %rdi
callq 0x9c27
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)
leaq 0xa8f7d(%rip), %rdx     # 0xd630d
pushq $0xd
popq %r8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x36047
movq 0x190(%rbx), %rsi
movq %rbx, %rdi
callq 0x2c000
movq 0x120(%rbx), %r15
movq 0x190(%rbx), %rsi
cmpq %r15, %rsi
je 0x2d3dc
movq 0x2e0(%rbx), %rsi
movq 0x8(%rsi), %rax
cmpb $0xb, (%rax)
jne 0x2d429
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2d432
movq 0x1b0(%rbx), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x2d4d9
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rcx
leaq 0xa8f12(%rip), %rdx     # 0xd631b
pushq $0x7
popq %r8
movq %rbx, %rdi
callq 0x36047
movq 0x190(%rbx), %rsi
movq %rbx, %rdi
callq 0x2c000
jmp 0x2d4d9
movq $0x0, 0x10(%rsp)
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rcx
cmpb $0xb, (%rcx)
jne 0x2d445
movq 0x8(%rcx), %r12
jmp 0x2d448
xorl %r12d, %r12d
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
cmpb $0xb, (%rcx)
jne 0x2d45b
movq 0x8(%rcx), %r13
jmp 0x2d45e
xorl %r13d, %r13d
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x2d471
movq 0x8(%rax), %rbp
jmp 0x2d473
xorl %ebp, %ebp
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x2cbf7
xorl %r9d, %r9d
cmpq %rax, %r15
setne %r9b
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
callq 0x355a2
movq 0x8(%rax), %rdx
testq %rdx, %rdx
jle 0x2d4d9
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
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, 0x20(%rbx)
movq $0x1ed, 0x18(%rbx)      # imm = 0x1ED
cmpb $0x1, 0x678(%rbx)
je 0x2d631
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 0x2ceec
testl %edx, %edx
jle 0x2d57d
movq 0x1b8(%rbx), %rsi
movq 0x10(%rsi), %rsi
cmpq $0x0, 0x8(%rsi)
jle 0x2d57d
movq 0x190(%rbx), %rsi
movq 0x1f10(%rbx), %rax
movq %rdx, 0x8(%rax)
movq 0x1f10(%rbx), %rax
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rcx
leaq 0xa8d8b(%rip), %rdx     # 0xd6301
pushq $0xb
jmp 0x2d32e
movl 0x184(%rbx), %edx
testl %edx, %edx
je 0x2d39f
movq 0x178(%rbx), %rsi
decl %edx
movq (%rsi,%rdx,8), %rdx
cmpb $0x23, (%rdx)
jne 0x2d39f
movq 0x8(%rdx), %rdx
cmpq %rcx, 0x8(%rdx)
je 0x2d39f
cmpb $0x0, 0x2(%rdx)
jne 0x2d39f
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
je 0x2d39f
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 0x2d313
addq $0x5b0, %rbx            # imm = 0x5B0
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x8530
addq $0x5b0, %rbx            # imm = 0x5B0
pushq $0x4
jmp 0x2d628