// File: /workspace/github_c_makefile_star2_O1/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
movb $0x1, %bpl
cmpb $0x1, (%rsi)
jne 0xb4ab2
movq %r8, %r13
movq %rcx, %r9
movq %rdx, %r10
movq %rsi, %r12
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x8(%r12), %rbx
movb $0x1, %r15b
cmpb $0x1, (%rbx)
jne 0xb4773
movq 0x8(%rbx), %r14
cmpb $0xa, (%r14)
jne 0xb4396
cmpw $0x20a, (%r14)          # imm = 0x20A
jne 0xb41e6
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
cmpq $0x1c2, %rdx            # imm = 0x1C2
jg 0xb421e
leaq -0x19f(%rdx), %rcx
cmpq $0x17, %rcx
ja 0xb43a0
leaq 0x5d36b(%rip), %r8      # 0x111418
movslq (%r8,%rcx,4), %rsi
addq %r8, %rsi
xorl %ecx, %ecx
jmpq *%rsi
movq 0x10(%rbx), %rax
cmpb $0x1, (%rax)
jne 0xb474c
movq 0x8(%rax), %rcx
movb (%rcx), %cl
decb %cl
cmpb $0x1, %cl
ja 0xb474c
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0xb474c
movq 0x8(%rax), %r14
cmpb $0x1, (%r14)
jne 0xb47de
cmpq $0x1ad, %rdx            # imm = 0x1AD
sete %al
cmpq $0x1b2, %rdx            # imm = 0x1B2
sete %sil
orb %al, %sil
movq %r9, %rcx
movq %r13, 0x28(%rsp)
movq 0x8(%r14), %rdx
cmpb $0x1, (%rdx)
jne 0xb413c
testb %sil, %sil
movq %r9, %rax
cmovneq %rcx, %rax
movq 0x8(%rdx), %r13
cmpb $0x1, (%rax)
sete %dl
jne 0xb4145
cmpq %r13, 0x8(%rax)
je 0xb4145
movq 0x10(%rax), %rax
jmp 0xb4128
xorl %eax, %eax
xorl %ebp, %ebp
jmp 0xb41cb
testb %dl, %dl
jne 0xb41c2
cmpb $0xa, (%r13)
jne 0xb41c2
testb $-0x80, 0x6(%r13)
jne 0xb41c2
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xb418f
movq %rcx, 0x30(%rsp)
movb %sil, 0x27(%rsp)
callq 0xb389
movb 0x27(%rsp), %sil
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r9
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rdx
movq %rdx, 0x90(%rdi)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r13, 0x8(%rdx)
movq %rcx, 0x10(%rdx)
movq %rdx, 0x4e0(%rdi)
movb $0x1, %al
movq %rdx, %rcx
jmp 0xb41c6
xorl %eax, %eax
xorl %ebp, %ebp
movq 0x28(%rsp), %r13
testb %al, %al
je 0xb44ae
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
je 0xb4111
jmp 0xb47e1
cmpw $0x801, (%rbx)          # imm = 0x801
jne 0xb4396
movq 0x10(%rbx), %rsi
movq %r10, %rdx
movq %r9, %rcx
movq %r13, %r8
callq 0xb401a
testb %al, %al
je 0xb426a
testb $0x2, 0x3(%r14)
movq 0x18(%rsp), %r10
jne 0xb42b6
movq 0x10(%rsp), %r9
jmp 0xb4279
cmpq $0x1cf, %rdx            # imm = 0x1CF
jg 0xb4283
leaq -0x1ca(%rdx), %rcx
cmpq $0x2, %rcx
jae 0xb43d5
movq 0x10(%rbx), %rsi
movq %r10, %rdx
movq %r9, %rcx
movq %r13, %r8
callq 0xb401a
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r9
testb %al, %al
jne 0xb4766
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0xb476a
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x8(%rsp), %rdi
jmp 0xb4773
cmpq $0x1d0, %rdx            # imm = 0x1D0
je 0xb455b
cmpq $0x1e4, %rdx            # imm = 0x1E4
je 0xb45ce
movl $0x0, %ecx
cmpq $0x1f1, %rdx            # imm = 0x1F1
jne 0xb476a
movb $0x1, %cl
jmp 0xb4924
movq 0x10(%rbx), %rdx
movq 0x8(%rsp), %rdi
cmpq 0x110(%rdi), %rdx
movq 0x10(%rsp), %r9
je 0xb4791
movq 0x8(%rdx), %rsi
cmpb $0x1, (%r9)
sete %al
jne 0xb42f9
movq %r9, %rcx
cmpq %rsi, 0x8(%r9)
je 0xb42f9
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
sete %al
jne 0xb42f9
cmpq %rsi, 0x8(%rcx)
jne 0xb42e7
testb %al, %al
jne 0xb4355
movb (%r10), %cl
cmpb $0x1, %cl
sete %al
movl %eax, %r11d
jne 0xb432b
movq %r10, %r8
movl %eax, %r11d
cmpq %rsi, 0x8(%r10)
je 0xb432b
movq 0x10(%r8), %r8
cmpb $0x1, (%r8)
sete %r11b
jne 0xb432b
cmpq %rsi, 0x8(%r8)
jne 0xb4317
testb %r11b, %r11b
jne 0xb4350
movq 0x10(%rdx), %rsi
cmpb $0x1, (%rsi)
jne 0xb4350
movq 0x10(%rsi), %rdx
cmpb $0x1, (%rdx)
jne 0xb4350
movq 0x10(%rdx), %r8
cmpb $0x1, (%r8)
jne 0xb4937
movb $0x1, (%r13)
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r10, %rdx
movq %r9, %rcx
movq %r13, %r8
movq %r10, %r14
callq 0xb401a
testb %al, %al
je 0xb47b6
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb5374
testb %al, %al
movq 0x10(%rsp), %r9
movq %r14, %r10
movq 0x8(%rsp), %rdi
jne 0xb4773
xorl %r15d, %r15d
xorl %ebp, %ebp
jmp 0xb4773
movl $0x0, %ecx
cmpq $0x19b, %rdx            # imm = 0x19B
jne 0xb476a
movq 0x10(%rbx), %rax
cmpb $0x1, (%rax)
jne 0xb4261
movq 0x10(%rax), %rax
cmpq 0x110(%rdi), %rax
jne 0xb4261
jmp 0xb4766
movl $0x0, %ecx
cmpq $0x1c3, %rdx            # imm = 0x1C3
jne 0xb476a
movq 0x10(%rbx), %rbx
movb (%rbx), %r14b
cmpb $0x1, %r14b
jne 0xb47c8
movq 0x8(%rbx), %rsi
movq %r10, %rdx
movq %r9, %rcx
movq %r13, %r8
callq 0xb401a
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r9
testb %al, %al
jne 0xb43e7
xorl %ecx, %ecx
jmp 0xb47ca
movq 0x10(%rbx), %rax
cmpb $0x1, (%rax)
jne 0xb474c
movq 0x8(%rax), %r14
movzbl (%r14), %eax
cmpl $0xa, %eax
je 0xb4880
cmpl $0x1, %eax
jne 0xb44a2
movq 0x8(%r14), %rsi
cmpb $0xa, (%rsi)
jne 0xb44a2
callq 0xa2e84
testq %rax, %rax
je 0xb49f1
movzbl (%rax), %ecx
leaq 0xa6718(%rip), %rdx     # 0x15ab80
cmpb $0x0, (%rcx,%rdx)
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x8(%rsp), %rdi
jne 0xb49e5
testb $0x40, 0x3(%rax)
jne 0xb49e5
cmpb $0x30, (%rax)
jb 0xb44a2
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
testb $0x20, 0x2(%rax)
jne 0xb49e5
xorl %eax, %eax
xorl %ebp, %ebp
testb %al, %al
jne 0xb4a54
xorl %eax, %eax
jmp 0xb4750
movq 0x10(%rbx), %rax
cmpb $0x1, (%rax)
jne 0xb4758
movq 0x8(%rax), %r14
cmpb $0x1, (%r14)
jne 0xb4758
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xb4758
cmpb $0x1, (%r14)
jne 0xb452c
movq 0x8(%r14), %rax
cmpb $0x1, (%rax)
jne 0xb4758
movq 0x10(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0xb4758
movq %r10, %rdx
movq %r9, %rcx
movq %r13, %r8
callq 0xb401a
testb %al, %al
je 0xb4a97
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x8(%rsp), %rdi
je 0xb44e3
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r10, %rdx
movq %r9, %rcx
movq %r13, %r8
callq 0xb401a
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r9
andb %al, %bpl
movl %ebp, %ecx
jmp 0xb475c
movq 0x10(%rbx), %rax
cmpb $0x1, (%rax)
jne 0xb47d5
movq 0x8(%rax), %rsi
movq %r10, %rdx
movq %r9, %rcx
movq %r13, %r8
callq 0xb401a
testb %al, %al
je 0xb4819
movq 0x10(%rbx), %r14
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
setne %bl
jne 0xb490b
movq 0x8(%r14), %rax
cmpb $0x1, (%rax)
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x8(%rsp), %rdi
jne 0xb47d7
movq 0x10(%rax), %rsi
movq %r10, %rdx
movq %r9, %rcx
movq %r13, %r8
callq 0xb401a
testb %al, %al
jne 0xb4586
jmp 0xb481b
movq 0x10(%rbx), %rax
cmpb $0x1, (%rax)
jne 0xb474c
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0xb474c
movq 0x8(%rax), %r14
cmpb $0x1, (%r14)
movq %r9, %rcx
movq %r13, 0x28(%rsp)
jne 0xb4822
movq 0x8(%r14), %rax
cmpb $0x1, (%rax)
jne 0xb465a
movq 0x8(%rax), %r13
cmpb $0x1, (%rcx)
sete %al
jne 0xb462e
movq %rcx, %rdx
cmpq %r13, 0x8(%rcx)
je 0xb462e
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
sete %al
jne 0xb462e
cmpq %r13, 0x8(%rdx)
jne 0xb461c
testb %al, %al
jne 0xb465a
cmpb $0x1, (%r10)
sete %al
jne 0xb4656
movq %r10, %rdx
cmpq %r13, 0x8(%r10)
je 0xb4656
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
sete %al
jne 0xb4656
cmpq %r13, 0x8(%rdx)
jne 0xb4644
testb %al, %al
je 0xb467c
xorl %r13d, %r13d
xorl %ebp, %ebp
testb %r13b, %r13b
je 0xb492b
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
movq 0x28(%rsp), %r13
je 0xb45fe
jmp 0xb4822
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xb46aa
movq %rcx, 0x30(%rsp)
callq 0xb389
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r9
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rdx
movq %rdx, 0x90(%rdi)
movq -0x8(%rax), %r8
movq $0x200001, (%r8)        # imm = 0x200001
movq %r13, 0x8(%r8)
movq %rcx, 0x10(%r8)
movq %r8, 0x4e0(%rdi)
movq 0x8(%r14), %rax
movq 0x10(%rax), %rsi
movb $0x1, %r13b
cmpb $0x1, (%rsi)
jne 0xb4718
movq %r10, %rdx
movq %r8, 0x30(%rsp)
movq %r8, %rcx
movq 0x28(%rsp), %r8
callq 0xb401a
testb %al, %al
je 0xb4720
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x8(%rsp), %rdi
jmp 0xb465f
movq %r8, %rcx
jmp 0xb465f
movq 0x8(%rsp), %rdi
movq 0x110(%rdi), %rax
movq %rax, 0x4e0(%rdi)
xorl %r13d, %r13d
movq 0x30(%rsp), %rcx
xorl %ebp, %ebp
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
jmp 0xb465f
xorl %eax, %eax
xorl %ebp, %ebp
testb %al, %al
jne 0xb4766
xorl %eax, %eax
jmp 0xb4768
xorl %eax, %eax
xorl %ecx, %ecx
testb %al, %al
je 0xb4924
movl %ecx, %ebp
movb $0x1, %al
movl %ebp, %ecx
testb %al, %al
jne 0xb4771
xorl %r15d, %r15d
movl %ecx, %ebp
testb %r15b, %r15b
je 0xb4ab2
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
je 0xb404f
jmp 0xb4aaf
movb $0x1, %bpl
cmpq 0x1670(%rdi), %r14
je 0xb47b1
cmpq 0x1268(%rdi), %r14
je 0xb47b1
cmpq 0x1558(%rdi), %r14
sete %bpl
xorl %r15d, %r15d
jmp 0xb4773
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x10(%rsp), %r9
movq %r14, %r10
jmp 0xb4279
movl %ebp, %ecx
cmpb $0x1, %r14b
jne 0xb4764
jmp 0xb4924
xorl %ebx, %ebx
xorl %ecx, %ecx
jmp 0xb491c
movq %r9, %rcx
movq 0x110(%rdi), %rax
movq %rax, 0x4e0(%rdi)
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r10, %rdx
movq %r13, %r8
callq 0xb401a
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r9
andb %al, %bpl
jmp 0xb4750
xorl %ebx, %ebx
xorl %ecx, %ecx
jmp 0xb490d
movq 0x110(%rdi), %rax
movq %rax, 0x4e0(%rdi)
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %r10, %rdx
movq %rcx, %r14
movq %r13, %r8
callq 0xb401a
testb %al, %al
je 0xb48f8
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0xb487c
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq %r14, %rcx
movq %r13, %r8
callq 0xb401a
testb %al, %al
je 0xb48f8
movb $0x1, %al
jmp 0xb48fc
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0xb4a1f
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0xb4a1f
movq %r13, 0x28(%rsp)
movzwl (%r14), %r13d
movl %r13d, %eax
orl $0x8000, %eax           # imm = 0x8000
movw %ax, (%r14)
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0xb5340
andl $0x7fff, %r13d          # imm = 0x7FFF
movw %r13w, (%r14)
movl %eax, %ecx
xorb $0x1, %cl
andb %bpl, %cl
testb %al, %al
je 0xb4a09
xorl %eax, %eax
movl %ecx, %ebp
movq 0x28(%rsp), %r13
jmp 0xb48fc
xorl %eax, %eax
xorl %ebp, %ebp
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
jmp 0xb4a8d
movl %ebp, %ecx
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x8(%rsp), %rdi
testb %bl, %bl
jne 0xb4764
xorl %eax, %eax
jmp 0xb476a
xorl %eax, %eax
movq 0x28(%rsp), %r13
jmp 0xb4750
cmpq 0xf70(%rdi), %r14
jne 0xb497a
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0xb497a
movl %eax, %r11d
cmpb $0x1, %cl
jne 0xb4971
movq %r10, %r8
movl %eax, %r11d
cmpq %rsi, 0x8(%r10)
je 0xb4971
movq 0x10(%r8), %r8
cmpb $0x1, (%r8)
sete %r11b
jne 0xb4971
cmpq %rsi, 0x8(%r8)
jne 0xb495d
testb %r11b, %r11b
jne 0xb4350
movq 0x8(%rdx), %rdx
movzbl (%rdx), %esi
cmpl $0x1, %esi
je 0xb49c1
cmpl $0xa, %esi
jne 0xb4355
cmpb $0x1, %cl
jne 0xb49af
movq %r10, %rcx
cmpq %rdx, 0x8(%r10)
je 0xb49af
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
sete %al
jne 0xb49af
cmpq %rdx, 0x8(%rcx)
jne 0xb499d
testb %al, %al
jne 0xb4350
cmpb $0x1, %sil
jne 0xb4355
movq %r10, %rsi
callq 0x8e9e0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r9
testb %al, %al
jne 0xb4350
jmp 0xb4355
movb $0x1, (%r13)
movb $0x1, %al
jmp 0xb44a6
xorl %eax, %eax
xorl %ebp, %ebp
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x8(%rsp), %rdi
jmp 0xb44a6
movl %ecx, %ebp
movq 0x28(%rsp), %r13
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x8(%rsp), %rdi
cmpb $0x1, (%r9)
sete %al
jne 0xb4a4b
movq 0x10(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %r9, %rdx
cmpq %rcx, 0x8(%r9)
je 0xb4a4b
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
sete %al
jne 0xb4a4b
cmpq %rcx, 0x8(%rdx)
jne 0xb4a39
testb %al, %al
jne 0xb4a54
movb $0x1, (%r13)
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r10, %rdx
movq %r9, %rcx
movq %r13, %r8
movq %r10, %r14
callq 0xb401a
testb %al, %al
je 0xb4a81
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb5374
andb %al, %bpl
jmp 0xb4a85
xorl %eax, %eax
xorl %ebp, %ebp
movq 0x10(%rsp), %r9
movq %r14, %r10
movq 0x8(%rsp), %rdi
jmp 0xb4750
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x8(%rsp), %rdi
jmp 0xb475c
movb $0x1, %bpl
andb $0x1, %bpl
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq