// File: /workspace/github_c_makefile_star2_O3/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 0xa658e
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 0xa5860
cmpl $0xa, %eax
jne 0xa59e0
movq (%r12), %rsi
btl $0x18, %esi
jb 0xa59e0
btq $0x30, %rsi
jae 0xa5993
movq 0x8(%r14), %rax
movq 0x18(%rax), %rdx
movq 0x20(%r12), %rcx
movl $0x18, %edi
cmpq %rcx, %rdx
je 0xa5835
movq %rax, %r8
movq %rdx, %r9
jle 0xa582c
movq %rax, %r8
movq 0x10(%r8), %r8
movq 0x18(%r8), %r9
cmpq %r9, %rcx
jl 0xa581f
cmpq %rcx, %r9
jne 0xa59f5
movq (%r12,%rdi), %r9
cmpb $0x20, (%r9)
jne 0xa5993
movq (%r9), %rdi
andl $0x1000000, %edi        # imm = 0x1000000
andl $0x40000, %esi          # imm = 0x40000
orq %rdi, %rsi
jne 0xa59e0
jmp 0xa59a6
movq 0x8(%r12), %rax
cmpb $0xa, (%rax)
jne 0xa59e0
movq 0x10(%r12), %rcx
cmpb $0x1, (%rcx)
jne 0xa59e0
movq 0x10(%rcx), %rcx
movq 0x110(%r14), %rdx
cmpq %rdx, %rcx
je 0xa5896
cmpq %rdx, 0x10(%rcx)
jne 0xa59e0
movq 0x8(%r14), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rax), %rsi
movl $0x18, %ecx
cmpq %rsi, %rdi
je 0xa58c4
jle 0xa58bb
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rsi
jl 0xa58ae
cmpq %rsi, %rdi
jne 0xa5a48
movq (%rax,%rcx), %rsi
cmpb $0x20, (%rsi)
jne 0xa59e0
movq %rsi, 0x8(%rbx)
movq 0x10(%rsi), %rbp
movzbl (%rbp), %ecx
leaq 0xad29c(%rip), %rdx     # 0x152b80
movq (%rbp), %rax
movl %eax, %esi
shrl $0x1e, %esi
andl $0x1, %esi
orb (%rcx,%rdx), %sil
xorl %r13d, %r13d
cmpb $0x1, %sil
jne 0xa59e3
movl %eax, %ecx
andl $0x1000000, %ecx        # imm = 0x1000000
jne 0xa59e3
movzbl %al, %ecx
xorl %r13d, %r13d
leal -0x13(%rcx), %edx
cmpl $0x9, %edx
ja 0xa5bc6
leaq 0x62b34(%rip), %rcx     # 0x10845c
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
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 0xa17a5
testb %al, %al
je 0xa59e3
cmpl $0x7, 0x60(%rbx)
jg 0xa5980
movl $0x8, 0x60(%rbx)
movq (%rbx), %rax
movq %rax, 0x38(%rbx)
leaq -0x205e(%rip), %rax     # 0xa3930
jmp 0xa5c9b
btl $0x12, %esi
jb 0xa59e0
movq 0x8(%r14), %rax
movq 0x18(%rax), %rdx
movq 0x20(%r12), %rcx
movl $0x18, %esi
cmpq %rcx, %rdx
je 0xa59c4
jle 0xa59bf
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdx
cmpq %rdx, %rcx
jl 0xa59b2
cmpq %rcx, %rdx
jne 0xa5a23
movq (%r12,%rsi), %rcx
cmpb $0x20, (%rcx)
jne 0xa59e0
testb $0x1, 0x3(%rcx)
jne 0xa59e0
movq 0x10(%rcx), %rax
cmpb $0x9, (%rax)
jne 0xa5a75
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
cmpb $0x1c, (%r8)
jne 0xa5835
movq 0x8(%r8), %r9
testq %r9, %r9
je 0xa5a1d
cmpq %r12, 0x8(%r9)
je 0xa5839
movq 0x18(%r9), %r9
jmp 0xa5a08
movq 0x10(%r8), %r8
jmp 0xa59fa
movl $0x10, %esi
cmpb $0x1c, (%rax)
jne 0xa59c4
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xa5a42
cmpq %r12, 0x8(%rcx)
je 0xa59c8
movq 0x18(%rcx), %rcx
jmp 0xa5a31
movq 0x10(%rax), %rax
jmp 0xa5a28
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xa58c4
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0xa5a6f
cmpq %rax, 0x8(%rsi)
je 0xa58c8
movq 0x18(%rsi), %rsi
jmp 0xa5a5a
movq 0x10(%rdx), %rdx
jmp 0xa5a4d
movslq 0x2258(%r14), %rax
movq %rax, 0x10(%rsp)
movq %rcx, 0x8(%rbx)
movq 0x10(%rcx), %rax
movzbl (%rax), %eax
movq 0x8e8(%r14,%rax,8), %rbp
movq 0x10(%r15), %r13
cmpq 0x10d0(%r14), %rbp
je 0xa5b2c
movq 0x10(%r13), %r13
cmpq 0x11e0(%r14), %rbp
je 0xa5b7c
movq %r14, %rdi
movq %r13, %rsi
callq 0xa844a
movq %r14, %rdi
movq %rax, %rsi
callq 0xa86c6
testb %al, %al
je 0xa5ae3
movq %r14, %rdi
movq %rbp, %rsi
callq 0xa86c6
testb %al, %al
je 0xa59e0
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa2000
testb %al, %al
je 0xa59e0
leaq 0x2bfe(%rip), %rax      # 0xa8700
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
movq 0x2260(%r14,%rax,8), %rax
movq %rax, 0x18(%rbx)
movq (%rax), %rax
movq %rax, 0x20(%rbx)
movabsq $0x100000005, %rax      # imm = 0x100000005
jmp 0xa5bb6
movq 0x10(%r13), %rsi
movq 0x8(%rsi), %rax
cmpb $0xa, (%rax)
jne 0xa5bf9
movq %r14, %rdi
movq %rax, %rsi
callq 0x9f8a2
testq %rax, %rax
je 0xa5aa5
movq %rax, 0x10(%rbx)
leaq 0x23cd(%rip), %rax      # 0xa7f29
movq %rax, (%rbx)
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rax, 0x60(%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
jmp 0xa5ed5
movq 0x8(%r13), %rsi
movzbl (%rsi), %eax
cmpl $0x1, %eax
je 0xa5ee1
cmpl $0xa, %eax
je 0xa5e9e
cmpl $0xd, %eax
jne 0xa5f34
movq %rsi, 0x10(%rbx)
leaq 0x273d(%rip), %rax      # 0xa82e6
movq %rax, (%rbx)
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, 0x60(%rbx)
movl $0x0, 0x70(%rbx)
jmp 0xa5ed9
cmpl $0x1, %ecx
jne 0xa59e3
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xa59e0
leaq -0x234aa(%rip), %r13    # 0x8273e
movq %r13, 0x18(%rbx)
movl $0xb, 0x10(%rsp)
jmp 0xa5fa9
movq %r14, %rdi
callq 0x9fbc8
testb %al, %al
je 0xa5f34
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa7fa6
movb $0x1, %r13b
testb %al, %al
jne 0xa59e3
leaq 0x24ab(%rip), %rax      # 0xa80d1
movq %rax, (%rbx)
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, 0x60(%rbx)
movl $0x0, 0x70(%rbx)
jmp 0xa59e3
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 0x9f4af
testb %al, %al
je 0xa59e3
cmpl $0x7, 0x60(%rbx)
jg 0xa5c8d
movl $0x8, 0x60(%rbx)
movq (%rbx), %rax
movq %rax, 0x38(%rbx)
leaq -0x23c7(%rip), %rax     # 0xa38d4
movq %rax, (%rbx)
jmp 0xa5ed9
movq 0x10(%r12), %rax
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
je 0xa59e0
movq 0x8(%rax), %rax
testb $-0x80, 0x6(%rax)
jne 0xa5cea
cmpb $0x1, (%rax)
jne 0xa5f81
movq 0x8(%rax), %rcx
cmpq 0x17b0(%r14), %rcx
jne 0xa5f81
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
jne 0xa5f81
leaq -0x9a25d(%rip), %r13    # 0xba94
jmp 0xa5f88
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xa59e0
leaq -0x6f3eb(%rip), %r13    # 0x36924
movq %r13, 0x18(%rbx)
movl $0x8, 0x10(%rsp)
jmp 0xa5fa9
shrq $0x30, %rax
movq 0x10(%r12), %rcx
movq 0x10(%rcx), %rdx
movq 0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x110(%r14), %rdx
je 0xa5f58
testq %rcx, %rcx
je 0xa59e0
cmpq $0x2, 0x10(%rcx)
jne 0xa59e0
testb $0x2, %al
leaq 0x2d26(%rip), %rax      # 0xa8a85
leaq 0x2b1a(%rip), %rcx      # 0xa8880
cmoveq %rax, %rcx
movq %rcx, 0x28(%rbx)
movq 0x10(%r12), %r13
movq 0x10(%r13), %r12
movq 0x10(%r15), %rax
movq 0x10(%rax), %r15
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x9f8a2
testq %rax, %rax
je 0xa615b
movq %rax, 0x18(%rbx)
movq 0x8(%r13), %rsi
movq %r14, %rdi
callq 0x9f8a2
testq %rax, %rax
je 0xa615b
movq %rax, 0x10(%rbx)
movq 0x8(%r15), %rax
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0xa5dd8
cmpl $0x1, %ecx
jne 0xa62be
movq 0x8(%rax), %rax
cmpq 0x17b0(%r14), %rax
je 0xa62be
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2000
testb %al, %al
je 0xa59e0
leaq 0x2dd0(%rip), %rax      # 0xa8bc2
movq %rax, (%rbx)
jmp 0xa62dd
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
cmpq 0x110(%r14), %rax
jne 0xa59e0
movq 0x8d8(%r14), %rax
movq 0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
cmpb $0x30, (%rax)
jb 0xa59e0
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xa59e0
cmpl $0xa, (%rax)
je 0xa61bf
movq 0x10(%rax), %rax
xorl %r13d, %r13d
testq %rax, %rax
jne 0xa5e3d
jmp 0xa59e3
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xa59e0
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa844a
cmpq 0x1020(%r14), %rax
jne 0xa59e0
leaq -0x23314(%rip), %r13    # 0x82b79
movq %r13, 0x18(%rbx)
movl $0x9, 0x10(%rsp)
jmp 0xa5fa9
movq %r14, %rdi
callq 0x9f915
testq %rax, %rax
je 0xa5ab6
movq %rax, 0x10(%rbx)
leaq 0x2439(%rip), %rax      # 0xa82f3
movq %rax, (%rbx)
movabsq $0x200000003, %rax      # imm = 0x200000003
movq %rax, 0x60(%rbx)
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rax, 0x70(%rbx)
movb $0x1, %r13b
jmp 0xa59e3
movq %r14, %rdi
movq %r13, %rsi
callq 0x44f61
testb %al, %al
je 0xa5f34
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa8367
testb %al, %al
jne 0xa5bac
leaq 0x24ce(%rip), %rax      # 0xa83d8
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
movq 0x2260(%r14,%rax,8), %rax
movq %rax, 0x20(%rbx)
movq (%rax), %rax
movq %rax, 0x28(%rbx)
movabsq $0x100000006, %rax      # imm = 0x100000006
jmp 0xa5bb6
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq 0x10(%rsp), %r8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa815d
testq %rcx, %rcx
je 0xa5f68
cmpq $0x1, 0x10(%rcx)
jne 0xa59e0
testb $0x2, %al
jne 0xa5f96
leaq -0x23c20(%rip), %r13    # 0x82353
movq %r13, 0x18(%rbx)
movl $0x6, 0x10(%rsp)
jmp 0xa5fa9
leaq 0x2d68(%rip), %r13      # 0xa8cf0
movq %r13, 0x18(%rbx)
movl $0xc, 0x10(%rsp)
jmp 0xa5fa9
leaq 0x2782(%rip), %r13      # 0xa871f
movq %r13, 0x18(%rbx)
movl $0xe, 0x10(%rsp)
movq 0x10(%r12), %r12
movq 0x8(%r12), %rsi
movb (%rsi), %al
cmpb $0xa, %al
jne 0xa6025
movslq 0x2258(%r14), %r12
movq 0x8(%r14), %rdi
callq 0xa56a4
testq %rax, %rax
je 0xa59e0
movq %rax, 0x10(%rbx)
movq 0x10(%rax), %rcx
cmpb $0xb, (%rcx)
jne 0xa6378
testb $0x4, 0x3(%rax)
je 0xa6378
movzbl (%rbp), %eax
cmpl $0x18, %eax
je 0xa625a
cmpl $0x13, %eax
jne 0xa627c
movq 0x10(%rcx), %rax
cmpq 0x8(%rbp), %rax
jg 0xa6378
movl $0x9, 0x10(%rsp)
leaq 0x2d08(%rip), %r13      # 0xa8d28
jmp 0xa6374
movzbl (%rbp), %ecx
cmpl $0x1, %ecx
je 0xa6040
cmpl $0x13, %ecx
je 0xa6040
leaq 0xa4be6(%rip), %rdx     # 0x14ac20
cmpb $0x1, (%rcx,%rdx)
jne 0xa608f
movq %r14, %rdi
movq %r12, %rsi
callq 0x9fbc8
testb %al, %al
je 0xa59e0
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa2000
testb %al, %al
je 0xa59e0
leaq 0x300d(%rip), %rax      # 0xa907f
movq %rax, (%rbx)
movabsq $0x100000004, %rax      # imm = 0x100000004
movq %rax, 0x60(%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x70(%rbx)
jmp 0xa5ed9
cmpb $0x1, %al
jne 0xa60f9
movq 0x8(%rsi), %rax
cmpq 0x17b0(%r14), %rax
jne 0xa60f9
movq 0x10(%rsi), %r13
cmpb $0x1, (%r13)
jne 0xa60f9
movq 0x10(%r13), %rax
cmpq 0x110(%r14), %rax
jne 0xa60f9
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpb $0xa, (%rsi)
jne 0xa60f9
movq 0x8(%r14), %rdi
callq 0xa56a4
testq %rax, %rax
je 0xa60f9
movq 0x8(%r13), %rcx
movq %rcx, 0x20(%rbx)
movq %rax, 0x10(%rbx)
leaq 0x3007(%rip), %rax      # 0xa90f1
movq %rax, (%rbx)
movabsq $0x200000005, %rax      # imm = 0x200000005
jmp 0xa614b
movq %r14, %rdi
movq %r12, %rsi
callq 0xa2000
testb %al, %al
je 0xa59e0
movq 0x10(%r15), %rax
movq 0x10(%rax), %r15
movq 0x8(%r15), %rsi
cmpb $0xa, (%rsi)
jne 0xa623b
movq 0x8(%r14), %rdi
callq 0xa56a4
testq %rax, %rax
je 0xa623b
movq %rax, 0x10(%rbx)
leaq 0x2fd5(%rip), %rax      # 0xa9113
movq %rax, (%rbx)
movabsq $0x200000004, %rax      # imm = 0x200000004
movq %rax, 0x60(%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x70(%rbx)
jmp 0xa6582
movq %r14, %rdi
movq %r13, %rsi
callq 0x9fbc8
testb %al, %al
je 0xa59e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x9fbc8
testb %al, %al
je 0xa59e0
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2000
testb %al, %al
je 0xa59e0
leaq 0x2ac5(%rip), %rax      # 0xa8c60
movq %rax, (%rbx)
movzwl 0x6(%rbp), %eax
andl $0x2, %eax
leal 0x6(,%rax,4), %eax
movabsq $0x100000006, %rcx      # imm = 0x100000006
movq %rcx, 0x60(%rbx)
jmp 0xa6087
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xa59e0
movq %rax, 0x20(%rbx)
movq 0x10(%r12), %r13
movq 0x8(%r13), %rsi
movq %r14, %rdi
callq 0x9f8a2
testq %rax, %rax
je 0xa630b
movq %rax, %r12
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x44f61
testb %al, %al
je 0xa59e0
leaq -0x669f(%rip), %rax     # 0x9fb6d
movq %rax, 0x38(%rbx)
leaq -0x2943(%rip), %rax     # 0xa38d4
movq %rax, (%rbx)
movq %r12, 0x10(%rbx)
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rbx)
movabsq $0x100000003, %rax      # imm = 0x100000003
jmp 0xa5ed5
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2000
testb %al, %al
je 0xa59e0
leaq 0x2f16(%rip), %rax      # 0xa916b
jmp 0xa6072
movq 0x10(%rcx), %rax
cmpq 0x8(%rbp), %rax
jg 0xa6378
movl $0xa, 0x10(%rsp)
leaq 0x2abf(%rip), %r13      # 0xa8d36
jmp 0xa6374
leaq 0xa499d(%rip), %rdx     # 0x14ac20
cmpb $0x1, (%rax,%rdx)
jne 0xa6378
movq 0x10(%rcx), %rcx
cmpq 0x8(%rbp), %rcx
jg 0xa6378
cmpl $0x15, %eax
jne 0xa62aa
testb $0x2, 0x6(%rbp)
jne 0xa6365
movl $0xd, 0x10(%rsp)
leaq 0x2b64(%rip), %r13      # 0xa8e1d
jmp 0xa6374
leaq 0x2969(%rip), %rax      # 0xa8c2e
movq %rax, (%rbx)
movq 0x8(%r15), %rax
cmpb $0x1, (%rax)
jne 0xa62d9
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rbx)
movzwl 0x6(%rbp), %eax
andl $0x2, %eax
leal 0x6(,%rax,4), %eax
movl %eax, 0x70(%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x74(%rbx)
movabsq $0x300000006, %rax      # imm = 0x300000006
jmp 0xa650e
movq %r14, %rdi
movq %r13, %rsi
callq 0x9fbc8
testb %al, %al
je 0xa59e0
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x44f61
testb %al, %al
je 0xa59e0
leaq -0x6000(%rip), %rax     # 0xa033d
movq %rax, 0x38(%rbx)
leaq -0x2a74(%rip), %rax     # 0xa38d4
movq %rax, (%rbx)
movabsq $0x100000005, %rax      # imm = 0x100000005
movq %rax, 0x60(%rbx)
movl $0x3, 0x70(%rbx)
jmp 0xa5ed9
movl $0xe, 0x10(%rsp)
leaq 0x29d9(%rip), %r13      # 0xa8d4d
movq %r13, 0x18(%rbx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %r15
movq 0x8(%r15), %rsi
movzbl (%rsi), %eax
cmpl $0x1, %eax
je 0xa63d7
cmpl $0xa, %eax
jne 0xa651b
movq 0x8(%r14), %rdi
callq 0xa56a4
testq %rax, %rax
je 0xa63fe
movzbl (%rbp), %ecx
cmpq $0x13, %rcx
jne 0xa64c8
movq %r13, 0x20(%rbx)
movq %rax, 0x18(%rbx)
leaq 0x2a69(%rip), %rax      # 0xa8e29
movq %rax, (%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x70(%rbx)
movq $0x1, 0x74(%rbx)
jmp 0xa6504
movq 0x8(%rsi), %rax
cmpq 0x17b0(%r14), %rax
jne 0xa63fe
movq 0x10(%rsi), %rax
cmpb $0x1, (%rax)
jne 0xa63fe
movq 0x10(%rax), %rcx
cmpq 0x110(%r14), %rcx
je 0xa6517
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2000
testb %al, %al
je 0xa59e0
movzbl (%rbp), %eax
cmpq $0x13, %rax
jne 0xa648a
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rbx)
movl 0x10(%rsp), %ebp
movl %ebp, 0x70(%rbx)
movl $0x1, 0x74(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0xa8ec1
movb $0x1, %r13b
testb %al, %al
jne 0xa59e3
leaq 0x2b7e(%rip), %rax      # 0xa8fd5
movq %rax, (%rbx)
movq 0x2260(%r14,%r12,8), %rax
movq %rax, 0x20(%rbx)
movq (%rax), %rax
movq %rax, 0x28(%rbx)
movabsq $0x200000006, %rax      # imm = 0x200000006
movq %rax, 0x60(%rbx)
movl %ebp, 0x70(%rbx)
movl $0x1, 0x74(%rbx)
jmp 0xa59e3
cmpq $0x1, %rax
je 0xa641b
leaq 0xa4789(%rip), %rcx     # 0x14ac20
cmpb $0x0, (%rax,%rcx)
jne 0xa641b
leaq 0x2b7d(%rip), %rax      # 0xa9025
movq %rax, (%rbx)
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x70(%rbx)
movl %eax, 0x74(%rbx)
jmp 0xa5ed9
cmpq $0x1, %rcx
je 0xa63b1
leaq 0xa4747(%rip), %rdx     # 0x14ac20
cmpb $0x0, (%rcx,%rdx)
jne 0xa63b1
movq %r13, 0x20(%rbx)
movq %rax, 0x18(%rbx)
leaq 0x2961(%rip), %rax      # 0xa8e53
movq %rax, (%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x70(%rbx)
movq $0x0, 0x74(%rbx)
movabsq $0x300000005, %rax      # imm = 0x300000005
movq %rax, 0x60(%rbx)
jmp 0xa5ed9
movq 0x8(%rax), %rsi
movq %rsi, 0x20(%rbx)
movzbl (%rbp), %eax
cmpq $0x13, %rax
movl 0x10(%rsp), %edx
jne 0xa6554
leaq 0x2945(%rip), %rax      # 0xa8e79
movq %rax, (%rbx)
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rbx)
movl %edx, 0x70(%rbx)
movl $0x1, 0x74(%rbx)
jmp 0xa5ed9
cmpq $0x1, %rax
je 0xa652d
leaq 0xa46bf(%rip), %rcx     # 0x14ac20
cmpb $0x0, (%rax,%rcx)
jne 0xa652d
leaq 0x2931(%rip), %rax      # 0xa8e9f
movq %rax, (%rbx)
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rbx)
movl %edx, 0x70(%rbx)
movl $0x0, 0x74(%rbx)
jmp 0xa5ed9
addq $0x2190, %r14           # imm = 0x2190
movq %r14, %rdi
movl $0x1, %esi
callq 0x8530