LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: oprec_if_a_opla_laq_a
static s7_pointer oprec_if_a_opla_laq_a(s7_scheme *sc)
                {
                    if (sc->rec_testf(sc, sc->rec_testp) == sc->F)
                        return(sc->rec_resf(sc, sc->rec_resp));
                    recur_push(sc, sc->rec_f1f(sc, sc->rec_f1p));
                    slot_set_value(sc->rec_slot1, sc->rec_f2f(sc, sc->rec_f2p));
                    slot_set_value(sc->rec_slot1, recur_swap(sc, oprec_if_a_opla_laq_a(sc)));
                    set_car(sc->t2_1, oprec_if_a_opla_laq_a(sc));
                    set_car(sc->t2_2, recur_pop(sc));
                    return(sc->rec_call(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2f0(%rdi), %rsi
callq *0x360(%rdi)
cmpq 0x120(%rbx), %rax
je 0xdadc7
movq 0x2f8(%rbx), %rsi
movq %rbx, %rdi
callq *0x368(%rbx)
movq %rax, %r14
movq 0x2d8(%rbx), %rdx
cmpq %rdx, 0x2d0(%rbx)
jne 0xdad0d
movq 0x2e8(%rbx), %r15
leaq (%rdx,%rdx), %rax
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rsi
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0xae0f
movq $0x0, 0x20(%rax)
movq %rax, 0x18(%r15)
movq (%rax), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rax
movq %rax, 0x2d8(%rbx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, (%rcx,%rax,8)
incq %rax
movq %rax, 0x2d0(%rbx)
movq 0x300(%rbx), %rsi
movq %rbx, %rdi
callq *0x370(%rbx)
movq 0x348(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
callq 0xdac8b
movq 0x2d0(%rbx), %rcx
movq 0x2e8(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq -0x8(%rdx,%rcx,8), %rsi
movq %rax, -0x8(%rdx,%rcx,8)
movq 0x348(%rbx), %rax
movq %rsi, 0x10(%rax)
movq %rbx, %rdi
callq 0xdac8b
leaq 0x570(%rbx), %rcx
movq 0x570(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rdx
leaq -0x1(%rax), %rsi
movq %rsi, 0x2d0(%rbx)
movq 0x10(%rdx), %rdx
movq -0x8(%rdx,%rax,8), %rax
movq 0x578(%rbx), %rdx
movq %rax, 0x8(%rdx)
leaq 0x3b8(%rbx), %rax
jmp 0xdadd5
leaq 0x3b0(%rbx), %rax
leaq 0x340(%rbx), %rcx
movq (%rax), %rax
movq (%rcx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: oprec_d_if_a_a_opla_laq
static s7_double oprec_d_if_a_a_opla_laq(s7_scheme *sc)
                {
                    s7_double x1, x2;
                    sc->pc = 0;
                    if (sc->rec_test_o->v[0].fb(sc->rec_test_o))
                    {
                        sc->pc++;
                        return(sc->rec_result_o->v[0].fd(sc->rec_result_o));
                    }
                    sc->pc = sc->rec_pc1;
                    x1 = sc->rec_a1_o->v[0].fd(sc->rec_a1_o);
                    real(sc->rec_val1) = sc->rec_a2_o->v[0].fd(sc->rec_a2_o);
                    x2 = oprec_d_if_a_a_opla_laq(sc);
                    real(sc->rec_val1) = x1;
                    return(sc->rec_d_dd_f(oprec_d_if_a_a_opla_laq(sc), x2));
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x0, 0x2258(%rdi)
movq 0x400(%rdi), %rdi
callq *(%rdi)
testb %al, %al
je 0xdae1c
incl 0x2258(%rbx)
movq 0x408(%rbx), %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *(%rdi)
movl 0x460(%rbx), %eax
movl %eax, 0x2258(%rbx)
movq 0x410(%rbx), %rdi
callq *(%rdi)
movsd %xmm0, 0x10(%rsp)
movq 0x418(%rbx), %rdi
callq *(%rdi)
movq 0x450(%rbx), %rax
movsd %xmm0, 0x8(%rax)
movq %rbx, %rdi
callq 0xdade5
movsd %xmm0, 0x8(%rsp)
movq 0x450(%rbx), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x448(%rbx), %r14
movq %rbx, %rdi
callq 0xdade5
movsd 0x8(%rsp), %xmm1
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: oprec_d_if_a_opla_laq_a
static s7_double oprec_d_if_a_opla_laq_a(s7_scheme *sc)
                {
                    s7_double x1, x2;
                    sc->pc = 0;
                    if (!(sc->rec_test_o->v[0].fb(sc->rec_test_o)))
                    {
                        sc->pc++;
                        return(sc->rec_result_o->v[0].fd(sc->rec_result_o));
                    }
                    sc->pc = sc->rec_pc1;
                    x1 = sc->rec_a1_o->v[0].fd(sc->rec_a1_o);
                    sc->pc++;
                    real(sc->rec_val1) = sc->rec_a2_o->v[0].fd(sc->rec_a2_o);
                    x2 = oprec_d_if_a_opla_laq_a(sc);
                    real(sc->rec_val1) = x1;
                    return(sc->rec_d_dd_f(oprec_d_if_a_opla_laq_a(sc), x2));
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x0, 0x2258(%rdi)
movq 0x400(%rdi), %rdi
callq *(%rdi)
testb %al, %al
je 0xdaf25
movl 0x460(%rbx), %eax
movl %eax, 0x2258(%rbx)
movq 0x410(%rbx), %rdi
callq *(%rdi)
movsd %xmm0, 0x10(%rsp)
incl 0x2258(%rbx)
movq 0x418(%rbx), %rdi
callq *(%rdi)
movq 0x450(%rbx), %rax
movsd %xmm0, 0x8(%rax)
movq %rbx, %rdi
callq 0xdae8d
movsd %xmm0, 0x8(%rsp)
movq 0x450(%rbx), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x448(%rbx), %r14
movq %rbx, %rdi
callq 0xdae8d
movsd 0x8(%rsp), %xmm1
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rax
incl 0x2258(%rbx)
movq 0x408(%rbx), %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *(%rdi)
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: oprec_if_a_a_opa_la_laq
static s7_pointer oprec_if_a_a_opa_la_laq(s7_scheme *sc)
                {
                    if (sc->rec_testf(sc, sc->rec_testp) != sc->F)
                        return(sc->rec_resf(sc, sc->rec_resp));
                    recur_push(sc, sc->rec_f1f(sc, sc->rec_f1p));
                    recur_push(sc, sc->rec_f2f(sc, sc->rec_f2p));
                    slot_set_value(sc->rec_slot1, sc->rec_f3f(sc, sc->rec_f3p));
                    slot_set_value(sc->rec_slot1, recur_swap(sc, oprec_if_a_a_opa_la_laq(sc)));
                    set_car(sc->t3_2, oprec_if_a_a_opa_la_laq(sc));
                    set_car(sc->t3_3, recur_pop(sc));
                    set_car(sc->t3_1, recur_pop(sc));
                    return(sc->rec_call(sc, sc->t3_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2f0(%rdi), %rsi
callq *0x360(%rdi)
cmpq 0x120(%rbx), %rax
je 0xdb054
leaq 0x3b0(%rbx), %rcx
leaq 0x340(%rbx), %rax
jmp 0xdb219
movq 0x2f8(%rbx), %rsi
movq %rbx, %rdi
callq *0x368(%rbx)
movq %rax, %r14
movq 0x2d8(%rbx), %rdx
cmpq %rdx, 0x2d0(%rbx)
jne 0xdb0b4
movq 0x2e8(%rbx), %r15
leaq (%rdx,%rdx), %rax
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rsi
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0xae0f
movq $0x0, 0x20(%rax)
movq %rax, 0x18(%r15)
movq (%rax), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rax
movq %rax, 0x2d8(%rbx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, (%rcx,%rax,8)
incq %rax
movq %rax, 0x2d0(%rbx)
movq 0x300(%rbx), %rsi
movq %rbx, %rdi
callq *0x370(%rbx)
movq %rax, %r14
movq 0x2d8(%rbx), %rdx
cmpq %rdx, 0x2d0(%rbx)
jne 0xdb134
movq 0x2e8(%rbx), %r15
leaq (%rdx,%rdx), %rax
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rsi
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0xae0f
movq $0x0, 0x20(%rax)
movq %rax, 0x18(%r15)
movq (%rax), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rax
movq %rax, 0x2d8(%rbx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, (%rcx,%rax,8)
incq %rax
movq %rax, 0x2d0(%rbx)
movq 0x308(%rbx), %rsi
movq %rbx, %rdi
callq *0x378(%rbx)
movq 0x348(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
callq 0xdb023
movq 0x2d0(%rbx), %rcx
movq 0x2e8(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq -0x8(%rdx,%rcx,8), %rsi
movq %rax, -0x8(%rdx,%rcx,8)
movq 0x348(%rbx), %rax
movq %rsi, 0x10(%rax)
movq %rbx, %rdi
callq 0xdb023
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x2d0(%rbx)
movq 0x10(%rcx), %rcx
movq -0x8(%rcx,%rax,8), %rax
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x2d0(%rbx)
movq 0x10(%rcx), %rcx
movq -0x8(%rcx,%rax,8), %rcx
leaq 0x580(%rbx), %rax
movq 0x580(%rbx), %rdx
movq %rcx, 0x8(%rdx)
leaq 0x3b8(%rbx), %rcx
movq (%rcx), %rcx
movq (%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: oprec_if_a_opa_la_laq_a
static s7_pointer oprec_if_a_opa_la_laq_a(s7_scheme *sc)
                {
                    if (sc->rec_testf(sc, sc->rec_testp) == sc->F)
                        return(sc->rec_resf(sc, sc->rec_resp));
                    recur_push(sc, sc->rec_f1f(sc, sc->rec_f1p));
                    recur_push(sc, sc->rec_f2f(sc, sc->rec_f2p));
                    slot_set_value(sc->rec_slot1, sc->rec_f3f(sc, sc->rec_f3p));
                    slot_set_value(sc->rec_slot1, recur_swap(sc, oprec_if_a_opa_la_laq_a(sc)));
                    set_car(sc->t3_2, oprec_if_a_opa_la_laq_a(sc));
                    set_car(sc->t3_3, recur_pop(sc));
                    set_car(sc->t3_1, recur_pop(sc));
                    return(sc->rec_call(sc, sc->t3_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2f0(%rdi), %rsi
callq *0x360(%rdi)
cmpq 0x120(%rbx), %rax
je 0xdb412
movq 0x2f8(%rbx), %rsi
movq %rbx, %rdi
callq *0x368(%rbx)
movq %rax, %r14
movq 0x2d8(%rbx), %rdx
cmpq %rdx, 0x2d0(%rbx)
jne 0xdb2ab
movq 0x2e8(%rbx), %r15
leaq (%rdx,%rdx), %rax
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rsi
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0xae0f
movq $0x0, 0x20(%rax)
movq %rax, 0x18(%r15)
movq (%rax), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rax
movq %rax, 0x2d8(%rbx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, (%rcx,%rax,8)
incq %rax
movq %rax, 0x2d0(%rbx)
movq 0x300(%rbx), %rsi
movq %rbx, %rdi
callq *0x370(%rbx)
movq %rax, %r14
movq 0x2d8(%rbx), %rdx
cmpq %rdx, 0x2d0(%rbx)
jne 0xdb32b
movq 0x2e8(%rbx), %r15
leaq (%rdx,%rdx), %rax
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rsi
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0xae0f
movq $0x0, 0x20(%rax)
movq %rax, 0x18(%r15)
movq (%rax), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rax
movq %rax, 0x2d8(%rbx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, (%rcx,%rax,8)
incq %rax
movq %rax, 0x2d0(%rbx)
movq 0x308(%rbx), %rsi
movq %rbx, %rdi
callq *0x378(%rbx)
movq 0x348(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
callq 0xdb229
movq 0x2d0(%rbx), %rcx
movq 0x2e8(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq -0x8(%rdx,%rcx,8), %rsi
movq %rax, -0x8(%rdx,%rcx,8)
movq 0x348(%rbx), %rax
movq %rsi, 0x10(%rax)
movq %rbx, %rdi
callq 0xdb229
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x2d0(%rbx)
movq 0x10(%rcx), %rcx
movq -0x8(%rcx,%rax,8), %rax
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x2d0(%rbx)
movq 0x10(%rcx), %rcx
movq -0x8(%rcx,%rax,8), %rcx
leaq 0x580(%rbx), %rax
movq 0x580(%rbx), %rdx
movq %rcx, 0x8(%rdx)
leaq 0x3b8(%rbx), %rcx
jmp 0xdb420
leaq 0x3b0(%rbx), %rcx
leaq 0x340(%rbx), %rax
movq (%rcx), %rcx
movq (%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opinit_if_a_a_and_a_laa_laa
static void opinit_if_a_a_and_a_laa_laa(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer caller, la1, la2;

                    rec_set_test(sc, cdr(code));
                    rec_set_res(sc, cddr(code));

                    caller = opt3_pair(code);
                    la1 = caddr(caller);
                    la2 = cadddr(caller);

                    rec_set_f1(sc, cdr(caller));
                    rec_set_f2(sc, cdr(la1));
                    rec_set_f3(sc, cddr(la1));
                    rec_set_f4(sc, cdr(la2));
                    rec_set_f5(sc, cddr(la2));
                    sc->rec_slot1 = let_slots(sc->envir);
                    sc->rec_slot2 = next_slot(sc->rec_slot1);
                }

// Assembly:
movq 0x10(%rsi), %rax
movq %rax, 0x2f0(%rdi)
movq 0x20(%rax), %rcx
movq %rcx, 0x360(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rdi)
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq %rax, 0x340(%rdi)
movq 0x20(%rax), %rcx
movq %rcx, 0x3b0(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x340(%rdi)
movq 0x28(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x2f8(%rdi)
movq 0x20(%rax), %rsi
movq %rsi, 0x368(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x2f8(%rdi)
movq 0x10(%rdx), %rax
movq %rax, 0x300(%rdi)
movq 0x20(%rax), %rsi
movq %rsi, 0x370(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x300(%rdi)
movq 0x10(%rdx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x308(%rdi)
movq 0x20(%rax), %rdx
movq %rdx, 0x378(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x308(%rdi)
movq 0x10(%rcx), %rax
movq %rax, 0x310(%rdi)
movq 0x20(%rax), %rdx
movq %rdx, 0x380(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x310(%rdi)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x318(%rdi)
movq 0x20(%rax), %rcx
movq %rcx, 0x388(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x318(%rdi)
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, 0x348(%rdi)
movq 0x18(%rax), %rax
movq %rax, 0x350(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opinit_cond_a_a_a_laa_opa_laaq
static void opinit_cond_a_a_a_laa_opa_laaq(s7_scheme *sc, bool cond)
                {
                    s7_pointer caller;
                    rec_set_test(sc, (cond) ? cadr(sc->code) : cdr(sc->code));
                    rec_set_res(sc, (cond) ? cdadr(sc->code) : cddr(sc->code));

                    sc->rec_f1p = (cond) ? caddr(sc->code) : cdr(cadddr(sc->code));
                    sc->rec_f2p = cdadr(sc->rec_f1p);
                    rec_set_f3(sc, cdr(sc->rec_f2p));

                    sc->rec_f1f = c_callee(sc->rec_f1p);
                    sc->rec_f1p = car(sc->rec_f1p);
                    sc->rec_f2f = c_callee(sc->rec_f2p);
                    sc->rec_f2p = car(sc->rec_f2p);

                    caller = opt3_pair(sc->code);          /* opA_LAA */

                    rec_set_f4(sc, cdr(caller));
                    sc->rec_f5p = cdr(opt3_pair(caller));  /* (L)AA */
                    rec_set_f6(sc, cdr(sc->rec_f5p));
                    sc->rec_f5f = c_callee(sc->rec_f5p);
                    sc->rec_f5p = car(sc->rec_f5p);
                    sc->rec_call = c_callee(caller);

                    sc->rec_slot1 = let_slots(sc->envir);
                    sc->rec_slot2 = next_slot(sc->rec_slot1);
                }

// Assembly:
movq (%rdi), %rax
addq $0x10, %rax
testl %esi, %esi
je 0xdc241
movq (%rax), %rax
addq $0x8, %rax
movq (%rax), %rax
movq %rax, 0x2f0(%rdi)
movq 0x20(%rax), %rcx
movq %rcx, 0x360(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rdi)
movq (%rdi), %rax
addq $0x10, %rax
testb %sil, %sil
je 0xdc274
movq (%rax), %rax
addq $0x8, %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x340(%rdi)
movq 0x20(%rax), %rcx
movq %rcx, 0x3b0(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x340(%rdi)
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
testb %sil, %sil
je 0xdc2ae
addq $0x8, %rax
jmp 0xdc2ba
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rax
movq %rax, 0x2f8(%rdi)
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x300(%rdi)
movq 0x10(%rcx), %rdx
movq %rdx, 0x308(%rdi)
movq 0x20(%rdx), %rsi
movq %rsi, 0x378(%rdi)
movq 0x8(%rdx), %rdx
movq %rdx, 0x308(%rdi)
movq 0x20(%rax), %rdx
movq %rdx, 0x368(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x2f8(%rdi)
movq 0x20(%rcx), %rax
movq %rax, 0x370(%rdi)
movq 0x8(%rcx), %rax
movq %rax, 0x300(%rdi)
movq (%rdi), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x310(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x380(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x310(%rdi)
movq 0x28(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x318(%rdi)
movq 0x10(%rcx), %rdx
movq %rdx, 0x320(%rdi)
movq 0x20(%rdx), %rsi
movq %rsi, 0x390(%rdi)
movq 0x8(%rdx), %rdx
movq %rdx, 0x320(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x388(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x318(%rdi)
movq 0x20(%rax), %rax
movq %rax, 0x3b8(%rdi)
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, 0x348(%rdi)
movq 0x18(%rax), %rax
movq %rax, 0x350(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opinit_cond_a_a_a_a_opla_laq
static void opinit_cond_a_a_a_a_opla_laq(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer caller;
                    rec_set_test(sc, cadr(code));
                    rec_set_res(sc, cdadr(code));
                    rec_set_f1(sc, caddr(code));
                    rec_set_f2(sc, cdaddr(code));
                    caller = opt3_pair(code);
                    rec_set_f3(sc, cdadr(caller));
                    rec_set_f4(sc, opt3_pair(caller));
                    sc->rec_slot1 = let_slots(sc->envir);
                    sc->rec_call = c_callee(caller);
                }

// Assembly:
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rdi)
movq 0x20(%rax), %rcx
movq %rcx, 0x360(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x2f0(%rdi)
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x340(%rdi)
movq 0x20(%rax), %rcx
movq %rcx, 0x3b0(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x340(%rdi)
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2f8(%rdi)
movq 0x20(%rax), %rcx
movq %rcx, 0x368(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x2f8(%rdi)
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x300(%rdi)
movq 0x20(%rax), %rcx
movq %rcx, 0x370(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x300(%rdi)
movq 0x28(%rsi), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x308(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x378(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x308(%rdi)
movq 0x28(%rax), %rcx
movq %rcx, 0x310(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x380(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x310(%rdi)
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x348(%rdi)
movq 0x20(%rax), %rax
movq %rax, 0x3b8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: oprec_cond_a_a_a_a_opla_laq
static s7_pointer oprec_cond_a_a_a_a_opla_laq(s7_scheme *sc)
                {
                    if (sc->rec_testf(sc, sc->rec_testp) != sc->F)
                        return(sc->rec_resf(sc, sc->rec_resp));
                    if (sc->rec_f1f(sc, sc->rec_f1p) != sc->F)
                        return(sc->rec_f2f(sc, sc->rec_f2p));
                    recur_push(sc, sc->rec_f3f(sc, sc->rec_f3p));
                    slot_set_value(sc->rec_slot1, sc->rec_f4f(sc, sc->rec_f4p));
                    slot_set_value(sc->rec_slot1, recur_swap(sc, oprec_cond_a_a_a_a_opla_laq(sc)));
                    set_car(sc->t2_1, oprec_cond_a_a_a_a_opla_laq(sc));
                    set_car(sc->t2_2, recur_pop(sc));
                    return(sc->rec_call(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2f0(%rdi), %rsi
callq *0x360(%rdi)
cmpq 0x120(%rbx), %rax
je 0xdc7b8
leaq 0x3b0(%rbx), %rax
leaq 0x340(%rbx), %rcx
jmp 0xdc8fc
movq 0x2f8(%rbx), %rsi
movq %rbx, %rdi
callq *0x368(%rbx)
cmpq 0x120(%rbx), %rax
je 0xdc7e4
leaq 0x370(%rbx), %rax
leaq 0x300(%rbx), %rcx
jmp 0xdc8fc
movq 0x308(%rbx), %rsi
movq %rbx, %rdi
callq *0x378(%rbx)
movq %rax, %r14
movq 0x2d8(%rbx), %rdx
cmpq %rdx, 0x2d0(%rbx)
jne 0xdc844
movq 0x2e8(%rbx), %r15
leaq (%rdx,%rdx), %rax
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rsi
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0xae0f
movq $0x0, 0x20(%rax)
movq %rax, 0x18(%r15)
movq (%rax), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rax
movq %rax, 0x2d8(%rbx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, (%rcx,%rax,8)
incq %rax
movq %rax, 0x2d0(%rbx)
movq 0x310(%rbx), %rsi
movq %rbx, %rdi
callq *0x380(%rbx)
movq 0x348(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
callq 0xdc787
movq 0x2d0(%rbx), %rcx
movq 0x2e8(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq -0x8(%rdx,%rcx,8), %rsi
movq %rax, -0x8(%rdx,%rcx,8)
movq 0x348(%rbx), %rax
movq %rsi, 0x10(%rax)
movq %rbx, %rdi
callq 0xdc787
leaq 0x570(%rbx), %rcx
movq 0x570(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rdx
leaq -0x1(%rax), %rsi
movq %rsi, 0x2d0(%rbx)
movq 0x10(%rdx), %rdx
movq -0x8(%rdx,%rax,8), %rax
movq 0x578(%rbx), %rdx
movq %rax, 0x8(%rdx)
leaq 0x3b8(%rbx), %rax
movq (%rax), %rax
movq (%rcx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: oprec_cond_a_a_a_a_opa_laaq
static s7_pointer oprec_cond_a_a_a_a_opa_laaq(s7_scheme *sc)
                {
                    if (sc->rec_testf(sc, sc->rec_testp) != sc->F)
                        return(sc->rec_resf(sc, sc->rec_resp));
                    if (sc->rec_f1f(sc, sc->rec_f1p) != sc->F)
                        return(sc->rec_f2f(sc, sc->rec_f2p));
                    recur_push(sc, sc->rec_f3f(sc, sc->rec_f3p));
                    recur_push(sc, sc->rec_f4f(sc, sc->rec_f4p));
                    slot_set_value(sc->rec_slot2, sc->rec_f5f(sc, sc->rec_f5p));
                    slot_set_value(sc->rec_slot1, recur_pop(sc));
                    set_car(sc->t2_2, oprec_cond_a_a_a_a_opa_laaq(sc));
                    set_car(sc->t2_1, recur_pop(sc));
                    return(sc->rec_call(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2f0(%rdi), %rsi
callq *0x360(%rdi)
cmpq 0x120(%rbx), %rax
je 0xdc93d
leaq 0x3b0(%rbx), %rcx
leaq 0x340(%rbx), %rax
jmp 0xdcaff
movq 0x2f8(%rbx), %rsi
movq %rbx, %rdi
callq *0x368(%rbx)
cmpq 0x120(%rbx), %rax
je 0xdc969
leaq 0x370(%rbx), %rcx
leaq 0x300(%rbx), %rax
jmp 0xdcaff
movq 0x308(%rbx), %rsi
movq %rbx, %rdi
callq *0x378(%rbx)
movq %rax, %r14
movq 0x2d8(%rbx), %rdx
cmpq %rdx, 0x2d0(%rbx)
jne 0xdc9c9
movq 0x2e8(%rbx), %r15
leaq (%rdx,%rdx), %rax
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rsi
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0xae0f
movq $0x0, 0x20(%rax)
movq %rax, 0x18(%r15)
movq (%rax), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rax
movq %rax, 0x2d8(%rbx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, (%rcx,%rax,8)
incq %rax
movq %rax, 0x2d0(%rbx)
movq 0x310(%rbx), %rsi
movq %rbx, %rdi
callq *0x380(%rbx)
movq %rax, %r14
movq 0x2d8(%rbx), %rdx
cmpq %rdx, 0x2d0(%rbx)
jne 0xdca49
movq 0x2e8(%rbx), %r15
leaq (%rdx,%rdx), %rax
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rsi
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0xae0f
movq $0x0, 0x20(%rax)
movq %rax, 0x18(%r15)
movq (%rax), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rax
movq %rax, 0x2d8(%rbx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, (%rcx,%rax,8)
incq %rax
movq %rax, 0x2d0(%rbx)
movq 0x318(%rbx), %rsi
movq %rbx, %rdi
callq *0x388(%rbx)
movq 0x350(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x2d0(%rbx)
movq 0x10(%rcx), %rcx
movq -0x8(%rcx,%rax,8), %rax
movq 0x348(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
callq 0xdc90c
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x2d0(%rbx), %rax
movq 0x2e8(%rbx), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x2d0(%rbx)
movq 0x10(%rcx), %rcx
movq -0x8(%rcx,%rax,8), %rcx
leaq 0x570(%rbx), %rax
movq 0x570(%rbx), %rdx
movq %rcx, 0x8(%rdx)
leaq 0x3b8(%rbx), %rcx
movq (%rcx), %rcx
movq (%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: oprec_i_cond_a_a_a_laa_lopa_laaq
static s7_int oprec_i_cond_a_a_a_laa_lopa_laaq(s7_scheme *sc)
                {
                    s7_int i1, i2;
                    sc->pc = 0;
                    if (sc->rec_test_o->v[0].fb(sc->rec_test_o))
                    {
                        sc->pc++;
                        return(sc->rec_result_o->v[0].fi(sc->rec_result_o));
                    }
                    sc->pc = sc->rec_pc1;
                    if (sc->rec_a1_o->v[0].fb(sc->rec_a1_o))
                    {
                        i1 = sc->rec_a2_o->v[0].fi(sc->rec_a2_o);
                        sc->pc++;
                        integer(sc->rec_val2) = sc->rec_a3_o->v[0].fi(sc->rec_a3_o);
                        integer(sc->rec_val1) = i1;
                        return(oprec_i_cond_a_a_a_laa_lopa_laaq(sc));
                    }
                    sc->pc = sc->rec_pc2;
                    i1 = sc->rec_a4_o->v[0].fi(sc->rec_a4_o);
                    sc->pc++;
                    i2 = sc->rec_a5_o->v[0].fi(sc->rec_a5_o);
                    sc->pc++;
                    integer(sc->rec_val2) = sc->rec_a6_o->v[0].fi(sc->rec_a6_o);
                    integer(sc->rec_val1) = i2;
                    integer(sc->rec_val2) = oprec_i_cond_a_a_a_laa_lopa_laaq(sc);
                    integer(sc->rec_val1) = i1;
                    return(oprec_i_cond_a_a_a_laa_lopa_laaq(sc));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x2258(%rbx)
movq 0x400(%rbx), %rdi
callq *(%rdi)
testb %al, %al
jne 0xdcee7
movl 0x460(%rbx), %eax
movl %eax, 0x2258(%rbx)
movq 0x410(%rbx), %rdi
callq *(%rdi)
testb %al, %al
je 0xdce75
movq 0x418(%rbx), %rdi
callq *(%rdi)
movq %rax, %r14
incl 0x2258(%rbx)
movq 0x420(%rbx), %rdi
callq *(%rdi)
jmp 0xdcecc
movl 0x464(%rbx), %eax
movl %eax, 0x2258(%rbx)
movq 0x428(%rbx), %rdi
callq *(%rdi)
movq %rax, %r14
incl 0x2258(%rbx)
movq 0x430(%rbx), %rdi
callq *(%rdi)
movq %rax, %r15
incl 0x2258(%rbx)
movq 0x438(%rbx), %rdi
callq *(%rdi)
movq 0x458(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x450(%rbx), %rax
movq %r15, 0x8(%rax)
movq %rbx, %rdi
callq 0xdce1c
movq 0x458(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x450(%rbx), %rax
movq %r14, 0x8(%rax)
jmp 0xdce24
incl 0x2258(%rbx)
movq 0x408(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmpq *(%rdi)
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: oprec_i_cond_a_a_a_laa_lopa_laaq_0
static s7_int oprec_i_cond_a_a_a_laa_lopa_laaq_0(s7_scheme *sc)
                {
                    s7_int i1, i2;
                    if (sc->rec_fb1(sc->rec_test_o))
                        return(sc->rec_fi1(sc->rec_result_o));
                    if (sc->rec_fb2(sc->rec_a1_o))
                    {
                        i1 = sc->rec_fi2(sc->rec_a2_o);
                        integer(sc->rec_val2) = sc->rec_fi3(sc->rec_a3_o);
                        integer(sc->rec_val1) = i1;
                        return(oprec_i_cond_a_a_a_laa_lopa_laaq_0(sc));
                    }
                    i1 = sc->rec_fi4(sc->rec_a4_o);
                    i2 = sc->rec_fi5(sc->rec_a5_o);
                    integer(sc->rec_val2) = sc->rec_fi6(sc->rec_a6_o);
                    integer(sc->rec_val1) = i2;
                    integer(sc->rec_val2) = oprec_i_cond_a_a_a_laa_lopa_laaq_0(sc);
                    integer(sc->rec_val1) = i1;
                    return(oprec_i_cond_a_a_a_laa_lopa_laaq_0(sc));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x400(%r15), %rdi
callq *0x3f0(%r15)
testb %al, %al
jne 0xdcfb5
movq 0x410(%r15), %rdi
callq *0x3f8(%r15)
testb %al, %al
je 0xdcf4c
movq 0x418(%r15), %rdi
callq *0x3c8(%r15)
movq %rax, %rbx
movq 0x420(%r15), %rdi
callq *0x3d0(%r15)
jmp 0xdcf9a
movq 0x428(%r15), %rdi
callq *0x3d8(%r15)
movq %rax, %rbx
movq 0x430(%r15), %rdi
callq *0x3e0(%r15)
movq %rax, %r14
movq 0x438(%r15), %rdi
callq *0x3e8(%r15)
movq 0x458(%r15), %rcx
movq %rax, 0x8(%rcx)
movq 0x450(%r15), %rax
movq %r14, 0x8(%rax)
movq %r15, %rdi
callq 0xdcefb
movq 0x458(%r15), %rcx
movq %rax, 0x8(%rcx)
movq 0x450(%r15), %rax
movq %rbx, 0x8(%rax)
jmp 0xdcf03
movq %r15, %rax
movq 0x408(%r15), %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x3c0(%rax)
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: apply_safe_closure_star_1
static bool apply_safe_closure_star_1(s7_scheme *sc)                   /* -------- define* (lambda*) -------- */
                {
                    s7_pointer z;
                    /* fprintf(stderr, "%s %s\n", __func__, DISPLAY(sc->code)); */
                    /* slots are in "reverse order" -- in the same order as the args, despite let printout (which reverses the order!) */

                    sc->envir = closure_let(sc->code);
                    if (has_no_defaults(sc->code))
                    {
                        for (z = let_slots(sc->envir); tis_slot(z); z = next_slot(z))
                        {
                            clear_checked_slot(z);
                            slot_set_value(z, sc->F);
                        }
                        if (!is_null(sc->args))
                            lambda_star_set_args(sc);                     /* load up current arg vals */
                        sc->code = closure_body(sc->code);
                        return(false); /* goto BEGIN */
                    }

                    for (z = let_slots(sc->envir); tis_slot(z); z = next_slot(z))
                    {
                        clear_checked_slot(z);
                        slot_set_value(z, (slot_defaults(z)) ? sc->undefined : slot_expression(z));
                    }
                    return(set_star_args(sc, slot_pending_value(let_slots(sc->envir))));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rdi)
testb $0x2, 0x6(%rax)
movq 0x8(%rcx), %rax
jne 0xdd346
testq %rax, %rax
je 0xdd2c3
leaq 0x128(%rbx), %rcx
andb $-0x41, 0x2(%rax)
movzwl 0x6(%rax), %edx
leaq 0x28(%rax), %rsi
testb $0x4, %dl
cmovneq %rcx, %rsi
movq (%rsi), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xdd2a0
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %r14
movq %rbx, %rdi
callq 0xdd389
movq %r14, 0x10(%rbx)
cmpb $0x20, (%r14)
jne 0xdd375
movq (%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%rbx)
movq %rbx, %rdi
callq 0xddab1
movl %eax, %ecx
movb $0x1, %al
cmpl $0x5, %ecx
je 0xdd381
movq 0x50(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movups -0x20(%rax), %xmm0
movups %xmm0, (%rbx)
movq -0x10(%rax), %rax
movq %rax, 0x10(%rbx)
jmp 0xdd375
testq %rax, %rax
je 0xdd360
andb $-0x41, 0x2(%rax)
movq 0x120(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rax), %rax
jmp 0xdd346
movq 0x10(%rbx), %rax
cmpq 0x110(%rbx), %rax
je 0xdd375
movq %rbx, %rdi
callq 0xdd389
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: lambda_star_argument_set_value
static s7_pointer lambda_star_argument_set_value(s7_scheme *sc, s7_pointer sym, s7_pointer val, s7_pointer slot, bool check_rest)
                {
                    s7_pointer x;
                    if (val == sc->no_value) val = sc->unspecified;
                    if (sym == slot_symbol(slot))
                        return(star_set(sc, slot, val, check_rest));
                    for (x = let_slots(sc->envir) /* presumably the arglist */; tis_slot(x); x = next_slot(x))
                        if (slot_symbol(x) == sym)
                            return(star_set(sc, x, val, check_rest));
                    return(sc->no_value);
                }

// Assembly:
movq 0x138(%rdi), %rax
cmpq %rdx, %rax
jne 0xdd99f
movq 0x130(%rdi), %rdx
cmpq %rsi, 0x8(%rcx)
je 0xdd9bf
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %r9
testq %r9, %r9
je 0xdd9be
cmpq %rsi, 0x8(%r9)
je 0xdd9ca
movq 0x18(%r9), %r9
jmp 0xdd9ad
retq
movzbl %r8b, %eax
movq %rcx, %rsi
movl %eax, %ecx
jmp 0xdd9d3
movzbl %r8b, %ecx
movq %r9, %rsi
jmp 0xdd9d3
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: star_set
static s7_pointer star_set(s7_scheme *sc, s7_pointer slot, s7_pointer val, bool check_rest)
                {
                    if (is_checked_slot(slot))
                        return(s7_error(sc, sc->wrong_type_arg_symbol, set_elist_3(sc, parameter_set_twice_string, slot_symbol(slot), sc->args)));
                    if ((check_rest) && (is_rest_slot(slot)))
                        return(s7_error(sc, sc->wrong_type_arg_symbol,
                                    set_elist_3(sc, wrap_string(sc, "can't set rest arg ~S to ~S via keyword", 39),
                                        slot_symbol(slot), val)));
                    set_checked_slot(slot);
                    slot_set_value(slot, val);
                    return(val);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %rax
btl $0x16, %eax
jb 0xdd9fc
movq %rdx, %rbx
testb %cl, %cl
je 0xdd9ed
testb $0x2, 0x6(%rsi)
jne 0xdda47
orq $0x400000, %rax         # imm = 0x400000
movq %rax, (%rsi)
movq %rbx, 0x10(%rsi)
jmp 0xdda3c
movq 0x1940(%rdi), %rbx
movq 0x7d686(%rip), %rax     # 0x15b090
movq 0x8(%rsi), %rcx
movq 0x10(%rdi), %rdx
movq 0x6e8(%rdi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x6e8(%rdi), %rdx
movq %rbx, %rsi
callq 0x3b366
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1940(%rdi), %r14
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rdi)
leaq 0x42f22(%rip), %rcx     # 0x120994
movq %rcx, 0x10(%rax)
movq $0x27, 0x8(%rax)
movq 0x8(%rsi), %rcx
movq 0x6e8(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x6e8(%rdi), %rdx
movq %r14, %rsi
callq 0x3b366
movq %r14, %rbx
jmp 0xdda3c
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: string_ref_1
static s7_pointer string_ref_1(s7_scheme *sc, s7_pointer strng, s7_pointer index)
    {
        char *str;
        s7_int ind;

        if (!s7_is_integer(index))
            return(method_or_bust(sc, index, sc->string_ref_symbol, list_2(sc, strng, index), T_INTEGER, 2));
        ind = s7_integer(index);
        if (ind < 0)
            return(wrong_type_argument_with_type(sc, sc->string_ref_symbol, 2, index, a_non_negative_integer_string));
        if (ind >= string_length(strng))
            return(out_of_range(sc, sc->string_ref_symbol, small_int(2), index, its_too_large_string));

        str = string_value(strng);
        return(s7_make_character(sc, ((uint8_t *)str)[ind]));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0xb, (%rdx)
jne 0xdf026
movq 0x8(%r14), %rax
testq %rax, %rax
js 0xdf0b6
cmpq 0x8(%r15), %rax
jge 0xdf0ea
movq 0x10(%r15), %rcx
movzbl (%rcx,%rax), %eax
movq 0x73a3b(%rip), %rcx     # 0x152a58
movq (%rcx,%rax,8), %r14
jmp 0xdf143
movq 0x1548(%rbx), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0xdf04c
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0xb, %r8d
movl $0x2, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf1ae
movq 0x1548(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x6f898(%rip), %rdx     # 0x14e960
movq 0x140(%rbx), %r8
movq 0x7bb02(%rip), %r9      # 0x15abd8
movq %rbx, %rdi
movq %r14, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb31d
movq 0x1548(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x6f864(%rip), %rcx     # 0x14e960
movq 0x7393d(%rip), %rdx     # 0x152a40
movq 0x1ee8(%rbx), %rsi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rbx), %r14
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b366
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_vector_set_3
static s7_pointer g_vector_set_3(s7_scheme *sc, s7_pointer args)
                {
                    /* (vector-set! vector index value) */
                    s7_pointer ind, vec, val;
                    s7_int index;

                    vec = car(args);
                    if (!is_any_vector(vec))
                        return(g_vector_set(sc, args));
                    if (is_immutable_vector(vec))
                        return(immutable_object_error(sc, set_elist_3(sc, immutable_error_string, sc->vector_set_symbol, vec)));
                    if (vector_rank(vec) > 1)
                        return(g_vector_set(sc, args));

                    ind = cadr(args);
                    if (!s7_is_integer(ind))
                        return(g_vector_set(sc, args));
                    index = s7_integer(ind);
                    if ((index < 0) ||
                            (index >= vector_length(vec)))
                        return(out_of_range(sc, sc->vector_set_symbol, small_int(2), wrap_integer1(sc, index), (index < 0) ? its_negative_string : its_too_large_string));

                    val = caddr(args);
                    if (is_typed_vector(vec))
                        return(typed_vector_setter(sc, vec, index, val));

                    vector_setter(vec)(sc, vec, index, val);
                    return(val);
                }

// Assembly:
pushq %rbx
movq %rsi, %rax
movq 0x8(%rsi), %rsi
movzbl (%rsi), %ecx
leaq 0x73abe(%rip), %rdx     # 0x152c20
cmpb $0x0, (%rcx,%rdx)
je 0xdf1b8
testb $0x1, 0x3(%rsi)
jne 0xdf1c1
movq 0x18(%rsi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0xdf182
cmpq $0x2, 0x10(%rcx)
jge 0xdf1b8
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rdx
cmpb $0xb, (%rdx)
jne 0xdf1b8
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
js 0xdf205
cmpq 0x8(%rsi), %rdx
jge 0xdf205
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rbx
testb $0x2, 0x6(%rsi)
jne 0xdf278
movq %rbx, %rcx
callq *0x28(%rsi)
jmp 0xdf200
movq %rax, %rsi
popq %rbx
jmp 0x7fcf5
movq 0x737a0(%rip), %rax     # 0x152968
movq 0x1668(%rdi), %rcx
movq 0x6e8(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x6e8(%rdi), %rdx
movq 0xea8(%rdi), %rbx
movq %rbx, %rsi
callq 0x3b366
movq %rbx, %rax
popq %rbx
retq
testq %rdx, %rdx
movq 0x1668(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x6f746(%rip), %rcx     # 0x14e960
movq 0x1f00(%rdi), %rsi
movq %rdx, 0x8(%rsi)
movq 0x1ee8(%rdi), %rdx
leaq 0x73815(%rip), %rsi     # 0x152a48
leaq 0x73806(%rip), %r8      # 0x152a40
cmovsq %rsi, %r8
movq 0x1f00(%rdi), %rsi
movq (%r8), %r8
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ee8(%rdi), %rdx
jmp 0xdf1f8
movq %rbx, %rcx
popq %rbx
jmp 0x3db91
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_vector_set_4
static s7_pointer g_vector_set_4(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer v, ip1, ip2, val;
                    s7_int i1, i2;
                    v = car(args);
                    ip1 = cadr(args);
                    ip2 = caddr(args);
                    if ((!is_any_vector(v)) ||
                            (vector_rank(v) != 2) ||
                            (is_immutable(v)) ||
                            (!s7_is_integer(ip1)) ||
                            (!s7_is_integer(ip2)))
                        return(g_vector_set(sc, args));
                    i1 = s7_integer(ip1);
                    i2 = s7_integer(ip2);
                    if ((i1 < 0) || (i2 < 0) ||
                            (i1 >= vector_dimension(v, 0)) ||
                            (i2 >= vector_dimension(v, 1)))
                        return(g_vector_set(sc, args));
                    val = cadddr(args);
                    if (is_typed_vector(v))
                        return(typed_vector_setter(sc, v, i2 + (i1 * vector_offset(v, 0)), val));
                    vector_setter(v)(sc, v, i2 + (i1 * vector_offset(v, 0)), val);
                    return(val);
                }

// Assembly:
pushq %rbx
movq %rsi, %rax
movq 0x8(%rsi), %rsi
movzbl (%rsi), %ecx
leaq 0x7398d(%rip), %rdx     # 0x152c20
cmpb $0x1, (%rcx,%rdx)
jne 0xdf312
movq 0x18(%rsi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0xdf312
cmpq $0x2, 0x10(%rcx)
jne 0xdf312
testb $0x1, 0x3(%rsi)
jne 0xdf312
movq 0x10(%rax), %r8
movq 0x8(%r8), %rdx
cmpb $0xb, (%rdx)
jne 0xdf312
movq 0x10(%r8), %r9
movq 0x8(%r9), %r8
cmpb $0xb, (%r8)
jne 0xdf312
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
js 0xdf312
movq 0x8(%r8), %r8
testq %r8, %r8
js 0xdf312
movq (%rcx), %r10
cmpq (%r10), %rdx
jge 0xdf312
cmpq 0x8(%r10), %r8
jge 0xdf312
movq 0x10(%r9), %rax
movq 0x8(%rax), %rbx
testb $0x2, 0x6(%rsi)
jne 0xdf31b
movq 0x18(%rcx), %rax
imulq (%rax), %rdx
addq %r8, %rdx
movq %rbx, %rcx
callq *0x28(%rsi)
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rsi
popq %rbx
jmp 0x7fcf5
movq 0x18(%rcx), %rax
imulq (%rax), %rdx
addq %r8, %rdx
movq %rbx, %rcx
popq %rbx
jmp 0x3db91
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: check_for_cyclic_code
static s7_pointer check_for_cyclic_code(s7_scheme *sc, s7_pointer code)
                {
                    if (tree_is_cyclic(sc, code))
                        eval_error(sc, "attempt to evaluate a circular list: ~A", 39, code);
                    resize_stack(sc); /* we've already checked that resize_stack is needed */
                    return(sc->F);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3b2ff
testb %al, %al
je 0xdf3a9
movq 0x1918(%rbx), %rsi
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x41424(%rip), %rcx     # 0x120791
movq %rcx, 0x10(%rax)
movq $0x27, 0x8(%rax)
movq 0x6e0(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3b366
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc15d0
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: apply_macro_star_1
static void apply_macro_star_1(s7_scheme *sc)
                {
                    /* here the defaults (if any) are not evalled, and there is not exisiting frame */
                    s7_pointer p;
                    for (p = closure_args(sc->code); is_pair(p); p = cdr(p))
                    {
                        s7_pointer par;
                        par = car(p);
                        if (is_pair(par))
                            make_slot_1(sc, sc->envir, car(par), cadr(par));
                        else
                        {
                            if (!is_keyword(par))
                                make_slot_1(sc, sc->envir, par, sc->F);
                            else
                            {
                                if (par == sc->key_rest_symbol)
                                {
                                    set_is_rest_slot(make_slot_1(sc, sc->envir, cadr(p), sc->nil));
                                    p = cdr(p);
                                }
                            }
                        }
                    }
                    if (is_symbol(p))
                        set_is_rest_slot(make_slot_1(sc, sc->envir, p, sc->nil));
                    let_set_slots(sc->envir, reverse_slots(sc, let_slots(sc->envir)));
                    lambda_star_set_args(sc);
                    sc->code = T_Pair(closure_body(sc->code));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
addq $0x8, %r14
movq (%r14), %r14
movzbl (%r14), %eax
cmpl $0x1, %eax
jne 0xdf47d
movq 0x8(%r14), %rdx
cmpb $0x1, (%rdx)
jne 0xdf430
movq 0x8(%rbx), %rsi
movq 0x8(%rdx), %rax
movq 0x10(%rdx), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, %rdi
movq %rax, %rdx
jmp 0xdf444
testb $-0x80, 0x6(%rdx)
jne 0xdf44f
movq 0x8(%rbx), %rsi
movq 0x120(%rbx), %rcx
movq %rbx, %rdi
callq 0xb169
addq $0x10, %r14
jmp 0xdf403
cmpq 0x1890(%rbx), %rdx
jne 0xdf449
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rbx), %rsi
movq 0x110(%rbx), %rcx
movq %rbx, %rdi
callq 0xb169
orb $0x2, 0x6(%rax)
movq 0x10(%r14), %r14
jmp 0xdf449
cmpl $0xa, %eax
jne 0xdf49c
movq 0x8(%rbx), %rsi
movq 0x110(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb169
orb $0x2, 0x6(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xdf4c0
xorl %edx, %edx
movq %rax, %rcx
movq 0x18(%rax), %rax
movq %rdx, 0x18(%rcx)
movq %rcx, %rdx
testq %rax, %rax
jne 0xdf4ab
jmp 0xdf4c2
xorl %ecx, %ecx
movq 0x8(%rbx), %rax
movq %rcx, 0x8(%rax)
movq %rbx, %rdi
callq 0xdd389
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: dotimes
static bool dotimes(s7_scheme *sc, s7_pointer code, bool safe_case)
                {
                    s7_pointer body;
                    body = caddr(code);   /* here we assume one expr in body */
                    if (((is_syntactic_pair(body)) ||
                                (is_syntactic_symbol(car(body)))) &&
                            ((symbol_syntax_op_checked(body) == OP_LET) ||
                             (symbol_syntax_op(car(body)) == OP_LET_STAR)))
                        return(do_let(sc, sc->args, code) == goto_safe_do_end_clauses);
                    return(opt_dotimes(sc, cddr(code), code, safe_case));
                }

// Assembly:
movl %edx, %eax
movq %rsi, %rdx
movq 0x10(%rsi), %rcx
movq 0x10(%rcx), %rsi
movq 0x8(%rsi), %rcx
movzwl (%rcx), %r8d
cmpl $0x201, %r8d            # imm = 0x201
jne 0xdf822
movzwl 0x4(%rcx), %r8d
cmpq $0x1ad, %r8             # imm = 0x1AD
je 0xdf810
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
cmpq $0x1af, 0x10(%rcx)      # imm = 0x1AF
jne 0xdf84d
pushq %rax
movq 0x10(%rdi), %rsi
callq 0xe0314
cmpl $0x4, %eax
sete %al
popq %rcx
retq
movq 0x8(%rcx), %r9
cmpw $0x20a, (%r9)           # imm = 0x20A
jne 0xdf84d
movzwl %r8w, %r8d
cmpl $0x201, %r8d            # imm = 0x201
je 0xdf7ec
movq 0x8(%rcx), %r8
movq 0x10(%r8), %r8
movq 0x10(%r8), %r8
movq 0x10(%r8), %r8
jmp 0xdf7f1
movzbl %al, %ecx
jmp 0xdf852
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_nbp_fs_nr
static s7_pointer opt_if_nbp_fs_nr(opt_info *o)
                {
                    opt_info *o1;
                    oo_rc(o->sc, o, 4, 1);
                    o1 = o->sc->opts[o->sc->pc];
                    if (!(o->v[2].b_pi_f(o->sc, o1->v[0].fp(o1), integer(slot_value(o->v[3].p))))) /* b_pi_fs */
                    {
                        o1 = o->sc->opts[++o->sc->pc];
                        o1->v[0].fp(o1);
                    }
                    return(NULL);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
movq 0x2260(%r14,%rax,8), %rdi
callq *(%rdi)
movq 0x18(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq *%r15
testb %al, %al
jne 0xe0bb6
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq