// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x2f8, %rsp            # imm = 0x2F8
movq %rdi, 0x2e8(%rsp)
movq %rsi, 0x2e0(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x50(%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
decq %rax
movq %rax, 0x2d8(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x148(%rsp)
subq $0x1, %rax
je 0x29c1f
jmp 0x281d9
movq 0x148(%rsp), %rax
addq $-0x193, %rax           # imm = 0xFE6D
subq $0x4, %rax
jb 0x2864c
jmp 0x281f3
movq 0x148(%rsp), %rax
subq $0x197, %rax            # imm = 0x197
je 0x28b45
jmp 0x28209
movq 0x148(%rsp), %rax
addq $-0x1a0, %rax           # imm = 0xFE60
subq $0x2, %rax
jb 0x29c55
jmp 0x28223
movq 0x148(%rsp), %rax
addq $-0x1a3, %rax           # imm = 0xFE5D
subq $0x3, %rax
jb 0x29c55
jmp 0x2823d
movq 0x148(%rsp), %rax
subq $0x1a7, %rax            # imm = 0x1A7
je 0x29b9c
jmp 0x28253
movq 0x148(%rsp), %rax
subq $0x1ab, %rax            # imm = 0x1AB
je 0x28e5d
jmp 0x28269
movq 0x148(%rsp), %rax
subq $0x1ae, %rax            # imm = 0x1AE
je 0x2919e
jmp 0x2827f
movq 0x148(%rsp), %rax
subq $0x1b0, %rax            # imm = 0x1B0
je 0x295b4
jmp 0x28295
movq 0x148(%rsp), %rax
subq $0x1b3, %rax            # imm = 0x1B3
je 0x29757
jmp 0x282ab
movq 0x148(%rsp), %rax
subq $0x1b5, %rax            # imm = 0x1B5
je 0x298e4
jmp 0x282c1
movq 0x148(%rsp), %rax
subq $0x1c4, %rax            # imm = 0x1C4
je 0x29b9c
jmp 0x282d7
movq 0x148(%rsp), %rax
subq $0x1c7, %rax            # imm = 0x1C7
je 0x29b9c
jmp 0x282ed
movq 0x148(%rsp), %rax
subq $0x1e0, %rax            # imm = 0x1E0
je 0x29c8e
jmp 0x28303
movq 0x148(%rsp), %rax
subq $0x1f2, %rax            # imm = 0x1F2
je 0x29b9c
jmp 0x28319
movq 0x148(%rsp), %rax
subq $0x1f7, %rax            # imm = 0x1F7
je 0x29cf8
jmp 0x2832f
movq 0x148(%rsp), %rax
subq $0x203, %rax            # imm = 0x203
je 0x29bb5
jmp 0x28345
movq 0x148(%rsp), %rax
subq $0x204, %rax            # imm = 0x204
je 0x29c6a
jmp 0x2835b
movq 0x148(%rsp), %rax
addq $-0x216, %rax           # imm = 0xFDEA
subq $0x3, %rax
jb 0x29c8e
jmp 0x28375
movq 0x148(%rsp), %rax
subq $0x227, %rax            # imm = 0x227
je 0x2900a
jmp 0x2838b
movq 0x148(%rsp), %rax
subq $0x22c, %rax            # imm = 0x22C
je 0x28e5d
jmp 0x283a1
movq 0x148(%rsp), %rax
addq $-0x256, %rax           # imm = 0xFDAA
subq $0x4, %rax
jb 0x29407
jmp 0x283bb
movq 0x148(%rsp), %rax
addq $-0x27d, %rax           # imm = 0xFD83
subq $0x7, %rax
jb 0x29b9c
jmp 0x283d5
movq 0x148(%rsp), %rax
subq $0x286, %rax            # imm = 0x286
je 0x29a71
jmp 0x283eb
movq 0x148(%rsp), %rax
subq $0x28d, %rax            # imm = 0x28D
je 0x29a71
jmp 0x28401
movq 0x148(%rsp), %rax
subq $0x293, %rax            # imm = 0x293
je 0x29b08
jmp 0x28417
movq 0x148(%rsp), %rax
addq $-0x2e0, %rax           # imm = 0xFD20
subq $0x6, %rax
jb 0x29b9c
jmp 0x28431
movq 0x148(%rsp), %rax
subq $0x300, %rax            # imm = 0x300
je 0x289cb
jmp 0x28447
movq 0x148(%rsp), %rax
subq $0x301, %rax            # imm = 0x301
je 0x28ad9
jmp 0x2845d
movq 0x148(%rsp), %rax
subq $0x303, %rax            # imm = 0x303
je 0x28b0f
jmp 0x28473
movq 0x148(%rsp), %rax
subq $0x305, %rax            # imm = 0x305
je 0x288f3
jmp 0x28489
movq 0x148(%rsp), %rax
addq $-0x307, %rax           # imm = 0xFCF9
subq $0x4, %rax
jb 0x288f3
jmp 0x284a3
movq 0x148(%rsp), %rax
subq $0x30b, %rax            # imm = 0x30B
je 0x28929
jmp 0x284b9
movq 0x148(%rsp), %rax
subq $0x30c, %rax            # imm = 0x30C
je 0x2895f
jmp 0x284cf
movq 0x148(%rsp), %rax
addq $-0x312, %rax           # imm = 0xFCEE
subq $0x2, %rax
jb 0x28a37
jmp 0x284e9
movq 0x148(%rsp), %rax
subq $0x314, %rax            # imm = 0x314
je 0x28a6d
jmp 0x284ff
movq 0x148(%rsp), %rax
subq $0x315, %rax            # imm = 0x315
je 0x28aa3
jmp 0x28515
movq 0x148(%rsp), %rax
subq $0x316, %rax            # imm = 0x316
je 0x287f6
jmp 0x2852b
movq 0x148(%rsp), %rax
subq $0x317, %rax            # imm = 0x317
je 0x28832
jmp 0x28541
movq 0x148(%rsp), %rax
subq $0x318, %rax            # imm = 0x318
je 0x29168
jmp 0x28557
movq 0x148(%rsp), %rax
subq $0x31a, %rax            # imm = 0x31A
je 0x287f6
jmp 0x2856d
movq 0x148(%rsp), %rax
subq $0x31b, %rax            # imm = 0x31B
je 0x28832
jmp 0x28583
movq 0x148(%rsp), %rax
subq $0x31c, %rax            # imm = 0x31C
je 0x288bd
jmp 0x28599
movq 0x148(%rsp), %rax
subq $0x31e, %rax            # imm = 0x31E
je 0x289cb
jmp 0x285af
movq 0x148(%rsp), %rax
subq $0x320, %rax            # imm = 0x320
je 0x28a01
jmp 0x285c5
movq 0x148(%rsp), %rax
subq $0x322, %rax            # imm = 0x322
je 0x289cb
jmp 0x285db
movq 0x148(%rsp), %rax
subq $0x323, %rax            # imm = 0x323
je 0x287d3
jmp 0x285f1
movq 0x148(%rsp), %rax
subq $0x324, %rax            # imm = 0x324
je 0x28a6d
jmp 0x28607
movq 0x148(%rsp), %rax
subq $0x325, %rax            # imm = 0x325
je 0x28aa3
jmp 0x2861d
movq 0x148(%rsp), %rax
subq $0x329, %rax            # imm = 0x329
je 0x28995
jmp 0x28633
movq 0x148(%rsp), %rax
subq $0x32b, %rax            # imm = 0x32B
je 0x287b0
jmp 0x29eb8
movq 0x2e0(%rsp), %rax
movq %rax, 0x2d0(%rsp)
movq 0x2d0(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x28797
movq 0x2d0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2c0(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x2b8(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x286e6
movq 0x2e8(%rsp), %rdi
callq 0xc670
movq 0x2e8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x2c8(%rsp)
movq 0x2c8(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x2c0(%rsp), %rcx
movq 0x2c8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x2b8(%rsp), %rcx
movq 0x2c8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x2c8(%rsp), %rax
movq %rax, 0x2b0(%rsp)
movq 0x2b0(%rsp), %rdx
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x2d0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2d0(%rsp)
jmp 0x2865c
movq 0x2d0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x317, %edx            # imm = 0x317
movq %rdx, (%rax,%rcx,8)
jmp 0x28834
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x31b, %edx            # imm = 0x31B
movq %rdx, (%rax,%rcx,8)
jmp 0x28834
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x28834
movq 0x2e0(%rsp), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
jne 0x28862
movq 0x2e0(%rsp), %rax
movq (%rax), %rax
andq $0x10000000, %rax       # imm = 0x10000000
cmpq $0x0, %rax
je 0x28894
movq 0x2e0(%rsp), %rax
movq (%rax), %rcx
andq $-0x10000001, %rcx      # imm = 0xEFFFFFFF
movq %rcx, (%rax)
movq 0x2e8(%rsp), %rdi
movq 0x2e0(%rsp), %rsi
callq 0x44270
movq %rax, 0x2e0(%rsp)
movq 0x2e0(%rsp), %rax
movzwl (%rax), %ecx
orl $0x8000, %ecx           # imm = 0x8000
movw %cx, (%rax)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x31d, %edx            # imm = 0x31D
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x306, %edx            # imm = 0x306
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x30d, %edx            # imm = 0x30D
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x30e, %edx            # imm = 0x30E
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x32a, %edx            # imm = 0x32A
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x31f, %edx            # imm = 0x31F
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x321, %edx            # imm = 0x321
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x326, %edx            # imm = 0x326
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x327, %edx            # imm = 0x327
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x328, %edx            # imm = 0x328
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x302, %edx            # imm = 0x302
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x304, %edx            # imm = 0x304
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e0(%rsp), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x28b7a
movq 0x2e8(%rsp), %rax
movq 0x130(%rax), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e0(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x28bb0
movq 0x2e0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x3, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x2a0(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x298(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x28c2d
movq 0x2e8(%rsp), %rdi
callq 0xc670
movq 0x2e8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x2a8(%rsp)
movq 0x2a8(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x2a0(%rsp), %rcx
movq 0x2a8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x298(%rsp), %rcx
movq 0x2a8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x2a8(%rsp), %rax
movq %rax, 0x290(%rsp)
movq 0x290(%rsp), %rdx
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2d0(%rsp)
movq 0x2d0(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x28e14
movq 0x2d0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x280(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x278(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x28d63
movq 0x2e8(%rsp), %rdi
callq 0xc670
movq 0x2e8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x288(%rsp)
movq 0x288(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x280(%rsp), %rcx
movq 0x288(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x278(%rsp), %rcx
movq 0x288(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x288(%rsp), %rax
movq %rax, 0x270(%rsp)
movq 0x270(%rsp), %rdx
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x2d0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2d0(%rsp)
jmp 0x28cd5
movq 0x2d0(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x3, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x2d0(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1918(%rax), %rax
movq %rax, 0x120(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x2e8(%rsp), %rdi
leaq 0x1c68ca(%rip), %rsi    # 0x1ef76d
movl $0x17, %edx
callq 0xb880
movq %rax, 0x130(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x18d8(%rax), %rax
movq %rax, 0x138(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x3, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x140(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1638(%rax), %rax
movq %rax, 0x260(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x258(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x28f48
movq 0x2e8(%rsp), %rdi
callq 0xc670
movq 0x2e8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x268(%rsp)
movq 0x268(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x140(%rsp), %rcx
movq 0x138(%rsp), %rdx
movq 0x130(%rsp), %rsi
movq 0x128(%rsp), %rdi
movq 0x260(%rsp), %r8
movq 0x268(%rsp), %rax
movq %r8, 0x8(%rax)
movq 0x258(%rsp), %r8
movq 0x268(%rsp), %rax
movq %r8, 0x10(%rax)
movq 0x268(%rsp), %rax
movq %rax, 0x250(%rsp)
movq 0x250(%rsp), %r8
callq 0xd7140
movq 0x118(%rsp), %rdi
movq 0x120(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1918(%rax), %rax
movq %rax, 0x100(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x2e8(%rsp), %rdi
leaq 0x1c6735(%rip), %rsi    # 0x1ef785
movl $0x1a, %edx
callq 0xb880
movq %rax, 0x110(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1638(%rax), %rax
movq %rax, 0x240(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x238(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x290b6
movq 0x2e8(%rsp), %rdi
callq 0xc670
movq 0x2e8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x248(%rsp)
movq 0x248(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x110(%rsp), %rsi
movq 0x108(%rsp), %rdi
movq 0x240(%rsp), %rcx
movq 0x248(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x238(%rsp), %rcx
movq 0x248(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x248(%rsp), %rax
movq %rax, 0x230(%rsp)
movq 0x230(%rsp), %rdx
callq 0xb830
movq 0xf8(%rsp), %rdi
movq 0x100(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
movl $0x319, %edx            # imm = 0x319
movq %rdx, (%rax,%rcx,8)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x228(%rsp)
movq 0x228(%rsp), %rax
movq %rax, 0x220(%rsp)
movq 0x220(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x29202
jmp 0x291ec
movq 0x220(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x220(%rsp)
jmp 0x291d6
movq 0x220(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x218(%rsp)
movq 0x228(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2925a
jmp 0x29230
movq 0x228(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x228(%rsp)
movq 0x218(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x218(%rsp)
jmp 0x2921a
movq 0x218(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x210(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1918(%rax), %rax
movq %rax, 0xd0(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x2e8(%rsp), %rdi
leaq 0x1c64e8(%rip), %rsi    # 0x1ef7a0
movl $0x18, %edx
callq 0xb880
movq %rax, 0xe0(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x17a8(%rax), %rax
movq %rax, 0xe8(%rsp)
movq 0x210(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1638(%rax), %rax
movq %rax, 0x200(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x1f8(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x29345
movq 0x2e8(%rsp), %rdi
callq 0xc670
movq 0x2e8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x208(%rsp)
movq 0x208(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0xf0(%rsp), %rcx
movq 0xe8(%rsp), %rdx
movq 0xe0(%rsp), %rsi
movq 0xd8(%rsp), %rdi
movq 0x200(%rsp), %r8
movq 0x208(%rsp), %rax
movq %r8, 0x8(%rax)
movq 0x1f8(%rsp), %r8
movq 0x208(%rsp), %rax
movq %r8, 0x10(%rax)
movq 0x208(%rsp), %rax
movq %rax, 0x1f0(%rsp)
movq 0x1f0(%rsp), %r8
callq 0xd7140
movq 0xc8(%rsp), %rdi
movq 0xd0(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1918(%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x2e8(%rsp), %rdi
leaq 0x1c6353(%rip), %rsi    # 0x1ef7a0
movl $0x18, %edx
callq 0xb880
movq %rax, 0xb0(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x17a8(%rax), %rax
movq %rax, 0xb8(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0xc0(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1638(%rax), %rax
movq %rax, 0x1e0(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x294f2
movq 0x2e8(%rsp), %rdi
callq 0xc670
movq 0x2e8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x1e8(%rsp)
movq 0x1e8(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0xc0(%rsp), %rcx
movq 0xb8(%rsp), %rdx
movq 0xb0(%rsp), %rsi
movq 0xa8(%rsp), %rdi
movq 0x1e0(%rsp), %r8
movq 0x1e8(%rsp), %rax
movq %r8, 0x8(%rax)
movq 0x1d8(%rsp), %r8
movq 0x1e8(%rsp), %rax
movq %r8, 0x10(%rax)
movq 0x1e8(%rsp), %rax
movq %rax, 0x1d0(%rsp)
movq 0x1d0(%rsp), %r8
callq 0xd7140
movq 0x98(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1918(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x2e8(%rsp), %rdi
leaq 0x1c61af(%rip), %rsi    # 0x1ef7a0
movl $0x18, %edx
callq 0xb880
movq %rax, 0x80(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1888(%rax), %rax
movq %rax, 0x88(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x3, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x90(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1638(%rax), %rax
movq %rax, 0x1c0(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x1b8(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x2969e
movq 0x2e8(%rsp), %rdi
callq 0xc670
movq 0x2e8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x1c8(%rsp)
movq 0x1c8(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x90(%rsp), %rcx
movq 0x88(%rsp), %rdx
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdi
movq 0x1c0(%rsp), %r8
movq 0x1c8(%rsp), %rax
movq %r8, 0x8(%rax)
movq 0x1b8(%rsp), %r8
movq 0x1c8(%rsp), %rax
movq %r8, 0x10(%rax)
movq 0x1c8(%rsp), %rax
movq %rax, 0x1b0(%rsp)
movq 0x1b0(%rsp), %r8
callq 0xd7140
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1918(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x2e8(%rsp), %rdi
leaq 0x1c600c(%rip), %rsi    # 0x1ef7a0
movl $0x18, %edx
callq 0xb880
movq %rax, 0x50(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1878(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1638(%rax), %rax
movq %rax, 0x1a0(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x198(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x29834
movq 0x2e8(%rsp), %rdi
callq 0xc670
movq 0x2e8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x1a8(%rsp)
movq 0x1a8(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x60(%rsp), %rcx
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdi
movq 0x1a0(%rsp), %r8
movq 0x1a8(%rsp), %rax
movq %r8, 0x8(%rax)
movq 0x198(%rsp), %r8
movq 0x1a8(%rsp), %rax
movq %r8, 0x10(%rax)
movq 0x1a8(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0x190(%rsp), %r8
callq 0xd7140
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1918(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x2e8(%rsp), %rdi
leaq 0x1c5e7f(%rip), %rsi    # 0x1ef7a0
movl $0x18, %edx
callq 0xb880
movq %rax, 0x20(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1880(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x1638(%rax), %rax
movq %rax, 0x180(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x178(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x299c1
movq 0x2e8(%rsp), %rdi
callq 0xc670
movq 0x2e8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x188(%rsp)
movq 0x188(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq 0x180(%rsp), %r8
movq 0x188(%rsp), %rax
movq %r8, 0x8(%rax)
movq 0x178(%rsp), %r8
movq 0x188(%rsp), %rax
movq %r8, 0x10(%rax)
movq 0x188(%rsp), %rax
movq %rax, 0x170(%rsp)
movq 0x170(%rsp), %r8
callq 0xd7140
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e0(%rsp), %rax
movq %rax, 0x2d0(%rsp)
movq 0x2d0(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x29aef
movq 0x2d0(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x29ad7
movq 0x2e8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
jmp 0x29ad9
movq 0x2d0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2d0(%rsp)
jmp 0x29a81
movq 0x2d0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e0(%rsp), %rax
movq %rax, 0x2d0(%rsp)
movq 0x2d0(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x29b83
movq 0x2d0(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x120(%rcx), %rax
je 0x29b6b
movq 0x2d0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
jmp 0x29b6d
movq 0x2d0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2d0(%rsp)
jmp 0x29b18
movq 0x2d0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
jmp 0x29bb7
movq 0x2e8(%rsp), %rax
movq 0x50(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x2e8(%rsp), %rax
movq 0x2e8(%rsp), %rcx
movq 0x50(%rcx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x2e8(%rsp), %rdi
movq 0x2e0(%rsp), %rsi
callq 0x28170
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x50(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x2e8(%rsp), %rdi
movq 0x2e0(%rsp), %rsi
callq 0x28170
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movb $0x0, 0x18(%rax)
jmp 0x29c90
movq 0x2e8(%rsp), %rax
movq 0x50(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x2e8(%rsp), %rax
movq 0x2e8(%rsp), %rcx
movq 0x50(%rcx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x2e8(%rsp), %rdi
movq 0x2e0(%rsp), %rsi
callq 0x28170
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
movq 0x2d8(%rsp), %rax
subq $0x4, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2d0(%rsp)
movq 0x2d0(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x29e57
movq 0x2d0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x160(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x158(%rsp)
movq 0x2e8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x2e8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x29da6
movq 0x2e8(%rsp), %rdi
callq 0xc670
movq 0x2e8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x168(%rsp)
movq 0x168(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x160(%rsp), %rcx
movq 0x168(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x158(%rsp), %rcx
movq 0x168(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x168(%rsp), %rax
movq %rax, 0x150(%rsp)
movq 0x150(%rsp), %rdx
movq 0x2e8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x2d8(%rsp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x2d0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2d0(%rsp)
jmp 0x29d1c
jmp 0x29e59
movq 0x2e8(%rsp), %rax
movq 0x50(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x2e8(%rsp), %rax
movq 0x2e8(%rsp), %rcx
movq 0x50(%rcx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x2d0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x29f5b
jmp 0x29eba
movq 0x2e0(%rsp), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
je 0x29eee
movq 0x2e8(%rsp), %rdi
movq 0x2e0(%rsp), %rsi
callq 0x44270
movq %rax, 0x2e0(%rsp)
movq 0x2e0(%rsp), %rax
movq (%rax), %rax
andq $0x10000000, %rax       # imm = 0x10000000
cmpq $0x0, %rax
je 0x29f37
movq 0x2e0(%rsp), %rax
movq (%rax), %rcx
andq $-0x10000001, %rcx      # imm = 0xEFFFFFFF
movq %rcx, (%rax)
movq 0x2e8(%rsp), %rdi
movq 0x2e0(%rsp), %rsi
callq 0x44270
movq %rax, 0x2e0(%rsp)
movq 0x2e0(%rsp), %rax
movzwl (%rax), %ecx
orl $0x8000, %ecx           # imm = 0x8000
movw %cx, (%rax)
movq 0x2e0(%rsp), %rax
movq %rax, 0x2f0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x2f8, %rsp            # imm = 0x2F8
retq
nopl (%rax,%rax)