// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_cell_set
static bool opt_cell_set(s7_scheme *sc, s7_pointer car_x) /* len == 3 here (p_syntax) */
                {
                    opt_info *opc;
                    s7_pointer target;

                    opc = alloc_opo(sc, car_x);
                    target = cadr(car_x);
                    if (is_symbol(target))
                    {
                        s7_pointer settee;
                        if ((is_constant_symbol(sc, target)) ||
                                (symbol_has_setter(target)))
                            return(return_false(sc, car_x, __func__, __LINE__));
                        settee = symbol_to_slot(sc, target);

                        if ((is_slot(settee)) &&
                                (!is_immutable(settee)) &&
                                (!is_syntax(slot_value(settee))))
                        {
                            s7_pointer atype, stype;
                            int32_t start_pc;
                            start_pc = sc->pc;

                            opc->v[1].p = settee;
                            stype = s7_type_of(sc, slot_value(settee));

                            if (stype == sc->is_integer_symbol)
                            {
                                if (is_symbol(caddr(car_x)))
                                {
                                    s7_pointer val_slot;
                                    val_slot = opt_integer_symbol(sc, caddr(car_x));
                                    if (val_slot)
                                    {
                                        opc->v[2].p = val_slot;
                                        opc->v[0].fp = opt_set_p_i_s;
                                        return(oo_set_type_2(opc, 3, 1, 2, OO_I, OO_I));
                                    }
                                }
                                else
                                {
                                    if (int_optimize(sc, cddr(car_x)))
                                    {
                                        if (!set_p_i_f_combinable(sc, opc))
                                        {
                                            opc->v[0].fp = opt_set_p_i_f;
                                            return(oo_set_type_1(opc, 3, 1, OO_P));
                                        }
                                        oo_check(sc, opc);
                                        return(true);
                                    }
                                    return(check_type_uncertainty(sc, target, car_x, opc, start_pc));
                                }
                            }
                            if (stype == sc->is_float_symbol)
                            {
                                if (is_float(caddr(car_x)))
                                {
                                    opc->v[2].p = caddr(car_x);
                                    opc->v[0].fp = opt_set_p_c;
                                    return(oo_set_type_1(opc, 3, 1, OO_P));
                                }
                                if (is_symbol(caddr(car_x)))
                                {
                                    s7_pointer val_slot;
                                    val_slot = opt_float_symbol(sc, caddr(car_x));
                                    if (val_slot)
                                    {
                                        opc->v[2].p = val_slot;
                                        opc->v[0].fp = opt_set_p_d_s;
                                        return(oo_set_type_2(opc, 3, 1, 2, OO_D, OO_D));
                                    }
                                }
                                else
                                {
                                    if ((is_pair(caddr(car_x))) &&
                                            (float_optimize(sc, cddr(car_x))))
                                    {
                                        if (!set_p_d_f_combinable(sc, opc))
                                        {
                                            opc->v[0].fp = opt_set_p_d_f;
                                            opc->v[4].o1 = sc->opts[start_pc];
                                            opc->v[5].fd = sc->opts[start_pc]->v[0].fd;
                                            return(oo_set_type_1(opc, 6, 1, OO_P));
                                        }
                                        return(oo_set_type_1(opc, 3, 1, OO_P));
                                    }
                                    return(check_type_uncertainty(sc, target, car_x, opc, start_pc));
                                }
                            }
                            atype = opt_arg_type(sc, cddr(car_x));
                            if ((is_some_number(sc, atype)) &&
                                    (!is_some_number(sc, stype)))
                                return(return_false(sc, car_x, __func__, __LINE__));
                            if (cell_optimize(sc, cddr(car_x)))
                            {
                                opc->v[0].fp = opt_set_p_p_f;
                                opc->v[3].o1 = sc->opts[start_pc];
                                opc->v[4].fp = sc->opts[start_pc]->v[0].fp;
                                return(oo_set_type_1(opc, 5, 1, OO_P));
                            }
                        }
                    }
                    else
                    {
                        if ((is_pair(target)) &&
                                (is_symbol(car(target))) &&
                                (is_pair(cdr(target))) &&
                                ((is_null(cddr(target))) || (is_null(cdddr(target)))))
                        {
                            s7_pointer s_slot;
                            s_slot = symbol_to_slot(sc, car(target));
                            if (is_slot(s_slot))
                            {
                                s7_pointer obj;
                                opc->v[1].p = s_slot;
                                obj = slot_value(s_slot);
                                if (/* (!has_methods(obj)) && */ /* not mentioned in d_impicit */
                                        (is_mutable_sequence(obj)))
                                {
                                    opt_type_t op2 = OO_P;
                                    s7_pointer index;
                                    switch (type(obj))
                                    {
                                        case T_STRING:
                                            {
                                                s7_pointer val_type;
                                                if (is_pair(cddr(target))) return(return_false(sc, car_x, __func__, __LINE__));
                                                val_type = opt_arg_type(sc, cddr(car_x));
                                                if (val_type != sc->is_char_symbol)
                                                    return(return_false(sc, car_x, __func__, __LINE__));
                                                opc->v[3].p_pip_f = string_set_p_pip_direct;
                                                op2 = OO_S;
                                            }
                                            break;

                                        case T_VECTOR:
                                            /* is_opt_int below to handle the index */
                                            if (is_null(cddr(target)))
                                            {
                                                if (vector_rank(obj) != 1) return(return_false(sc, car_x, __func__, __LINE__));
                                                if (is_typed_vector(obj))
                                                {
                                                    op2 = OO_TV;
                                                    opc->v[3].p_pip_f = typed_vector_set_p_pip_direct;
                                                }
                                                else
                                                {
                                                    op2 = OO_PV;
                                                    opc->v[3].p_pip_f = vector_set_p_pip_direct;
                                                }
                                            }
                                            else
                                            {
                                                s7_pointer indexp1, indexp2, valp, slot;
                                                if (vector_rank(obj) != 2) return(return_false(sc, car_x, __func__, __LINE__));
                                                opc->v[5].p_piip_f = (is_typed_vector(obj)) ? typed_vector_set_p_piip_direct : vector_set_p_piip_direct;
                                                indexp1 = cdr(target);
                                                indexp2 = cddr(target);
                                                valp = cddr(car_x);
                                                slot = opt_integer_symbol(sc, car(indexp2));
                                                if (slot)
                                                {
                                                    opc->v[3].p = slot;
                                                    slot = opt_integer_symbol(sc, car(indexp1));
                                                    if (slot)
                                                    {
                                                        opc->v[2].p = slot;
                                                        if ((is_symbol(car(valp))) ||
                                                                (is_unquoted_pair(car(valp))))
                                                        {
                                                            if (cell_optimize(sc, valp))
                                                            {
                                                                opc->v[0].fp = opt_p_piip_sssf;
                                                                return(oo_set_type_3(opc, 6, 1, 2, 3, (is_typed_vector(obj)) ? OO_TV : OO_PV, OO_I, OO_I));
                                                            }
                                                            return(return_false(sc, car_x, __func__, __LINE__));
                                                        }
                                                        opc->v[0].fp = opt_p_piip_sssc;
                                                        opc->v[4].p = (is_pair(car(valp))) ? cadar(valp) : car(valp);
                                                        return(oo_set_type_3(opc, 6, 1, 2, 3, (is_typed_vector(obj)) ? OO_TV : OO_PV, OO_I, OO_I));
                                                    }
                                                }
                                                if ((int_optimize(sc, indexp1)) &&
                                                        (int_optimize(sc, indexp2)) &&
                                                        (cell_optimize(sc, valp)))
                                                {
                                                    /* v[1].p is set above as the vector slot */
                                                    opc->v[0].fp = opt_p_piip_sfff;
                                                    return(oo_set_type_1(opc, 6, 1, (is_typed_vector(obj)) ? OO_TV : OO_PV));
                                                }
                                                return(return_false(sc, car_x, __func__, __LINE__));
                                            }
                                            break;

                                        case T_FLOAT_VECTOR:
                                            if (opt_float_vector_set(sc, opc, car(target), cdr(target), (is_null(cddr(target))) ? NULL : cddr(target), cddr(car_x)))
                                            {
                                                if (oo_size(opc) < 8) oo_resize(opc, 8);
                                                opc->v[7].fd = opc->v[0].fd;
                                                opc->v[0].fp = d_to_p;
                                                oo_check(sc, opc);
                                                return(true);
                                            }
                                            return(return_false(sc, car_x, __func__, __LINE__));

                                        case T_BYTE_VECTOR:
                                        case T_INT_VECTOR:
                                            if (opt_int_vector_set(sc, OO_AV, opc, car(target), cdr(target), (is_null(cddr(target))) ? NULL : cddr(target), cddr(car_x)))
                                            {
                                                if (oo_size(opc) < 8) oo_resize(opc, 8);
                                                opc->v[7].fi = opc->v[0].fi;
                                                opc->v[0].fp = i_to_p;
                                                oo_check(sc, opc);
                                                return(true);
                                            }
                                            return(return_false(sc, car_x, __func__, __LINE__));

                                        case T_C_OBJECT:
                                            if ((is_null(cddr(target))) &&
                                                    (is_c_function(c_object_setf(sc, obj))))
                                            {
                                                /* d_7pid_ok assumes cadr is the target, not car etc */
                                                s7_d_7pid_t func;
                                                func = s7_d_7pid_function(c_object_setf(sc, obj));
                                                if (func)
                                                {
                                                    s7_pointer slot;
                                                    opc->v[4].d_7pid_f = func;
                                                    slot = opt_integer_symbol(sc, cadr(target));
                                                    if (slot)
                                                    {
                                                        if (float_optimize(sc, cddr(car_x)))
                                                        {
                                                            opc->v[7].fd = opt_d_7pid_ssf;
                                                            opc->v[0].fp = d_to_p; /* cell_optimize, so need to return s7_pointer */
                                                            opc->v[2].p = slot;
                                                            return(oo_set_type_2(opc, 5, 1, 2, OO_V, OO_I));
                                                        }
                                                    }
                                                    else
                                                    {
                                                        if ((int_optimize(sc, cdr(target))) &&
                                                                (float_optimize(sc, cddr(car_x))))
                                                        {
                                                            opc->v[7].fd = opt_d_7pid_sff;
                                                            opc->v[0].fp = d_to_p;
                                                            return(oo_set_type_1(opc, 5, 1, OO_V));
                                                        }}}
                                            }
                                            return(return_false(sc, car_x, __func__, __LINE__));

                                        case T_PAIR:
                                            if (is_pair(cddr(target))) return(return_false(sc, car_x, __func__, __LINE__));
                                            op2 = OO_L;
                                            opc->v[3].p_pip_f = list_set_p_pip_direct;
                                            break;

                                        case T_HASH_TABLE:
                                            if (is_pair(cddr(target))) return(return_false(sc, car_x, __func__, __LINE__));
                                            op2 = OO_H;
                                            opc->v[3].p_ppp_f = s7_hash_table_set;
                                            break;

                                        case T_LET:
                                            /* here we know the let is a covered mutable let */
                                            if (is_pair(cddr(target))) return(return_false(sc, car_x, __func__, __LINE__));
                                            op2 = OO_E;
                                            if ((is_keyword(cadr(target))) ||
                                                    ((is_quoted_symbol(cadr(target)))))
                                                opc->v[3].p_ppp_f = let_set_1;
                                            else opc->v[3].p_ppp_f = let_set_p_ppp_2;
                                            break;

                                        default:
                                            return(return_false(sc, car_x, __func__, __LINE__));
                                    }
                                    index = cadr(target);
                                    if (is_symbol(index))
                                    {
                                        s7_pointer slot;
                                        int32_t start;
                                        start = sc->pc;
                                        slot = opt_simple_symbol(sc, index);
                                        if (slot)
                                        {
                                            opc->v[2].p = slot;
                                            if ((is_opt_int(slot_value(slot))) &&
                                                    (is_step_end(opc->v[2].p)))
                                            {
                                                if (is_string(obj))
                                                {
                                                    if (denominator(slot_value(opc->v[2].p)) <= string_length(obj))
                                                    {
                                                        opc->v[3].p_pip_f = string_set_unchecked;
                                                        op2 = OO_S;
                                                    }
                                                }
                                                else
                                                {
                                                    if (is_byte_vector(obj))
                                                    {
                                                        if (denominator(slot_value(opc->v[2].p)) <= byte_vector_length(obj))
                                                        {
                                                            opc->v[3].p_pip_f = byte_vector_set_unchecked_p;
                                                            op2 = OO_BV;
                                                        }
                                                    }
                                                    else
                                                    {
                                                        if (is_any_vector(obj)) /* true for all 3 vectors */
                                                        {
                                                            if ((is_any_vector(obj)) &&
                                                                    (denominator(slot_value(opc->v[2].p)) <= vector_length(obj)))
                                                            {
                                                                if ((is_normal_vector(obj)) && (is_typed_vector(obj)))
                                                                {
                                                                    opc->v[3].p_pip_f = typed_vector_set_unchecked;
                                                                    op2 = OO_TV;
                                                                }
                                                                else
                                                                {
                                                                    opc->v[3].p_pip_f = vector_set_unchecked;
                                                                    op2 = OO_AV; /* AV=any vector */
                                                                }}}}}
                                            }
                                            if (is_symbol(caddr(car_x)))
                                            {
                                                s7_pointer val_slot;
                                                val_slot = opt_simple_symbol(sc, caddr(car_x));
                                                if (val_slot)
                                                {
                                                    if ((is_string(obj)) ||
                                                            (is_any_vector(obj)) ||
                                                            (is_pair(obj)))
                                                    {
                                                        opc->v[4].p_pip_f = opc->v[3].p_pip_f;
                                                        opc->v[3].p = val_slot;
                                                        opc->v[0].fp = opt_p_pip_sss;
                                                        return(oo_set_type_3(opc, 5, 1, 2, 3, op2, OO_I, OO_P));
                                                    }
                                                    opc->v[4].p_ppp_f = opc->v[3].p_ppp_f;
                                                    opc->v[3].p = val_slot;
                                                    opc->v[0].fp = opt_p_ppp_sss;
                                                    return(oo_set_type_3(opc, 5, 1, 2, 3, op2, OO_P, OO_P));
                                                }
                                            }
                                            else
                                            {
                                                if ((!is_pair(caddr(car_x))) ||
                                                        (is_proper_quote(sc, caddr(car_x))))
                                                {
                                                    if (!is_pair(caddr(car_x)))
                                                        opc->v[4].p = caddr(car_x);
                                                    else opc->v[4].p = cadr(caddr(car_x));
                                                    if ((is_string(obj)) ||
                                                            (is_any_vector(obj)) ||
                                                            (is_pair(obj)))
                                                    {
                                                        opc->v[0].fp = opt_p_pip_ssc;
                                                        return(oo_set_type_2(opc, 5, 1, 2, op2, OO_I));
                                                    }
                                                    opc->v[0].fp = opt_p_ppp_ssc;
                                                    return(oo_set_type_2(opc, 5, 1, 2, op2, OO_P));
                                                }
                                            }
                                            if (cell_optimize(sc, cddr(car_x)))
                                            {
                                                if ((is_string(obj)) ||
                                                        (is_any_vector(obj)) ||
                                                        (is_pair(obj)))
                                                {
                                                    oo_set_type_2(opc, 5, 1, 2, op2, OO_I); /* needed in p_pip_ssf_combinable! */
                                                    if (p_pip_ssf_combinable(sc, opc, start))
                                                        return(true);
                                                    opc->v[0].fp = opt_p_pip_ssf;
                                                    opc->v[4].o1 = sc->opts[start];
                                                    opc->v[5].fp = sc->opts[start]->v[0].fp;
                                                    return(oo_set_type_2(opc, 6, 1, 2, op2, OO_I));
                                                }
                                                opc->v[0].fp = opt_p_ppp_ssf;
                                                return(oo_set_type_2(opc, 5, 1, 2, op2, op2));
                                            }
                                        }
                                    }
                                    else
                                    {
                                        if ((is_string(obj)) ||
                                                (is_pair(obj)) ||
                                                (is_any_vector(obj)))
                                        {
                                            if ((int_optimize(sc, cdr(target))) &&
                                                    (cell_optimize(sc, cddr(car_x))))
                                            {
                                                opc->v[0].fp = opt_p_pip_sff;
                                                return(oo_set_type_1(opc, 4, 1, op2));
                                            }
                                            return(return_false(sc, car_x, __func__, __LINE__));
                                        }
                                        if ((is_proper_quote(sc, cadr(target))) &&
                                                (is_symbol(caddr(car_x))))
                                        {
                                            s7_pointer val_slot;
                                            val_slot = opt_simple_symbol(sc, caddr(car_x));
                                            if (val_slot)
                                            {
                                                opc->v[4].p = cadr(cadr(target));
                                                opc->v[2].p = val_slot;
                                                opc->v[0].fp = opt_p_ppp_scs;
                                                return(oo_set_type_2(opc, 5, 1, 2, op2, OO_P));
                                            }
                                        }
                                        if (cell_optimize(sc, cdr(target)))
                                        {
                                            if (is_symbol(caddr(car_x)))
                                            {
                                                s7_pointer val_slot;
                                                val_slot = opt_simple_symbol(sc, caddr(car_x));
                                                if (val_slot)
                                                {
                                                    opc->v[2].p = val_slot;
                                                    opc->v[0].fp = opt_p_ppp_sfs;
                                                    return(oo_set_type_2(opc, 4, 1, 2, op2, OO_P));
                                                }
                                            }
                                            if (cell_optimize(sc, cddr(car_x)))
                                            {
                                                opc->v[0].fp = opt_p_ppp_sff;
                                                return(oo_set_type_1(opc, 4, 1, op2));
                                            }}}}}}
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movslq 0x2258(%rdi), %rax
cmpq $0x100, %rax            # imm = 0x100
jge 0xad2c4
movq %rsi, %r15
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r14)
movq 0x2260(%r14,%rax,8), %rbx
movq $0x0, 0x38(%rbx)
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r12
movzbl (%r12), %eax
cmpl $0x1, %eax
je 0xac4d1
cmpl $0xa, %eax
jne 0xac77b
movq (%r12), %rax
btl $0x18, %eax
jb 0xac773
testb $0x1, 0x6(%r12)
je 0xac630
movq 0x8(%r14), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%r12), %rsi
movl $0x18, %ecx
cmpq %rsi, %rdi
je 0xac4a8
jle 0xac46c
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rsi
jl 0xac45f
cmpq %rsi, %rdi
je 0xac4a8
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xac4a8
movq 0x8(%rdx), %rdi
testq %rdi, %rdi
sete %r8b
je 0xac49a
cmpq %r12, 0x8(%rdi)
je 0xac494
movq 0x18(%rdi), %rdi
jmp 0xac47f
xorl %r8d, %r8d
movq %rdi, %rsi
testb %r8b, %r8b
je 0xac4ac
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
je 0xac47b
movq (%r12,%rcx), %rsi
cmpb $0x20, (%rsi)
jne 0xac630
movq (%rsi), %rcx
andl $0x1000000, %ecx        # imm = 0x1000000
andl $0x40000, %eax          # imm = 0x40000
orq %rcx, %rax
jne 0xac773
jmp 0xac63a
movq 0x8(%r12), %rax
cmpb $0xa, (%rax)
jne 0xac77b
movq 0x10(%r12), %rcx
cmpb $0x1, (%rcx)
jne 0xac77b
movq 0x10(%rcx), %rcx
movq 0x110(%r14), %rdx
cmpq %rdx, %rcx
je 0xac507
cmpq %rdx, 0x10(%rcx)
jne 0xac77b
movq 0x8(%r14), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rax), %rsi
movl $0x18, %ecx
cmpq %rsi, %rdi
je 0xac568
jle 0xac52c
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rsi
jl 0xac51f
cmpq %rsi, %rdi
je 0xac568
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xac568
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
sete %r8b
je 0xac554
cmpq %rax, 0x8(%rsi)
je 0xac557
movq 0x18(%rsi), %rsi
jmp 0xac53f
movq %rdi, %rsi
testb %r8b, %r8b
je 0xac56c
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %rsi, %rdi
je 0xac53b
movq (%rax,%rcx), %rsi
cmpb $0x20, (%rsi)
jne 0xac794
movq %rsi, 0x8(%rbx)
movq 0x10(%rsi), %rdx
movzbl (%rdx), %eax
leaq 0xae5f9(%rip), %rcx     # 0x15ab80
cmpb $0x0, (%rax,%rcx)
jne 0xac597
testb $0x40, 0x3(%rdx)
je 0xac794
testb $0x1, 0x3(%rdx)
jne 0xac794
movzbl (%rdx), %eax
xorl %r13d, %r13d
leal -0x13(%rax), %ecx
cmpl $0x9, %ecx
ja 0xac895
leaq 0x64e36(%rip), %rax     # 0x1113f0
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
xorl %ebp, %ebp
jmpq *%rcx
movq 0x8(%r12), %rcx
movq 0x10(%r12), %r8
movq 0x10(%r8), %rax
xorl %r13d, %r13d
cmpq 0x110(%r14), %rax
movl $0x0, %r9d
cmovneq %rax, %r9
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl $0xd, %esi
movq %rbx, %rdx
callq 0xa82ef
movl $0x0, %ebp
testb %al, %al
je 0xac797
cmpl $0x7, 0x60(%rbx)
jg 0xac61d
movl $0x8, 0x60(%rbx)
movq (%rbx), %rax
movq %rax, 0x38(%rbx)
leaq -0x21ad(%rip), %rax     # 0xaa47e
jmp 0xac928
btl $0x12, %eax
jb 0xac773
movq 0x8(%r14), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%r12), %rdx
movl $0x18, %eax
cmpq %rdx, %rsi
je 0xac69c
jle 0xac660
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xac653
cmpq %rdx, %rsi
je 0xac69c
movl $0x10, %eax
cmpb $0x1c, (%rcx)
jne 0xac69c
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
sete %dil
je 0xac688
cmpq %r12, 0x8(%rdx)
je 0xac68b
movq 0x18(%rdx), %rdx
jmp 0xac673
movq %rsi, %rdx
testb %dil, %dil
je 0xac6a0
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
movq %rdx, %rsi
je 0xac66f
movq (%r12,%rax), %rdx
movb $0x1, %al
cmpb $0x20, (%rdx)
jne 0xac792
testb $0x1, 0x3(%rdx)
jne 0xac792
movq 0x10(%rdx), %rcx
cmpb $0x9, (%rcx)
je 0xac777
movslq 0x2258(%r14), %r13
movq %rdx, 0x8(%rbx)
movq 0x10(%rdx), %rax
movzbl (%rax), %eax
movq 0x8e8(%r14,%rax,8), %rbp
cmpq 0x10d0(%r14), %rbp
je 0xac79e
cmpq 0x11e0(%r14), %rbp
je 0xac7f2
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xaf307
movq %r14, %rdi
movq %rax, %rsi
callq 0xaf5f1
testb %al, %al
je 0xac724
movq %r14, %rdi
movq %rbp, %rsi
callq 0xaf5f1
testb %al, %al
je 0xac773
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa8bbb
movb $0x1, %bpl
testb %al, %al
je 0xac88e
leaq 0x2ee5(%rip), %rax      # 0xaf62b
movq %rax, (%rbx)
movq 0x2260(%r14,%r13,8), %rax
movq %rax, 0x18(%rbx)
movq 0x2260(%r14,%r13,8), %rax
movq (%rax), %rax
movq %rax, 0x20(%rbx)
movabsq $0x100000005, %rax      # imm = 0x100000005
jmp 0xac87e
xorl %eax, %eax
xorl %ebp, %ebp
testb %al, %al
je 0xac77d
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xac777
movb $0x1, %r13b
testb %r13b, %r13b
jne 0xac77b
jmp 0xac77d
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsi), %rax
cmpb $0xa, (%rax)
jne 0xac844
movq %r14, %rdi
movq %rax, %rsi
callq 0xa639f
testq %rax, %rax
je 0xac6e9
movq %rax, 0x10(%rbx)
leaq 0x25fb(%rip), %rax      # 0xaedcd
movq %rax, (%rbx)
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rax, 0x60(%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
jmp 0xacbd5
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movzbl (%rsi), %ecx
cmpl $0x1, %ecx
je 0xacbde
cmpl $0xa, %ecx
je 0xacb9e
cmpl $0xd, %ecx
jne 0xacc34
movq %rsi, 0x10(%rbx)
leaq 0x2978(%rip), %rax      # 0xaf19f
movq %rax, (%rbx)
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, 0x60(%rbx)
movl $0x0, 0x70(%rbx)
jmp 0xacbd9
movq %r14, %rdi
callq 0xa66f0
testb %al, %al
je 0xacc34
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaee4a
movb $0x1, %bpl
testb %al, %al
jne 0xacc4a
leaq 0x2704(%rip), %rax      # 0xaef75
movq %rax, (%rbx)
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, 0x60(%rbx)
movl $0x0, 0x70(%rbx)
jmp 0xacc4a
movb $0x1, %al
jmp 0xac777
movl $0x0, %ebp
cmpl $0x1, %eax
jne 0xac797
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xacf77
leaq -0x23cad(%rip), %rax    # 0x88c0f
movq %rax, 0x18(%rbx)
movl $0xb, %r13d
jmp 0xacc9e
movq 0x8(%r12), %rdx
movq 0x10(%r12), %rcx
movq 0x10(%rcx), %rax
xorl %r13d, %r13d
cmpq 0x110(%r14), %rax
movl $0x0, %r8d
cmovneq %rax, %r8
movq 0x10(%r15), %rax
movq 0x10(%rax), %r9
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa5f60
movl $0x0, %ebp
testb %al, %al
je 0xac797
cmpl $0x7, 0x60(%rbx)
jg 0xac91a
movl $0x8, 0x60(%rbx)
movq (%rbx), %rax
movq %rax, 0x38(%rbx)
leaq -0x2506(%rip), %rax     # 0xaa422
movq %rax, (%rbx)
movb $0x1, %bpl
xorl %r13d, %r13d
jmp 0xac797
movq 0x10(%r12), %rax
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
je 0xacf77
movq 0x8(%rax), %rax
testb $-0x80, 0x6(%rax)
jne 0xac97d
cmpb $0x1, (%rax)
jne 0xacc7a
movq 0x8(%rax), %rcx
cmpq 0x17b0(%r14), %rcx
jne 0xacc7a
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
jne 0xacc7a
leaq -0xa0071(%rip), %rax    # 0xc913
jmp 0xacc81
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xacf77
leaq -0x73beb(%rip), %rax    # 0x38db7
movq %rax, 0x18(%rbx)
movl $0x8, %r13d
jmp 0xacc9e
movq 0x10(%r12), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rdx), %rax
movq 0x20(%rax), %rax
cmpq 0x110(%r14), %rcx
je 0xacc51
testq %rax, %rax
je 0xacf77
cmpq $0x2, 0x10(%rax)
jne 0xacf77
movq %rdx, %r13
movzwl 0x6(%rdx), %eax
testb $0x2, %al
leaq 0x2fbd(%rip), %rax      # 0xaf9b0
leaq 0x2db1(%rip), %rcx      # 0xaf7ab
cmoveq %rax, %rcx
movq %rcx, 0x28(%rbx)
movq 0x10(%r12), %rbp
movq 0x10(%rbp), %r12
movq 0x10(%r15), %rax
movq 0x10(%rax), %r15
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0xa639f
testq %rax, %rax
je 0xace4a
movq %rax, 0x18(%rbx)
movq 0x8(%rbp), %rsi
movq %r14, %rdi
callq 0xa639f
testq %rax, %rax
je 0xace4a
movq %rax, 0x10(%rbx)
movq 0x8(%r15), %rax
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0xaca6c
cmpl $0x1, %ecx
jne 0xacf81
movq 0x8(%rax), %rax
cmpq 0x17b0(%r14), %rax
je 0xacf81
movq %r14, %rdi
movq %r15, %rsi
callq 0xa8bbb
testb %al, %al
je 0xacf77
leaq 0x3067(%rip), %rax      # 0xafaed
movq %rax, (%rbx)
jmp 0xacfa0
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
cmpq 0x110(%r14), %rax
jne 0xacf77
movq 0x8d8(%r14), %rax
movq 0x8(%rdx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rdi
cmpb $0x30, (%rdi)
jb 0xacf77
callq 0x47615
testq %rax, %rax
je 0xacf77
movq %rax, 0x20(%rbx)
movq 0x10(%r12), %r13
movq 0x8(%r13), %rsi
movq %r14, %rdi
callq 0xa639f
testq %rax, %rax
je 0xacf25
movq %rax, %r12
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x47b96
testb %al, %al
je 0xacf77
leaq -0x6479(%rip), %rax     # 0xa6695
movq %rax, 0x38(%rbx)
leaq -0x26f7(%rip), %rax     # 0xaa422
movq %rax, (%rbx)
movq %r12, 0x10(%rbx)
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rbx)
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, 0x70(%rbx)
jmp 0xac92b
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
xorl %r13d, %r13d
cmpb $0x1, (%rax)
movl $0x0, %ecx
je 0xacb91
movq 0x10(%r15), %rax
movq %rdx, %r13
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xaf307
movq %r13, %rdx
xorl %r13d, %r13d
movl $0x0, %ecx
cmpq 0x1020(%r14), %rax
jne 0xacb91
leaq -0x23b3b(%rip), %rax    # 0x8904a
movq %rax, 0x18(%rbx)
movb $0x1, %cl
movl $0x9, %r13d
testb %cl, %cl
jne 0xacc9e
jmp 0xacf77
movq %r14, %rdi
callq 0xa6424
testq %rax, %rax
je 0xac6f6
movq %rax, 0x10(%rbx)
leaq 0x25f6(%rip), %rax      # 0xaf1b0
movq %rax, (%rbx)
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rax, 0x60(%rbx)
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rax, 0x70(%rbx)
movb $0x1, %bpl
jmp 0xacc4a
movq %r14, %rdi
movq %rax, %rsi
callq 0x47b96
testb %al, %al
je 0xacc34
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaf224
testb %al, %al
jne 0xac82a
leaq 0x268e(%rip), %rax      # 0xaf295
movq %rax, (%rbx)
movq 0x2260(%r14,%r13,8), %rax
movq %rax, 0x20(%rbx)
movq 0x2260(%r14,%r13,8), %rax
movq (%rax), %rax
movq %rax, 0x28(%rbx)
movabsq $0x100000006, %rax      # imm = 0x100000006
jmp 0xac834
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movl %r13d, %r8d
callq 0xaf001
movl %eax, %ebp
xorl %eax, %eax
jmp 0xac777
testq %rax, %rax
je 0xacc61
cmpq $0x1, 0x10(%rax)
jne 0xacf77
testb $0x2, 0x6(%rdx)
jne 0xacc8d
leaq -0x24446(%rip), %rax    # 0x88828
movq %rax, 0x18(%rbx)
movl $0x6, %r13d
jmp 0xacc9e
leaq 0x2f9a(%rip), %rax      # 0xafc1b
movq %rax, 0x18(%rbx)
movl $0xc, %r13d
jmp 0xacc9e
leaq 0x29b6(%rip), %rax      # 0xaf64a
movq %rax, 0x18(%rbx)
movl $0xe, %r13d
movq 0x10(%r12), %rsi
movq 0x8(%rsi), %r12
movb (%r12), %al
cmpb $0xa, %al
jne 0xacd27
movq %rdx, 0x10(%rsp)
movslq 0x2258(%r14), %rbp
movq %r14, %rdi
movq %r12, %rsi
callq 0xac2d6
testq %rax, %rax
je 0xacd8a
movq %rax, 0x10(%rbx)
movq 0x10(%rax), %rcx
cmpb $0xb, (%rcx)
jne 0xad069
testb $0x4, 0x3(%rax)
je 0xad069
movq 0x10(%rsp), %rdx
movzbl (%rdx), %eax
cmpl $0x18, %eax
je 0xaceb2
cmpl $0x13, %eax
jne 0xaced5
movq 0x10(%rcx), %rax
cmpq 0x8(%rdx), %rax
jg 0xad069
movq %rbp, %rsi
movl $0x9, %r13d
leaq 0x2f31(%rip), %rax      # 0xafc53
jmp 0xad062
movzbl (%rdx), %ecx
cmpl $0x1, %ecx
je 0xacd41
cmpl $0x13, %ecx
je 0xacd41
leaq 0xa5ee5(%rip), %rdx     # 0x152c20
cmpb $0x1, (%rcx,%rdx)
jne 0xacd94
movq %r14, %rdi
callq 0xa66f0
testb %al, %al
je 0xacf77
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa8bbb
testb %al, %al
je 0xacf77
leaq 0x323a(%rip), %rax      # 0xaffaa
movq %rax, (%rbx)
movabsq $0x100000004, %rax      # imm = 0x100000004
movq %rax, 0x60(%rbx)
movl %r13d, 0x70(%rbx)
jmp 0xac92b
xorl %ebp, %ebp
movb $0x1, %r13b
jmp 0xac797
cmpb $0x1, %al
movl %r13d, 0x8(%rsp)
jne 0xacdaf
movq 0x8(%r12), %rax
cmpq 0x17b0(%r14), %rax
je 0xacfd3
xorl %ebp, %ebp
movq %r14, %rdi
callq 0xa8bbb
testb %al, %al
je 0xacd8c
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpb $0xa, (%rsi)
jne 0xace11
movq %r14, %rdi
callq 0xac2d6
testq %rax, %rax
je 0xace08
movq %rax, 0x10(%rbx)
leaq 0x3258(%rip), %rcx      # 0xb003e
movq %rcx, (%rbx)
movabsq $0x200000004, %rcx      # imm = 0x200000004
movq %rcx, 0x60(%rbx)
movl 0x8(%rsp), %ecx
movl %ecx, 0x70(%rbx)
movl $0x0, 0x74(%rbx)
movb $0x1, %bpl
testq %rax, %rax
jne 0xac92e
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa8bbb
movb $0x1, %r13b
testb %al, %al
je 0xac797
leaq 0x3263(%rip), %rax      # 0xb0096
movq %rax, (%rbx)
movabsq $0x100000004, %rax      # imm = 0x100000004
movq %rax, 0x60(%rbx)
movl 0x8(%rsp), %eax
jmp 0xaceaa
movq %r14, %rdi
movq %rbp, %rsi
callq 0xa66f0
testb %al, %al
je 0xacf77
movq %r14, %rdi
movq %r12, %rsi
callq 0xa66f0
testb %al, %al
je 0xacf77
movq %r14, %rdi
movq %r15, %rsi
callq 0xa8bbb
testb %al, %al
je 0xacf77
leaq 0x2d01(%rip), %rax      # 0xafb8b
movq %rax, (%rbx)
movzwl 0x6(%r13), %eax
andl $0x2, %eax
leal 0x6(,%rax,4), %eax
movabsq $0x100000006, %rcx      # imm = 0x100000006
movq %rcx, 0x60(%rbx)
movl %eax, 0x70(%rbx)
jmp 0xac92b
movq 0x10(%rcx), %rax
cmpq 0x8(%rdx), %rax
jg 0xad069
movq %rbp, %rsi
movl $0xa, %r13d
leaq 0x2d91(%rip), %rax      # 0xafc61
jmp 0xad062
movq %rbp, %rsi
leaq 0xa5d41(%rip), %rdx     # 0x152c20
cmpb $0x1, (%rax,%rdx)
jne 0xad066
movq 0x10(%rcx), %rcx
movq 0x10(%rsp), %rdx
cmpq 0x8(%rdx), %rcx
movq %rsi, %rbp
jg 0xad069
cmpl $0x15, %eax
jne 0xacf13
movq 0x10(%rsp), %rax
testb $0x2, 0x6(%rax)
jne 0xad055
movl $0xd, %r13d
leaq 0x2e28(%rip), %rax      # 0xafd48
jmp 0xad062
movq %r14, %rdi
movq %r13, %rsi
callq 0xa66f0
testb %al, %al
je 0xacf77
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x47b96
testb %al, %al
je 0xacf77
leaq -0x6090(%rip), %rax     # 0xa6ebf
movq %rax, 0x38(%rbx)
leaq -0x2b38(%rip), %rax     # 0xaa422
movq %rax, (%rbx)
movabsq $0x100000005, %rax      # imm = 0x100000005
movq %rax, 0x60(%rbx)
movl $0x3, 0x70(%rbx)
jmp 0xac92b
xorl %r13d, %r13d
xorl %ebp, %ebp
jmp 0xac797
leaq 0x2bd1(%rip), %rax      # 0xafb59
movq %rax, (%rbx)
movq 0x8(%r15), %rax
cmpb $0x1, (%rax)
jne 0xacf9c
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rbx)
movzwl 0x6(%r13), %eax
andl $0x2, %eax
leal 0x6(,%rax,4), %eax
movabsq $0x300000006, %rcx      # imm = 0x300000006
movq %rcx, 0x60(%rbx)
movl %eax, 0x70(%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x74(%rbx)
jmp 0xac92b
movq %rsi, %r13
movq 0x10(%r12), %rax
cmpb $0x1, (%rax)
jne 0xad04b
movq 0x10(%rax), %rax
cmpq 0x110(%r14), %rax
jne 0xad04b
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpb $0xa, (%rsi)
jne 0xad04b
movq %r14, %rdi
callq 0xac2d6
testq %rax, %rax
setne %bpl
movq %r13, %rsi
je 0xacdb1
movq 0x10(%r12), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x20(%rbx)
movq %rax, 0x10(%rbx)
leaq 0x2fee(%rip), %rax      # 0xb001c
movq %rax, (%rbx)
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rbx)
movl 0x8(%rsp), %eax
movl %eax, 0x70(%rbx)
jmp 0xad2b8
xorl %ebp, %ebp
movq %r13, %rsi
jmp 0xacdb1
movl $0xe, %r13d
leaq 0x2c16(%rip), %rax      # 0xafc78
movq %rax, 0x18(%rbx)
movq %rsi, %rbp
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movzbl (%rsi), %eax
cmpl $0x1, %eax
je 0xad0e3
cmpl $0xa, %eax
jne 0xad24f
movq %rbp, 0x8(%rsp)
movq %r14, %rdi
callq 0xac2d6
testq %rax, %rax
setne %bpl
je 0xad111
movq 0x10(%rsp), %rcx
movzbl (%rcx), %ecx
cmpq $0x13, %rcx
jne 0xad1f3
movq 0x18(%rbx), %rcx
movq %rcx, 0x20(%rbx)
movq %rax, 0x18(%rbx)
leaq 0x2c93(%rip), %rax      # 0xafd54
movq %rax, (%rbx)
movabsq $0x300000005, %rax      # imm = 0x300000005
movq %rax, 0x60(%rbx)
movl %r13d, 0x70(%rbx)
movq $0x1, 0x74(%rbx)
jmp 0xac92b
movq %rbp, 0x8(%rsp)
movq 0x8(%rsi), %rcx
cmpq 0x17b0(%r14), %rcx
jne 0xad10f
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0xad10f
movq 0x10(%rcx), %rcx
cmpq 0x110(%r14), %rcx
je 0xad243
xorl %ebp, %ebp
movl %r13d, %r12d
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa8bbb
movb $0x1, %r13b
testb %al, %al
movq 0x10(%rsp), %rax
je 0xac797
movzbl (%rax), %eax
cmpq $0x13, %rax
jne 0xad1b7
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rbx)
movl %r12d, 0x70(%rbx)
movl $0x1, 0x74(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %r15
movl %r15d, %edx
callq 0xafdec
movb $0x1, %bpl
testb %al, %al
jne 0xac92e
leaq 0x2d85(%rip), %rax      # 0xaff00
movq %rax, (%rbx)
movq 0x2260(%r14,%r15,8), %rax
movq %rax, 0x20(%rbx)
movq 0x2260(%r14,%r15,8), %rax
movq (%rax), %rax
movq %rax, 0x28(%rbx)
movabsq $0x200000006, %rax      # imm = 0x200000006
movq %rax, 0x60(%rbx)
movl %r12d, 0x70(%rbx)
movl $0x1, 0x74(%rbx)
jmp 0xac92e
cmpq $0x1, %rax
je 0xad13d
leaq 0xa5a5c(%rip), %rcx     # 0x152c20
cmpb $0x0, (%rax,%rcx)
jne 0xad13d
leaq 0x2d7b(%rip), %rax      # 0xaff50
movq %rax, (%rbx)
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rbx)
movl %r12d, 0x70(%rbx)
movl %r12d, 0x74(%rbx)
jmp 0xac92b
cmpq $0x1, %rcx
je 0xad0ae
leaq 0xa5a1c(%rip), %rdx     # 0x152c20
cmpb $0x0, (%rcx,%rdx)
jne 0xad0ae
movq 0x18(%rbx), %rcx
movq %rcx, 0x20(%rbx)
movq %rax, 0x18(%rbx)
leaq 0x2b5d(%rip), %rax      # 0xafd7e
movq %rax, (%rbx)
movabsq $0x300000005, %rax      # imm = 0x300000005
movq %rax, 0x60(%rbx)
movl %r13d, 0x70(%rbx)
movq $0x0, 0x74(%rbx)
jmp 0xac92b
cmpb $0x1, %al
jne 0xad24f
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rsi
movq %rsi, 0x20(%rbx)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpq $0x13, %rax
jne 0xad289
leaq 0x2b3c(%rip), %rax      # 0xafda4
movq %rax, (%rbx)
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rbx)
movl %r13d, 0x70(%rbx)
movl $0x1, 0x74(%rbx)
jmp 0xac92b
cmpq $0x1, %rax
je 0xad261
leaq 0xa598a(%rip), %rcx     # 0x152c20
cmpb $0x0, (%rax,%rcx)
jne 0xad261
leaq 0x2b27(%rip), %rax      # 0xafdca
movq %rax, (%rbx)
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rbx)
movl %r13d, 0x70(%rbx)
movl $0x0, 0x74(%rbx)
jmp 0xac92b
addq $0x2190, %r14           # imm = 0x2190
movq %r14, %rdi
movl $0x1, %esi
callq 0x9530