// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: splice_in_values
static s7_pointer splice_in_values(s7_scheme *sc, s7_pointer args)
                {
                    int64_t top;
                    s7_pointer x;
                    top = s7_stack_top(sc) - 1; /* stack_end - stack_start if negative, we're in big trouble */
#if SHOW_EVAL_OPS
                    safe_print(fprintf(stderr, "splice %s %s\n", op_names[stack_op(sc->stack, top)], DISPLAY_80(sc->args)));
#endif

                    switch (stack_op(sc->stack, top))
                    {
                        /* the normal case -- splice values into caller's args */
                        case OP_EVAL_ARGS1:
                        case OP_EVAL_ARGS2:
                        case OP_EVAL_ARGS3:
                        case OP_EVAL_ARGS4:
                            /* code = args yet to eval in order, args = evalled args reversed
                             *
                             * it's not safe to simply reverse args and tack the current stacked args onto its (new) end,
                             *   setting stacked args to cdr of reversed-args and returning car because the list (args)
                             *   can be some variable's value in a macro expansion via ,@ and reversing it in place
                             *   (all this to avoid consing), clobbers the variable's value.
                             */
                            for (x = args; is_not_null(cdr(x)); x = cdr(x))
                                stack_args(sc->stack, top) = cons(sc, car(x), stack_args(sc->stack, top));
                            return(car(x));

                            /* in the next set, the main evaluator branches blithely assume no multiple-values,
                             *   and if it happens anyway, we go to a different branch here
                             */
                        case OP_SAFE_CLOSURE_FP_2:
                            stack_element(sc->stack, top) = (s7_pointer)OP_SAFE_CLOSURE_FP_MV_1;
                            goto FP_MV;

                        case OP_SAFE_C_FP_2:
                            stack_element(sc->stack, top) = (s7_pointer)OP_SAFE_C_FP_MV_1;
                            goto FP_MV;

                        case OP_SAFE_C_FP_1:
                        case OP_SAFE_CLOSURE_FP_1:
                            stack_element(sc->stack, top) = (s7_pointer)(stack_op(sc->stack, top) + 1); /* replace with mv version */

                        case OP_SAFE_C_FP_MV_1:
                        case OP_SAFE_CLOSURE_FP_MV_1:
FP_MV:
                            if ((is_immutable(args)) || /* (let () (define (func) (with-output-to-string (lambda () (apply-values (write '(1 2)))))) (func) (func)) */
                                    (needs_copied_args(args)))
                            {
                                clear_needs_copied_args(args);
                                args = copy_list(sc, args);
                            }
                            set_multiple_value(args);
                            return(args);

                        case OP_SAFE_C_SSP_1:
                            stack_element(sc->stack, top) = (s7_pointer)OP_SAFE_C_SSP_MV_1;
                            return(args);

                        case OP_SAFE_C_SP_1:
                        case OP_SAFE_CONS_SP_1:
                        case OP_SAFE_ADD_SP_1:
                        case OP_SAFE_SUBTRACT_SP_1:
                        case OP_SAFE_MULTIPLY_SP_1:
                            stack_element(sc->stack, top) = (s7_pointer)OP_SAFE_C_SP_MV;
                            return(args);

                        case OP_SAFE_C_PS_1:
                            stack_element(sc->stack, top) = (s7_pointer)OP_SAFE_C_PS_MV;
                            return(args);

                        case OP_SAFE_C_PC_1:
                            stack_element(sc->stack, top) = (s7_pointer)OP_SAFE_C_PC_MV;
                            return(args);

                        case OP_SAFE_C_PA_1:
                            stack_element(sc->stack, top) = (s7_pointer)OP_SAFE_C_PA_MV;
                            return(args);

                        case OP_C_P_1:
                        case OP_SAFE_C_P_1:
                        case OP_NOT_P_1:
                            stack_element(sc->stack, top) = (s7_pointer)OP_C_P_MV;
                            return(args);

                        case OP_C_AP_1:
                            stack_element(sc->stack, top) = (s7_pointer)OP_C_AP_MV;
                            return(args);

                        case OP_SAFE_CLOSURE_P_1:
                        case OP_CLOSURE_P_1:
                            stack_element(sc->stack, top) = (s7_pointer)OP_CLOSURE_P_MV;
                            return(args);

                        case OP_SAFE_CLOSURE_AP_1:
                        case OP_CLOSURE_AP_1:
                            stack_element(sc->stack, top) = (s7_pointer)OP_CLOSURE_AP_MV;
                            return(args);

                        case OP_SAFE_CLOSURE_PA_1:
                        case OP_CLOSURE_PA_1:
                            stack_element(sc->stack, top) = (s7_pointer)OP_CLOSURE_PA_MV;
                            return(args);

                        case OP_SAFE_C_PP_1:
                            stack_element(sc->stack, top) = (s7_pointer)OP_SAFE_C_PP_3_MV;
                            return(args);

                        case OP_SAFE_C_PP_5:
                            stack_element(sc->stack, top) = (s7_pointer)OP_SAFE_C_PP_6_MV;
                            return(args);

                        case OP_EVAL_ARGS5:
                            /* code = previous arg saved, args = ante-previous args reversed
                             *   we'll take value->code->args and reverse in args5
                             *   if one value, return it, else
                             *      put code onto args, splice as above until there are 2 left
                             *      set code to first and value to last
                             */
                            if (is_null(args))
                                return(sc->unspecified);

                            if (is_null(cdr(args)))
                                return(car(args));

                            stack_args(sc->stack, top) = cons(sc, stack_code(sc->stack, top), stack_args(sc->stack, top));
                            for (x = args; is_not_null(cddr(x)); x = cdr(x))
                                stack_args(sc->stack, top) = cons(sc, car(x), stack_args(sc->stack, top));
                            stack_code(sc->stack, top) = car(x);
                            return(cadr(x));

                            /* look for errors here rather than glomming up the set! and let code. */
                        case OP_SET_SAFE:             /* symbol is sc->code after pop */
                        case OP_SET1:                 /* (set! var (values 1 2 3)) */
                            eval_error_with_caller2(sc, "~A: can't set '~A to ~S", 23, sc->set_symbol,
                                    stack_code(sc->stack, top), cons(sc, sc->values_symbol, args));

                        case OP_SET_PAIR_P_1:
                            eval_error(sc, "too many values to set! ~S", 26, cons(sc, sc->values_symbol, args));

                        case OP_INCREMENT_SP_1:       /* slot is in stack_args(top), args is the values list */
                            stack_element(sc->stack, top) = (s7_pointer)OP_INCREMENT_SP_MV;
                            return(args);

                        case OP_LET1:                                             /* (let ((var (values 1 2 3))) ...) */
                            {
                                s7_pointer p, let_code, vars, sym;
                                p = stack_args(sc->stack, top);
                                for (let_code = p; is_pair(cdr(let_code)); let_code = cdr(let_code));
                                for (vars = caar(let_code); is_pair(cdr(p)); p = cdr(p), vars = cdr(vars));
                                sym = caar(vars);
                                eval_error_with_caller2(sc, "~A: can't bind '~A to ~S", 24, sc->let_symbol, sym, cons(sc, sc->values_symbol, args));
                                /* stack_args: ((((x (values 1 2))) x)) in (let ((x (values 1 2))) x)
                                 *             (1 (((x 1) (y (values 1 2))) x)) in (let ((x 1) (y (values 1 2))) x)
                                 */
                            }

                        case OP_LET_ONE_NEW_1:             /* sc->args = symbol */
                        case OP_LET_ONE_OLD_1:
                        case OP_LET_ONE_P_NEW_1:
                        case OP_LET_ONE_P_OLD_1:
                            eval_error_with_caller2(sc, "~A: can't bind '~A to ~S", 24, sc->let_symbol,
                                    stack_args(sc->stack, top), cons(sc, sc->values_symbol, args));

                        case OP_LET_STAR1:             /* here caar(sc->code) is bound to sc->value */
                            eval_error_with_caller2(sc, "~A: can't bind '~A to ~S", 24, sc->let_star_symbol,
                                    caar(stack_code(sc->stack, top)), cons(sc, sc->values_symbol, args));

                        case OP_LETREC1:               /* here sc->args is the slot about to receive a value */
                            eval_error_with_caller2(sc, "~A: can't bind '~A to ~S", 24, sc->letrec_symbol,
                                    slot_symbol(stack_args(sc->stack, top)), cons(sc, sc->values_symbol, args));

                        case OP_LETREC_STAR1:
                            eval_error_with_caller2(sc, "~A: can't bind '~A to ~S", 24, sc->letrec_star_symbol,
                                    slot_symbol(stack_args(sc->stack, top)), cons(sc, sc->values_symbol, args));

                            /* handle 'and' and 'or' specially */
                        case OP_AND_P1:
                        case OP_AND_SAFE_P_REST: /* from OP_AND_SAFE_P1 or P2 */
                            for (x = args; is_not_null(cdr(x)); x = cdr(x))
                                if (car(x) == sc->F)
                                    return(sc->F);
                            return(car(x));

                        case OP_OR_P1:
                            for (x = args; is_not_null(cdr(x)); x = cdr(x))
                                if (car(x) != sc->F)
                                    return(car(x));
                            return(car(x));

                        case OP_IF1:    /* (if (values ...) ...) */
                        case OP_IF_PP: case OP_IF_PPP: case OP_IF_PR: case OP_IF_PRR:
                        case OP_WHEN_PP: case OP_UNLESS_PP: case OP_WITH_LET1:
                        case OP_CASE_G_G: case OP_CASE_G_S: case OP_CASE_E_G: case OP_CASE_E_S: case OP_CASE_S_G: case OP_CASE_S_S: case OP_CASE_I_S:
                        case OP_COND1: case OP_COND1_SIMPLE:
                            return(car(args));

                        case OP_BARRIER:
                            pop_stack(sc);
                            return(splice_in_values(sc, args));

                        case OP_GC_PROTECT:
                            sc->stack_end -= 4;
                            return(splice_in_values(sc, args));

                        case OP_BEGIN0: case OP_BEGIN1: case OP_BEGIN_1: case OP_BEGIN_1_UNCHECKED: case OP_BEGIN_2_UNCHECKED:
                            /* here we have a values call with nothing to splice into.  So flush it...
                             *   otherwise the multiple-values bit gets set in some innocent list and never unset:
                             *     (let ((x '((1 2)))) (eval `(apply apply values x)) x) -> ((values 1 2))
                             * other cases: (+ 1 (begin (values 5 6) (values 2 3)) 4) -> 10 -- the (5 6) is dropped
                             *              (let () (values 1 2 3) 4) but (+ (let () (values 1 2))) -> 3
                             */
                            return(args);

                        case OP_DEACTIVATE_GOTO:  /* (+ (call-with-exit (lambda (ret) (values 1 2 3)))) */
                            call_exit_active(stack_args(sc->stack, top)) = false;

                        case OP_CATCH:
                        case OP_CATCH_1:
                        case OP_CATCH_2:
                        case OP_CATCH_ALL:
                            /* (+ (catch #t (lambda () (values 3 4)) (lambda args args))) */
                            pop_stack(sc);
                            return(splice_in_values(sc, args));

                        case OP_EXPANSION:
                            /* we get here if a reader-macro (define-expansion) returns multiple values.
                             *    these need to be read in order into the current reader lists (we'll assume OP_READ_LIST is next in the stack.
                             *    and that it will be expecting the next arg entry in sc->value).
                             */
                            top -= 4;
                            for (x = args; is_not_null(cdr(x)); x = cdr(x))
                                stack_args(sc->stack, top) = cons(sc, car(x), stack_args(sc->stack, top));
                            pop_stack(sc);               /* need GC protection in loop above, so do this afterwards */
                            return(car(x));              /* sc->value from OP_READ_LIST point of view */

                        default:
                            /* fprintf(stderr, "splice on: %s\n", op_names[stack_op(sc->stack, top)]); */
                            break;
                    }

                    /* let it meander back up the call chain until someone knows where to splice it
                     *   the is_immutable check protects against setting the multiple value bit on (say) sc->hash_table_signature
                     */
                    if (is_immutable(args))
                        args = copy_list(sc, args); /* copy need else (apply values x) where x is a list can leave the mv bit on for x's value */
                    if (needs_copied_args(args))
                    {
                        clear_needs_copied_args(args);
                        args = copy_list(sc, args);
                    }
                    set_multiple_value(args);
                    return(args);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rdi), %rdx
movq %rdx, %r12
subq 0x48(%rbx), %r12
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rax
movq -0x8(%rax,%r12), %rcx
leaq -0x216(%rcx), %rsi
cmpq $0x3, %rsi
jb 0x29b19
leaq -0x2e0(%rcx), %rsi
cmpq $0x4b, %rsi
jbe 0x29c39
cmpq $0x1, %rcx
je 0x29b35
cmpq $0x1e0, %rcx            # imm = 0x1E0
je 0x29b19
cmpq $0x203, %rcx            # imm = 0x203
je 0x29b19
cmpq $0x204, %rcx            # imm = 0x204
jne 0x29b42
movq -0x10(%rax,%r12), %rax
movb $0x0, 0x18(%rax)
movq 0x50(%rbx), %rdx
leaq -0x20(%rdx), %rax
movq %rax, 0x50(%rbx)
movups -0x20(%rdx), %xmm0
movups -0x10(%rdx), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movq %rax, %rdx
jmp 0x29ab9
addq $-0x20, %rdx
movq %rdx, 0x50(%rbx)
jmp 0x29ab9
leaq -0x193(%rcx), %rdx
cmpq $0x22, %rdx
jbe 0x29c57
leaq -0x27d(%rcx), %rax
cmpq $0x16, %rax
jbe 0x29cdd
leaq -0x256(%rcx), %rax
cmpq $0x4, %rax
jb 0x29cf6
cmpq $0x1c4, %rcx            # imm = 0x1C4
je 0x29ced
cmpq $0x1c7, %rcx            # imm = 0x1C7
je 0x29ced
cmpq $0x1f2, %rcx            # imm = 0x1F2
je 0x29ced
cmpq $0x22c, %rcx            # imm = 0x22C
je 0x29dbc
cmpq $0x227, %rcx            # imm = 0x227
je 0x2a259
cmpq $0x1f7, %rcx            # imm = 0x1F7
jne 0x29e14
sarq $0x3, %r12
movq 0x10(%r14), %rax
cmpq 0x110(%rbx), %rax
je 0x2a2fd
movq 0x8(%r14), %r15
movq 0x38(%rbx), %rcx
movq 0x90(%rbx), %rax
movq 0x10(%rcx), %rcx
movq -0x30(%rcx,%r12,8), %r13
cmpq 0x98(%rbx), %rax
ja 0x29c08
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x38(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, -0x30(%rcx,%r12,8)
movq 0x10(%r14), %r14
jmp 0x29bc7
leaq 0xa9584(%rip), %rdx     # 0xd31c4
movslq (%rdx,%rsi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movq $0x306, -0x8(%rax,%r12) # imm = 0x306
jmp 0x2a244
leaq 0xa947e(%rip), %rcx     # 0xd30dc
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
sarq $0x3, %r12
movq 0x8(%r14), %r15
movq 0x10(%r14), %rax
cmpq 0x110(%rbx), %rax
je 0x2a247
movq 0x38(%rbx), %rcx
movq 0x90(%rbx), %rax
movq 0x10(%rcx), %rcx
movq -0x10(%rcx,%r12,8), %r13
cmpq 0x98(%rbx), %rax
ja 0x29cac
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x38(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, -0x10(%rcx,%r12,8)
movq 0x10(%r14), %r14
jmp 0x29c6b
leaq 0xa9484(%rip), %rcx     # 0xd3168
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %r15
jmp 0x2a247
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %r13
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0xb9b06(%rip), %rax     # 0xe3828
movq %rax, 0x10(%r13)
movq $0x18, 0x8(%r13)
movq 0x17a8(%rbx), %rdx
movq 0x38(%rbx), %rcx
movq 0x90(%rbx), %rax
movq 0x10(%rcx), %rcx
movq -0x10(%rcx,%r12), %r12
jmp 0x29f39
movq $0x31f, -0x8(%rax,%r12) # imm = 0x31F
jmp 0x2a244
movq 0x110(%rbx), %rax
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r14
cmpq %rax, %r14
je 0x29e3d
movq 0x120(%rbx), %r15
cmpq %r15, %rcx
jne 0x29d63
jmp 0x2a247
movq $0x328, -0x8(%rax,%r12) # imm = 0x328
jmp 0x2a244
incq %rcx
movq %rcx, -0x8(%rax,%r12)
jmp 0x2a217
movq $0x327, -0x8(%rax,%r12) # imm = 0x327
jmp 0x2a244
movq $0x326, -0x8(%rax,%r12) # imm = 0x326
jmp 0x2a244
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %r13
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0xb9a0d(%rip), %rax     # 0xe37f5
movq %rax, 0x10(%r13)
movq $0x17, 0x8(%r13)
movq 0x18d8(%rbx), %rdx
movq 0x38(%rbx), %rcx
movq 0x90(%rbx), %rax
movq 0x10(%rcx), %rcx
movq -0x20(%rcx,%r12), %r12
jmp 0x29f39
movq (%r14), %rax
btl $0x18, %eax
jae 0x29e2e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35492
movq %rax, %r14
movq (%rax), %rax
btl $0x1c, %eax
jb 0x2a221
jmp 0x2a23b
movq %rcx, %r15
jmp 0x2a247
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %r13
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0xb99b7(%rip), %rax     # 0xe3828
movq %rax, 0x10(%r13)
movq $0x18, 0x8(%r13)
movq 0x1888(%rbx), %rdx
movq 0x38(%rbx), %rcx
movq 0x90(%rbx), %rax
movq 0x10(%rcx), %rcx
movq -0x20(%rcx,%r12), %rcx
movq 0x8(%rcx), %rcx
jmp 0x29f35
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %r13
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0xb995b(%rip), %rax     # 0xe3828
movq %rax, 0x10(%r13)
movq $0x18, 0x8(%r13)
movq 0x1878(%rbx), %rdx
jmp 0x29f21
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %r13
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0xb991a(%rip), %rax     # 0xe3828
movq %rax, 0x10(%r13)
movq $0x18, 0x8(%r13)
movq 0x1880(%rbx), %rdx
movq 0x38(%rbx), %rcx
movq 0x90(%rbx), %rax
movq 0x10(%rcx), %rcx
movq -0x10(%rcx,%r12), %rcx
movq 0x8(%rcx), %r12
movq 0x1638(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x29f60
movq %rbx, %rdi
movq %rdx, (%rsp)
callq 0x9c27
movq (%rsp), %rdx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0x6f0(%rbx), %rcx
movq %r13, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rdx, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %r12, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6f0(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2cdc0
jmp 0x2a247
movq -0x10(%rax,%r12), %rax
movq %rax, %rdx
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
je 0x29fc0
movq 0x8(%rcx), %rcx
addq $0x8, %rcx
movq (%rcx), %rdx
movq 0x10(%rax), %rax
leaq 0x10(%rdx), %rcx
cmpb $0x1, (%rax)
je 0x29fd4
movq 0x8(%rdx), %rax
movq 0x8(%rax), %rdx
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %r13
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0xb9810(%rip), %rax     # 0xe3828
movq %rax, 0x10(%r13)
movq $0x18, 0x8(%r13)
movq 0x17a8(%rbx), %rbp
movq 0x1638(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x2a059
movq %rbx, %rdi
movq %rdx, (%rsp)
callq 0x9c27
movq (%rsp), %rdx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0x6f0(%rbx), %rcx
movq %r13, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rbp, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rdx, 0x8(%rcx)
jmp 0x29f99
movq 0x110(%rbx), %rcx
cmpq %r14, %rcx
je 0x2a32f
cmpq %rcx, 0x10(%r14)
je 0x29ced
sarq $0x3, %r12
movq -0x20(%rax,%r12,8), %r15
movq -0x10(%rax,%r12,8), %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x2a0de
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x38(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, -0x10(%rcx,%r12,8)
movq 0x8(%r14), %r15
movq 0x10(%r14), %rax
movq 0x10(%rax), %rcx
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rax
cmpq 0x110(%rbx), %rcx
je 0x2a31d
movq -0x10(%rax,%r12,8), %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x2a14e
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x38(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, -0x10(%rcx,%r12,8)
movq 0x10(%r14), %r14
jmp 0x2a109
movq 0x110(%rbx), %rax
movq 0x8(%r14), %r15
movq 0x10(%r14), %r14
cmpq %rax, %r14
je 0x2a247
cmpq 0x120(%rbx), %r15
je 0x2a186
jmp 0x2a247
movq $0x321, -0x8(%rax,%r12) # imm = 0x321
jmp 0x2a244
movq $0x304, -0x8(%rax,%r12) # imm = 0x304
jmp 0x2a244
movq $0x302, -0x8(%rax,%r12) # imm = 0x302
jmp 0x2a244
movq $0x319, -0x8(%rax,%r12) # imm = 0x319
jmp 0x2a244
movq $0x30e, -0x8(%rax,%r12) # imm = 0x30E
jmp 0x2a244
movq $0x317, -0x8(%rax,%r12) # imm = 0x317
jmp 0x2a217
movq $0x31d, -0x8(%rax,%r12) # imm = 0x31D
jmp 0x2a244
movq $0x30d, -0x8(%rax,%r12) # imm = 0x30D
jmp 0x2a244
movq $0x32a, -0x8(%rax,%r12) # imm = 0x32A
jmp 0x2a244
movq $0x31b, -0x8(%rax,%r12) # imm = 0x31B
movq (%r14), %rax
testl $0x11000000, %eax       # imm = 0x11000000
je 0x2a23b
andq $-0x10000001, %rax      # imm = 0xEFFFFFFF
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35492
movq %rax, %r14
movzwl (%rax), %eax
orl $0x8000, %eax           # imm = 0x8000
movw %ax, (%r14)
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %r12
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0xb9588(%rip), %rax     # 0xe380d
movq %rax, 0x10(%r12)
movq $0x1a, 0x8(%r12)
movq 0x1638(%rbx), %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x2a2b9
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r13, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0x6e0(%rbx), %rcx
movq %r12, 0x8(%rcx)
movq 0x6e0(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rdx
jmp 0x29fa8
movq 0x50(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movups -0x20(%rax), %xmm0
movups -0x10(%rax), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x29ced
movq %r15, -0x20(%rax,%r12,8)
movq 0x10(%r14), %rax
movq 0x8(%rax), %r15
jmp 0x2a247
movq 0x130(%rbx), %r15
jmp 0x2a247