// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_for_each_closure
static s7_pointer g_for_each_closure(s7_scheme *sc, s7_pointer f, s7_pointer seq)
                {
                    s7_pointer body;

                    body = closure_body(f);
                    if (!no_cell_opt(body))
                    {
                        s7_function func;
                        s7_pointer old_e, expr, pars, val, slot;

                        old_e = sc->envir;
                        pars = closure_args(f);

                        if (is_float_vector(seq))
                            val = real_zero;
                        else
                        {
                            if ((is_int_vector(seq)) || (is_byte_vector(seq)))
                                val = small_int(0);
                            else val = sc->F;
                        }

                        new_frame_with_slot(sc, closure_let(f), sc->envir, car(pars), val);
                        slot = let_slots(sc->envir);

                        if (is_null(cdr(body)))
                        {
                            expr = car(body);
                            func = s7_optimize_nr(sc, body);
                        }
                        else
                        {
                            expr = cons(sc, sc->begin_symbol, body);
                            sc->v = expr; /* GC protection? */
                            func = s7_cell_optimize(sc, cons(sc, expr, sc->nil), true);
                        }

                        if (func)
                        {
                            if (is_pair(seq))
                            {
                                s7_pointer x, y;
                                for (x = seq, y = x; is_pair(x); )
                                {
                                    slot_set_value(slot, car(x));
                                    func(sc, expr);
                                    x = cdr(x);
                                    if (is_pair(x))
                                    {
                                        slot_set_value(slot, car(x));
                                        func(sc, expr);
                                        y = cdr(y);
                                        x = cdr(x);
                                        if (x == y) return(sc->unspecified);
                                    }
                                }
                                return(sc->unspecified);
                            }

                            if (is_float_vector(seq))
                            {
                                s7_double *vals;
                                s7_int i, len;
                                len = vector_length(seq);
                                vals = float_vector_floats(seq);

                                if ((len > 1000) &&
                                        (!tree_has_setters(sc, body)))
                                {
                                    s7_pointer sv;
                                    sv = s7_make_mutable_real(sc, 0.0);
                                    slot_set_value(slot, sv);
                                    for (i = 0; i < len; i++)
                                    {
                                        real(sv) = vals[i];
                                        func(sc, expr);
                                    }
                                    return(sc->unspecified);
                                }
                                for (i = 0; i < len; i++)
                                {
                                    slot_set_value(slot, make_real(sc, vals[i]));
                                    func(sc, expr);
                                }
                                return(sc->unspecified);
                            }

                            /* if no set! vector|list|let|hash-table-set! set-car!|cdr! mutable arg? */
                            if (is_int_vector(seq))
                            {
                                s7_int *vals;
                                s7_int i, len;
                                len = vector_length(seq);
                                vals = int_vector_ints(seq);

                                if ((len > 1000) &&
                                        (!tree_has_setters(sc, body)))
                                {
                                    s7_pointer sv;
                                    sv = make_mutable_integer(sc, 0);
                                    slot_set_value(slot, sv);
                                    /* since there are no setters, the inner step is also mutable if there is one
                                     *    func=opt_cell_any_nr, sc->opts[0]->v[0].fp(sc->opts[0]) fp=opt_do_1 -> mutable version
                                     *    see opt_do_1
                                     */
                                    for (i = 0; i < len; i++)
                                    {
                                        integer(sv) = vals[i];
                                        func(sc, expr);
                                    }
                                    return(sc->unspecified);
                                }

                                for (i = 0; i < len; i++)
                                {
                                    slot_set_value(slot, make_integer(sc, vals[i]));
                                    func(sc, expr);
                                }
                                return(sc->unspecified);
                            }

                            sc->z = seq;
                            if (!is_iterator(sc->z))
                                sc->z = s7_make_iterator(sc, sc->z);
                            seq = sc->z;
                            push_stack_no_let(sc, OP_GC_PROTECT, seq, f);
                            sc->z = sc->nil;
                            while (true)
                            {
                                slot_set_value(slot, s7_iterate(sc, seq));
                                if (iterator_is_at_end(seq))
                                {
                                    unstack(sc);
                                    /* free_cell(sc, seq); */ /* 16-Jan-19 */
                                    return(sc->unspecified);
                                }
                                func(sc, expr);
                            }
                        }
                        set_no_cell_opt(body);
                        sc->envir = old_e;
                    }

                    if ((is_null(cdr(body))) &&
                            (is_pair(seq)))
                    {
                        s7_pointer c;
                        c = make_counter(sc, seq);
                        counter_set_result(c, seq);
                        push_stack(sc, OP_FOR_EACH_2, c, f);
                        return(sc->unspecified);
                    }

                    sc->z = seq;
                    if (!is_iterator(sc->z))
                        sc->z = s7_make_iterator(sc, sc->z);
                    push_stack(sc, OP_FOR_EACH_1, make_counter(sc, sc->z), f);
                    sc->z = sc->nil;
                    return(sc->unspecified);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x10(%rsi), %rbp
testb $0x4, 0x3(%rbp)
jne 0xcc622
movq 0x8(%r13), %rax
movb (%r12), %cl
addb $-0x16, %cl
cmpb $0x3, %cl
jae 0xcc40f
movzbl %cl, %ecx
leaq 0x7997f(%rip), %rdx     # 0x145d88
movq (%rdx,%rcx,8), %rcx
jmp 0xcc416
leaq 0x120(%rbx), %rcx
movq 0x8(%rbx), %rdx
movq %rdx, 0x8(%rsp)
movq (%rcx), %r15
movq 0x8(%rax), %r14
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcc445
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x20001c, (%rax)       # imm = 0x20001C
movq 0x250(%rbx), %rcx
incq %rcx
movq %rcx, 0x250(%rbx)
movq %rcx, 0x18(%rax)
movq %r13, 0x10(%rsp)
movq 0x18(%r13), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq $0x20, (%rcx)
movq %r14, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movq %rcx, 0x18(%r14)
movq 0x250(%rbx), %rdx
movq %rdx, 0x20(%r14)
incl 0x28(%r14)
movq $0x0, 0x18(%rcx)
movq %rcx, 0x8(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %r13
movq 0x10(%rbp), %rax
cmpq 0x110(%rbx), %rax
je 0xcc57c
movq 0x1808(%rbx), %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcc504
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x200001, (%r14)       # imm = 0x200001
movq %r15, 0x8(%r14)
movq %rbp, 0x10(%r14)
movq %r14, 0x4d0(%rbx)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r15
cmpq 0x98(%rbx), %rax
ja 0xcc54f
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rsi
movq $0x200001, (%rsi)       # imm = 0x200001
movq %r14, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movq %rbx, %rdi
movl $0x1, %edx
callq 0xcca5b
jmp 0xcc590
movq 0x8(%rbp), %r14
movq %rbx, %rdi
movq %rbp, %rsi
movl $0x1, %edx
callq 0x4588d
movq %rax, %r15
testq %rax, %rax
je 0xcc610
movzbl (%r12), %eax
cmpl $0x17, %eax
je 0xcc842
cmpl $0x16, %eax
je 0xcc7a0
cmpl $0x1, %eax
jne 0xcc8e4
movq %r13, %rbp
movq %r12, %r13
movq 0x8(%r12), %rax
movq %rax, 0x10(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq *%r15
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0xcc78a
movq 0x8(%r12), %rax
movq %rax, 0x10(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq *%r15
movq 0x10(%r13), %r13
movq 0x10(%r12), %r12
cmpq %r13, %r12
je 0xcc78a
cmpb $0x1, (%r12)
je 0xcc5be
jmp 0xcc78a
orb $0x4, 0x3(%rbp)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %r13
movq 0x10(%rbp), %rax
cmpq 0x110(%rbx), %rax
jne 0xcc6ce
cmpb $0x1, (%r12)
jne 0xcc6ce
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcc65d
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x1f, (%rax)
movq 0x110(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %r12, 0x10(%rax)
movq $0x0, 0x28(%rax)
movq 0x110(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %r12, 0x8(%rax)
movq 0x50(%rbx), %rcx
movq %r13, (%rcx)
movq 0x8(%rbx), %rcx
movq 0x50(%rbx), %rdx
movq %rcx, 0x8(%rdx)
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x1fa, 0x18(%rax)      # imm = 0x1FA
addq $0x20, 0x50(%rbx)
jmp 0xcc78a
movq %r12, 0x4f0(%rbx)
cmpb $0x1d, (%r12)
je 0xcc6ee
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb067
movq %rax, 0x4f0(%rbx)
movq 0x50(%rbx), %rax
movq %r13, (%rax)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x4f0(%rbx), %r14
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcc727
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x1f, (%rax)
movq 0x110(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %r14, 0x10(%rax)
movq $0x0, 0x28(%rax)
movq 0x110(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x1f9, 0x18(%rax)      # imm = 0x1F9
addq $0x20, 0x50(%rbx)
movq 0x110(%rbx), %rax
movq %rax, 0x4f0(%rbx)
movq 0x130(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, 0x10(%rsp)
movq 0x8(%r12), %rax
movq 0x10(%r12), %rcx
movq %rcx, 0x8(%rsp)
cmpq $0x3e9, %rax            # imm = 0x3E9
jl 0xcc95f
movq %rax, %r12
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xccab5
testb %al, %al
jne 0xcc96b
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcc7f5
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r13
movq $0x500000b, (%r13)      # imm = 0x500000B
movq $0x0, 0x8(%r13)
movq 0x10(%rsp), %rax
movq %r13, 0x10(%rax)
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
movq (%rax,%rbp,8), %rax
movq %rax, 0x8(%r13)
movq %rbx, %rdi
movq %r14, %rsi
callq *%r15
incq %rbp
cmpq %rbp, %r12
jne 0xcc81f
jmp 0xcc78a
movq %r13, 0x10(%rsp)
movq 0x8(%r12), %r13
movq 0x10(%r12), %r12
cmpq $0x3e9, %r13            # imm = 0x3E9
jl 0xcc9e5
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xccab5
testb %al, %al
jne 0xcc9ee
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcc890
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x500000d, (%rcx)      # imm = 0x500000D
movq $0x0, 0x8(%rcx)
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rcx, 0x10(%rax)
xorl %ebp, %ebp
movsd (%r12,%rbp,8), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq *%r15
incq %rbp
cmpq %rbp, %r13
jne 0xcc8be
jmp 0xcc78a
movq %r12, 0x4f0(%rbx)
cmpb $0x1d, (%r12)
je 0xcc900
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb067
movq %rax, %r12
movq 0x50(%rbx), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x50(%rbx), %rax
movq %r12, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%rbx)
movq 0x110(%rbx), %rax
movq %rax, 0x4f0(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq *0x28(%r12)
movq %rax, 0x10(%r13)
testb $-0x80, 0x3(%r12)
je 0xcc955
movq %rbx, %rdi
movq %r14, %rsi
callq *%r15
jmp 0xcc933
addq $-0x20, 0x50(%rbx)
jmp 0xcc78a
movq %rax, %r12
testq %rax, %rax
jle 0xcc78a
xorl %r13d, %r13d
movq 0x8(%rsp), %rax
movq (%rax,%r13,8), %rbp
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0xcc98d
leaq 0x79fc9(%rip), %rax     # 0x146950
movq (%rax,%rbp,8), %rax
jmp 0xcc9c6
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcc9ac
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %rbp, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %r14, %rsi
callq *%r15
incq %r13
cmpq %r13, %r12
jne 0xcc96e
jmp 0xcc78a
testq %r13, %r13
jle 0xcc78a
xorl %ebp, %ebp
movsd (%r12,%rbp,8), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcca21
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xa550
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %r14, %rsi
callq *%r15
incq %rbp
cmpq %rbp, %r13
jne 0xcc9f0
jmp 0xcc78a