LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: oprec_cond_a_a_a_a_oplaa_laaq
static s7_pointer oprec_cond_a_a_a_a_oplaa_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));
                    recur_push(sc, sc->rec_f5f(sc, sc->rec_f5p));
                    slot_set_value(sc->rec_slot2, sc->rec_f6f(sc, sc->rec_f6p));
                    slot_set_value(sc->rec_slot1, recur_pop(sc));
                    sc->value = oprec_cond_a_a_a_a_oplaa_laaq(sc);        /* second laa arg */
                    slot_set_value(sc->rec_slot2, recur_pop(sc));
                    slot_set_value(sc->rec_slot1, recur_pop(sc));
                    recur_push_unchecked(sc, sc->value);
                    set_car(sc->t2_1, oprec_cond_a_a_a_a_oplaa_laaq(sc)); /* first laa arg */
                    set_car(sc->t2_2, recur_pop(sc));
                    return(sc->rec_call(sc, sc->t2_1));
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2f0(%rdi), %rsi
callq *0x360(%rdi)
cmpq 0x120(%rbx), %rax
je 0xa7d6e
leaq 0x3b0(%rbx), %rax
leaq 0x340(%rbx), %rcx
jmp 0xa7f0b
movq 0x2f8(%rbx), %rsi
movq %rbx, %rdi
callq *0x368(%rbx)
cmpq 0x120(%rbx), %rax
je 0xa7d9a
leaq 0x370(%rbx), %rax
leaq 0x300(%rbx), %rcx
jmp 0xa7f0b
movq 0x308(%rbx), %rsi
movq %rbx, %rdi
callq *0x378(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa619e
movq 0x310(%rbx), %rsi
movq %rbx, %rdi
callq *0x380(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa619e
movq 0x318(%rbx), %rsi
movq %rbx, %rdi
callq *0x388(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa619e
movq 0x320(%rbx), %rsi
movq %rbx, %rdi
callq *0x390(%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 0xa7d41
movq %rax, 0x20(%rbx)
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 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 0x20(%rbx), %rax
movq 0x2e8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x2d0(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
incq %rdx
movq %rdx, 0x2d0(%rbx)
movq %rbx, %rdi
callq 0xa7d41
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
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x2258(%rbx)
movq 0x400(%rbx), %rdi
callq *(%rdi)
testb %al, %al
jne 0xa7fdf
movl 0x460(%rbx), %eax
movl %eax, 0x2258(%rbx)
movq 0x410(%rbx), %rdi
callq *(%rdi)
testb %al, %al
je 0xa7f6d
movq 0x418(%rbx), %rdi
callq *(%rdi)
movq %rax, %r14
incl 0x2258(%rbx)
movq 0x420(%rbx), %rdi
callq *(%rdi)
jmp 0xa7fc4
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 0xa7f17
movq 0x458(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x450(%rbx), %rax
movq %r14, 0x8(%rax)
jmp 0xa7f1f
incl 0x2258(%rbx)
movq 0x408(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmpq *(%rdi)
// File: /workspace/github_c_makefile_star2_O2/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 0xa80ad
movq 0x410(%r15), %rdi
callq *0x3f8(%r15)
testb %al, %al
je 0xa8044
movq 0x418(%r15), %rdi
callq *0x3c8(%r15)
movq %rax, %rbx
movq 0x420(%r15), %rdi
callq *0x3d0(%r15)
jmp 0xa8092
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 0xa7ff3
movq 0x458(%r15), %rcx
movq %rax, 0x8(%rcx)
movq 0x450(%r15), %rax
movq %rbx, 0x8(%rax)
jmp 0xa7ffb
movq %r15, %rax
movq 0x408(%r15), %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x3c0(%rax)
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: oprec_cond_a_a_a_laa_lopa_laaq
static s7_pointer oprec_cond_a_a_a_laa_lopa_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)
                    {
                        recur_push(sc, sc->rec_f2f(sc, sc->rec_f2p));
                        slot_set_value(sc->rec_slot2, sc->rec_f3f(sc, sc->rec_f3p));
                        slot_set_value(sc->rec_slot1, recur_pop(sc));
                        return(oprec_cond_a_a_a_laa_lopa_laaq(sc));
                    }
                    recur_push(sc, sc->rec_f4f(sc, sc->rec_f4p));
                    recur_push(sc, sc->rec_f5f(sc, sc->rec_f5p));
                    slot_set_value(sc->rec_slot2, sc->rec_f6f(sc, sc->rec_f6p));
                    slot_set_value(sc->rec_slot1, recur_pop(sc));
                    slot_set_value(sc->rec_slot2, oprec_cond_a_a_a_laa_lopa_laaq(sc));
                    slot_set_value(sc->rec_slot1, recur_pop(sc));
                    return(oprec_cond_a_a_a_laa_lopa_laaq(sc));
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2f0(%rbx), %rsi
movq %rbx, %rdi
callq *0x360(%rbx)
cmpq 0x120(%rbx), %rax
jne 0xa81ef
movq 0x2f8(%rbx), %rsi
movq %rbx, %rdi
callq *0x368(%rbx)
cmpq 0x120(%rbx), %rax
je 0xa812c
movq 0x300(%rbx), %rsi
movq %rbx, %rdi
callq *0x370(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa619e
movq 0x308(%rbx), %rsi
movq %rbx, %rdi
callq *0x378(%rbx)
jmp 0xa81b2
movq 0x310(%rbx), %rsi
movq %rbx, %rdi
callq *0x380(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa619e
movq 0x318(%rbx), %rsi
movq %rbx, %rdi
callq *0x388(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa619e
movq 0x320(%rbx), %rsi
movq %rbx, %rdi
callq *0x390(%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 0xa80c2
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)
jmp 0xa80c6
movq 0x340(%rbx), %rsi
movq 0x3b0(%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x18(%rcx), %rax
movq %rax, 0x8(%rdi)
addq $0x8, %rax
testb $0x2, 0x6(%rcx)
jne 0xa8283
leaq 0x128(%rbx), %rcx
movq (%rax), %rax
testq %rax, %rax
je 0xa82a0
movq (%rax), %rdx
movq %rdx, %rsi
andq $-0x400001, %rsi        # imm = 0xFFBFFFFF
btq $0x32, %rdx
leaq 0x28(%rax), %rdx
cmovbq %rcx, %rdx
movq %rsi, (%rax)
movq (%rdx), %rdx
movq %rdx, 0x10(%rax)
addq $0x18, %rax
jmp 0xa8251
movq (%rax), %rax
testq %rax, %rax
je 0xa82b5
andb $-0x41, 0x2(%rax)
movq 0x120(%rbx), %rcx
movq %rcx, 0x10(%rax)
addq $0x18, %rax
jmp 0xa8283
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xa87dd
movq 0x10(%rbx), %rax
cmpq 0x110(%rbx), %rax
je 0xa82ca
movq %rbx, %rdi
callq 0xa82d8
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: set_star_args
static inline bool set_star_args(s7_scheme *sc, s7_pointer top)
                {
                    lambda_star_set_args(sc);                     /* load up current arg vals */
                    sc->args = top;
                    if (is_slot(sc->args))
                    {
                        /* get default values, which may involve evaluation -- see also OP_LAMBDA_STAR_DEFAULT  */
                        push_stack(sc, OP_GC_PROTECT, sc->args, sc->code);
                        if (lambda_star_default(sc) == goto_eval) return(true); /* else fall_through */
                        pop_stack_no_op(sc);              /* get original args and code back */
                    }
                    sc->code = closure_body(sc->code);
                    return(false);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa82d8
movq %r14, 0x10(%rbx)
cmpb $0x20, (%r14)
jne 0xa8855
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 0xa899e
movl %eax, %ecx
movb $0x1, %al
cmpl $0x5, %ecx
je 0xa8861
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)
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_O2/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 0xa887c
movq 0x130(%rdi), %rdx
cmpq %rsi, 0x8(%rcx)
je 0xa889e
movq 0x8(%rdi), %r9
addq $0x8, %r9
movq (%r9), %r9
testq %r9, %r9
je 0xa88a9
cmpq %rsi, 0x8(%r9)
je 0xa88aa
addq $0x18, %r9
jmp 0xa888a
movzbl %r8b, %eax
movq %rcx, %rsi
movl %eax, %ecx
jmp 0xa88b3
retq
movzbl %r8b, %ecx
movq %r9, %rsi
jmp 0xa88b3
// File: /workspace/github_c_makefile_star2_O2/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 0xa8944
movq %rdx, %rbx
btq $0x31, %rax
setae %dl
xorb $0x1, %cl
orb %dl, %cl
jne 0xa8986
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 0x3b13f(%rip), %rcx     # 0xe3a44
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 0x2cdc0
movq %r14, %rbx
jmp 0xa8993
movq 0x1940(%rdi), %rbx
movq 0x7973e(%rip), %rax     # 0x122090
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 0x2cdc0
jmp 0xa8993
orq $0x400000, %rax         # imm = 0x400000
movq %rax, (%rsi)
movq %rbx, 0x10(%rsi)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: list_ref_1
static s7_pointer list_ref_1(s7_scheme *sc, s7_pointer lst, s7_pointer ind)
                {
                    s7_int i, index;
                    s7_pointer p;

                    if (!s7_is_integer(ind))
                        return(method_or_bust(sc, ind, sc->list_ref_symbol, list_2(sc, lst, ind), T_INTEGER, 2));
                    index = s7_integer(ind);
                    if ((index < 0) || (index > sc->max_list_length))
                        return(out_of_range(sc, sc->list_ref_symbol, small_int(2), ind, (index < 0) ? its_negative_string : its_too_large_string));

                    for (i = 0, p = lst; (i < index) && is_pair(p); i++, p = cdr(p)) {}

                    if (!is_pair(p))
                    {
                        if (is_null(p))
                            return(out_of_range(sc, sc->list_ref_symbol, small_int(2), ind, its_too_large_string));
                        return(wrong_type_argument_with_type(sc, sc->list_ref_symbol, 1, lst, a_proper_list_string));
                    }
                    return(car(p));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0xb, (%rdx)
jne 0xa9746
movq 0x8(%rbx), %rax
testq %rax, %rax
js 0xa9708
cmpq 0x2b0(%r14), %rax
jle 0xa97d2
testq %rax, %rax
movq 0x1258(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x6c243(%rip), %rdx     # 0x115960
leaq 0x70324(%rip), %rax     # 0x119a48
leaq 0x70315(%rip), %rcx     # 0x119a40
cmovsq %rax, %rcx
movq (%rcx), %r8
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcb8f
movq 0x1258(%r14), %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0xa9773
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %rbx, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%r14), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%r14)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %rax, 0x10(%rcx)
pushq $0xb
popq %r8
pushq $0x2
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcd70
movq %r15, %rcx
movb (%rcx), %dl
subq $0x1, %rax
jb 0xa97e8
cmpb $0x1, %dl
jne 0xa97fb
movq 0x10(%rcx), %rcx
jmp 0xa97d5
cmpb $0x1, %dl
jne 0xa97fb
movq 0x8(%rcx), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x1258(%r14), %rax
movq 0x8(%rax), %rsi
cmpq 0x110(%r14), %rcx
je 0xa9838
movq 0x6c142(%rip), %rdx     # 0x115958
movq 0x140(%r14), %r8
movq 0x783f4(%rip), %r9      # 0x121c18
movq %r14, %rdi
movq %r15, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9bbb
movq 0x6c121(%rip), %rdx     # 0x115960
movq 0x701fa(%rip), %r8      # 0x119a40
jmp 0xa9732
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0xb, (%rdx)
jne 0xa9912
movq 0x8(%rbx), %rax
testq %rax, %rax
js 0xa999e
cmpq 0x8(%r15), %rax
jge 0xa99d2
movq 0x10(%r15), %rcx
movzbl (%rcx,%rax), %eax
movq 0x70154(%rip), %rcx     # 0x119a58
movq (%rcx,%rax,8), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x1548(%r14), %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0xa993f
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %rbx, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%r14), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%r14)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %rax, 0x10(%rcx)
pushq $0xb
popq %r8
pushq $0x2
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcd70
movq 0x1548(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x6bfb0(%rip), %rdx     # 0x115960
movq 0x140(%r14), %r8
movq 0x7821a(%rip), %r9      # 0x121bd8
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9bbb
movq 0x1548(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x6bf7c(%rip), %rdx     # 0x115960
movq 0x70055(%rip), %r8      # 0x119a40
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcb8f
// File: /workspace/github_c_makefile_star2_O2/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 0x7020f(%rip), %rdx     # 0x119c20
cmpb $0x0, (%rcx,%rdx)
je 0xa9a6e
movq (%rsi), %rcx
btl $0x18, %ecx
jb 0xa9a77
movq 0x18(%rsi), %rdx
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
je 0xa9a34
cmpq $0x2, 0x10(%rdx)
jge 0xa9a6e
movq 0x10(%rax), %r8
movq 0x8(%r8), %rdx
cmpb $0xb, (%rdx)
jne 0xa9a6e
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
js 0xa9aad
cmpq 0x8(%rsi), %rdx
jge 0xa9aad
movq 0x10(%r8), %rax
movq 0x8(%rax), %rbx
btq $0x31, %rcx
jb 0xa9af2
movq %rbx, %rcx
callq *0x28(%rsi)
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rsi
popq %rbx
jmp 0x627c1
movq 0x6feea(%rip), %rax     # 0x119968
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), %rsi
popq %rbx
jmp 0x972b
testq %rdx, %rdx
movq 0x1668(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x6be9e(%rip), %rax     # 0x115960
movq 0x1f00(%rdi), %rcx
movq %rdx, 0x8(%rcx)
movq 0x1f00(%rdi), %rcx
leaq 0x6ff6d(%rip), %rdx     # 0x119a48
leaq 0x6ff5e(%rip), %r8      # 0x119a40
cmovsq %rdx, %r8
movq (%r8), %r8
movq %rax, %rdx
popq %rbx
jmp 0xcb8f
movq %rbx, %rcx
popq %rbx
jmp 0x2ecba
// File: /workspace/github_c_makefile_star2_O2/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 0x70113(%rip), %rdx     # 0x119c20
cmpb $0x1, (%rcx,%rdx)
jne 0xa9b91
movq 0x18(%rsi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0xa9b91
cmpq $0x2, 0x10(%rcx)
jne 0xa9b91
movq (%rsi), %r8
btl $0x18, %r8d
jb 0xa9b91
movq 0x10(%rax), %r9
movq 0x8(%r9), %rdx
cmpb $0xb, (%rdx)
jne 0xa9b91
movq 0x10(%r9), %r10
movq 0x8(%r10), %r9
cmpb $0xb, (%r9)
jne 0xa9b91
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
js 0xa9b91
movq 0x8(%r9), %r9
testq %r9, %r9
js 0xa9b91
movq (%rcx), %r11
cmpq (%r11), %rdx
jge 0xa9b91
cmpq 0x8(%r11), %r9
jge 0xa9b91
movq 0x10(%r10), %rax
movq 0x8(%rax), %rbx
btq $0x31, %r8
jb 0xa9b9a
movq 0x18(%rcx), %rax
imulq (%rax), %rdx
addq %r9, %rdx
movq %rbx, %rcx
callq *0x28(%rsi)
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rsi
popq %rbx
jmp 0x627c1
movq 0x18(%rcx), %rax
imulq (%rax), %rdx
addq %r9, %rdx
movq %rbx, %rcx
popq %rbx
jmp 0x2ecba
// File: /workspace/github_c_makefile_star2_O2/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 0x2cd63
testb %al, %al
je 0xa9c28
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 0x39c55(%rip), %rcx     # 0xe3841
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 0x2cdc0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x91caf
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: let_temp_done
static void let_temp_done(s7_scheme *sc, s7_pointer args, s7_pointer code, s7_pointer let)
                {
                    /* called in call/cc, call-with-exit and, catch (unwind to catch) */
                    push_stack(sc, OP_EVAL_DONE, sc->args, sc->code);
                    sc->args = T_Pos(args);
                    sc->code = code;
                    sc->envir = let;
                    eval(sc, OP_LET_TEMP_DONE);
                }

// Assembly:
movq (%rdi), %rax
movq 0x50(%rdi), %r8
movq %rax, (%r8)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %r8
movq %rax, 0x8(%r8)
movq 0x10(%rdi), %rax
movq 0x50(%rdi), %r8
movq %rax, 0x10(%r8)
movq 0x50(%rdi), %rax
movq $0x1df, 0x18(%rax)      # imm = 0x1DF
addq $0x20, 0x50(%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
movl $0x1ba, %esi            # imm = 0x1BA
jmp 0xe1a8
// File: /workspace/github_c_makefile_star2_O2/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 0xa9d6b
movq 0x8(%r14), %rdx
cmpb $0x1, (%rdx)
jne 0xa9d1e
movq 0x8(%rbx), %rsi
movq 0x8(%rdx), %rax
movq 0x10(%rdx), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, %rdi
movq %rax, %rdx
jmp 0xa9d32
testb $-0x80, 0x6(%rdx)
jne 0xa9d3d
movq 0x8(%rbx), %rsi
movq 0x120(%rbx), %rcx
movq %rbx, %rdi
callq 0x9a09
addq $0x10, %r14
jmp 0xa9cf1
cmpq 0x1890(%rbx), %rdx
jne 0xa9d37
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rbx), %rsi
movq 0x110(%rbx), %rcx
movq %rbx, %rdi
callq 0x9a09
orb $0x2, 0x6(%rax)
movq 0x10(%r14), %r14
jmp 0xa9d37
cmpl $0xa, %eax
jne 0xa9d8a
movq 0x8(%rbx), %rsi
movq 0x110(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9a09
orb $0x2, 0x6(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x89849
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq %rbx, %rdi
callq 0xa82d8
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpw $0x201, (%rcx)          # imm = 0x201
jne 0xaa0a7
movzwl 0x4(%rcx), %r8d
jmp 0xaa0bf
movq 0x8(%rcx), %r8
cmpw $0x20a, (%r8)           # imm = 0x20A
jne 0xaa0f0
movq 0x10(%r8), %r8
movq 0x10(%r8), %r8
movq 0x10(%r8), %r8
cmpq $0x1ad, %r8             # imm = 0x1AD
je 0xaa0de
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
cmpq $0x1af, 0x10(%rcx)      # imm = 0x1AF
jne 0xaa0f0
pushq %rax
movq 0x10(%rdi), %rsi
callq 0xaab07
cmpl $0x4, %eax
sete %al
popq %rcx
retq
movzbl %al, %ecx
jmp 0xaa0f5
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_add_x1
static s7_pointer g_add_x1(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer x;
        x = car(args);
        if (is_t_integer(x))
            return(make_integer(sc, integer(x) + 1));
        return(g_add_x1_1(sc, x, args));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0xb, (%rsi)
jne 0xab4f0
movq 0x8(%rsi), %rax
leaq 0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xab4ff
leaq 0x6a467(%rip), %rcx     # 0x115950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xab538
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x920da
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xab51e
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_num_eq_2
static s7_pointer g_num_eq_2(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer x, y;
        x = car(args);
        y = cadr(args);
        if ((is_t_integer(x)) && (is_t_integer(y))) /* this is by far the most common case (ratios aren't used much, and = with floats is frowned upon) */
            return(make_boolean(sc, integer(x) == integer(y)));
        return(num_eq_p_pp(sc, x, y));
    }

// Assembly:
movq %rsi, %rax
movq 0x8(%rsi), %rsi
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
cmpb $0xb, (%rsi)
jne 0x6e8d2
cmpb $0xb, (%rdx)
jne 0x6e8d2
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq 0x8(%rdx), %rax
setne %cl
movq 0x118(%rdi,%rcx,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_num_eq_xi
static s7_pointer g_num_eq_xi(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer x, y;
        x = car(args);
        y = cadr(args);
        if (is_t_integer(x))
            return(make_boolean(sc, integer(x) == integer(y)));
        if (is_t_real(x))
            return(make_boolean(sc, real(x) == integer(y)));
        if (!is_number(x))
            return(eq_out_x(sc, x, y));
        return(sc->F);
    }

// Assembly:
movq %rsi, %rax
movq 0x8(%rsi), %rsi
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movzbl (%rsi), %eax
cmpl $0xd, %eax
je 0xab5a9
cmpl $0xb, %eax
jne 0xab5c6
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq 0x8(%rdx), %rax
setne %cl
movq 0x118(%rdi,%rcx,8), %rax
retq
cvtsi2sdq 0x8(%rdx), %xmm0
cmpneqsd 0x8(%rsi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
leaq 0x6e3a3(%rip), %rcx     # 0x119970
cmpb $0x0, (%rax,%rcx)
je 0xab5fc
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: do_tree_has_definers
static inline bool do_tree_has_definers(s7_scheme *sc, s7_pointer tree)
                {
                    /* we can't be very fancy here because quote gloms up everything: (cond '(define x 0) ...) etc, and the tree here can
                     *   be arbitrarily messed up, and we need to be reasonably fast.  So we accept some false positives: (case ((define)...)...) or '(define...)
                     * but what about ((f...)...) where (f...) returns a macro that defines something?
                     */
                    s7_pointer p;
                    for (p = tree; is_pair(p); p = cdr(p))
                    {
                        s7_pointer pp;
                        pp = car(p);
                        if (is_symbol(pp))
                        {
                            if ((is_definer(pp)) &&
                                    ((pp != sc->varlet_symbol) ||
                                     ((is_pair(cdr(p))) &&         /* if varlet, is target let local? */
                                      (is_symbol(cadr(p))) &&
                                      (!symbol_is_in_list(sc, cadr(p))))))
                            {
#if DO_PRINT
                                fprintf(stderr, "definer: %s\n", DISPLAY(pp));
#endif
                                return(true);
                            }
                        }
                        else
                        {
                            if ((is_pair(pp)) &&
                                    (do_tree_has_definers(sc, pp)))
                                return(true);
                        }
                    }
                    return(false);
                }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb (%rbx), %bpl
cmpb $0x1, %bpl
jne 0xabb39
movq 0x8(%rbx), %rsi
movzbl (%rsi), %eax
cmpl $0x1, %eax
je 0xabb27
cmpl $0xa, %eax
jne 0xabb33
testb $0x4, 0x6(%rsi)
je 0xabb33
cmpq 0x1640(%r14), %rsi
jne 0xabb39
movq 0x10(%rbx), %rax
cmpb $0x1, (%rax)
jne 0xabb33
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
jne 0xabb33
movl 0x2c(%rax), %ecx
cmpl 0xa88(%r14), %ecx
jne 0xabb39
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%r14), %eax
je 0xabb33
jmp 0xabb39
movq %r14, %rdi
callq 0xabac0
testb %al, %al
jne 0xabb39
movq 0x10(%rbx), %rbx
jmp 0xabaca
cmpb $0x1, %bpl
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_tree_outest
static void fx_tree_outest(s7_scheme *sc, s7_pointer tree, s7_pointer v1, s7_pointer v2, s7_pointer v3, s7_pointer v4)
                {
                    if ((!is_pair(tree)) ||
                            ((is_symbol(car(tree))) &&
                             (is_definer_or_binder(car(tree)))))
                        return;
                    if ((!has_fx(tree)) ||
                            (!fx_tree_out2(sc, tree, v1, v2, v3, v4)))
                        fx_tree_outest(sc, car(tree), v1, v2, v3, v4);
                    fx_tree_outest(sc, cdr(tree), v1, v2, v3, v4);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpb $0x1, (%r12)
jne 0xabe2f
movq 0x8(%r12), %r13
movb (%r13), %al
cmpb $0xa, %al
jne 0xabd90
testb $0xc, 0x6(%r13)
jne 0xabe2f
cmpb $0x1, %al
jne 0xabdb7
movzwl 0x6(%r12), %eax
andl $0x4, %eax
je 0xabdb7
movq 0x10(%r13), %rbp
cmpb $0x1, (%rbp)
jne 0xabdb7
leaq -0x6336(%rip), %rax     # 0xa5a7a
cmpq %rax, 0x20(%r12)
je 0xabdcf
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xabd56
movq 0x10(%r12), %r12
jmp 0xabd6d
movq 0x8(%rbp), %rax
testq %rax, %rax
je 0xabdb7
cmpq %rbx, %rax
je 0xabdb7
cmpq %r15, %rax
je 0xabdb7
cmpq %r14, %rax
je 0xabdb7
movq 0x8(%r13), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x8b8cd
testq %rax, %rax
je 0xabdb7
orb $0x8, 0x3(%r13)
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x8b8cd
movq %rax, 0x20(%rbp)
leaq 0xadf1(%rip), %rax      # 0xb6c13
movq %rax, 0x20(%r12)
orb $0x4, 0x6(%r12)
jmp 0xabdc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: make_permanent_let
static s7_pointer make_permanent_let(s7_scheme *sc, s7_pointer vars)
    {
        s7_pointer frame, var, slot;
        frame = alloc_pointer(sc);

#if S7_DEBUGGING
        permanent_slots++;
#endif
        set_type(frame, T_LET | T_SAFE_PROCEDURE | T_UNHEAP);
        let_id(frame) = ++sc->let_number;
        set_outlet(frame, sc->envir);
        slot = make_permanent_slot(sc, caar(vars), sc->F);
        add_permanent_let_or_slot(sc, slot);
        symbol_set_local(caar(vars), sc->let_number, slot);
        let_set_slots(frame, slot);
        for (var = cdr(vars); is_pair(var); var = cdr(var))
        {
            s7_pointer last_slot;
            last_slot = slot;
            slot = make_permanent_slot(sc, caar(var), sc->F);
            add_permanent_let_or_slot(sc, slot);
            symbol_set_local(caar(var), sc->let_number, slot);
            slot_set_next(last_slot, slot);
        }
        slot_set_next(slot, slot_end(sc));
        add_permanent_let_or_slot(sc, frame); /* need to mark outlet and maybe slot values */
        return(frame);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0xd35f
movq %rax, %r14
movabsq $0x400000000020001c, %rax # imm = 0x400000000020001C
movq %rax, (%r14)
movq 0x250(%rbx), %rax
incq %rax
movq %rax, 0x250(%rbx)
movq %rax, 0x18(%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%r14)
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
movq 0x120(%rbx), %rdx
movq %rbx, %rdi
callq 0x982d
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb6c5c
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
movq %r12, 0x18(%rax)
movq 0x250(%rbx), %rax
movq 0x8(%r15), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x20(%rcx)
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
incl 0x28(%rax)
movq %r12, 0x8(%r14)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0xabf63
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
movq 0x120(%rbx), %rdx
movq %rbx, %rdi
callq 0x982d
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb6c5c
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
movq %r13, 0x18(%rax)
movq 0x250(%rbx), %rax
movq 0x8(%r15), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x20(%rcx)
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
incl 0x28(%rax)
movq %r13, 0x18(%r12)
movq %r13, %r12
jmp 0xabf00
andq $0x0, 0x18(%r12)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb6c5c
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: collect_variables
static inline s7_pointer collect_variables(s7_scheme *sc, s7_pointer lst, s7_pointer e)
    {
        /* collect local variable names from let/do (pre-error-check) */
        s7_pointer p;
        sc->w = e;
        for (p = lst; is_pair(p); p = cdr(p))
            sc->w = cons(sc, add_symbol_to_list(sc, caar(p)), sc->w);
        return(sc->w);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x4d8(%rdi)
cmpb $0x1, (%rbx)
jne 0xac014
movq 0x8(%rbx), %rax
movq 0x8(%rax), %r15
movl 0xa88(%r14), %eax
movl %eax, 0x2c(%r15)
movl 0xa8c(%r14), %eax
movq 0x8(%r15), %rcx
movq 0x20(%rcx), %rcx
movl %eax, 0xc(%rcx)
movq 0x4d8(%r14), %r12
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xabfe9
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x4d8(%r14)
movq 0x10(%rbx), %rbx
jmp 0xabf99
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: find_uncomplicated_symbol
static inline s7_pointer find_uncomplicated_symbol(s7_scheme *sc, s7_pointer symbol, s7_pointer e)
                {
                    s7_pointer x;
                    int64_t id;
#if OPTIMIZE_PRINT
                    fprintf(stderr, "  find %s in %s (in list: %d)\n", DISPLAY(symbol), DISPLAY(e), symbol_is_in_list(sc, symbol));
#endif
                    if ((symbol_is_in_list(sc, symbol)) &&
                            (let_memq(symbol, e)))   /* it's probably a local variable reference */
                        return(sc->nil);

                    if (is_global(symbol))
                        return(global_slot(symbol));

                    /* see 59108 (OP_DEFINE_* in optimize_syntax) -- keyword version of name is used if a definition is
                     *   contingent on some run-time decision, so we're looking here for local defines that might not happen.
                     *   s7test.scm has a test case using acos.
                     */
                    if ((has_keyword(symbol)) &&
                            (symbol_is_in_list(sc, symbol_to_keyword(sc, symbol))))
                        return(sc->nil);

                    id = symbol_id(symbol);
                    for (x = sc->envir; id < let_id(x); x = outlet(x));
                    for (; is_let(x); x = outlet(x))
                    {
                        s7_pointer y;
                        if (let_id(x) == id)
                            return(local_slot(symbol));

                        for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                            if (slot_symbol(y) == symbol)
                                return(y);
                    }

                    return(global_slot(symbol)); /* it's no longer global perhaps (local definition now inaccessible) */
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x2c(%rsi), %eax
cmpl 0xa88(%rdi), %eax
jne 0xb1c0e
movq 0x8(%rbx), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%r14), %eax
jne 0xb1c0e
cmpb $0x1, (%rdx)
jne 0xb1c0e
cmpq %rbx, 0x8(%rdx)
je 0xb1c57
movq 0x10(%rdx), %rdx
jmp 0xb1bfd
movq (%rbx), %rax
btl $0x10, %eax
jb 0xb1c9e
btl $0x1a, %eax
jae 0xb1c60
movq %r14, %rdi
movq %rbx, %rsi
callq 0x313cf
movl 0x2c(%rax), %eax
cmpl 0xa88(%r14), %eax
jne 0xb1c60
movq %r14, %rdi
movq %rbx, %rsi
callq 0x313cf
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%r14), %eax
jne 0xb1c60
addq $0x110, %r14            # imm = 0x110
jmp 0xb1ca5
movq 0x20(%rbx), %rcx
addq $0x8, %r14
movq (%r14), %rdx
leaq 0x10(%rdx), %r14
cmpq 0x18(%rdx), %rcx
jl 0xb1c68
jmp 0xb1c99
cmpq %rcx, 0x18(%rdx)
je 0xb1cb0
leaq 0x8(%rdx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0xb1c95
cmpq %rbx, 0x8(%rax)
je 0xb1ca8
addq $0x18, %rax
jmp 0xb1c81
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
je 0xb1c77
addq $0x10, %rbx
movq %rbx, %r14
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x18, %rbx
jmp 0xb1ca2
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: make_permanent_integer
static s7_pointer make_permanent_integer(s7_int i)
    {
        if (is_small(i)) return(small_int(i));

        if (i == MAX_ARITY) return(max_arity);
        if (i == CLOSURE_ARITY_NOT_SET) return(arity_not_set);
        if (i == -1) return(minus_one);
        if (i == -2) return(minus_two);
        /* a few -3 */

        return(make_permanent_integer_unchecked(i));
    }

// Assembly:
cmpq $0x7ff, %rdi            # imm = 0x7FF
ja 0xb1ccb
leaq 0x63c8a(%rip), %rax     # 0x115950
movq (%rax,%rdi,8), %rax
retq
cmpq $-0x2, %rdi
je 0xb1d05
cmpq $-0x1, %rdi
je 0xb1cf5
cmpq $0x40000000, %rdi       # imm = 0x40000000
je 0xb1cfd
cmpq $0x20000000, %rdi       # imm = 0x20000000
jne 0xb6796
movq 0x696b4(%rip), %rax     # 0x11b3a8
retq
movq 0x726fc(%rip), %rax     # 0x1243f8
retq
movq 0x726fc(%rip), %rax     # 0x124400
retq
movq 0x726fc(%rip), %rax     # 0x124408
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_count
static int32_t fx_count(s7_scheme *sc, s7_pointer x)
                {
                    int32_t count = 0;
                    s7_pointer p;
                    for (p = cdr(x); is_pair(p); p = cdr(p))
                        if (is_fxable(sc, car(p)))
                            count++;
                    return(count);
                }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
jne 0xb1d35
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0xa2689
movzbl %al, %eax
addl %eax, %ebp
jmp 0xb1d19
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq