// File: /workspace/github_c_makefile_star2_O3/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 $0x28, %rsp
cmpb $0x1, (%rsi)
jne 0xad7cf
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
movq 0x8(%r13), %rbp
cmpb $0x1, (%rbp)
jne 0xad7c0
movq 0x8(%rbp), %r14
cmpb $0xa, (%r14)
jne 0xad80c
cmpw $0x20a, (%r14)          # imm = 0x20A
jne 0xad1cf
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
cmpq $0x1c2, %rdx            # imm = 0x1C2
jg 0xad2e7
leaq -0x19f(%rdx), %rcx
cmpq $0x17, %rcx
ja 0xad4a7
leaq 0x5b3f3(%rip), %rsi     # 0x108484
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
movq 0x10(%rbp), %rcx
cmpb $0x1, (%rcx)
jne 0xad80c
movq 0x8(%rcx), %r14
movb (%r14), %al
leal -0x1(%rax), %esi
cmpb $0x1, %sil
ja 0xad80c
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xad80c
movq %r15, 0x18(%rsp)
movq %r12, %rcx
cmpb $0x1, %al
jne 0xad1a7
cmpq $0x1ad, %rdx            # imm = 0x1AD
sete %al
cmpq $0x1b2, %rdx            # imm = 0x1B2
sete %dl
orb %al, %dl
movq %r12, %r15
movq %r12, 0x10(%rsp)
movq 0x8(%r14), %rax
cmpb $0x1, (%rax)
jne 0xad80c
movq %r12, %rcx
movq 0x8(%rax), %r12
testb %dl, %dl
movq %rcx, %rax
cmovneq %r15, %rax
cmpb $0x1, (%rax)
jne 0xad128
cmpq %r12, 0x8(%rax)
je 0xad80c
movq 0x10(%rax), %rax
jmp 0xad113
cmpb $0xa, (%r12)
jne 0xad80c
testb $-0x80, 0x6(%r12)
jne 0xad80c
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xad16c
movq %rbx, %rdi
movq %rbx, 0x20(%rsp)
movl %edx, %ebx
callq 0xa550
movl %ebx, %edx
movq 0x20(%rsp), %rbx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r12, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movq %rcx, 0x4e0(%rbx)
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
movq %rcx, %r15
movq 0x10(%rsp), %r12
je 0xad0f6
movq 0x110(%rbx), %rax
movq %rax, 0x4e0(%rbx)
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %r15
jmp 0xad310
cmpw $0x801, (%rbp)          # imm = 0x801
jne 0xad80c
movq 0x10(%rbp), %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xad00e
testb %al, %al
je 0xad80c
testb $0x2, 0x3(%r14)
je 0xad7c0
movq 0x10(%rbp), %rcx
cmpq 0x110(%rbx), %rcx
je 0xad7d3
movq 0x8(%rcx), %rdx
cmpb $0x1, (%r12)
jne 0xad237
movq %r12, %rax
cmpq %rdx, 0x8(%rax)
je 0xad78e
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xad224
movq 0x8(%rsp), %rax
movb (%rax), %al
cmpb $0x1, %al
jne 0xad25a
movq 0x8(%rsp), %rsi
cmpq %rdx, 0x8(%rsi)
je 0xad78a
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
je 0xad247
movq 0x10(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0xad78a
movq 0x10(%rdx), %rcx
cmpb $0x1, (%rcx)
jne 0xad78a
movq 0x10(%rcx), %rsi
cmpb $0x1, (%rsi)
je 0xad78a
cmpq 0xf70(%rbx), %r14
jne 0xad2b3
movq 0x8(%rdx), %rdx
cmpb $0xa, (%rdx)
jne 0xad2b3
cmpb $0x1, %al
jne 0xad769
movq 0x8(%rsp), %rsi
cmpq %rdx, 0x8(%rsi)
je 0xad78a
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
je 0xad2a0
movq 0x8(%rcx), %rdx
movb (%rdx), %cl
cmpb $0xa, %cl
jne 0xad774
cmpb $0x1, %al
jne 0xad78e
movq 0x8(%rsp), %rax
cmpq %rdx, 0x8(%rax)
je 0xad78a
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xad2cf
jmp 0xad78e
cmpq $0x1cf, %rdx            # imm = 0x1CF
jg 0xad31d
leaq -0x1ca(%rdx), %rcx
cmpq $0x2, %rcx
jae 0xad4d7
movq 0x10(%rbp), %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xad00e
jmp 0xad7bc
cmpq $0x1d0, %rdx            # imm = 0x1D0
je 0xad639
cmpq $0x1e4, %rdx            # imm = 0x1E4
jne 0xad7f3
movq 0x10(%rbp), %rax
cmpb $0x1, (%rax)
jne 0xad80c
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0xad80c
movq 0x8(%rax), %r14
cmpb $0x1, (%r14)
movq %r12, %rcx
jne 0xad44d
movq %r12, %rdx
movq %r15, 0x18(%rsp)
movq %r12, 0x10(%rsp)
movq 0x8(%r14), %rax
cmpb $0x1, (%rax)
jne 0xad80c
movq 0x8(%rax), %r15
cmpb $0x1, (%rdx)
jne 0xad39b
movq %rdx, %rax
cmpq %r15, 0x8(%rax)
je 0xad80c
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xad388
movq 0x8(%rsp), %rax
cmpb $0x1, (%rax)
jne 0xad3bd
movq 0x8(%rsp), %rax
cmpq %r15, 0x8(%rax)
je 0xad80c
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xad3aa
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xad3e2
movq %rbx, %rdi
movq %rdx, %r12
callq 0xa550
movq %r12, %rdx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r15, 0x8(%rcx)
movq %rdx, 0x10(%rcx)
movq %rcx, 0x4e0(%rbx)
movq 0x8(%r14), %rax
movq 0x10(%rax), %rsi
cmpb $0x1, (%rsi)
movq 0x18(%rsp), %r15
jne 0xad437
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq %rcx, %r12
movq %r15, %r8
callq 0xad00e
movq %r12, %rcx
testb %al, %al
je 0xad7fe
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
movq %rcx, %rdx
movq 0x10(%rsp), %r12
je 0xad36f
movq 0x110(%rbx), %rax
movq %rax, 0x4e0(%rbx)
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq %rcx, %r14
movq %r15, %r8
callq 0xad00e
testb %al, %al
je 0xad80c
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0xad7c0
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq %r14, %rcx
jmp 0xad310
cmpq $0x19b, %rdx            # imm = 0x19B
jne 0xad80e
movq 0x10(%rbp), %rax
cmpb $0x1, (%rax)
jne 0xad80c
movq 0x10(%rax), %rax
cmpq 0x110(%rbx), %rax
je 0xad7c0
jmp 0xad80c
cmpq $0x1c3, %rdx            # imm = 0x1C3
jne 0xad80e
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
jne 0xad7c0
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xad00e
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0xad4e4
jmp 0xad80e
movq 0x10(%rbp), %rax
cmpb $0x1, (%rax)
jne 0xad80c
movq 0x8(%rax), %r14
cmpb $0x1, (%r14)
jne 0xad80c
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xad80c
movq 0x8(%r14), %rax
cmpb $0x1, (%rax)
jne 0xad80c
movq 0x10(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0xad80c
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xad00e
testb %al, %al
je 0xad80c
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
je 0xad53e
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rsi
jmp 0xad305
movq 0x10(%rbp), %rax
cmpb $0x1, (%rax)
jne 0xad80c
movq 0x8(%rax), %r14
movzbl (%r14), %ecx
cmpl $0xa, %ecx
je 0xad6a8
cmpl $0x1, %ecx
jne 0xad80c
movq 0x8(%r14), %rax
cmpb $0xa, (%rax)
jne 0xad80c
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xad5e7
jle 0xad5de
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xad5d1
cmpq %rdx, %rsi
jne 0xad733
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0xad80c
movzbl (%rax), %ecx
leaq 0xa557e(%rip), %rdx     # 0x152b80
cmpb $0x0, (%rcx,%rdx)
jne 0xad78a
movq (%rax), %rcx
btl $0x1e, %ecx
jb 0xad78a
cmpb $0x30, %cl
jb 0xad80c
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
testb $0x20, 0x2(%rax)
jne 0xad78a
jmp 0xad80c
movq 0x10(%rbp), %rax
cmpb $0x1, (%rax)
movq 0x8(%rsp), %rdx
jne 0xad80c
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0xad00e
testb %al, %al
je 0xad80c
movq 0x10(%rbp), %r14
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
jne 0xad7c0
movq 0x8(%r14), %rax
cmpb $0x1, (%rax)
jne 0xad80c
movq 0x10(%rax), %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xad00e
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0xad669
jmp 0xad80e
movq (%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xad718
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xad718
movq %r12, 0x10(%rsp)
movq %r15, %r12
movzwl (%r14), %r15d
movl %r15d, %eax
orl $0x8000, %eax           # imm = 0x8000
movw %ax, (%r14)
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0xae07f
andl $0x7fff, %r15d          # imm = 0x7FFF
movw %r15w, (%r14)
testb %al, %al
jne 0xad80c
movq 0x10(%rbp), %rax
movq 0x8(%rax), %r14
movq %r12, %r15
movq 0x10(%rsp), %r12
cmpb $0x1, (%r12)
jne 0xad78a
movq %r12, %rcx
cmpq %r14, 0x8(%rcx)
je 0xad792
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
je 0xad722
jmp 0xad78a
cmpb $0x1c, (%rcx)
jne 0xad757
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xad751
cmpq %rax, 0x8(%rdx)
je 0xad5eb
movq 0x18(%rdx), %rdx
jmp 0xad73c
movq 0x10(%rcx), %rcx
jmp 0xad733
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xad5eb
jmp 0xad80c
movq 0x8(%rcx), %rdx
movb (%rdx), %cl
cmpb $0xa, %cl
je 0xad78e
cmpb $0x1, %cl
jne 0xad78e
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x882f9
testb %al, %al
je 0xad78e
movb $0x1, (%r15)
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0xad00e
testb %al, %al
je 0xad80c
movq 0x10(%rbp), %rdi
movq %r14, %rsi
callq 0xae0b3
testb %al, %al
je 0xad80c
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
je 0xad036
movb $0x1, %al
jmp 0xad80e
cmpq 0x1670(%rbx), %r14
je 0xad7cf
movb $0x1, %al
cmpq 0x1268(%rbx), %r14
je 0xad80e
cmpq 0x1558(%rbx), %r14
sete %al
jmp 0xad80e
cmpq $0x1f1, %rdx            # imm = 0x1F1
je 0xad7cf
jmp 0xad80e
movq 0x110(%rbx), %rax
movq %rax, 0x4e0(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq