// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_cell_do
static bool opt_cell_do(s7_scheme *sc, s7_pointer car_x, int32_t len)
                {
                    opt_info *opc;
                    s7_pointer p, end, frame = NULL, old_e, slot, stop, ind, ind_step, var;
                    int32_t i, var_len, body_len, body_index, step_len, rtn_len, step_pc;
                    bool has_set = false;

                    /* fprintf(stderr, "%s: %s\n", __func__, DISPLAY_80(car_x)); */

                    if (len < 3)
                        return(return_false(sc, car_x, __func__, __LINE__));

                    if (!s7_is_proper_list(sc, cadr(car_x)))
                        return(return_false(sc, car_x, __func__, __LINE__));
                    var_len = safe_list_length(cadr(car_x));
                    step_len = var_len;
                    body_len = len - 3;
                    end = caddr(car_x);
                    if (!is_pair(end))
                        return(return_false(sc, car_x, __func__, __LINE__));

                    old_e = sc->envir;
                    opc = alloc_opo(sc, car_x);

                    new_frame(sc, sc->envir, frame);
                    push_stack(sc, OP_GC_PROTECT, old_e, frame);

                    /* the vars have to be added to the frame before evaluating the inits
                     *    else symbol_id can be > let_id (see "(test (do ((i (do ((i (do ((i 0 (+ i 1)))...")
                     */
                    clear_symbol_list(sc);
                    for (p = cadr(car_x); is_pair(p); p = cdr(p))
                    {
                        s7_pointer var, sym;
                        var = car(p);
                        if ((is_pair(var)) &&
                                (is_symbol(car(var))) &&
                                (is_pair(cdr(var))))
                        {
                            sym = car(var);

                            if ((is_constant_symbol(sc, sym)) ||
                                    (symbol_has_setter(sym)))
                                return(return_false(sc, car_x, __func__, __LINE__));
                            if (symbol_is_in_list(sc, sym))
                                eval_error(sc, "duplicate identifier in do: ~A", 30, var);
                            add_symbol_to_list(sc, sym);
                            add_slot(frame, sym, sc->undefined);
                        }
                        else return(return_false(sc, car_x, __func__, __LINE__));
                    }

                    if (tis_slot(let_slots(frame)))
                        let_set_slots(frame, reverse_slots(sc, let_slots(frame)));

                    for (p = cadr(car_x), slot = let_slots(frame); is_pair(p); p = cdr(p), slot = next_slot(slot))
                    {
                        s7_pointer var;
                        var = car(p);
                        if (!cell_optimize(sc, cdr(var))) /* opt init in outer env */
                            return(return_false(sc, car_x, __func__, __LINE__));
                        if (is_pair(cddr(var)))
                        {
                            set_has_stepper(slot);
                            if (!is_null(cdddr(var)))
                                return(return_false(sc, car_x, __func__, __LINE__));
                        }
                        else
                        {
                            step_len--;
                            if (!is_null(cddr(var)))
                                return(return_false(sc, car_x, __func__, __LINE__));
                        }
                        if (is_symbol(cadr(var)))
                            slot_set_value(slot, slot_value(symbol_to_slot(sc, cadr(var))));
                        else
                        {
                            if (!is_pair(cadr(var)))
                                slot_set_value(slot, cadr(var));
                            else
                            {
                                if (is_proper_quote(sc, cadr(var)))
                                    slot_set_value(slot, cadadr(var));
                                else
                                {
                                    s7_pointer sf;
                                    sf = lookup_checked(sc, caadr(var));
                                    if (is_c_function(sf))
                                    {
                                        s7_pointer sig;
                                        sig = c_function_signature(sf);
                                        if ((is_pair(sig)) &&
                                                ((car(sig) == sc->is_integer_symbol) ||
                                                 ((is_pair(car(sig))) &&
                                                  (direct_memq(sc->is_integer_symbol, car(sig))))))
                                            slot_set_value(slot, small_int(0));
                                    }}}}}
                    sc->envir = frame;
                    for (p = cadr(car_x); is_pair(p); p = cdr(p))
                    {
                        s7_pointer var;
                        var = car(p);
                        if (is_pair(cddr(var)))
                        {
                            s7_pointer init_type;
                            init_type = opt_arg_type(sc, cdr(var));
                            if (((init_type == sc->is_integer_symbol) ||
                                        (init_type == sc->is_float_symbol)) &&
                                    (opt_arg_type(sc, cddr(var)) != init_type))
                            {
#if OPT_PRINT
                                fprintf(stderr, "init_type: %s, but opt_arg: %s\n", DISPLAY(init_type), DISPLAY(opt_arg_type(sc, cddr(var))));
#endif
                                unstack(sc); /* not pop_stack! */
                                sc->envir = old_e;
                                return(return_false(sc, car_x, __func__, __LINE__));
                            }
                        }
                    }

                    if (!bool_optimize_nw(sc, end))
                    {
                        unstack(sc); /* not pop_stack! */
                        sc->envir = old_e;
                        return(return_false(sc, car_x, __func__, __LINE__));
                    }

                    stop = car(end);
                    if ((is_proper_list_3(sc, stop)) &&
                            ((car(stop) == sc->num_eq_symbol) || (car(stop) == sc->geq_symbol) || (car(stop) == sc->gt_symbol)) &&
                            (is_symbol(cadr(stop))) &&
                            ((is_opt_int(caddr(stop))) || (is_symbol(caddr(stop)))))
                    {
                        s7_pointer stop_slot;
                        if (is_symbol(caddr(stop)))
                            stop_slot = opt_integer_symbol(sc, caddr(stop));
                        else stop_slot = sc->nil;
                        if (stop_slot)
                        {
                            s7_int lim;
                            bool set_stop = false;
                            s7_pointer slot;

                            if (is_slot(stop_slot))
                                lim = integer(slot_value(stop_slot));
                            else lim = integer(caddr(stop));
                            if (car(stop) == sc->gt_symbol) lim++;

                            for (p = cadr(car_x), slot = let_slots(frame); is_pair(p); p = cdr(p), slot = next_slot(slot))
                            {
                                /* this could be put off until it is needed (ref/set), but this code is not called much
                                 *    another choice: go from init downto 0: init is lim
                                 */
                                if (slot_symbol(slot) == cadr(stop))
                                    set_stop = true; /* don't overrule this decision below */
                                if (has_stepper(slot))
                                {
                                    s7_pointer var, step;
                                    var = car(p);
                                    step = caddr(var);
                                    if ((is_opt_int(slot_value(slot))) &&
                                            (is_pair(step)) &&
                                            (is_pair(cdr(step))) &&
                                            (car(var) == cadr(stop)) &&
                                            (car(var) == cadr(step)) &&
                                            ((car(stop) != sc->num_eq_symbol) || /* else > protects at least the top */
                                             ((caddr(step) == small_int(1)) && (car(step) == sc->add_symbol))))
                                    {
                                        set_step_end(slot);
                                        denominator(slot_value(slot)) = lim;
                                    }
                                }
                            }

                            if (!set_stop)
                            {
                                s7_pointer slot;
                                slot = opt_integer_symbol(sc, cadr(stop));
                                if ((slot) &&
                                        (stop_is_safe(sc, cadr(stop), cddr(car_x))))
                                {
                                    set_step_end(slot);
                                    denominator(slot_value(slot)) = lim;
                                }
                            }
                        }
                    }

                    /* opt body */
                    body_index = sc->pc;
                    for (i = 3, p = cdddr(car_x); i < len; i++, p = cdr(p))
                    {
                        opt_info *start;
                        start = sc->opts[sc->pc];
                        if (!cell_optimize(sc, p))
                            break;
                        oo_idp_nr_fixup(start);
                    }

                    if (!is_null(p))
                    {
                        unstack(sc);
                        sc->envir = old_e;
                        return(return_false(sc, car_x, __func__, __LINE__));
                    }

                    /* we faked up sc->envir above, so s7_optimize_1 (float_optimize) isn't safe here
                     *    this means if clm nested loops get here, they aren't fully optimized -- fallback into dox would be better
                     */
                    step_pc = sc->pc;
                    for (p = cadr(car_x); is_pair(p); p = cdr(p))
                    {
                        s7_pointer var;
                        var = car(p);
                        opc->v[9].i = sc->pc;
                        if ((is_pair(cddr(var))) &&
                                (!cell_optimize(sc, cddr(var))))
                            break;
                    }

                    if (!is_null(p))
                    {
                        unstack(sc);
                        sc->envir = old_e;
                        return(return_false(sc, car_x, __func__, __LINE__));
                    }

                    rtn_len = 0;
                    opc->v[1].i = sc->pc - 1;
                    if (!is_list(cdr(end)))
                    {
                        unstack(sc);
                        sc->envir = old_e;
                        return(return_false(sc, car_x, __func__, __LINE__));
                    }
                    for (p = cdr(end); is_pair(p); p = cdr(p), rtn_len++)
                        if (!cell_optimize(sc, p))
                            break;
                    if (!is_null(p))
                    {
                        unstack(sc);
                        sc->envir = old_e;
                        return(return_false(sc, car_x, __func__, __LINE__));
                    }
                    opc->v[2].p = frame;
                    opc->v[3].i = len - 3; /* body_len */
                    opc->v[4].i = rtn_len;
                    opc->v[5].i = sc->pc - 1;
                    opc->v[9].o1 = sc->opts[step_pc];
                    sc->envir = old_e;

                    if ((var_len == 0) && (rtn_len == 0))
                    {
                        opc->v[0].fp = opt_do_no_vars;
                        return(oo_set_type_0(opc, 10));
                    }
                    opc->v[8].i = 0;
                    if (body_len == 1)
                    {
                        s7_pointer expr;
                        expr = cadddr(car_x);
                        if ((is_pair(expr)) &&
                                ((is_safe_setter(car(expr))) ||
                                 ((car(expr) == sc->vector_set_symbol) &&
                                  (is_null(cddddr(expr))) &&
                                  (is_code_constant(sc, cadddr(expr))))))
                            opc->v[8].i = 1;
                    }
                    if ((var_len != 1) || (step_len != 1) || (rtn_len != 0))
                    {
                        opc->v[0].fp = ((step_len == 1) && (body_len == 1) && (rtn_len == 1)) ? opt_do_step_1 : opt_do_any;
                        /* (do ((sum 0.0) (k 0 (+ k 1))) ((= k size) (set! (C i j) sum)) (set! sum (+ sum (* (A i k) (B k j))))) tmat */
                        return(oo_set_type_0(opc, 10));
                    }

                    opc->v[0].fp = (body_len == 1) ? opt_do_1 : opt_do_n;

                    var = caadr(car_x);
                    ind = car(var);
                    ind_step = caddr(var);
                    end = caaddr(car_x);
                    slot = let_slots(frame);

                    if ((is_pair(end)) &&                      /* (= i len|100) */
                            (cadr(end) == ind) &&
                            (is_pair(ind_step)))                   /* (+ i 1) */
                    {
                        if (((car(end) == sc->num_eq_symbol) || (car(end) == sc->geq_symbol)) &&
                                ((is_symbol(caddr(end))) || (is_t_integer(caddr(end)))) &&
                                (is_null(cdddr(end))) &&
                                (car(ind_step) == sc->add_symbol) &&
                                (cadr(ind_step) == ind) &&
                                (caddr(ind_step) == small_int(1)) &&
                                (is_null(cdddr(ind_step))) &&
                                (do_is_safe(sc, cdddr(car_x), sc->w = list_1(sc, ind), sc->nil, &has_set)))
                        {
                            let_set_dox_slot1(frame, slot);
                            let_set_dox_slot2_unchecked(frame, (is_symbol(caddr(end))) ? symbol_to_slot(sc, caddr(end)) : sc->undefined);
                            slot_set_value(slot, make_mutable_integer(sc, integer(slot_value(slot))));
                            opc->v[4].i = body_index;
                            if (body_len == 1)
                            {
                                opt_info *o1;
                                opc->v[0].fp = opt_do_very_simple;
                                if (is_t_integer(caddr(end)))
                                    opc->v[3].i = integer(caddr(end));

                                o1 = sc->opts[body_index];
                                /* v2, v3, v4, v5 are in use */
                                if (o1->v[0].fp == d_to_p_nr)
                                {
                                    /* snd-test: (do ((k 0 (+ k 1))) ((= k N)) (float-vector-set! rl k (read-sample rd))) */
                                    opc->v[0].fp = opt_do_prepackaged;
                                    opc->v[7].fp = opt_do_dpnr;
                                }
                                else
                                {
                                    if (o1->v[0].fp == i_to_p_nr)
                                    {
                                        opc->v[0].fp = opt_do_prepackaged;
                                        opc->v[7].fp = opt_do_ipnr;
                                    }
                                    else
                                    {
                                        if (o1->v[0].fp == opt_set_p_i_fo1)
                                        {
                                            opc->v[0].fp = opt_do_prepackaged;
                                            opc->v[7].fp = opt_do_setpif;
                                        }}}}
                            else
                            {
                                opc->v[0].fp = opt_dotimes_2;
                                if (is_t_integer(caddr(end)))
                                    opc->v[6].i = integer(caddr(end));
                            }
                        }
                        else
                        {
                            if ((car(end) == sc->is_null_symbol) &&
                                    (is_null(cddr(end))) &&
                                    (car(ind_step) == sc->cdr_symbol) &&
                                    (cadr(ind_step) == ind) &&
                                    (is_null(cddr(ind_step))) &&
                                    (body_len == 1) &&
                                    (do_is_safe(sc, cdddr(car_x), sc->w = list_1(sc, ind), sc->nil, &has_set)))
                                opc->v[0].fp = opt_do_list_simple;
                        }
                    }
                    return(oo_set_type_0(opc, 10));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movb $0x0, 0x17(%rsp)
cmpl $0x3, %edx
jge 0xadedc
xorl %r12d, %r12d
jmp 0xaeba1
movl %edx, %ebp
movq %rsi, 0x28(%rsp)
movq 0x10(%rsi), %r13
movq 0x8(%r13), %r15
movq %rdi, 0x8(%rsp)
movq %r15, %rsi
callq 0x3c2fb
xorl %r14d, %r14d
movl $0x0, %r12d
testb %al, %al
je 0xaeba1
cmpb $0x1, (%r15)
jne 0xadf1f
xorl %r14d, %r14d
movq 0x10(%r15), %r15
incl %r14d
cmpb $0x1, (%r15)
je 0xadf12
movq 0x10(%r13), %rax
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
movq 0x8(%rsp), %rdi
jne 0xaded4
movq %rax, 0x50(%rsp)
movslq 0x2258(%rdi), %rax
cmpq $0x100, %rax            # imm = 0x100
jge 0xaec4b
movq 0x8(%rdi), %r12
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%rdi)
movq 0x2260(%rdi,%rax,8), %rbx
movq $0x0, 0x38(%rbx)
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
movq 0x28(%rsp), %r15
ja 0xadf85
callq 0xb389
movq 0x8(%rsp), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rcx
movq $0x20001c, (%rcx)       # imm = 0x20001C
movq 0x250(%rdi), %rax
incq %rax
movq %rax, 0x250(%rdi)
movq %rax, 0x18(%rcx)
movq $0x0, 0x8(%rcx)
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rcx)
movq 0x50(%rdi), %rax
movq %rcx, 0x38(%rsp)
movq %rcx, (%rax)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rdi), %rax
movq %r12, 0x20(%rsp)
movq %r12, 0x10(%rax)
movq 0x50(%rdi), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%rdi)
incl 0xa88(%rdi)
jne 0xae015
movl $0x1, 0xa88(%rdi)
incl 0xa8c(%rdi)
movq 0x10(%r15), %rax
movq 0x8(%rax), %r15
cmpb $0x1, (%r15)
jne 0xae204
leaq 0x725d2(%rip), %r13     # 0x120600
movq 0x8(%r15), %rax
cmpb $0x1, (%rax)
jne 0xae0ed
movq 0x8(%rax), %rcx
cmpb $0xa, (%rcx)
jne 0xae0ed
movq 0x10(%rax), %rdx
cmpb $0x1, (%rdx)
jne 0xae0ed
movq (%rcx), %rdx
btl $0x18, %edx
jb 0xae0ed
testb $0x1, 0x6(%rcx)
je 0xae10d
movq 0x8(%rdi), %r11
movq 0x18(%r11), %r9
movq 0x20(%rcx), %r8
movl $0x18, %esi
cmpq %r8, %r9
je 0xae0cf
jle 0xae091
movq 0x10(%r11), %r11
movq 0x18(%r11), %r9
cmpq %r9, %r8
jl 0xae084
cmpq %r8, %r9
je 0xae0cf
movl $0x10, %esi
cmpb $0x1c, (%r11)
jne 0xae0cf
movq 0x8(%r11), %r9
testq %r9, %r9
sete %r10b
je 0xae0c0
cmpq %rcx, 0x8(%r9)
je 0xae0ba
movq 0x18(%r9), %r9
jmp 0xae0a5
xorl %r10d, %r10d
movq %r9, %r8
testb %r10b, %r10b
je 0xae0d3
movq 0x10(%r11), %r11
cmpb $0x1c, (%r11)
je 0xae0a1
movq (%rcx,%rsi), %r8
cmpb $0x20, (%r8)
jne 0xae10d
movq (%r8), %rsi
andl $0x1000000, %esi        # imm = 0x1000000
andl $0x40000, %edx          # imm = 0x40000
orq %rsi, %rdx
je 0xae113
xorl %eax, %eax
xorl %r12d, %r12d
testb %al, %al
je 0xaeba1
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
je 0xae02e
jmp 0xae204
btl $0x12, %edx
jb 0xae0ed
movl 0xa88(%rdi), %edx
cmpl %edx, 0x2c(%rcx)
jne 0xae19d
movq 0x8(%rcx), %rsi
movq 0x20(%rsi), %rsi
movl 0xc(%rsi), %esi
cmpl 0xa8c(%rdi), %esi
jne 0xae19d
movq 0x1918(%rdi), %r12
movq 0x820(%rdi), %rcx
movslq 0x7dc(%rdi), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rdi)
movq %r13, 0x10(%rcx)
movq $0x1e, 0x8(%rcx)
movq 0x6e0(%rdi), %rdx
movq %rcx, 0x8(%rdx)
movq 0x6e0(%rdi), %rcx
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rdi), %rdx
movq %r12, %rsi
callq 0x3b366
movq 0x8(%rsp), %rdi
testq %r12, %r12
setne %r12b
xorl %eax, %eax
jmp 0xae0f2
movl %edx, 0x2c(%rcx)
movl 0xa8c(%rdi), %eax
movq 0x8(%rcx), %rdx
movq 0x20(%rdx), %rdx
movl %eax, 0xc(%rdx)
movq 0x90(%rdi), %rax
movq 0x128(%rdi), %rdx
leaq -0x8(%rax), %rsi
movq %rsi, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0x20, (%rax)
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rax, 0x18(%rcx)
movq 0x38(%rsp), %rsi
movq 0x18(%rsi), %rdx
movq %rdx, 0x20(%rcx)
incl 0x28(%rcx)
movq 0x8(%rsi), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x8(%rsi)
movb $0x1, %al
jmp 0xae0f2
movq 0x38(%rsp), %rax
leaq 0x8(%rax), %r15
movq (%r15), %rax
testq %rax, %rax
movq 0x28(%rsp), %rsi
je 0xae232
xorl %ecx, %ecx
movq %rcx, %rdx
movq %rax, %rcx
movq 0x18(%rax), %rax
movq %rdx, 0x18(%rcx)
testq %rax, %rax
jne 0xae21c
movq %rcx, (%r15)
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r13
cmpb $0x1, (%r13)
movl %ebp, 0x30(%rsp)
movq %r15, 0x48(%rsp)
jne 0xae47c
movl %r14d, 0x34(%rsp)
movq (%r15), %r15
movq 0x8(%r13), %rbp
movq 0x10(%rbp), %rsi
callq 0xa8bbb
testb %al, %al
je 0xae287
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xae296
orb $-0x80, 0x2(%r15)
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
jmp 0xae29a
xorl %ecx, %ecx
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
jmp 0xae33a
decl 0x34(%rsp)
movq 0x8(%rsp), %rdi
cmpq 0x110(%rdi), %rax
je 0xae2b2
xorl %ecx, %ecx
xorl %r12d, %r12d
jmp 0xae33a
movq 0x10(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0xae35a
cmpl $0xa, %ecx
jne 0xae334
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %r8
movq 0x20(%rax), %rsi
movl $0x18, %ecx
cmpq %rsi, %r8
je 0xae32c
jle 0xae2f0
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r8
cmpq %r8, %rsi
jl 0xae2e3
cmpq %rsi, %r8
je 0xae32c
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xae32c
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
sete %r8b
je 0xae318
cmpq %rax, 0x8(%rsi)
je 0xae31b
movq 0x18(%rsi), %rsi
jmp 0xae303
movq %r9, %rsi
testb %r8b, %r8b
je 0xae330
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %rsi, %r9
je 0xae2ff
movq (%rax,%rcx), %rsi
movq 0x10(%rsi), %rax
movq %rax, 0x10(%r15)
movb $0x1, %cl
testb %cl, %cl
je 0xaeba1
addq $0x18, %r15
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
je 0xae253
jmp 0xae481
movq 0x8(%rax), %rcx
cmpq 0x17b0(%rdi), %rcx
jne 0xae381
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0xae381
movq 0x10(%rcx), %rcx
cmpq 0x110(%rdi), %rcx
je 0xae46f
movq 0x8(%rax), %rsi
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdx
movq 0x20(%rsi), %rax
cmpq %rax, %rdx
je 0xae3aa
jle 0xae3a5
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdx
cmpq %rdx, %rax
jl 0xae398
cmpq %rax, %rdx
jne 0xae429
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xae3c1
callq 0xa2ee9
movq 0x8(%rsp), %rdi
movb $0x1, %cl
cmpb $0x30, (%rax)
jb 0xae33a
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
cmpb $0x1, (%rax)
jne 0xae33a
movq 0x8(%rax), %rax
movq 0x10d0(%rdi), %rdx
cmpq %rdx, %rax
je 0xae41d
cmpb $0x1, (%rax)
jne 0xae33a
cmpq %rdx, 0x8(%rax)
je 0xae41d
movq 0x10(%rax), %rax
movb (%rax), %sil
cmpb $0x1, %sil
jne 0xae33a
cmpq %rdx, 0x8(%rax)
jne 0xae3fc
cmpb $0x1, %sil
jne 0xae33a
movq 0xa052c(%rip), %rax     # 0x14e950
jmp 0xae334
cmpb $0x1c, (%rcx)
jne 0xae45b
movq 0x8(%rcx), %r8
testq %r8, %r8
sete %dl
je 0xae44a
cmpq %rsi, 0x8(%r8)
je 0xae446
movq 0x18(%r8), %r8
jmp 0xae432
movq 0x10(%r8), %rax
testb %dl, %dl
je 0xae3b2
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xae42e
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
je 0xae3ae
xorl %eax, %eax
jmp 0xae3b2
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
jmp 0xae334
movl %r14d, 0x34(%rsp)
movq %rbx, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rdi)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r15
cmpb $0x1, (%r15)
jne 0xae50e
movq 0x8(%r15), %rbx
movq 0x10(%rbx), %rsi
movq 0x10(%rsi), %rax
movb $0x1, %bpl
cmpb $0x1, (%rax)
jne 0xae4ff
callq 0xaf307
movq 0x8(%rsp), %rdi
movq %rax, %r13
cmpq 0x10d0(%rdi), %rax
je 0xae4d5
cmpq 0x11e0(%rdi), %r13
jne 0xae4ff
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
callq 0xaf307
movq 0x8(%rsp), %rdi
cmpq %r13, %rax
je 0xae4ff
addq $-0x20, 0x50(%rdi)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rdi)
xorl %ebp, %ebp
xorl %r12d, %r12d
testb %bpl, %bpl
je 0xaeba1
movq 0x10(%r15), %r15
jmp 0xae49c
movq 0x50(%rsp), %rbx
movq %rbx, %rsi
movq %rdi, %r12
callq 0xb0bfb
testb %al, %al
je 0xae5c4
movq 0x8(%rbx), %r15
cmpb $0x1, (%r15)
movq 0x18(%rsp), %rbx
movq %r12, %rdi
movl 0x30(%rsp), %ebp
jne 0xae55f
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0xae55f
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xae55f
movq 0x10(%rax), %rax
cmpq 0x110(%rdi), %rax
je 0xae6c0
movslq 0x2258(%rdi), %rax
movq %rax, 0x40(%rsp)
movq 0x28(%rsp), %r15
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %r12
cmpl $0x3, %ebp
je 0xae5de
cmpl $0x5, %ebp
movl %ebp, %eax
movl $0x4, %ebp
cmovgel %eax, %ebp
addl $-0x3, %ebp
movslq 0x2258(%rdi), %rax
movq 0x2260(%rdi,%rax,8), %r13
movq %r12, %rsi
callq 0xa8bbb
testb %al, %al
je 0xae5d9
movq %r13, %rdi
callq 0xb080a
movq 0x10(%r12), %r12
decl %ebp
movq 0x8(%rsp), %rdi
jne 0xae591
jmp 0xae5de
addq $-0x20, 0x50(%r12)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%r12)
jmp 0xaded4
movq 0x8(%rsp), %rdi
cmpq 0x110(%rdi), %r12
je 0xae5fa
addq $-0x20, 0x50(%rdi)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rdi)
jmp 0xaded4
movslq 0x2258(%rdi), %r13
movq 0x10(%r15), %rax
movq 0x8(%rax), %r15
cmpb $0x1, (%r15)
movq 0x20(%rsp), %r12
jne 0xae64e
movl 0x30(%rsp), %ebp
movq 0x8(%r15), %rax
movslq 0x2258(%rdi), %rcx
movq %rcx, 0x48(%rbx)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0xae642
callq 0xa8bbb
movq 0x8(%rsp), %rdi
testb %al, %al
je 0xae652
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
je 0xae618
jmp 0xae652
movl 0x30(%rsp), %ebp
cmpq 0x110(%rdi), %r15
jne 0xae6b2
movslq 0x2258(%rdi), %rax
decq %rax
movq %rax, 0x8(%rbx)
movq 0x50(%rsp), %rcx
movq 0x10(%rcx), %rax
movb (%rax), %al
decb %al
cmpb $0x1, %al
ja 0xae6b2
movq 0x10(%rcx), %r15
xorl %r12d, %r12d
cmpb $0x1, (%r15)
jne 0xae728
xorl %r12d, %r12d
movq %r15, %rsi
callq 0xa8bbb
testb %al, %al
je 0xae723
incl %r12d
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq 0x8(%rsp), %rdi
je 0xae68e
jmp 0xae728
addq $-0x20, 0x50(%rdi)
movq %r12, 0x8(%rdi)
jmp 0xaded4
movq 0x8(%r15), %r12
cmpq 0xea0(%rdi), %r12
je 0xae6e3
cmpq 0xf48(%rdi), %r12
je 0xae6e3
cmpq 0xf58(%rdi), %r12
jne 0xae55f
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
cmpb $0xa, (%rcx)
jne 0xae55f
movq 0x10(%rax), %r13
movq 0x8(%r13), %rsi
movb (%rsi), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0xa, %cl
jne 0xae55f
cmpb $0xa, %al
jne 0xae9d9
callq 0xa639f
movq 0x8(%rsp), %rdi
jmp 0xae9e0
movq 0x8(%rsp), %rdi
cmpq 0x110(%rdi), %r15
jne 0xae5e7
addl $-0x3, %ebp
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rbx)
movl %ebp, %eax
movq %rax, 0x18(%rbx)
movl %r12d, %eax
movq %rax, 0x20(%rbx)
movslq 0x2258(%rdi), %rax
decq %rax
movq %rax, 0x28(%rbx)
movq 0x2260(%rdi,%r13,8), %rax
movq %rax, 0x48(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rdi)
movl %r14d, %eax
orl %r12d, %eax
jne 0xae788
leaq 0x5126(%rip), %rax      # 0xb38a6
movq %rax, (%rbx)
jmp 0xaeb96
movq $0x0, 0x40(%rbx)
cmpl $0x1, %ebp
movq 0x28(%rsp), %r15
jne 0xae7f5
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0xae7f5
movq 0x8(%rax), %rcx
testb $0x1, 0x7(%rcx)
jne 0xae7ed
cmpq 0x1668(%rdi), %rcx
jne 0xae7f5
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
cmpq 0x110(%rdi), %rcx
jne 0xae7f5
movq 0x8(%rax), %rsi
callq 0xb398d
movq 0x8(%rsp), %rdi
testb %al, %al
je 0xae7f5
movq $0x1, 0x40(%rbx)
xorl $0x1, %r14d
movl 0x34(%rsp), %eax
xorl $0x1, %eax
orl %eax, %r14d
orl %r12d, %r14d
je 0xae82e
xorl $0x1, %ebp
xorl $0x1, %r12d
orl %eax, %ebp
leaq 0x5212(%rip), %rax      # 0xb3a2a
leaq 0x532b(%rip), %rcx      # 0xb3b4a
orl %r12d, %ebp
cmoveq %rax, %rcx
movq %rcx, (%rbx)
jmp 0xaeb96
cmpl $0x1, %ebp
leaq 0x5498(%rip), %rax      # 0xb3cd0
leaq 0x563e(%rip), %rcx      # 0xb3e7d
cmoveq %rax, %rcx
movq %rcx, (%rbx)
movq 0x10(%r15), %rcx
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rdx), %r14
cmpb $0x1, (%r14)
jne 0xaeb96
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq 0x8(%rdx), %r12
movq 0x10(%r14), %rcx
cmpq %r12, 0x8(%rcx)
jne 0xaeb96
movq 0x10(%rdx), %rdx
movq 0x10(%rdx), %rdx
movq 0x8(%rdx), %r15
cmpb $0x1, (%r15)
jne 0xaeb96
movq 0x48(%rsp), %rdx
movq (%rdx), %r13
movq 0x8(%r14), %rdx
cmpq 0xea0(%rdi), %rdx
je 0xae8b7
movq 0x8(%rsp), %rsi
cmpq 0xf48(%rsi), %rdx
jne 0xaeb57
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
movb (%rdx), %dl
andb $-0x2, %dl
cmpb $0xa, %dl
jne 0xaeb57
movq 0x8(%rsp), %rdx
movq 0x110(%rdx), %rbx
cmpq %rbx, 0x10(%rcx)
jne 0xaeb57
movq 0x8(%r15), %rcx
movq 0x8(%rsp), %rdx
cmpq 0xba8(%rdx), %rcx
jne 0xaeb57
movq 0x10(%r15), %rcx
cmpq %r12, 0x8(%rcx)
jne 0xaeb57
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
cmpq 0xa0042(%rip), %rdx     # 0x14e958
jne 0xaeb57
cmpq %rbx, 0x10(%rcx)
jne 0xaeb57
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rcx
movq 0x90(%rcx), %rax
cmpq 0x98(%rcx), %rax
ja 0xae94e
movq 0x8(%rsp), %rdi
callq 0xb389
movq 0x8(%rsp), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r12, 0x8(%rdx)
movq %rbx, 0x10(%rdx)
movq %rdx, 0x4d8(%rdi)
movq 0x110(%rdi), %rcx
leaq 0x17(%rsp), %r8
movq 0x20(%rsp), %rsi
callq 0xb401a
testb %al, %al
je 0xaeb57
movq 0x38(%rsp), %rcx
movq %r13, 0x20(%rcx)
movq (%rcx), %r15
movq %r15, %rax
orq $0x10000, %rax          # imm = 0x10000
movq %rax, (%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpb $0xa, (%rsi)
jne 0xaec5c
movq 0x8(%rsp), %rdi
callq 0xccb2
jmp 0xaec68
movq 0x110(%rdi), %rax
testq %rax, %rax
je 0xae55f
addq $0x8, %r13
leaq 0x10(%rax), %rcx
cmpb $0x20, (%rax)
cmovneq %r13, %rcx
xorl %edx, %edx
cmpq 0xf58(%rdi), %r12
movq (%rcx), %rcx
sete %dl
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
addq 0x8(%rcx), %rdx
movq %rdx, 0x40(%rsp)
cmpb $0x1, (%rax)
jne 0xaeafb
xorl %ecx, %ecx
movl $0x1, %edx
movq 0x48(%rsp), %rsi
movq (%rsi), %rsi
movq (%rsi), %rdi
movq 0x10(%r15), %r8
movq 0x8(%r8), %r10
cmpq %r10, 0x8(%rsi)
movzbl %cl, %ecx
cmovel %edx, %ecx
btl $0x17, %edi
jae 0xaead7
movq 0x10(%rsi), %r8
cmpb $0xb, (%r8)
jne 0xaead7
movq 0x8(%rax), %rbx
movq 0x10(%rbx), %r9
movq 0x10(%r9), %r9
movq 0x8(%r9), %r9
cmpb $0x1, (%r9)
jne 0xaead7
movq 0x10(%r9), %r11
cmpb $0x1, (%r11)
jne 0xaead7
movq 0x8(%rbx), %rbx
cmpq %r10, %rbx
jne 0xaead7
cmpq 0x8(%r11), %rbx
jne 0xaead7
movq 0x8(%r15), %r10
movq 0x8(%rsp), %rbx
cmpq 0xea0(%rbx), %r10
je 0xaeab4
orq $0x4000000, %rdi        # imm = 0x4000000
movq %rdi, (%rsi)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%r8)
jmp 0xaead7
movq 0x10(%r11), %r10
movq 0x8(%r10), %r10
cmpq 0x9fe95(%rip), %r10     # 0x14e958
jne 0xaead7
movq 0x8(%r9), %r9
movq 0x8(%rsp), %r10
cmpq 0xba8(%r10), %r9
je 0xaea9f
addq $0x18, %rsi
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xaea32
testb $0x1, %cl
movq 0x18(%rsp), %rbx
movq 0x8(%rsp), %rdi
jne 0xae55f
movq 0x10(%r15), %rax
movq 0x8(%rax), %r13
movq %r13, %rsi
callq 0xa639f
movq 0x8(%rsp), %rdi
testq %rax, %rax
je 0xae55f
movq %rax, %r12
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdx
movq %r13, %rsi
callq 0xb385e
movq 0x8(%rsp), %rdi
testb %al, %al
je 0xae55f
orb $0x4, 0x3(%r12)
movq 0x10(%r12), %rax
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xae55f
movq 0x8(%r14), %rax
movq 0x8(%rsp), %rcx
cmpq 0x1118(%rcx), %rax
movq 0x18(%rsp), %rbx
jne 0xaeb96
movq 0x10(%r14), %rax
movq 0x110(%rcx), %r13
cmpq %r13, 0x10(%rax)
jne 0xaeb96
movq 0x8(%r15), %rax
cmpq 0xda0(%rcx), %rax
jne 0xaeb96
movq 0x10(%r15), %rax
cmpq %r12, 0x8(%rax)
je 0xaebb7
movq $0xa, 0x60(%rbx)
movb $0x1, %r12b
andb $0x1, %r12b
movl %r12d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, %ebp
jne 0xaeb96
cmpq %r13, 0x10(%rax)
jne 0xaeb96
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %r14
movq 0x90(%rcx), %rax
cmpq 0x98(%rcx), %rax
ja 0xaebed
movq 0x8(%rsp), %rdi
callq 0xb389
movq 0x8(%rsp), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r12, 0x8(%rdx)
movq %r13, 0x10(%rdx)
movq %rdx, 0x4d8(%rdi)
movq 0x110(%rdi), %rcx
leaq 0x17(%rsp), %r8
movq %r14, %rsi
callq 0xb401a
testb %al, %al
movq 0x18(%rsp), %rbx
je 0xaeb96
leaq 0x6614(%rip), %rax      # 0xb525a
jmp 0xae780
addq $0x2190, %rdi           # imm = 0x2190
movl $0x1, %esi
callq 0x9530
movq 0x8(%rsp), %rax
movq 0x128(%rax), %rax
movq 0x38(%rsp), %rcx
movq %rax, 0x28(%rcx)
orq $0x810000, %r15         # imm = 0x810000
movq %r15, (%rcx)
movq 0x10(%r13), %rax
movq 0x8(%rax), %rbx
movq 0x8(%rsp), %rcx
movq 0x90(%rcx), %rax
cmpq 0x98(%rcx), %rax
ja 0xaeca2
movq 0x8(%rsp), %rdi
callq 0xb389
movq 0x8(%rsp), %rdx
movq 0x90(%rdx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdx)
movq -0x8(%rax), %rax
movq $0x500000b, (%rax)      # imm = 0x500000B
movq %rbx, 0x8(%rax)
movq %rax, 0x10(%r13)
movq 0x18(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, 0x20(%rax)
cmpl $0x1, %ebp
jne 0xaed65
leaq 0x5ddd(%rip), %rax      # 0xb4ac7
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0xaed10
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq %rax, 0x18(%rcx)
movq 0x8(%rsp), %rax
movq 0x40(%rsp), %rcx
movq 0x2260(%rax,%rcx,8), %rax
movq (%rax), %rax
leaq 0x1bfe(%rip), %rcx      # 0xb092a
cmpq %rcx, %rax
je 0xaed96
leaq 0x1d23(%rip), %rcx      # 0xb0a5b
cmpq %rcx, %rax
je 0xaedae
leaq 0x158f(%rip), %rcx      # 0xb02d3
cmpq %rcx, %rax
movq 0x18(%rsp), %rbx
jne 0xaeb96
leaq 0x6171(%rip), %rax      # 0xb4eca
movq %rax, (%rbx)
leaq 0x62d5(%rip), %rax      # 0xb5038
jmp 0xaedc4
leaq 0x638e(%rip), %rax      # 0xb50fa
movq 0x18(%rsp), %rbx
movq %rax, (%rbx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0xaeb96
movq 0x8(%rax), %rax
movq %rax, 0x30(%rbx)
jmp 0xaeb96
leaq 0x612d(%rip), %rax      # 0xb4eca
movq 0x18(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x61d0(%rip), %rax      # 0xb4f7c
jmp 0xaedc4
leaq 0x6115(%rip), %rax      # 0xb4eca
movq 0x18(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x6216(%rip), %rax      # 0xb4fda
movq %rax, 0x38(%rbx)
jmp 0xaeb96