// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0xf8(%rsp)
movq %rcx, 0xf0(%rsp)
movq %r8, 0xe8(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff710
movq 0xe0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff6f5
movq 0xd8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xff6e9
movq 0xd0(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x20a, %eax            # imm = 0x20A
jne 0xff3d0
movq 0xd0(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
addq $-0x19b, %rax           # imm = 0xFE65
movq %rax, 0x20(%rsp)
subq $0x56, %rax
ja 0xff3be
movq 0x20(%rsp), %rax
leaq 0xe161e(%rip), %rcx     # 0x1dfe3c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xfe869
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x108(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0xfe876
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff3cb
movq 0xf0(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xfe8ac
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xfe8e9
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0xfe8e9
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xfe90e
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xfeb0a
movq 0xb8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xfe95b
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xb8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x1ad, 0xc8(%rsp) # imm = 0x1AD
je 0xfe99c
cmpq $0x1b2, 0xc8(%rsp) # imm = 0x1B2
jne 0xfe9ab
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0xfe9b8
movq 0xf0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xde1a0
testb $0x1, %al
jne 0xfe9cd
jmp 0xfe9da
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xa8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xfea00
movq 0xa8(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xfea0d
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xa8(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x108(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x108(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xfea5a
movq 0x108(%rsp), %rdi
callq 0xc670
movq 0x108(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x98(%rsp), %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x90(%rsp), %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0xa0(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0x4e0(%rax)
movq 0xb8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb8(%rsp)
jmp 0xfe926
movq 0x108(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0x4e0(%rax)
movq 0x108(%rsp), %rdi
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0xb0(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xfeb6e
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff3cb
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xfeb9f
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xfebac
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xf0(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xfedb0
movq 0xb8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xfec09
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xb8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xde1a0
testb $0x1, %al
jne 0xfec4c
movq 0x78(%rsp), %rdi
movq 0xf8(%rsp), %rsi
callq 0xde1a0
testb $0x1, %al
jne 0xfec4c
jmp 0xfec59
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x108(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x108(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xfec9d
movq 0x108(%rsp), %rdi
callq 0xc670
movq 0x108(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x70(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0x4e0(%rax)
movq 0xb8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xfed95
movq 0x108(%rsp), %rdi
movq 0xb8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0x80(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xfed95
movq 0x108(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0x4e0(%rax)
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xfed97
movq 0xb8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb8(%rsp)
jmp 0xfebd4
movq 0x108(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0x4e0(%rax)
movq 0x108(%rsp), %rdi
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0x80(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xfee18
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xfee7e
movq 0x108(%rsp), %rdi
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0x80(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xfee7e
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff3cb
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xfeea4
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xfef89
movq 0x50(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xfeee8
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xfeef5
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0x108(%rsp), %rdi
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xde990
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0xfef6c
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1237a7(%rip), %rax    # 0x2226d0
testb $0x1, (%rax,%rcx)
jne 0xfef79
movq 0x48(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
jne 0xfef79
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0xfef6c
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
andq $0x200000, %rax         # imm = 0x200000
cmpq $0x0, %rax
jne 0xfef79
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xe8(%rsp), %rax
movb $0x1, (%rax)
jmp 0xff05b
movq 0x108(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff02d
movq 0x108(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff02d
movq 0x50(%rsp), %rax
movzwl (%rax), %ecx
orl $0x8000, %ecx           # imm = 0x8000
movw %cx, (%rax)
movq 0x108(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x100790
andb $0x1, %al
movb %al, 0x47(%rsp)
movq 0x50(%rsp), %rax
movzwl (%rax), %ecx
andl $0xffff7fff, %ecx       # imm = 0xFFFF7FFF
movw %cx, (%rax)
testb $0x1, 0x47(%rsp)
je 0xff02b
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff02d
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xf0(%rsp), %rsi
callq 0xde1a0
testb $0x1, %al
jne 0xff059
movq 0xe8(%rsp), %rax
movb $0x1, (%rax)
jmp 0xff05b
movq 0x108(%rsp), %rdi
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xff0a1
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xd8(%rsp), %rdi
movq 0xf8(%rsp), %rsi
callq 0x100820
testb $0x1, %al
jne 0xff0c7
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff3cb
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff110
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff110
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xff11d
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff1bd
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff19b
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff19b
movq 0x108(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xff1a8
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff1aa
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0xff132
movq 0x108(%rsp), %rdi
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xff203
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff3cb
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff277
movq 0x108(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xff265
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff267
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0xff219
jmp 0xff3cb
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xff29d
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0x108(%rsp), %rdi
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xff2e3
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff36b
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff34c
movq 0x108(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xff359
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff35b
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0xff2f8
jmp 0xff3cb
movq 0x108(%rsp), %rdi
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xff3af
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff3cb
movb $0x1, 0x117(%rsp)
jmp 0xff718
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff6e7
movq 0xd8(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x801, %eax            # imm = 0x801
jne 0xff417
movq 0x108(%rsp), %rdi
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xff424
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xd0(%rsp), %rax
movq (%rax), %rax
andq $0x2000000, %rax        # imm = 0x2000000
cmpq $0x0, %rax
je 0xff6e3
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x108(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xff4ca
movq 0xd0(%rsp), %rcx
movq 0x108(%rsp), %rdx
movb $0x1, %al
cmpq 0x1670(%rdx), %rcx
movb %al, 0xf(%rsp)
je 0xff4b8
movq 0xd0(%rsp), %rcx
movq 0x108(%rsp), %rdx
movb $0x1, %al
cmpq 0x1268(%rdx), %rcx
movb %al, 0xf(%rsp)
je 0xff4b8
movq 0xd0(%rsp), %rax
movq 0x108(%rsp), %rcx
cmpq 0x1558(%rcx), %rax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x117(%rsp)
jmp 0xff718
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xf0(%rsp), %rsi
callq 0xde1a0
testb $0x1, %al
jne 0xff67b
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xf8(%rsp), %rsi
callq 0xde1a0
testb $0x1, %al
jne 0xff66e
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff66e
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff66e
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xff66e
movq 0xd0(%rsp), %rax
movq 0x108(%rsp), %rcx
cmpq 0xf70(%rcx), %rax
jne 0xff5d2
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xff5d2
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xf8(%rsp), %rsi
callq 0xde1a0
testb $0x1, %al
jne 0xff66e
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xff61b
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xf8(%rsp), %rsi
callq 0xde1a0
testb $0x1, %al
jne 0xff66e
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xff679
movq 0x108(%rsp), %rdi
movq 0xf8(%rsp), %rsi
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
callq 0xb80b0
testb $0x1, %al
jne 0xff66e
jmp 0xff679
movq 0xe8(%rsp), %rax
movb $0x1, (%rax)
jmp 0xff67b
movq 0x108(%rsp), %rdi
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq 0xf8(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq 0xe8(%rsp), %r8
callq 0xfe710
testb $0x1, %al
jne 0xff6be
movb $0x0, 0x117(%rsp)
jmp 0xff718
movq 0xd8(%rsp), %rdi
movq 0xf8(%rsp), %rsi
callq 0x100820
testb $0x1, %al
jne 0xff6e1
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff6e3
jmp 0xff6e5
jmp 0xff6e7
jmp 0xff6f3
movb $0x0, 0x117(%rsp)
jmp 0xff718
jmp 0xff6f5
jmp 0xff6f7
movq 0xe0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xe0(%rsp)
jmp 0xfe74f
movb $0x1, 0x117(%rsp)
movb 0x117(%rsp), %al
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
nopl (%rax)