LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xd4016
leaq 0x3b0(%rbx), %rax
leaq 0x340(%rbx), %rcx
jmp 0xd415a
movq 0x2f8(%rbx), %rsi
movq %rbx, %rdi
callq *0x368(%rbx)
cmpq 0x120(%rbx), %rax
je 0xd4042
leaq 0x370(%rbx), %rax
leaq 0x300(%rbx), %rcx
jmp 0xd415a
movq 0x308(%rbx), %rsi
movq %rbx, %rdi
callq *0x378(%rbx)
movq %rax, %r14
movq 0x2d0(%rbx), %rdx
cmpq 0x2d8(%rbx), %rdx
jne 0xd40a9
movq 0x2e8(%rbx), %r15
leaq (%rdx,%rdx), %rax
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rsi
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0x9fd6
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), %rdx
movq 0x2e8(%rbx), %rax
movq 0x10(%rax), %rax
movq %r14, (%rax,%rdx,8)
incq %rdx
movq %rdx, 0x2d0(%rbx)
movq 0x310(%rbx), %rsi
movq %rbx, %rdi
callq *0x380(%rbx)
movq 0x348(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
callq 0xd3fe5
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 0xd3fe5
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_O3/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 0xd419b
leaq 0x3b0(%rbx), %rcx
leaq 0x340(%rbx), %rax
jmp 0xd435d
movq 0x2f8(%rbx), %rsi
movq %rbx, %rdi
callq *0x368(%rbx)
cmpq 0x120(%rbx), %rax
je 0xd41c7
leaq 0x370(%rbx), %rcx
leaq 0x300(%rbx), %rax
jmp 0xd435d
movq 0x308(%rbx), %rsi
movq %rbx, %rdi
callq *0x378(%rbx)
movq %rax, %r14
movq 0x2d0(%rbx), %rdx
cmpq 0x2d8(%rbx), %rdx
jne 0xd422e
movq 0x2e8(%rbx), %r15
leaq (%rdx,%rdx), %rax
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rsi
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0x9fd6
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), %rdx
movq 0x2e8(%rbx), %rax
movq 0x10(%rax), %rax
movq %r14, (%rax,%rdx,8)
incq %rdx
movq %rdx, 0x2d0(%rbx)
movq 0x310(%rbx), %rsi
movq %rbx, %rdi
callq *0x380(%rbx)
movq %rax, %r14
movq 0x2d0(%rbx), %rdx
cmpq 0x2d8(%rbx), %rdx
jne 0xd42ae
movq 0x2e8(%rbx), %r15
leaq (%rdx,%rdx), %rax
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rsi
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0x9fd6
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), %rdx
movq 0x2e8(%rbx), %rax
movq 0x10(%rax), %rax
movq %r14, (%rax,%rdx,8)
incq %rdx
movq %rdx, 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 0xd416a
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_O3/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(%rdi)
movq 0x400(%rdi), %rdi
callq *(%rdi)
testb %al, %al
jne 0xd4756
movl 0x460(%rbx), %eax
movl %eax, 0x2258(%rbx)
movq 0x410(%rbx), %rdi
callq *(%rdi)
testb %al, %al
je 0xd46d3
movq 0x418(%rbx), %rdi
callq *(%rdi)
movq %rax, %r14
incl 0x2258(%rbx)
movq 0x420(%rbx), %rdi
callq *(%rdi)
jmp 0xd472a
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 0xd467a
movq 0x458(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x450(%rbx), %rax
movq %r14, 0x8(%rax)
movl $0x0, 0x2258(%rbx)
movq 0x400(%rbx), %rdi
jmp 0xd4693
incl 0x2258(%rbx)
movq 0x408(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmpq *(%rdi)
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %r12
pushq %rbx
movq %rdi, %rax
movq 0x400(%rdi), %rdi
movq %rax, %r12
callq *0x3f0(%rax)
testb %al, %al
jne 0xd4846
movq 0x410(%r12), %rdi
callq *0x3f8(%r12)
testb %al, %al
je 0xd47c3
movq 0x418(%r12), %rdi
callq *0x3c8(%r12)
movq %rax, %rbx
movq 0x420(%r12), %rdi
callq *0x3d0(%r12)
jmp 0xd4819
movq 0x428(%r12), %rdi
callq *0x3d8(%r12)
movq %rax, %rbx
movq 0x430(%r12), %rdi
callq *0x3e0(%r12)
movq %rax, %r14
movq 0x438(%r12), %rdi
callq *0x3e8(%r12)
movq 0x458(%r12), %rcx
movq %rax, 0x8(%rcx)
movq 0x450(%r12), %rax
movq %r14, 0x8(%rax)
movq %r12, %rdi
callq 0xd476a
movq 0x458(%r12), %rcx
movq %rax, 0x8(%rcx)
movq 0x450(%r12), %rax
movq %rbx, 0x8(%rax)
movq 0x400(%r12), %rdi
callq *0x3f0(%r12)
jmp 0xd4782
movq %r12, %rax
movq 0x408(%r12), %rdi
popq %rbx
popq %r12
popq %r14
jmpq *0x3c0(%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xd4bed
leaq 0x128(%rbx), %rcx
movq (%rax), %rdx
movq 0x18(%rax), %rsi
movq %rdx, %rdi
andq $-0x400001, %rdi        # imm = 0xFFBFFFFF
movq %rdi, (%rax)
leaq 0x28(%rax), %rdi
btq $0x32, %rdx
cmovbq %rcx, %rdi
movq (%rdi), %rdx
movq %rdx, 0x10(%rax)
movq %rsi, %rax
testq %rsi, %rsi
jne 0xd4b3a
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %r14
movq %rbx, %rdi
callq 0xd4c30
movq %r14, 0x10(%rbx)
cmpb $0x20, (%r14)
jne 0xd4c1c
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 0xd5331
movl %eax, %ecx
movb $0x1, %al
cmpl $0x5, %ecx
je 0xd4c28
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 0xd4c1c
testq %rax, %rax
je 0xd4c07
andb $-0x41, 0x2(%rax)
movq 0x120(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rax), %rax
jmp 0xd4bed
movq 0x10(%rbx), %rax
cmpq 0x110(%rbx), %rax
je 0xd4c1c
movq %rbx, %rdi
callq 0xd4c30
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_O3/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 0xd5212
movq 0x130(%rdi), %rdx
cmpq %rsi, 0x8(%rcx)
je 0xd5232
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %r9
testq %r9, %r9
je 0xd5231
cmpq %rsi, 0x8(%r9)
je 0xd523d
movq 0x18(%r9), %r9
jmp 0xd5220
retq
movzbl %r8b, %eax
movq %rcx, %rsi
movl %eax, %ecx
jmp 0xd5246
movzbl %r8b, %ecx
movq %r9, %rsi
jmp 0xd5246
// File: /workspace/github_c_makefile_star2_O3/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 0xd52d7
movq %rdx, %rbx
btq $0x31, %rax
setae %dl
xorb $0x1, %cl
orb %dl, %cl
jne 0xd5319
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 0x4280c(%rip), %rcx     # 0x117aa4
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 0x38dfa
movq %r14, %rbx
jmp 0xd5326
movq 0x1940(%rdi), %rbx
movq 0x7ddab(%rip), %rax     # 0x153090
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 0x38dfa
jmp 0xd5326
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_O3/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 0xd6769
movq 0x8(%r14), %rax
testq %rax, %rax
js 0xd67f9
cmpq 0x8(%r15), %rax
jge 0xd682d
movq 0x10(%r15), %rcx
movzbl (%rcx,%rax), %eax
movq 0x742f8(%rip), %rcx     # 0x14aa58
movq (%rcx,%rax,8), %r14
jmp 0xd6886
movq 0x1548(%rbx), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0xd6796
movq %rbx, %rdi
callq 0xa550
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 0xe42d
movq 0x1548(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x70155(%rip), %rdx     # 0x146960
movq 0x140(%rbx), %r8
movq 0x7c3bf(%rip), %r9      # 0x152bd8
movq %rbx, %rdi
movq %r14, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xa4e4
movq 0x1548(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x70121(%rip), %rcx     # 0x146960
movq 0x741fa(%rip), %rdx     # 0x14aa40
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 0x38dfa
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7437b(%rip), %rdx     # 0x14ac20
cmpb $0x0, (%rcx,%rdx)
je 0xd68ff
movq (%rsi), %rcx
btl $0x18, %ecx
jb 0xd6908
movq 0x18(%rsi), %rdx
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
je 0xd68c8
cmpq $0x2, 0x10(%rdx)
jge 0xd68ff
movq 0x10(%rax), %r8
movq 0x8(%r8), %rdx
cmpb $0xb, (%rdx)
jne 0xd68ff
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
js 0xd694c
cmpq 0x8(%rsi), %rdx
jge 0xd694c
movq 0x10(%r8), %rax
movq 0x8(%rax), %rbx
btq $0x31, %rcx
jb 0xd69bf
movq %rbx, %rcx
callq *0x28(%rsi)
jmp 0xd6947
movq %rax, %rsi
popq %rbx
jmp 0x79cc5
movq 0x74059(%rip), %rax     # 0x14a968
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 0x38dfa
movq %rbx, %rax
popq %rbx
retq
testq %rdx, %rdx
movq 0x1668(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x6ffff(%rip), %rcx     # 0x146960
movq 0x1f00(%rdi), %rsi
movq %rdx, 0x8(%rsi)
movq 0x1ee8(%rdi), %rdx
leaq 0x740ce(%rip), %rsi     # 0x14aa48
leaq 0x740bf(%rip), %r8      # 0x14aa40
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 0xd693f
movq %rbx, %rcx
popq %rbx
jmp 0x3b5f6
// File: /workspace/github_c_makefile_star2_O3/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 0x74246(%rip), %rdx     # 0x14ac20
cmpb $0x1, (%rcx,%rdx)
jne 0xd6a5e
movq 0x18(%rsi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0xd6a5e
cmpq $0x2, 0x10(%rcx)
jne 0xd6a5e
movq (%rsi), %r8
btl $0x18, %r8d
jb 0xd6a5e
movq 0x10(%rax), %r9
movq 0x8(%r9), %rdx
cmpb $0xb, (%rdx)
jne 0xd6a5e
movq 0x10(%r9), %r10
movq 0x8(%r10), %r9
cmpb $0xb, (%r9)
jne 0xd6a5e
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
js 0xd6a5e
movq 0x8(%r9), %r9
testq %r9, %r9
js 0xd6a5e
movq (%rcx), %r11
cmpq (%r11), %rdx
jge 0xd6a5e
cmpq 0x8(%r11), %r9
jge 0xd6a5e
movq 0x10(%r10), %rax
movq 0x8(%rax), %rbx
btq $0x31, %r8
jb 0xd6a67
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 0x79cc5
movq 0x18(%rcx), %rax
imulq (%rax), %rdx
addq %r9, %rdx
movq %rbx, %rcx
popq %rbx
jmp 0x3b5f6
// File: /workspace/github_c_makefile_star2_O3/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 0x38d93
testb %al, %al
je 0xd6af5
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 0x40de8(%rip), %rcx     # 0x1178a1
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 0x38dfa
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb990b
// File: /workspace/github_c_makefile_star2_O3/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 0xd6bc9
movq 0x8(%r14), %rdx
cmpb $0x1, (%rdx)
jne 0xd6b7c
movq 0x8(%rbx), %rsi
movq 0x8(%rdx), %rax
movq 0x10(%rdx), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, %rdi
movq %rax, %rdx
jmp 0xd6b90
testb $-0x80, 0x6(%rdx)
jne 0xd6b9b
movq 0x8(%rbx), %rsi
movq 0x120(%rbx), %rcx
movq %rbx, %rdi
callq 0xa332
addq $0x10, %r14
jmp 0xd6b4f
cmpq 0x1890(%rbx), %rdx
jne 0xd6b95
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rbx), %rsi
movq 0x110(%rbx), %rcx
movq %rbx, %rdi
callq 0xa332
orb $0x2, 0x6(%rax)
movq 0x10(%r14), %r14
jmp 0xd6b95
cmpl $0xa, %eax
jne 0xd6be8
movq 0x8(%rbx), %rsi
movq 0x110(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0xa332
orb $0x2, 0x6(%rax)
movq 0x8(%rbx), %rdx
movq 0x8(%rdx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0xd6c0e
movq %rax, %rdx
movq %rcx, %rax
movq 0x18(%rcx), %rcx
movq %rdx, 0x18(%rax)
testq %rcx, %rcx
jne 0xd6bf7
movq 0x8(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
callq 0xd4c30
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd6f3b
movzwl 0x4(%rcx), %r8d
jmp 0xd6f53
movq 0x8(%rcx), %r8
cmpw $0x20a, (%r8)           # imm = 0x20A
jne 0xd6f84
movq 0x10(%r8), %r8
movq 0x10(%r8), %r8
movq 0x10(%r8), %r8
cmpq $0x1ad, %r8             # imm = 0x1AD
je 0xd6f72
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
cmpq $0x1af, 0x10(%rcx)      # imm = 0x1AF
jne 0xd6f84
pushq %rax
movq 0x10(%rdi), %rsi
callq 0xd7a90
cmpl $0x4, %eax
sete %al
popq %rcx
retq
movzbl %al, %ecx
jmp 0xd6f89
// File: /workspace/github_c_makefile_star2_O3/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 0xd8d64
movq 0x8(%rsi), %rax
leaq 0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xd8d73
leaq 0x6dbf3(%rip), %rcx     # 0x146950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xd8dac
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb9ddd
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xd8d92
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x895ed
cmpb $0xb, (%rdx)
jne 0x895ed
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_O3/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 0xd8e1d
cmpl $0xb, %eax
jne 0xd8e3a
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 0x71b2f(%rip), %rcx     # 0x14a970
cmpb $0x0, (%rax,%rcx)
je 0xd8e70
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x1, (%rsi)
jne 0xd9499
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rbx), %rsi
movzbl (%rsi), %eax
cmpl $0x1, %eax
je 0xd9480
cmpl $0xa, %eax
jne 0xd948c
testb $0x4, 0x6(%rsi)
je 0xd948c
movb $0x1, %al
cmpq 0x1640(%r14), %rsi
jne 0xd949e
movq 0x10(%rbx), %rcx
cmpb $0x1, (%rcx)
jne 0xd948c
movq 0x8(%rcx), %rcx
cmpb $0xa, (%rcx)
jne 0xd948c
movl 0x2c(%rcx), %edx
cmpl 0xa88(%r14), %edx
jne 0xd949e
movq 0x8(%rcx), %rcx
movq 0x20(%rcx), %rcx
movl 0xc(%rcx), %ecx
cmpl 0xa8c(%r14), %ecx
je 0xd948c
jmp 0xd949e
movq %r14, %rdi
callq 0xd941b
testb %al, %al
jne 0xd949c
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0xd942a
xorl %eax, %eax
jmp 0xd949e
xorl %eax, %eax
retq
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x1, (%rdi)
jne 0xd97dd
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
leaq -0x8844(%rip), %r13     # 0xd0ea3
leaq 0xc71a(%rip), %rbp      # 0xe5e08
movq 0x8(%r12), %rdi
movb (%rdi), %al
cmpb $0xa, %al
jne 0xd9704
testb $0xc, 0x6(%rdi)
je 0xd9723
jmp 0xd97cf
cmpb $0x1, %al
jne 0xd9723
movzwl 0x6(%r12), %eax
andl $0x4, %eax
je 0xd9723
movq 0x10(%rdi), %rax
cmpb $0x1, (%rax)
jne 0xd9723
cmpq %r13, 0x20(%r12)
je 0xd9742
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xd96c0
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
je 0xd96ee
jmp 0xd97cf
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xd9723
cmpq %rbx, %rcx
je 0xd9723
cmpq %r15, %rcx
je 0xd9723
cmpq %r14, %rcx
je 0xd9723
movq 0x8(%rdi), %rcx
movq 0x10(%rcx), %rdx
movq 0x10(%rdx), %rdx
cmpb $0x30, (%rdx)
jb 0xd9723
movq 0x8(%rdx), %rdx
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
je 0xd9723
cmpl $0x2c, (%rdx)
je 0xd9783
movq 0x10(%rdx), %rdx
jmp 0xd9773
cmpq $0x0, 0x8(%rdx)
je 0xd9723
orb $0x8, 0x3(%rdi)
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
cmpb $0x30, (%rcx)
jb 0xd97b3
movq 0x8(%rcx), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0xd97b3
cmpl $0x2c, (%rcx)
je 0xd97c9
movq 0x10(%rcx), %rcx
jmp 0xd97a3
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %rbp, 0x20(%r12)
orb $0x4, 0x6(%r12)
jmp 0xd9731
movq 0x8(%rcx), %rcx
jmp 0xd97b5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: simple_stepper
static s7_pointer simple_stepper(s7_scheme *sc, s7_pointer v)
                {
                    if ((safe_list_length(v) == 3) &&
                            (is_fxable(sc, cadr(v))))
                    {
                        s7_pointer step_expr;
                        step_expr = caddr(v);
                        if ((is_optimized(step_expr)) &&
                                (((optimize_op(step_expr) == HOP_SAFE_C_SC) && (car(v) == cadr(step_expr))) ||
                                 ((is_h_safe_c_d(step_expr)) && /* replace with is_fxable? */
                                  (is_pair(cdr(step_expr))) &&         /* ((v 0 (+))) */
                                  (car(v) == cadr(step_expr)) &&
                                  ((opt1_cfunc(step_expr) == sc->add_x1) || (opt1_cfunc(step_expr) == sc->subtract_s1))) ||
                                 ((optimize_op(step_expr) == HOP_SAFE_C_CS) && (car(v) == caddr(step_expr)))))
                            return(step_expr);
                    }
                    return(NULL);
                }

// Assembly:
cmpb $0x1, (%rsi)
jne 0xd9847
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, %eax
movq %rsi, %rcx
movq 0x10(%rcx), %rcx
decq %rax
cmpb $0x1, (%rcx)
je 0xd97f6
testq %rax, %rax
jne 0xd9871
movq 0x10(%rbx), %r15
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xcd0e8
testb %al, %al
je 0xd9871
movq 0x10(%r15), %rax
movq 0x8(%rax), %rax
cmpw $0x801, (%rax)          # imm = 0x801
jne 0xd9871
movzwl 0x4(%rax), %ecx
cmpl $0x3, %ecx
je 0xd985e
cmpl $0xb, %ecx
je 0xd984a
cmpl $0x9, %ecx
jne 0xd9871
movq 0x8(%rbx), %rcx
movq 0x10(%rax), %rdx
jmp 0xd9856
xorl %eax, %eax
retq
movq 0x8(%rbx), %rcx
movq 0x10(%rax), %rdx
movq 0x10(%rdx), %rdx
cmpq 0x8(%rdx), %rcx
jne 0xd9871
jmp 0xd9873
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0xd9871
movq 0x8(%rbx), %rdx
cmpq 0x8(%rcx), %rdx
je 0xd9879
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x18(%rax), %rcx
cmpq 0x1a60(%r14), %rcx
je 0xd9873
cmpq 0x1a80(%r14), %rcx
jne 0xd9871
jmp 0xd9873
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: is_simple_end
static bool is_simple_end(s7_scheme *sc, s7_pointer end)
                {
                    return((is_optimized(end)) &&
                            (is_safe_c_op(optimize_op(end))) &&
                            (is_pair(cddr(end))) &&      /* end: (zero? n) */
                            (cadr(end) != caddr(end)) &&
#if (!WITH_GMP)
                            ((opt1_cfunc(end) == sc->num_eq_xi) ||
                             (optimize_op(end) == HOP_SAFE_C_SS) || (optimize_op(end) == HOP_SAFE_C_SC)));
#else
                    ((optimize_op(end) == HOP_SAFE_C_SS) || (optimize_op(end) == HOP_SAFE_C_SC)));
#endif
                }

// Assembly:
cmpw $0x801, (%rsi)          # imm = 0x801
jne 0xd995b
movl 0x4(%rsi), %eax
leal -0x2(%rax), %ecx
movzwl %cx, %ecx
cmpl $0x9b, %ecx
ja 0xd995b
movq 0x10(%rsi), %rcx
movq 0x10(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0xd995b
movq 0x8(%rcx), %rcx
cmpq 0x8(%rdx), %rcx
je 0xd995b
movq 0x18(%rsi), %rcx
cmpq 0x1c60(%rdi), %rcx
sete %cl
cmpw $0x7, %ax
sete %dl
orb %cl, %dl
cmpw $0x9, %ax
sete %al
orb %dl, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movabsq $0x4000000000000020, %r14 # imm = 0x4000000000000020
callq 0xec9f
movq %rax, %r13
leaq 0x1ffffc(%r14), %rax
movq %rax, (%r13)
movq 0x250(%rbx), %rax
incq %rax
movq %rax, 0x250(%rbx)
movq %rax, 0x18(%r13)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%r13)
movq 0x8(%r12), %rax
movq 0x8(%rax), %rbp
movq 0x120(%rbx), %r14
movq %rbx, %rdi
callq 0xec9f
movq %rax, %r15
movabsq $0x4000000000000020, %rax # imm = 0x4000000000000020
movq %rax, (%r15)
movq %rbp, 0x8(%r15)
movq %r14, 0x10(%r15)
movl $0x10, %edi
callq 0x8480
movq %r15, (%rax)
movq 0xc8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0xc8(%rbx)
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
movq %r15, 0x18(%rax)
movq 0x250(%rbx), %rax
movq 0x8(%r12), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x20(%rcx)
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
incl 0x28(%rax)
movq %r13, (%rsp)
movq %r15, 0x8(%r13)
movq 0x10(%r12), %rbp
cmpb $0x1, (%rbp)
jne 0xd9ace
movq 0x8(%rbp), %rax
movq 0x8(%rax), %r14
movq 0x120(%rbx), %r13
movq %rbx, %rdi
callq 0xec9f
movq %rax, %r12
movabsq $0x4000000000000020, %rax # imm = 0x4000000000000020
movq %rax, (%r12)
movq %r14, 0x8(%r12)
movq %r13, 0x10(%r12)
movl $0x10, %edi
callq 0x8480
movq %r12, (%rax)
movq 0xc8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0xc8(%rbx)
movq 0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %r12, 0x18(%rax)
movq 0x250(%rbx), %rax
movq 0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x20(%rcx)
movq 0x8(%rbp), %rax
movq 0x8(%rax), %rax
incl 0x28(%rax)
movq %r12, 0x18(%r15)
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
movq %r12, %r15
je 0xd9a3c
jmp 0xd9ad1
movq %r15, %r12
movq $0x0, 0x18(%r12)
movl $0x10, %edi
callq 0x8480
movq (%rsp), %rdx
movq %rdx, (%rax)
movq 0xc8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0xc8(%rbx)
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdx, %rax
movq %rdx, 0x4d8(%rdi)
cmpb $0x1, (%rsi)
jne 0xd9bb4
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
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 0xd9b7b
movq %r14, %rdi
callq 0xa550
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
cmpb $0x1, (%rbx)
je 0xd9b30
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdb65e
movq 0x8(%rbx), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%r14), %eax
jne 0xdb65e
cmpb $0x1, (%rdx)
jne 0xdb65e
cmpq %rbx, 0x8(%rdx)
je 0xdb6b1
movq 0x10(%rdx), %rdx
jmp 0xdb64d
movq (%rbx), %rax
btl $0x10, %eax
jb 0xdb6f8
btl $0x1a, %eax
jae 0xdb6bd
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xc250
movl 0x2c(%rax), %eax
cmpl 0xa88(%r14), %eax
jne 0xdb6bd
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xc250
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%r14), %eax
jne 0xdb6bd
addq $0x110, %r14            # imm = 0x110
movq %r14, %rbx
jmp 0xdb6fc
movq 0x20(%rbx), %rcx
addq $0x8, %r14
movq (%r14), %rdx
leaq 0x10(%rdx), %r14
cmpq 0x18(%rdx), %rcx
jl 0xdb6c5
jmp 0xdb6f3
cmpq %rcx, 0x18(%rdx)
je 0xdb707
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0xdb6ef
cmpq %rbx, 0x8(%rax)
je 0xdb6ff
movq 0x18(%rax), %rax
jmp 0xdb6de
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
je 0xdb6d4
addq $0x10, %rbx
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x18, %rbx
jmp 0xdb6fc
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
cmpq $0x7ff, %rdi            # imm = 0x7FF
ja 0xe060d
leaq 0x66349(%rip), %rax     # 0x146950
movq (%rax,%rbx,8), %rax
popq %rbx
retq
cmpq $0x1fffffff, %rbx       # imm = 0x1FFFFFFF
jg 0xe062b
cmpq $-0x2, %rbx
je 0xe0668
cmpq $-0x1, %rbx
jne 0xe0646
movq 0x74dcf(%rip), %rax     # 0x1553f8
jmp 0xe060b
cmpq $0x40000000, %rbx       # imm = 0x40000000
je 0xe0671
cmpq $0x20000000, %rbx       # imm = 0x20000000
jne 0xe0646
movq 0x6bd64(%rip), %rax     # 0x14c3a8
jmp 0xe060b
movl $0x1, %edi
movl $0x30, %esi
callq 0x8360
movabsq $0x400000000100000b, %rcx # imm = 0x400000000100000B
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
jmp 0xe060b
movq 0x74d99(%rip), %rax     # 0x155408
jmp 0xe060b
movq 0x74d88(%rip), %rax     # 0x155400
jmp 0xe060b