// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq %rdx, 0x1f0(%rsp)
movb $0x0, 0x1ef(%rsp)
movq 0x200(%rsp), %rax
movl $0xffffffff, 0x2188(%rax) # imm = 0xFFFFFFFF
movq 0x200(%rsp), %rax
movb $0x0, 0x218(%rax)
movq 0x200(%rsp), %rax
movb $0x0, 0x24b(%rax)
movq 0x200(%rsp), %rax
movb $0x1, 0x24c(%rax)
movq 0x200(%rsp), %rax
cmpl $0x0, 0x2138(%rax)
jle 0x2f9f9
jmp 0x2f9b9
movq 0x200(%rsp), %rax
movq 0x200(%rsp), %rcx
movslq 0x2138(%rcx), %rcx
movq 0x1f38(%rax,%rcx,8), %rax
movq (%rax), %rcx
andq $-0x401, %rcx           # imm = 0xFBFF
movq %rcx, (%rax)
movq 0x200(%rsp), %rax
movl $0x0, 0x2138(%rax)
jmp 0x2f9f9
movq 0x1f8(%rsp), %rcx
movq 0x200(%rsp), %rax
movq 0x1a0(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x1f0(%rsp), %rcx
movq 0x200(%rsp), %rax
movq 0x1a8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x200(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
je 0x2fa7b
movq 0x200(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x200(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x2fa7b
movq 0x200(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x200(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x200(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x200(%rsp), %rax
movq 0x198(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x200(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rcx
movq 0x200(%rsp), %rax
movq 0x1b0(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x1e0(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2fd4e
movl $0xffffffff, 0x1dc(%rsp) # imm = 0xFFFFFFFF
movq 0x1e0(%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0x2fb28
movq 0x1e0(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x1dc(%rsp)
movq 0x1e0(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x1d8(%rsp)
jmp 0x2fc85
movq 0x1e0(%rsp), %rax
movq %rax, 0x1d0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x1c8(%rsp)
movq 0x1d0(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2fc83
movq 0x1d0(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2fbbc
movq 0x1d0(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0x2fbbc
movq 0x1d0(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x1dc(%rsp)
movq 0x1d0(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x28(%rax), %eax
movl %eax, 0x1d8(%rsp)
jmp 0x2fc83
movq 0x1d0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1d0(%rsp)
movq 0x1d0(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2fbf2
movq 0x1d0(%rsp), %rax
cmpq 0x1c8(%rsp), %rax
jne 0x2fbf7
jmp 0x2fc83
movq 0x1d0(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2fc54
movq 0x1d0(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0x2fc54
movq 0x1d0(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x1dc(%rsp)
movq 0x1d0(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x28(%rax), %eax
movl %eax, 0x1d8(%rsp)
jmp 0x2fc83
jmp 0x2fc56
movq 0x1d0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1d0(%rsp)
movq 0x1c8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1c8(%rsp)
jmp 0x2fb48
jmp 0x2fc85
cmpl $0x0, 0x1dc(%rsp)
jle 0x2fd4c
movl 0x1dc(%rsp), %eax
movq 0x200(%rsp), %rcx
cmpl 0x6d4(%rcx), %eax
je 0x2fd4c
movl 0x1dc(%rsp), %ecx
movq 0x200(%rsp), %rax
movl %ecx, 0x6d4(%rax)
cmpl $0x0, 0x1dc(%rsp)
jle 0x2fd3d
cmpl $0x0, 0x1d8(%rsp)
jl 0x2fd3d
movl 0x1d8(%rsp), %eax
movq 0x200(%rsp), %rcx
cmpl 0x4a4(%rcx), %eax
jg 0x2fd3d
movslq 0x1dc(%rsp), %rcx
movq 0x200(%rsp), %rax
movq 0x1b8(%rax), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x200(%rsp), %rax
movq 0x498(%rax), %rax
movslq 0x1d8(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x200(%rsp), %rax
movq 0x1c0(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x2fd4a
movq 0x200(%rsp), %rdi
callq 0x45c00
jmp 0x2fd4c
jmp 0x2fd5b
movq 0x200(%rsp), %rdi
callq 0x45c00
movq 0x200(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x200(%rsp), %rcx
movq 0x48(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
subq $0x1, %rax
movq %rax, 0x1c0(%rsp)
cmpq $0x3, 0x1c0(%rsp)
jl 0x2fe4e
movq 0x200(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x1c0(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0x1ec128(%rip), %rax    # 0x21bee0
movq (%rax,%rcx,8), %rax
movq %rax, 0x1b8(%rsp)
cmpq $0x0, 0x1b8(%rsp)
je 0x2fe33
movq 0x1b8(%rsp), %rax
movq 0x200(%rsp), %rdi
movq 0x1c0(%rsp), %rsi
movq 0x1f8(%rsp), %rdx
movq 0x1f0(%rsp), %rcx
leaq 0x1ef(%rsp), %r8
callq *%rax
testb $0x1, %al
jne 0x2fe07
jmp 0x2fe33
movq 0x200(%rsp), %rax
testb $0x1, 0x678(%rax)
je 0x2fe31
movq 0x200(%rsp), %rdi
addq $0x5b0, %rdi            # imm = 0x5B0
movl $0x3, %esi
callq 0x9530
jmp 0x2fe33
jmp 0x2fe35
movq 0x1c0(%rsp), %rax
subq $0x4, %rax
movq %rax, 0x1c0(%rsp)
jmp 0x2fd86
testb $0x1, 0x1ef(%rsp)
jne 0x300cc
movq 0x200(%rsp), %rax
movq 0x208(%rax), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1ebfe9(%rip), %rax    # 0x21be60
testb $0x1, (%rax,%rcx)
jne 0x2feba
movq 0x200(%rsp), %rax
movq 0x208(%rax), %rax
movzbl (%rax), %eax
cmpl $0x14, %eax
jne 0x300cc
movq 0x200(%rsp), %rax
movq 0x208(%rax), %rax
movq (%rax), %rax
andq $0x200000, %rax         # imm = 0x200000
cmpq $0x0, %rax
je 0x300cc
movq 0x200(%rsp), %rdi
movq 0x200(%rsp), %rax
movq 0x208(%rax), %rsi
callq 0xba20
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x300cc
movq 0x200(%rsp), %rax
movq 0x208(%rax), %rax
movq %rax, 0x1b0(%rsp)
movq 0x200(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x200(%rsp), %rax
movq %rcx, 0x208(%rax)
movq 0x1b0(%rsp), %rcx
movq 0x200(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x200(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x200(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x200(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x200(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x200(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1f0, %ecx            # imm = 0x1F0
movq %rcx, 0x18(%rax)
movq 0x200(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x1b0(%rsp), %rcx
movq 0x200(%rsp), %rax
movq %rcx, (%rax)
movq 0x200(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x1f8(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x1f0(%rsp), %rax
movq %rax, 0x1a0(%rsp)
movq 0x200(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x198(%rsp)
movq 0x200(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x200(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x30019
movq 0x200(%rsp), %rdi
callq 0xc670
movq 0x200(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x1a8(%rsp)
movq 0x1a8(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x118(%rsp), %rsi
movq 0x110(%rsp), %rdi
movq 0x1a0(%rsp), %rcx
movq 0x1a8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x198(%rsp), %rcx
movq 0x1a8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x1a8(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0x190(%rsp), %rdx
callq 0xd9f0
movq %rax, %rcx
movq 0x200(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x200(%rsp), %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x163d0
jmp 0x30d19
movq 0x200(%rsp), %rax
movq 0x280(%rax), %rax
movq %rax, 0x188(%rsp)
cmpq $0x20, 0x188(%rsp)
jge 0x30101
movq 0x200(%rsp), %rax
movq $0x20, 0x280(%rax)
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x30131
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x3014f
movq 0x200(%rsp), %rax
movq 0x1d8(%rax), %rcx
movq 0x200(%rsp), %rax
movq %rcx, 0x190(%rax)
movq 0x1f0(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x30173
movq 0x1f0(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x301e4
movq 0x200(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq %rax, 0x108(%rsp)
movq 0x200(%rsp), %rdi
movq 0x1f8(%rsp), %rsi
movq 0x1f0(%rsp), %rdx
callq 0x36f70
movq 0x100(%rsp), %rdi
movq 0x108(%rsp), %rsi
movq %rax, %rcx
leaq 0x1b1c47(%rip), %rdx    # 0x1e1e18
xorl %r8d, %r8d
movl $0x7, %r9d
callq 0x45ce0
jmp 0x30363
movq 0x1f8(%rsp), %rax
movq 0x200(%rsp), %rcx
cmpq 0x18f8(%rcx), %rax
je 0x302f5
movq 0x1f0(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movl $0x7e, %esi
callq 0x91d0
cmpq $0x0, %rax
je 0x302f5
movq 0x1f0(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
addq $0x8, %rax
movq %rax, 0x170(%rsp)
movq 0x200(%rsp), %rdi
movq 0x170(%rsp), %rsi
callq 0xaa80
movq %rax, 0x178(%rsp)
movq 0x178(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x180(%rsp)
movq 0x180(%rsp), %rdi
movq 0x1f0(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
leaq 0x1b1b90(%rip), %rsi    # 0x1e1e20
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x10540
movq %rax, 0x168(%rsp)
movq 0x200(%rsp), %rdi
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rsi
movq 0x180(%rsp), %rdx
movq 0x1f0(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x168(%rsp), %r9
xorl %r8d, %r8d
callq 0x45ce0
movq 0x200(%rsp), %rdi
movq 0x178(%rsp), %rsi
callq 0xb230
jmp 0x30361
movq 0x200(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq %rax, 0xf8(%rsp)
movq 0x200(%rsp), %rdi
movq 0x1f8(%rsp), %rsi
movq 0x1f0(%rsp), %rdx
callq 0x36f70
movq 0xf0(%rsp), %rdi
movq 0xf8(%rsp), %rsi
movq %rax, %rcx
leaq 0x1b1ac5(%rip), %rdx    # 0x1e1e18
xorl %r8d, %r8d
movl $0x7, %r9d
callq 0x45ce0
jmp 0x30363
cmpq $0x20, 0x188(%rsp)
jge 0x30385
movq 0x188(%rsp), %rcx
movq 0x200(%rsp), %rax
movq %rcx, 0x280(%rax)
movq 0x200(%rsp), %rax
movq 0x1c0(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
jne 0x304d0
movq 0x200(%rsp), %rdi
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rsi
callq 0x2d390
movq 0x200(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq %rax, 0xd8(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0x200(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movl $0x28, %edx
callq 0x45d90
movq 0xc8(%rsp), %rdi
movq %rax, %rsi
callq 0x35ea0
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
movq %rax, %rcx
leaq 0x1b19e8(%rip), %rdx    # 0x1e1e23
xorl %r8d, %r8d
movl $0x8, %r9d
callq 0x45ce0
movq 0x200(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq %rax, 0xe8(%rsp)
movq 0x200(%rsp), %rdi
movq 0x200(%rsp), %rax
movq 0x1c0(%rax), %rax
movq 0x10(%rax), %rsi
movq 0x200(%rsp), %rax
movq 0x1b8(%rax), %rax
movq 0x10(%rax), %rdx
callq 0x36f70
movq 0xe0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq %rax, %rcx
leaq 0x1b196f(%rip), %rdx    # 0x1e1e2c
xorl %r8d, %r8d
movl $0x11, %r9d
callq 0x45ce0
jmp 0x30a98
movq 0x200(%rsp), %rax
movq 0x170(%rax), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0x3087f
movq 0x200(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x1e4acf(%rip), %rcx    # 0x214fd8
cmpq (%rcx), %rax
je 0x3087f
movq 0x200(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
jne 0x3087f
movq 0x200(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x160(%rsp)
movq 0x200(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %eax
movl %eax, 0x15c(%rsp)
cmpq $0x0, 0x160(%rsp)
je 0x3063f
movq 0x200(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq %rax, 0xc0(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x200(%rsp), %rdi
movq 0x160(%rsp), %rsi
movq 0x200(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
callq 0xb880
movq %rax, 0xb0(%rsp)
movq 0x200(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x45e30
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq %rax, %rdx
callq 0x36f70
movq 0xb8(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq %rax, %rcx
leaq 0x1b1812(%rip), %rdx    # 0x1e1e3e
xorl %r8d, %r8d
movl $0xa, %r9d
callq 0x45ce0
jmp 0x3087a
cmpl $0x0, 0x15c(%rsp)
jle 0x306f4
movq 0x200(%rsp), %rax
movq 0x1b8(%rax), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x8(%rax)
jle 0x306f4
movq 0x200(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x200(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x45e30
movq 0x90(%rsp), %rdi
movq %rax, %rsi
callq 0x35ea0
movq 0x98(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq %rax, %rcx
leaq 0x1b1768(%rip), %rdx    # 0x1e1e49
xorl %r8d, %r8d
movl $0xb, %r9d
callq 0x45ce0
jmp 0x30878
movq 0x200(%rsp), %rax
cmpl $0x0, 0x184(%rax)
jbe 0x30876
movq 0x200(%rsp), %rax
movq 0x178(%rax), %rax
movq 0x200(%rsp), %rcx
movl 0x184(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x150(%rsp)
movq 0x150(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0x30874
movq 0x150(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x1e4876(%rip), %rcx    # 0x214fd8
cmpq (%rcx), %rax
je 0x30874
movq 0x150(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
jne 0x30874
movq 0x150(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x160(%rsp)
movq 0x150(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %eax
movl %eax, 0x15c(%rsp)
cmpq $0x0, 0x160(%rsp)
je 0x30872
movq 0x200(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq %rax, 0x88(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x200(%rsp), %rdi
movq 0x160(%rsp), %rsi
movq 0x200(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
callq 0xb880
movq %rax, 0x78(%rsp)
movq 0x200(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x45e30
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq %rax, %rdx
callq 0x36f70
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq %rax, %rcx
leaq 0x1b15da(%rip), %rdx    # 0x1e1e3e
xorl %r8d, %r8d
movl $0xa, %r9d
callq 0x45ce0
jmp 0x30874
jmp 0x30876
jmp 0x30878
jmp 0x3087a
jmp 0x30a7c
movq 0x200(%rsp), %rax
movq 0x6b8(%rax), %rax
movq %rax, 0x148(%rsp)
cmpq $0x0, 0x148(%rsp)
je 0x30a7a
movq 0x200(%rsp), %rax
movq $0x0, 0x6b8(%rax)
movq 0x200(%rsp), %rax
cmpq $0x0, 0x6b0(%rax)
je 0x30a78
movq 0x200(%rsp), %rax
cmpq $0x0, 0x698(%rax)
jl 0x30a78
movq 0x200(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x200(%rsp), %rdi
movq 0x148(%rsp), %rsi
callq 0x145e0
movq %rax, 0x60(%rsp)
movq 0x200(%rsp), %rdi
movq 0x200(%rsp), %rax
movq 0x6b0(%rax), %rsi
callq 0x145e0
movq %rax, 0x68(%rsp)
movq 0x200(%rsp), %rax
movq 0x698(%rax), %rax
movq %rax, 0x140(%rsp)
movq 0x140(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x30995
movq 0x140(%rsp), %rcx
leaq 0x1e5af9(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x40(%rsp)
jmp 0x30a2d
jmp 0x30997
movq 0x200(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x200(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x309c4
movq 0x200(%rsp), %rdi
callq 0xc670
movq 0x200(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x130(%rsp)
movq 0x130(%rsp), %rax
movq $0xb, (%rax)
movq 0x140(%rsp), %rcx
movq 0x130(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x130(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x138(%rsp), %rcx
callq 0x359a0
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq %rax, %rcx
leaq 0x1b13eb(%rip), %rdx    # 0x1e1e55
xorl %r8d, %r8d
movl $0xd, %r9d
callq 0x45ce0
jmp 0x30a7a
jmp 0x30a7c
movq 0x200(%rsp), %rdi
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rsi
callq 0x2d390
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq 0x200(%rsp), %rcx
cmpq 0x120(%rcx), %rax
je 0x30c5b
movq 0x200(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x200(%rsp), %rax
movq 0x2e0(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x10790
movq %rax, 0x20(%rsp)
movq 0x200(%rsp), %rax
movq 0x2e0(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x10790
movq %rax, 0x28(%rsp)
movq 0x200(%rsp), %rax
movq 0x2e0(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x10790
movq %rax, 0x30(%rsp)
movq 0x200(%rsp), %rax
movq 0x2e0(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x10790
movq %rax, 0x38(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x200(%rsp), %rdi
movq 0x200(%rsp), %rax
movq 0x2e0(%rax), %rsi
movl $0x4, %edx
callq 0x2f590
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x9be0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
movzbl %al, %r9d
andl $0x1, %r9d
callq 0x447e0
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jle 0x30c56
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x200(%rsp), %rdi
movq 0x120(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0x120(%rsp), %rcx
movq 0x8(%rcx), %rdx
movq 0x200(%rsp), %rcx
movq 0x190(%rcx), %rcx
callq *%rax
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq 0x200(%rsp), %rdi
movq 0x200(%rsp), %rcx
movq 0x190(%rcx), %rdx
movl $0xa, %esi
callq *%rax
jmp 0x30cf5
movq 0x200(%rsp), %rax
movq 0x1b0(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x30cf3
movq 0x200(%rsp), %rax
movq %rax, (%rsp)
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x200(%rsp), %rdi
movq 0x200(%rsp), %rax
movq 0x1b0(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x35ea0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rcx
leaq 0x1b119a(%rip), %rdx    # 0x1e1e63
xorl %r8d, %r8d
movl $0x7, %r9d
callq 0x45ce0
movq 0x200(%rsp), %rdi
movq 0x200(%rsp), %rax
movq 0x190(%rax), %rsi
callq 0x2d390
jmp 0x30cf5
movq 0x1f8(%rsp), %rcx
movq 0x200(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x200(%rsp), %rax
movq $0x1ed, 0x18(%rax)      # imm = 0x1ED
movq 0x200(%rsp), %rax
testb $0x1, 0x678(%rax)
je 0x30d43
movq 0x200(%rsp), %rdi
addq $0x5b0, %rdi            # imm = 0x5B0
movl $0x4, %esi
callq 0x9530
movq 0x1f8(%rsp), %rax
addq $0x208, %rsp            # imm = 0x208
retq
nopw %cs:(%rax,%rax)