// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq 0x10(%rsi), %rbp
testb $0x4, 0x3(%rbp)
jne 0xd51a9
movq 0x8(%r13), %rax
movb (%r14), %cl
addb $-0x16, %cl
cmpb $0x3, %cl
jae 0xd4d84
movzbl %cl, %ecx
leaq 0x79002(%rip), %rdx     # 0x14dd80
movq (%rdx,%rcx,8), %rcx
jmp 0xd4d8b
leaq 0x120(%rbx), %rcx
movq 0x8(%rbx), %rdx
movq %rdx, (%rsp)
movq (%rcx), %r12
movq 0x8(%rax), %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xd4db2
movq %rbx, %rdi
callq 0xb389
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 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 %r15, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq %rcx, 0x18(%r15)
movq 0x250(%rbx), %rdx
movq %rdx, 0x20(%r15)
incl 0x28(%r15)
movq $0x0, 0x18(%rcx)
movq %rcx, 0x8(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %r12
movq 0x10(%rbp), %rax
cmpq 0x110(%rbx), %rax
movq %r13, 0x20(%rsp)
movq %rbp, 0x18(%rsp)
je 0xd4ef6
movq 0x1808(%rbx), %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xd4e76
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r13
movq $0x200001, (%r13)       # imm = 0x200001
movq %r15, 0x8(%r13)
movq %rbp, 0x10(%r13)
movq %r13, 0x4d0(%rbx)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r15
cmpq 0x98(%rbx), %rax
ja 0xd4ec2
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rsi
movq $0x200001, (%rsi)       # imm = 0x200001
movq %r13, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movq %rbx, %rdi
movl $0x1, %edx
callq 0xd543e
jmp 0xd4f0a
movq 0x8(%rbp), %r13
movq %rbx, %rdi
movq %rbp, %rsi
movl $0x1, %edx
callq 0x48508
movq %rax, %rbp
testq %rax, %rax
je 0xd4fa4
movzbl (%r14), %eax
cmpl $0x17, %eax
movq %r12, (%rsp)
je 0xd5070
cmpl $0x16, %eax
je 0xd4fba
cmpl $0x1, %eax
jne 0xd5111
movq %r14, 0x8(%rsp)
cmpb $0x1, (%r14)
jne 0xd4f93
movq 0x8(%rsp), %r15
movq %r15, %r12
movq (%rsp), %r14
movq 0x8(%r12), %rax
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movq %r13, %rsi
callq *%rbp
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0xd4f8c
movq 0x8(%r12), %rax
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movq %r13, %rsi
callq *%rbp
movq 0x10(%r15), %r15
movq 0x10(%r12), %r12
cmpq %r15, %r12
je 0xd4f93
cmpb $0x1, (%r12)
je 0xd4f50
movq 0x130(%rbx), %rax
movq 0x8(%rsp), %r14
jmp 0xd5196
movq 0x18(%rsp), %rax
orb $0x4, 0x3(%rax)
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
jmp 0xd5196
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
movq %rax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x3e9, %rcx            # imm = 0x3E9
jl 0xd4fea
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0xd5498
testb %al, %al
je 0xd5333
cmpq $0x0, 0x10(%rsp)
jle 0xd518f
xorl %r12d, %r12d
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %r15
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0xd5018
leaq 0x7993e(%rip), %rax     # 0x14e950
movq (%rax,%r15,8), %rax
jmp 0xd5051
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xd5030
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r15, 0x8(%rax)
movq (%rsp), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %r13, %rsi
callq *%rbp
incq %r12
cmpq %r12, 0x10(%rsp)
jne 0xd4ff9
jmp 0xd518f
movq 0x8(%r14), %rax
movq 0x10(%r14), %r12
movq %rax, 0x8(%rsp)
cmpq $0x3e9, %rax            # imm = 0x3E9
jl 0xd509a
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0xd5498
testb %al, %al
je 0xd53b5
cmpq $0x0, 0x8(%rsp)
jle 0xd518f
xorl %r15d, %r15d
movsd (%r12,%r15,8), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xd50d3
movq %rbx, %rdi
movsd %xmm0, 0x10(%rsp)
callq 0xb389
movsd 0x10(%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 (%rsp), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %r13, %rsi
callq *%rbp
incq %r15
cmpq %r15, 0x8(%rsp)
jne 0xd50a9
jmp 0xd518f
movq %r14, 0x4f0(%rbx)
cmpb $0x1d, (%r14)
je 0xd5130
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbec2
movq %rax, 0x4f0(%rbx)
movq 0x4f0(%rbx), %r14
movq 0x50(%rbx), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x50(%rbx), %rax
movq %r14, 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 %r14, %rsi
callq *0x28(%r14)
movq %rax, 0x10(%r12)
testb $-0x80, 0x3(%r14)
je 0xd518a
movq %rbx, %rdi
movq %r13, %rsi
callq *%rbp
jmp 0xd516a
addq $-0x20, 0x50(%rbx)
movq 0x130(%rbx), %rax
testq %rbp, %rbp
movq 0x20(%rsp), %r13
movq 0x18(%rsp), %rbp
jne 0xd5324
movq 0x10(%rbp), %rax
cmpq 0x110(%rbx), %rax
jne 0xd525b
cmpb $0x1, (%r14)
jne 0xd525b
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xd51dc
movq %rbx, %rdi
callq 0xb389
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 0x110(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq %r14, 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 0xd531d
movq %r14, 0x4f0(%rbx)
cmpb $0x1d, (%r14)
je 0xd527a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbec2
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 0xd52ac
movq %rbx, %rdi
callq 0xb389
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 0x110(%rbx), %rcx
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 $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xd534b
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x500000b, (%rax)      # imm = 0x500000B
movq $0x0, 0x8(%rax)
movq %rax, (%rsp)
movq %rax, 0x10(%r12)
movq 0x10(%rsp), %rax
cmpq $0x2, %rax
movl $0x1, %r12d
cmovgeq %rax, %r12
xorl %r15d, %r15d
movq 0x8(%rsp), %rax
movq (%rax,%r15,8), %rax
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
movq %rbx, %rdi
movq %r13, %rsi
callq *%rbp
incq %r15
cmpq %r15, %r12
jne 0xd538f
jmp 0xd518f
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xd53cd
movq %rbx, %rdi
callq 0xb389
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 (%rsp), %rax
movq %rcx, 0x10(%rsp)
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
cmpq $0x2, %rax
movl $0x1, %ecx
cmovgeq %rax, %rcx
movq %rcx, (%rsp)
xorl %r15d, %r15d
movsd (%r12,%r15,8), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq *%rbp
incq %r15
cmpq %r15, (%rsp)
jne 0xd5418
jmp 0xd518f