// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: do_is_safe
static bool do_is_safe(s7_scheme *sc, s7_pointer body, s7_pointer steppers, s7_pointer var_list, bool *has_set)
                {
                    /* here any (unsafe?) closure or jumping-op (call/cc) or shadowed variable is trouble */
                    s7_pointer p;
                    if (DO_PRINT) fprintf(stderr, "do_is_safe: %s\n", DISPLAY_80(body));
                    /* sc->code is the complete do form (do ...) */

                    for (p = body; is_pair(p); p = cdr(p))
                    {
                        s7_pointer expr;
                        expr = car(p);
                        if (DO_PRINT) fprintf(stderr, "    %s\n", DISPLAY_80(expr));
                        if (is_pair(expr))
                        {
                            s7_pointer x;
                            x = car(expr);
                            if (is_symbol(x))
                            {
                                if (is_syntactic_symbol(x))
                                {
                                    opcode_t op;
                                    s7_pointer func, vars;
                                    func = slot_value(global_slot(x));
                                    op = (opcode_t)syntax_opcode(func);
                                    switch (op)
                                    {
                                        case OP_MACROEXPAND:
                                            {if (DO_PRINT) fprintf(stderr, "macroexpand %d\n", __LINE__); return(false);}

                                        case OP_QUOTE:
                                            if ((!is_pair(cdr(expr))) || (!is_null(cddr(expr))))  /* (quote . 1) or (quote 1 2) etc */
                                            {if (DO_PRINT) fprintf(stderr, "bad quote %d\n", __LINE__); return(false);}
                                            break;

                                        case OP_LET:
                                        case OP_LET_STAR:
                                        case OP_LETREC:
                                        case OP_LETREC_STAR:
                                            {
                                                s7_pointer nv;
                                                nv = var_list;

                                                if (!is_pair(cdr(expr)))
                                                {if (DO_PRINT) fprintf(stderr, "bad let %d\n", __LINE__); return(false);}
                                                if (!is_list(cadr(expr)))
                                                {if (DO_PRINT) fprintf(stderr, "named let? %d\n", __LINE__); return(false);}
                                                if (!is_pair(cddr(expr)))
                                                {if (DO_PRINT) fprintf(stderr, "bad let body %d\n", __LINE__); return(false);}

                                                for (vars = cadr(expr); is_pair(vars); vars = cdr(vars))
                                                {
                                                    s7_pointer var;
                                                    if (!is_pair(car(vars)))
                                                    {if (DO_PRINT) fprintf(stderr, " bad let vars %d\n", __LINE__); return(false);}
                                                    var = caar(vars);
                                                    if (direct_memq(var, ((op == OP_LET) || (op == OP_LETREC)) ? nv : var_list))
                                                    {if (DO_PRINT) fprintf(stderr, "let shadows %d\n", __LINE__); return(false);}
                                                    if ((!is_symbol(var)) || (is_keyword(var)))
                                                    {if (DO_PRINT) fprintf(stderr, "let var name is bad: %d\n", __LINE__); return(false);}
                                                    nv = cons(sc, var, nv);
                                                    sc->x = nv;
                                                }
                                                sc->x = sc->nil;
                                                if (!do_is_safe(sc, cddr(expr), steppers, nv, has_set))
                                                {if (DO_PRINT) fprintf(stderr, "let unsafe body %d\n", __LINE__); return(false);}
                                                break;
                                            }

                                        case OP_DO:
                                            {
                                                s7_pointer nv;
                                                if ((!is_pair(cdr(expr))) || (!is_pair(cddr(expr))))  /* (do) or (do (...)) */
                                                {if (DO_PRINT) fprintf(stderr, "bad do %d\n", __LINE__); return(false);}
                                                nv = var_list;
                                                for (vars = cadr(expr); is_pair(vars); vars = cdr(vars))
                                                {
                                                    s7_pointer var;
                                                    if (!is_pair(car(vars)))
                                                    {if (DO_PRINT) fprintf(stderr, "bad do vars %d\n", __LINE__); return(false);}
                                                    var = caar(vars);
                                                    if ((direct_memq(var, nv)) ||
                                                            (direct_memq(var, steppers)))
                                                    {if (DO_PRINT) fprintf(stderr, "do stepper within step %d\n", __LINE__); return(false);}

                                                    nv = cons(sc, var, nv);
                                                    sc->x = nv;
                                                    if ((is_pair(cdar(vars))) &&
                                                            (!do_is_safe(sc, cdar(vars), steppers, nv, has_set)))
                                                    {
                                                        sc->x = sc->nil;
                                                        {if (DO_PRINT) fprintf(stderr, "bad stepper %d, step %s\n", __LINE__, DISPLAY_80(cdar(vars))); return(false);}
                                                    }
                                                }
                                                sc->x = sc->nil;
                                                if (!do_is_safe(sc, caddr(expr), steppers, nv, has_set))
                                                {if (DO_PRINT) fprintf(stderr, "bad init %d: %s\n", __LINE__, DISPLAY(caddr(expr))); return(false);}
                                                if ((is_pair(cdddr(expr))) &&
                                                        (!do_is_safe(sc, cdddr(expr), steppers, nv, has_set)))
                                                {if (DO_PRINT) fprintf(stderr, "bad step %d, %s\n", __LINE__, DISPLAY(cadddr(expr))); return(false);}
                                                if (DO_PRINT) fprintf(stderr, "do is ok\n");
                                                break;
                                            }

                                        case OP_SET:
                                            {
                                                s7_pointer settee;
                                                if (!is_pair(cdr(expr)))            /* (set!) */
                                                {if (DO_PRINT) fprintf(stderr, "bad set! %d\n", __LINE__); return(false);}
                                                settee = cadr(expr);
                                                if (!is_symbol(settee))             /* (set! (...) ...) which is tricky due to setter functions/macros */
                                                {
                                                    s7_pointer setv;
                                                    if ((!is_pair(settee)) ||
                                                            (!is_symbol(car(settee))))
                                                    {if (DO_PRINT) fprintf(stderr, "bad set target %d\n", __LINE__); return(false);}
                                                    setv = lookup_unexamined(sc, car(settee));
                                                    if (!((setv) &&
                                                                ((is_sequence(setv)) ||
                                                                 ((is_c_function(setv)) &&
                                                                  (is_safe_procedure(c_function_setter(setv)))))))
                                                    {if (DO_PRINT) fprintf(stderr, "bad set target %d\n", __LINE__); return(false);}
                                                    (*has_set) = true;
                                                }
                                                else
                                                {
                                                    if ((is_pair(caddr(sc->code))) &&        /* sc->code = do-form (formerly (cdr(do-form)) causing a bug here) */
                                                            (is_pair(caaddr(sc->code))))
                                                    {
                                                        bool res;
                                                        set_match_symbol(settee);
                                                        res = tree_match(caaddr(sc->code)); /* (set! end ...) in some fashion */
                                                        clear_match_symbol(settee);
                                                        if (res)
                                                        {
                                                            if (DO_PRINT)
                                                                fprintf(stderr, "set! end %d, settee: %s in %s\n", __LINE__, DISPLAY(settee), DISPLAY(caaddr(sc->code)));
                                                            return(false);
                                                        }
                                                    }

                                                    if (!direct_memq(cadr(expr), var_list)) /* is some non-local variable being set? */
                                                        (*has_set) = true;
                                                }
                                                if (!do_is_safe(sc, cddr(expr), steppers, var_list, has_set))
                                                {if (DO_PRINT) fprintf(stderr, "end-test: %d\n", __LINE__); return(false);}
                                                if (!safe_stepper_expr(expr, steppers))  /* is step var's value used as the stored value by set!? */
                                                {if (DO_PRINT) fprintf(stderr, "unsafe stepper: %d\n", __LINE__); return(false);}
                                            }
                                            break;

                                        case OP_LET_TEMPORARILY:
                                            {
                                                s7_pointer lp;
                                                if ((!is_pair(cdr(expr))) ||
                                                        (!is_pair(cadr(expr))) ||
                                                        (!is_pair(cddr(expr))))
                                                {if (DO_PRINT) fprintf(stderr, "bad let temp: %d\n", __LINE__); return(false);}
                                                for (lp = cadr(expr); is_pair(lp); lp = cdr(lp))
                                                    if ((!is_pair(car(lp))) ||
                                                            (!is_pair(cdar(lp))) ||
                                                            (!do_is_safe(sc, cdar(lp), steppers, var_list, has_set)))
                                                    {if (DO_PRINT) fprintf(stderr, "bad let-temp: %d\n", __LINE__); return(false);}
                                                if (!do_is_safe(sc, cddr(expr), steppers, var_list, has_set))
                                                {if (DO_PRINT) fprintf(stderr, "bad let-temp body: %d\n", __LINE__); return(false);}
                                                break;
                                            }

                                        case OP_COND:
                                            {
                                                s7_pointer cp;
                                                for (cp = cdr(expr); is_pair(cp); cp = cdr(cp))
                                                    if (!do_is_safe(sc, car(cp), steppers, var_list, has_set))
                                                    {if (DO_PRINT) fprintf(stderr, "bad cond: %d\n", __LINE__); return(false);}
                                                break;
                                            }

                                        case OP_CASE:
                                            {
                                                s7_pointer cp;
                                                if (!is_pair(cdr(expr)))
                                                {if (DO_PRINT) fprintf(stderr, "bad case: %d\n", __LINE__); return(false);}
                                                if (!do_is_safe(sc, cadr(expr), steppers, var_list, has_set))
                                                {if (DO_PRINT) fprintf(stderr, "bad case: %d\n", __LINE__); return(false);}
                                                for (cp = cddr(expr); is_pair(cp); cp = cdr(cp))
                                                    if ((!is_pair(car(cp))) ||      /* (case x #(123)...) */
                                                            (!do_is_safe(sc, cdar(cp), steppers, var_list, has_set)))
                                                    {if (DO_PRINT) fprintf(stderr, "bad case: %d\n", __LINE__); return(false);}
                                                break;
                                            }

                                        case OP_IF:
                                        case OP_WHEN:
                                        case OP_UNLESS:
                                        case OP_AND:
                                        case OP_OR:
                                        case OP_BEGIN:
                                            if (!do_is_safe(sc, cdr(expr), steppers, var_list, has_set))
                                            {if (DO_PRINT) fprintf(stderr, "bad if/or/etc: %d\n", __LINE__); return(false);}
                                            break;

                                        case OP_WITH_LET:
                                            return(true); /* ?? did I mean false here?? */

                                        default:
                                            {if (DO_PRINT) fprintf(stderr, "unsafe syntax %d\n", __LINE__); return(false);}
                                    }
                                } /* is_syntactic(x=car(expr)) */
                                else
                                {
                                    /* if a macro, we'll eventually expand it (if *_optimize), but that requires a symbol lookup here and s7_macroexpand */
                                    if ((!is_optimized(expr)) ||
                                            (!do_is_safe(sc, cdr(expr), steppers, var_list, has_set)))
                                    {if (DO_PRINT) fprintf(stderr, "%d, opt: %d\n", __LINE__, is_optimized(expr)); return(false);}
                                    else
                                    {
                                        if (is_setter(x))           /* "setter" includes stuff like cons and vector -- x is a symbol */
                                        {
                                            /* (hash-table-set! ht i 0) -- caddr is being saved, so this is not safe
                                             *   similarly (vector-set! v 0 i) etc
                                             */
                                            if (is_null(cdr(expr)))                         /* (vector) for example */
                                            {
                                                return((x == sc->vector_symbol) ||
                                                        (x == sc->list_symbol) ||
                                                        (x == sc->string_symbol));
                                            }
                                            if (!direct_memq(cadr(expr), var_list))         /* non-local is being changed */
                                            {
                                                if ((direct_memq(cadr(expr), steppers)) ||  /* stepper is being set? */
                                                        (!is_pair(cddr(expr))) ||
                                                        (!is_pair(cdddr(expr))) ||
                                                        (is_pair(cddddr(expr))) ||
                                                        ((x == sc->hash_table_set_symbol) &&
                                                         (is_symbol(caddr(expr))) &&
                                                         (direct_memq(caddr(expr), steppers))) ||
                                                        ((is_symbol(cadddr(expr))) &&
                                                         (direct_memq(cadddr(expr), steppers))) ||
                                                        ((is_pair(cadddr(expr))) &&
                                                         (tree_set_memq_b_7pp(sc, steppers, cadddr(expr)))))
                                                    (*has_set) = true;
                                            }
                                            if (!do_is_safe(sc, cddr(expr), steppers, var_list, has_set))
                                            {if (DO_PRINT) fprintf(stderr, "not safe %d\n", __LINE__); return(false);}
                                            if (!safe_stepper_expr(expr, steppers))
                                            {if (DO_PRINT) fprintf(stderr, "unsafe stepper %d\n", __LINE__); return(false);}
                                        }
                                    }
                                }
                            } /* is_symbol(x=car(expr)) */
                            else
                            {
                                {if (DO_PRINT) fprintf(stderr, "%d, %s not a symbol\n", __LINE__, DISPLAY_80(x)); return(false);}
                                /* car(expr) ("x") is not a symbol: ((mus-data loc) chan) for example
                                 *   but that's actually safe since it's just in effect vector-ref
                                 *   there are several examples in dlocsig: ((group-speakers group) i) etc
                                 */
                            }
                        }
                    }
                    return(true);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbp
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %rax
movq %rdi, %r12
movq %rdi, 0x18(%rsp)
movq %r8, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpb $0x1, (%rax)
setne %r14b
jne 0x8a685
movq 0x8(%rax), %r15
cmpb $0x1, (%r15)
jne 0x8a641
movq 0x8(%r15), %rbx
cmpb $0xa, (%rbx)
jne 0x8a685
cmpw $0x20a, (%rbx)          # imm = 0x20A
movq %rax, 0x10(%rsp)
jne 0x8a06b
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
leaq -0x19f(%rax), %rcx
cmpq $0x17, %rcx
ja 0x8a164
leaq 0x4a510(%rip), %rdx     # 0xd4478
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x10(%r15), %rdx
cmpb $0x1, (%rdx)
jne 0x8a685
movq 0x8(%rdx), %rbx
movb (%rbx), %cl
leal -0x1(%rcx), %esi
cmpb $0x1, %sil
ja 0x8a685
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
jne 0x8a685
movl %r14d, 0x34(%rsp)
cmpq $0x1ad, %rax            # imm = 0x1AD
sete %dl
cmpq $0x1b2, %rax            # imm = 0x1B2
sete %r14b
orb %dl, %r14b
movq 0x8(%rsp), %r12
cmpb $0x1, %cl
jne 0x8a491
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x8a682
movq 0x8(%rax), %r13
testb %r14b, %r14b
movq 0x8(%rsp), %rsi
cmovneq %r12, %rsi
movq %r13, %rdi
callq 0x7cf28
testb %al, %al
jne 0x8a682
cmpb $0xa, (%r13)
jne 0x8a682
testb $-0x80, 0x6(%r13)
jne 0x8a682
movq 0x18(%rsp), %rbp
movq 0x90(%rbp), %rax
cmpq 0x98(%rbp), %rax
ja 0x8a02e
movq %rbp, %rdi
callq 0x9c27
movq 0x90(%rbp), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbp)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x4e0(%rbp)
movq 0x10(%rbx), %rbx
movb (%rbx), %cl
movq %rax, %r12
movq 0x28(%rsp), %rbp
movq 0x20(%rsp), %r13
jmp 0x89fbe
cmpw $0x801, (%r15)          # imm = 0x801
jne 0x8a685
movq 0x10(%r15), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, %r8
callq 0x89ede
testb %al, %al
je 0x8a685
testb $0x2, 0x3(%rbx)
movq 0x10(%rsp), %rax
je 0x8a641
movl %r14d, %r13d
movq 0x10(%r15), %r14
cmpq 0x110(%r12), %r14
je 0x8a64a
movq 0x8(%r14), %r12
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x7cf28
testb %al, %al
jne 0x8a5fe
movq %r12, %rdi
movq 0x20(%rsp), %rsi
callq 0x7cf28
testb %al, %al
jne 0x8a5fa
movq 0x10(%r14), %rax
cmpb $0x1, (%rax)
jne 0x8a5fa
movq 0x10(%rax), %r14
cmpb $0x1, (%r14)
jne 0x8a5fa
movq 0x10(%r14), %rcx
cmpb $0x1, (%rcx)
je 0x8a5fa
movq 0x18(%rsp), %rcx
cmpq 0xf70(%rcx), %rbx
jne 0x8a139
movq 0x8(%rax), %rdi
cmpb $0xa, (%rdi)
jne 0x8a139
movq 0x20(%rsp), %rsi
callq 0x7cf28
testb %al, %al
jne 0x8a5fa
movq 0x8(%r14), %rdx
movzbl (%rdx), %eax
cmpl $0x1, %eax
je 0x8a5e7
cmpl $0xa, %eax
jne 0x8a5fe
movq %rdx, %rdi
movq 0x20(%rsp), %rsi
callq 0x7cf28
jmp 0x8a5f6
leaq -0x1ca(%rax), %rcx
cmpq $0x2, %rcx
jb 0x8a2d8
cmpq $0x19b, %rax            # imm = 0x19B
je 0x8a3f1
cmpq $0x1c3, %rax            # imm = 0x1C3
je 0x8a2c4
cmpq $0x1d0, %rax            # imm = 0x1D0
je 0x8a41a
cmpq $0x1e4, %rax            # imm = 0x1E4
jne 0x8a697
movq 0x10(%r15), %rbx
cmpb $0x1, (%rbx)
jne 0x8a685
movq 0x10(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x8a685
addq $0x8, %rbx
movq 0x8(%rsp), %rcx
movq (%rbx), %rbx
cmpb $0x1, (%rbx)
jne 0x8a58e
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x8a682
movq 0x8(%rax), %r13
movq %r13, %rdi
movq %rcx, %rbp
movq %rcx, %rsi
callq 0x7cf28
testb %al, %al
jne 0x8a682
movq %r13, %rdi
movq 0x20(%rsp), %rsi
callq 0x7cf28
testb %al, %al
jne 0x8a682
movq 0x90(%r12), %rax
cmpq 0x98(%r12), %rax
ja 0x8a232
movq %r12, %rdi
callq 0x9c27
movq 0x90(%r12), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r12)
movq %r12, %rdx
movq -0x8(%rax), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %r13, 0x8(%r12)
movq %rbp, 0x10(%r12)
movq %r12, 0x4e0(%rdx)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
cmpb $0x1, (%rsi)
movq 0x20(%rsp), %r13
jne 0x8a291
movq %rdx, %rbp
movq %rdx, %rdi
movq %r13, %rdx
movq %r12, %rcx
movq 0x28(%rsp), %r8
callq 0x89ede
movq %rbp, %rdx
testb %al, %al
je 0x8a674
addq $0x10, %rbx
movq %r12, %rcx
movq %rdx, %r12
movq 0x28(%rsp), %rbp
jmp 0x8a1c8
movq 0x8(%r15), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, %r8
callq 0x89ede
testb %al, %al
je 0x8a682
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq 0x10(%rsp), %rax
je 0x8a2a5
jmp 0x8a641
movq 0x10(%r15), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, %r8
callq 0x89ede
testb %al, %al
jmp 0x8a63a
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0x8a685
movq 0x8(%rax), %rbx
cmpb $0x1, (%rbx)
jne 0x8a685
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x8a685
movb $0x1, %al
cmpb $0x1, %al
jne 0x8a581
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x8a682
movq 0x10(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0x8a682
movq %r12, %rdi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, %r8
callq 0x89ede
testb %al, %al
je 0x8a682
movq 0x10(%rbx), %rbx
movb (%rbx), %al
jmp 0x8a31f
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0x8a685
movq 0x8(%rax), %r12
movzbl (%r12), %eax
cmpl $0xa, %eax
je 0x8a4c9
cmpl $0x1, %eax
jne 0x8a685
movq 0x8(%r12), %rsi
cmpb $0xa, (%rsi)
jne 0x8a685
movq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x7d158
testq %rax, %rax
je 0x8a685
movzbl (%rax), %ecx
leaq 0x977c6(%rip), %rdx     # 0x121b80
cmpb $0x0, (%rcx,%rdx)
jne 0x8a54a
movq (%rax), %rcx
btl $0x1e, %ecx
jb 0x8a54a
cmpb $0x30, %cl
jb 0x8a685
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
testb $0x20, 0x2(%rax)
jne 0x8a54a
jmp 0x8a685
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0x8a685
movq 0x10(%rax), %rax
cmpq 0x110(%r12), %rax
movq 0x10(%rsp), %rax
je 0x8a641
jmp 0x8a685
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0x8a685
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, %r8
callq 0x89ede
testb %al, %al
movq 0x10(%rsp), %rax
je 0x8a685
movq 0x10(%r15), %rbx
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
jne 0x8a641
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x8a682
movq 0x10(%rax), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, %r8
callq 0x89ede
xorl %r14d, %r14d
testb %al, %al
movq 0x10(%rsp), %rax
jne 0x8a44f
jmp 0x8a685
movq 0x18(%rsp), %rdi
movq 0x110(%rdi), %rax
movq %rax, 0x4e0(%rdi)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %rdi, %r12
movq %rbp, %r8
callq 0x89ede
testb %al, %al
movl 0x34(%rsp), %r14d
jmp 0x8a63a
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x8a534
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x8a534
movzwl (%r12), %ebx
movl %ebx, %eax
orl $0x8000, %eax           # imm = 0x8000
movw %ax, (%r12)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x8ae57
andl $0x7fff, %ebx           # imm = 0x7FFF
movw %bx, (%r12)
testb %al, %al
jne 0x8a685
movq 0x10(%r15), %rax
movq 0x8(%rax), %r12
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x7cf28
testb %al, %al
movq 0x18(%rsp), %r12
jne 0x8a54e
movb $0x1, (%rbp)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, %r8
callq 0x89ede
testb %al, %al
je 0x8a685
movq %r15, %rdi
movq %r13, %rsi
callq 0x8ae8b
jmp 0x8a2ef
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
jmp 0x8a2dc
movq 0x110(%r12), %rax
movq %rax, 0x4e0(%r12)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq %rcx, %rbx
movq %rbp, %r8
callq 0x89ede
testb %al, %al
je 0x8a685
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0x1, (%rsi)
movq 0x10(%rsp), %rax
jne 0x8a641
movq %r12, %rdi
movq %r13, %rdx
movq %rbx, %rcx
jmp 0x8a2e7
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x6d7b4
testb %al, %al
je 0x8a5fe
movb $0x1, (%rbp)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %r12
movq %r12, %rdi
movq 0x20(%rsp), %rbx
movq %rbx, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, %r8
callq 0x89ede
testb %al, %al
je 0x8a66f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8ae8b
testb %al, %al
movl %r13d, %r14d
movq %rbx, %r13
movq 0x10(%rsp), %rax
je 0x8a685
movq 0x10(%rax), %rax
jmp 0x89f0c
movb $0x1, %r14b
cmpq 0x1670(%r12), %rbx
je 0x8a685
cmpq 0x1268(%r12), %rbx
je 0x8a685
cmpq 0x1558(%r12), %rbx
sete %r14b
jmp 0x8a685
movl %r13d, %r14d
jmp 0x8a685
movq 0x110(%rdx), %rax
movq %rax, 0x4e0(%rdx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x1f1, %rax            # imm = 0x1F1
jne 0x8a685
movb $0x1, %r14b
jmp 0x8a685