// File: /workspace/github_c_makefile_star2_O1/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 0x3b3c1
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 0x3b3f0
movq 0x110(%rbx), %rcx
cmpq %rcx, %rax
je 0x3b3f0
movq %rcx, 0x8(%rbx)
movq 0x8(%rbx), %rax
movq 0x198(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x28(%rbx), %rdi
movq 0x1b0(%rbx), %rax
movq %rdi, 0x10(%rax)
cmpb $0x1, (%rdi)
movq %rdi, 0x10(%rsp)
jne 0x3b494
testb $0x4, 0x2(%rdi)
movq %rdi, %rdx
jne 0x3b46c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x1, (%rdi)
jne 0x3b46a
movq %rdi, %rsi
movq %rdi, %rcx
movq 0x8(%rsi), %rdx
cmpb $0x1, (%rdx)
jne 0x3b440
testb $0x4, 0x2(%rdx)
jne 0x3b46c
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
jne 0x3b46a
cmpq %rcx, %rsi
je 0x3b46a
movq 0x8(%rsi), %rdx
cmpb $0x1, (%rdx)
jne 0x3b45d
testb $0x4, 0x2(%rdx)
jne 0x3b46c
movq 0x10(%rsi), %rsi
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rsi)
je 0x3b431
jmp 0x3b472
movl 0x28(%rdx), %ecx
movl 0x2c(%rdx), %eax
testl %eax, %eax
jle 0x3b49c
cmpl 0x6d4(%rbx), %eax
je 0x3b49c
movl %eax, 0x6d4(%rbx)
testl %ecx, %ecx
js 0x3b494
cmpl 0x4a4(%rbx), %ecx
jle 0x3b9ad
movq %rbx, %rdi
callq 0x46936
movq 0x50(%rbx), %r13
subq 0x48(%rbx), %r13
sarq $0x3, %r13
cmpq $0x4, %r13
jl 0x3b501
decq %r13
leaq 0x118ef8(%rip), %r15    # 0x1543b0
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 0x3b4f4
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %rbp, %r8
callq *%rax
testb %al, %al
je 0x3b4f4
cmpb $0x1, 0x678(%rbx)
je 0x3bdc9
leaq -0x4(%r13), %rax
cmpq $0x6, %r13
movq %rax, %r13
jg 0x3b4bd
cmpb $0x0, 0xf(%rsp)
jne 0x3b614
movq 0x208(%rbx), %r13
movzbl (%r13), %eax
leaq 0x118e11(%rip), %rcx    # 0x154330
cmpb $0x0, (%rax,%rcx)
je 0x3b605
movq 0x18e0(%rbx), %rsi
movq 0x18(%r13), %rdx
movq %rbx, %rdi
callq 0xcd2c
cmpb $0x1, (%rax)
jne 0x3b614
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 0x3b5a8
movq %rbx, %rdi
callq 0xb389
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 0x10b83
jmp 0x3bc9d
cmpb $0x14, %al
jne 0x3b614
testb $0x20, 0x2(%r13)
jne 0x3b529
movq 0x280(%rbx), %rbp
cmpq $0x1f, %rbp
jg 0x3b62c
movq $0x20, 0x280(%rbx)
movq 0x190(%rbx), %rax
cmpb $0x22, (%rax)
jne 0x3b642
movq 0x8(%rax), %rax
cmpb $0x1, 0x2(%rax)
jne 0x3b650
movq 0x1d8(%rbx), %rax
movq %rax, 0x190(%rbx)
cmpb $0x1, (%r12)
jne 0x3b733
movq 0x8(%r12), %r15
cmpb $0x13, (%r15)
jne 0x3b733
cmpq %r14, 0x18f8(%rbx)
je 0x3b733
movq 0x10(%r15), %rdi
movl $0x7e, %esi
callq 0x91d0
testq %rax, %rax
je 0x3b733
movq 0x8(%r15), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0xa305
movq %rax, %r13
movq (%rax), %r15
movq 0x8(%r12), %rax
movq 0x10(%rax), %rdx
leaq 0xd7b74(%rip), %rsi     # 0x113228
movq %r15, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xd1cb
movq 0x190(%rbx), %rsi
cmpq %rsi, 0x120(%rbx)
je 0x3b6f3
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 0x9d135
addq $0x20, %rsp
movslq 0x8(%r13), %rax
cmpq $0x11, %rax
jne 0x3b9db
movq (%r13), %rdi
testq %rdi, %rdi
je 0x3b717
callq 0x9050
movq $0x0, (%r13)
movl $0x0, 0x8(%r13)
movq 0x838(%rbx), %rax
movq %rax, 0x18(%r13)
movq %r13, 0x838(%rbx)
jmp 0x3b783
movq 0x190(%rbx), %rsi
movq 0x708(%rbx), %rax
movq %r14, 0x8(%rax)
movq 0x710(%rbx), %rax
movq %r12, 0x8(%rax)
cmpq %rsi, 0x120(%rbx)
je 0x3b783
movq 0x708(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd7ab5(%rip), %rdx     # 0x113220
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0x7
pushq $0x1
callq 0x9d135
addq $0x20, %rsp
cmpq $0x1f, %rbp
jg 0x3b790
movq %rbp, 0x280(%rbx)
movq 0x1c0(%rbx), %rax
movq 0x10(%rax), %rax
cmpb $0x13, (%rax)
jne 0x3b890
movq 0x190(%rbx), %rdx
cmpq %rdx, 0x120(%rbx)
je 0x3b7c7
movq 0x8(%rdx), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
movl $0xa, %esi
callq *0x8(%rax)
movq 0x190(%rbx), %r12
movl $0x28, %edx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x469c9
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
cmpq %r12, 0x120(%rbx)
je 0x3b821
movq 0x700(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd7a25(%rip), %rdx     # 0x11322b
movq %rbx, %rdi
movq %r12, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0x8
pushq $0x1
callq 0x9d135
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 0x3bb38
movq 0x708(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd79c1(%rip), %rdx     # 0x113234
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0x11
pushq $0x1
callq 0x9d135
addq $0x20, %rsp
jmp 0x3bb38
movq 0x170(%rbx), %rax
cmpb $0x23, (%rax)
jne 0x3b8b6
movq 0x8(%rax), %rax
movq 0x112731(%rip), %rcx    # 0x14dfd8
movq (%rcx), %rcx
cmpq %rcx, 0x8(%rax)
je 0x3b8b6
cmpb $0x0, 0x2(%rax)
je 0x3b910
movq 0x6b8(%rbx), %rax
testq %rax, %rax
je 0x3bb15
movq $0x0, 0x6b8(%rbx)
cmpq $0x0, 0x6b0(%rbx)
je 0x3bb15
cmpq $0x0, 0x698(%rbx)
js 0x3bb15
cmpb $0x0, (%rax)
je 0x3b9f4
movq $-0x1, %rdx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%rax,%rdx)
movq %rcx, %rdx
jne 0x3b8fd
jmp 0x3b9f6
movq 0x10(%rax), %rdi
movslq 0x20(%rax), %rdx
testq %rdi, %rdi
je 0x3bcbc
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 0x3bb15
movq 0x708(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd78ab(%rip), %rdx     # 0x113246
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0xa
jmp 0x3bb0a
movl %eax, %eax
movq 0x1b8(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x498(%rbx), %rax
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq 0x1c0(%rbx), %rcx
movq %rax, 0x10(%rcx)
jmp 0x3b49c
movq 0x838(%rbx,%rax,8), %rcx
movq %rcx, 0x18(%r13)
movq %r13, 0x838(%rbx,%rax,8)
jmp 0x3b783
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 0x3ba4d
cmpb $0x0, (%rax)
je 0x3ba4d
movq $-0x1, %rdx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%rax,%rdx)
movq %rcx, %rdx
jne 0x3ba3d
jmp 0x3ba4f
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 0x3ba92
leaq 0x112ec4(%rip), %rax    # 0x14e950
movq (%rax,%rbp,8), %rax
jmp 0x3bacb
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x3baaa
movq %rbx, %rdi
callq 0xb389
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 0x3bb15
subq $0x8, %rsp
leaq 0xd7763(%rip), %rdx     # 0x11325d
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0xd
pushq $0x1
callq 0x9d135
addq $0x20, %rsp
movq 0x190(%rbx), %rdx
cmpq %rdx, 0x120(%rbx)
je 0x3bb38
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 0x3bb61
movq 0x2e0(%rbx), %rdi
movq 0x8(%rdi), %rcx
cmpb $0xb, (%rcx)
jne 0x3bbcc
movq 0x8(%rcx), %rsi
jmp 0x3bbce
movq 0x1b0(%rbx), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x3bc91
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
cmpq %rsi, 0x120(%rbx)
je 0x3bbb3
movq 0x700(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd76d0(%rip), %rdx     # 0x11326b
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0x7
pushq $0x1
callq 0x9d135
addq $0x20, %rsp
movq 0x190(%rbx), %rdx
cmpq %rdx, 0x120(%rbx)
jne 0x3bc7e
jmp 0x3bc91
xorl %esi, %esi
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rdx
cmpb $0xb, (%rdx)
jne 0x3bbe1
movq 0x8(%rdx), %rdx
jmp 0x3bbe3
xorl %edx, %edx
movq 0x10(%rcx), %r8
movq 0x8(%r8), %rcx
cmpb $0xb, (%rcx)
jne 0x3bbf6
movq 0x8(%rcx), %rcx
jmp 0x3bbf8
xorl %ecx, %ecx
movq 0x10(%r8), %r8
movq 0x8(%r8), %r8
cmpb $0xb, (%r8)
jne 0x3bc0c
movq 0x8(%r8), %r8
jmp 0x3bc0f
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpb $0x1, (%rdi)
jne 0x3bc2a
incq %r9
movq 0x10(%rdi), %rdi
cmpq $0x4, %r9
jne 0x3bc12
movl $0x4, %r9d
cmpq $0x4, %r9
jne 0x3bc3b
cmpb $0x1, (%rdi)
jne 0x3bc3b
addq $0x8, %rdi
jmp 0x3bc42
leaq 0x110(%rbx), %rdi
xorl %r9d, %r9d
cmpq (%rdi), %rax
setne %r9b
movq %rbx, %rdi
callq 0x45bae
movq 0x8(%rax), %rdx
testq %rdx, %rdx
jle 0x3bc91
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 0x3bddd
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %edx, %edx
jle 0x3bd27
movq 0x1b8(%rbx), %rsi
movq 0x10(%rsi), %rsi
cmpq $0x0, 0x8(%rsi)
jle 0x3bd27
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 0x3bb15
movq 0x700(%rbx), %rcx
subq $0x8, %rsp
leaq 0xd753c(%rip), %rdx     # 0x113251
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0xb
jmp 0x3bb0a
movl 0x184(%rbx), %edx
testl %edx, %edx
je 0x3bb15
movq 0x178(%rbx), %rsi
decl %edx
movq (%rsi,%rdx,8), %rdx
cmpb $0x23, (%rdx)
jne 0x3bb15
movq 0x8(%rdx), %rdx
cmpq %rcx, 0x8(%rdx)
je 0x3bb15
cmpb $0x0, 0x2(%rdx)
jne 0x3bb15
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
je 0x3bb15
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 0x3b971
addq $0x5b0, %rbx            # imm = 0x5B0
movq %rbx, %rdi
movl $0x3, %esi
callq 0x9530
addq $0x5b0, %rbx            # imm = 0x5B0
movq %rbx, %rdi
movl $0x4, %esi
callq 0x9530