// File: /workspace/github_c_makefile_star2_O1/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(%rbx), %rsi
movq %rsi, %rax
subq 0x48(%rbx), %rax
movq 0x38(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq -0x8(%rcx,%rax), %rdx
cmpq $0x215, %rdx            # imm = 0x215
jg 0x37ea0
movq %rax, %r15
sarq $0x3, %r15
cmpq $0x1f1, %rdx            # imm = 0x1F1
jg 0x37ebb
cmpq $0x1c3, %rdx            # imm = 0x1C3
jg 0x37edc
cmpq $0x1, %rdx
jne 0x37f4f
addq $-0x20, %rsi
movq %rsi, 0x50(%rbx)
jmp 0x37e52
cmpq $0x255, %rdx            # imm = 0x255
jg 0x37f20
leaq -0x216(%rdx), %rcx
cmpq $0x3, %rcx
jb 0x37f00
jmp 0x3809f
cmpq $0x203, %rdx            # imm = 0x203
jg 0x37eea
jne 0x38113
leaq -0x20(%rsi), %rax
movq %rax, 0x50(%rbx)
movups -0x20(%rsi), %xmm0
movups -0x10(%rsi), %xmm1
jmp 0x37f14
cmpq $0x1e0, %rdx            # imm = 0x1E0
je 0x37f00
jmp 0x381d7
cmpq $0x204, %rdx            # imm = 0x204
jne 0x381f1
movq -0x10(%rcx,%rax), %rax
movb $0x0, 0x18(%rax)
movq 0x50(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movups -0x20(%rax), %xmm0
movups -0x10(%rax), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
jmp 0x37e52
leaq -0x2e0(%rdx), %rsi
cmpq $0x4b, %rsi
ja 0x38000
leaq 0xd82bc(%rip), %rdi     # 0x1101f4
movslq (%rdi,%rsi,4), %rsi
addq %rdi, %rsi
jmpq *%rsi
movq $0x306, -0x8(%rcx,%rax) # imm = 0x306
jmp 0x38406
addq $-0x193, %rdx           # imm = 0xFE6D
cmpq $0x22, %rdx
ja 0x381f1
leaq 0xd81a5(%rip), %rsi     # 0x11010c
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
leaq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
cmpq 0x110(%rbx), %rcx
je 0x381cf
addq $0x10, %r14
movq (%rax), %r12
movq 0x38(%rbx), %rax
movq 0x90(%rbx), %rcx
movq 0x10(%rax), %rax
movq -0x10(%rax,%r15,8), %r13
cmpq 0x98(%rbx), %rcx
ja 0x37fb1
movq %rbx, %rdi
callq 0xb389
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 %r13, 0x10(%rax)
movq 0x38(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, -0x10(%rcx,%r15,8)
movq (%r14), %r14
leaq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
addq $0x10, %r14
cmpq 0x110(%rbx), %rcx
jne 0x37f89
jmp 0x381cf
leaq -0x27d(%rdx), %rcx
cmpq $0x16, %rcx
ja 0x38026
leaq 0xd8184(%rip), %rax     # 0x110198
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%r14), %r15
jmp 0x38774
addq $-0x256, %rdx           # imm = 0xFDAA
cmpq $0x4, %rdx
jae 0x381f1
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rcx
movslq 0x7dc(%rbx), %rdx
movq (%rcx,%rdx,8), %r12
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0xe8715(%rip), %rcx     # 0x120778
movq %rcx, 0x10(%r12)
movq $0x18, 0x8(%r12)
movq 0x17a8(%rbx), %rsi
movq 0x38(%rbx), %rcx
movq 0x90(%rbx), %rdx
movq 0x10(%rcx), %rcx
movq -0x10(%rcx,%rax), %rbp
jmp 0x386fa
movq $0x31f, -0x8(%rcx,%rax) # imm = 0x31F
jmp 0x38406
cmpq $0x227, %rdx            # imm = 0x227
je 0x38786
cmpq $0x22c, %rdx            # imm = 0x22C
jne 0x381f1
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rcx
movslq 0x7dc(%rbx), %rdx
movq (%rcx,%rdx,8), %r12
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0xe8660(%rip), %rcx     # 0x120745
movq %rcx, 0x10(%r12)
movq $0x17, 0x8(%r12)
movq 0x18d8(%rbx), %rsi
movq 0x38(%rbx), %rcx
movq 0x90(%rbx), %rdx
movq 0x10(%rcx), %rcx
movq -0x20(%rcx,%rax), %rbp
jmp 0x386fa
cmpq $0x1f2, %rdx            # imm = 0x1F2
je 0x3801d
cmpq $0x1f7, %rdx            # imm = 0x1F7
jne 0x381f1
leaq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
cmpq 0x110(%rbx), %rcx
je 0x381b4
addq $0x10, %r14
movq (%rax), %r12
movq 0x38(%rbx), %rax
movq 0x90(%rbx), %rcx
movq 0x10(%rax), %rax
movq -0x30(%rax,%r15,8), %r13
cmpq 0x98(%rbx), %rcx
ja 0x3816a
movq %rbx, %rdi
callq 0xb389
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 %r13, 0x10(%rax)
movq 0x38(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, -0x30(%rcx,%r15,8)
movq (%r14), %r14
leaq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
addq $0x10, %r14
cmpq 0x110(%rbx), %rcx
jne 0x38142
movq 0x50(%rbx), %rcx
leaq -0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movups -0x20(%rcx), %xmm0
movups -0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq (%rax), %r15
jmp 0x38774
cmpq $0x1c4, %rdx            # imm = 0x1C4
je 0x3801d
cmpq $0x1c7, %rdx            # imm = 0x1C7
je 0x3801d
testb $0x1, 0x3(%r14)
je 0x38206
movq %rbx, %rdi
movq %r14, %rsi
callq 0x45a8d
movq %rax, %r14
movq (%r14), %rax
btl $0x1c, %eax
jae 0x38226
andq $-0x10000001, %rax      # imm = 0xEFFFFFFF
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x45a8d
movq %rax, %r14
orb $-0x80, 0x1(%r14)
jmp 0x38406
movq $0x326, -0x8(%rcx,%rax) # imm = 0x326
jmp 0x38406
movq $0x327, -0x8(%rcx,%rax) # imm = 0x327
jmp 0x38406
movq $0x328, -0x8(%rcx,%rax) # imm = 0x328
jmp 0x38406
incq %rdx
jmp 0x382b4
movq 0x110(%rbx), %rax
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r14
cmpq %rax, %r14
je 0x38284
movq 0x120(%rbx), %r15
cmpq %r15, %rcx
jne 0x38266
jmp 0x38774
movq %rcx, %r15
jmp 0x38774
movq $0x304, -0x8(%rcx,%rax) # imm = 0x304
jmp 0x38406
movq $0x30e, -0x8(%rcx,%rax) # imm = 0x30E
jmp 0x38406
movl $0x317, %edx            # imm = 0x317
jmp 0x382b4
movl $0x31b, %edx            # imm = 0x31B
movq %rdx, -0x8(%rcx,%rax)
movq (%r14), %rax
testl $0x11000000, %eax       # imm = 0x11000000
je 0x383b0
movq %rax, %rcx
andq $-0x10000001, %rcx      # imm = 0xEFFFFFFF
movq %rcx, (%r14)
cmpb $0x1, %al
jne 0x383b5
movq %r14, 0x4c8(%rbx)
movq 0x8(%r14), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x38306
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %r12, 0x8(%r15)
movq %r13, 0x10(%r15)
movq %r15, 0x4e8(%rbx)
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
jne 0x38399
movq %r15, %r12
movq 0x8(%r14), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x38362
movq %rbx, %rdi
callq 0xb389
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 %rbp, 0x10(%rax)
movq %rax, 0x10(%r12)
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
movq %rax, %r12
je 0x3833f
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
jmp 0x383bc
movq %r14, %r15
jmp 0x383bc
movq 0x110(%rbx), %r15
orb $-0x80, 0x1(%r15)
jmp 0x38774
movq $0x302, -0x8(%rcx,%rax) # imm = 0x302
jmp 0x38406
movq $0x321, -0x8(%rcx,%rax) # imm = 0x321
jmp 0x38406
movq $0x30d, -0x8(%rcx,%rax) # imm = 0x30D
jmp 0x38406
movq $0x32a, -0x8(%rcx,%rax) # imm = 0x32A
jmp 0x38406
movq $0x31d, -0x8(%rcx,%rax) # imm = 0x31D
jmp 0x38406
movq $0x319, -0x8(%rcx,%rax) # imm = 0x319
movq %r14, %r15
jmp 0x38774
movq 0x110(%rbx), %rax
movq 0x8(%r14), %r15
movq 0x10(%r14), %r14
cmpq %rax, %r14
je 0x38774
cmpq 0x120(%rbx), %r15
je 0x38415
jmp 0x38774
movq -0x10(%rcx,%rax), %rax
movq %rax, %rdx
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
je 0x3843c
movq 0x8(%rcx), %rcx
addq $0x8, %rcx
movq (%rcx), %rdx
movq 0x10(%rax), %rax
leaq 0x10(%rdx), %rcx
cmpb $0x1, (%rax)
je 0x38450
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 0xe82e4(%rip), %rax     # 0x120778
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 0x384ce
movq %rbx, %rdi
movq %rdx, (%rsp)
callq 0xb389
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 0x3875a
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rcx
movslq 0x7dc(%rbx), %rdx
movq (%rcx,%rdx,8), %r12
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0xe8239(%rip), %rcx     # 0x120778
movq %rcx, 0x10(%r12)
movq $0x18, 0x8(%r12)
movq 0x1880(%rbx), %rsi
jmp 0x386e2
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rcx
movslq 0x7dc(%rbx), %rdx
movq (%rcx,%rdx,8), %r12
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0xe81f3(%rip), %rcx     # 0x120778
movq %rcx, 0x10(%r12)
movq $0x18, 0x8(%r12)
movq 0x1888(%rbx), %rsi
movq 0x38(%rbx), %rcx
movq 0x90(%rbx), %rdx
movq 0x10(%rcx), %rcx
movq -0x20(%rcx,%rax), %rax
movq 0x8(%rax), %rax
jmp 0x386f6
movq 0x110(%rbx), %rax
cmpq %r14, %rax
je 0x38846
cmpq %rax, 0x10(%r14)
je 0x3801d
movq -0x20(%rcx,%r15,8), %r12
movq -0x10(%rcx,%r15,8), %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x385f3
movq %rbx, %rdi
callq 0xb389
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 %r13, 0x10(%rax)
movq 0x38(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, -0x10(%rcx,%r15,8)
leaq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
addq $0x10, %r14
movq 0x10(%rcx), %rcx
cmpq 0x110(%rbx), %rcx
je 0x3882a
movq (%rax), %r12
movq 0x38(%rbx), %rax
movq 0x90(%rbx), %rcx
movq 0x10(%rax), %rax
movq -0x10(%rax,%r15,8), %r13
cmpq 0x98(%rbx), %rcx
ja 0x3866a
movq %rbx, %rdi
callq 0xb389
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 %r13, 0x10(%rax)
movq 0x38(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, -0x10(%rcx,%r15,8)
movq (%r14), %r14
jmp 0x38625
movq 0x1918(%rbx), %r15
movq 0x820(%rbx), %rcx
movslq 0x7dc(%rbx), %rdx
movq (%rcx,%rdx,8), %r12
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0xe80ab(%rip), %rcx     # 0x120778
movq %rcx, 0x10(%r12)
movq $0x18, 0x8(%r12)
movq 0x1878(%rbx), %rsi
movq 0x38(%rbx), %rcx
movq 0x90(%rbx), %rdx
movq 0x10(%rcx), %rcx
movq -0x10(%rcx,%rax), %rax
movq 0x8(%rax), %rbp
movq 0x1638(%rbx), %r13
cmpq 0x98(%rbx), %rdx
ja 0x3871a
movq %rbx, %rdi
movq %rsi, (%rsp)
callq 0xb389
movq (%rsp), %rsi
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 0x6f0(%rbx), %rcx
movq %r12, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rsi, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rbp, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6f0(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3b366
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 0xe7fab(%rip), %rax     # 0x12075d
movq %rax, 0x10(%r12)
movq $0x1a, 0x8(%r12)
movq 0x1638(%rbx), %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x387df
movq %rbx, %rdi
callq 0xb389
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 0x38769
movq (%rax), %rax
movq 0x38(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, -0x20(%rcx,%r15,8)
movq (%r14), %rax
movq 0x8(%rax), %r15
jmp 0x38774
movq 0x130(%rbx), %r15
jmp 0x38774