LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: op_tc_or_a_and_a_a_l3a
static void op_tc_or_a_and_a_a_l3a(s7_scheme *sc, bool or_case, s7_pointer code)
                {
                    s7_pointer fx_and1, fx_and2, fx_or, fx_la, la_slot, fx_laa, laa_slot, fx_l3a, l3a_slot;

                    fx_or = cdr(code);             /* first clause of or */
                    fx_and1 = (or_case) ? cdadr(fx_or) : cdaddr(fx_or);
                    fx_and2 = cdr(fx_and1);
                    fx_la = cdadr(fx_and2);
                    la_slot = let_slots(sc->envir);
                    fx_laa = cdr(fx_la);
                    laa_slot = next_slot(la_slot);
                    fx_l3a = cdr(fx_laa);
                    l3a_slot = next_slot(laa_slot);

                    while (true)
                    {
                        s7_pointer p;
                        p = fx_call(sc, fx_or);
                        if (p != sc->F) {sc->value = p; return;}
                        p = fx_call(sc, fx_and1);
                        if (p == sc->F) {sc->value = p; return;}
                        p = fx_call(sc, fx_and2);
                        if (p == sc->F) {sc->value = p; return;}
                        slot_set_value(la_slot, fx_call(sc, fx_la));
                        slot_set_value(laa_slot, fx_call(sc, fx_laa));
                        slot_set_value(l3a_slot, fx_call(sc, fx_l3a));
                    }
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rax
testl %esi, %esi
jne 0xc31ee
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r15
movq 0x10(%r15), %r12
movq 0x10(%r12), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r13
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x10(%r13), %rbp
movq %rax, 0x20(%rsp)
movq 0x18(%rax), %rax
movq 0x10(%rbp), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
jne 0xc32b6
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
cmpq 0x120(%rbx), %rax
je 0xc32b6
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
cmpq 0x120(%rbx), %rax
je 0xc32b6
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq *0x20(%r13)
movq 0x20(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rbp)
movq 0x18(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rcx)
jmp 0xc3237
movq %rax, 0x20(%rbx)
addq $0x28, %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: op_tc_if_a_z_if_a_z_laa
static bool op_tc_if_a_z_if_a_z_laa(s7_scheme *sc, bool cond, s7_pointer code)
                {
                    s7_pointer if_test, if_true, if_false, f_test, f_true, la, la_slot, laa, laa_slot, endp;
                    if_test = (cond) ? cadr(code) : cdr(code);
                    if_true = cdr(if_test);
                    if (!cond) if_false = cadr(if_true);
                    f_test = (cond) ? caddr(code) : cdr(if_false);
                    f_true = cdr(f_test);
                    la = (cond) ?  cdadr(cadddr(code)) : cdadr(f_true);
                    la_slot = let_slots(sc->envir);
                    laa = cdr(la);
                    laa_slot = next_slot(la_slot);

                    while (true)
                    {
                        s7_pointer a1;
                        if (fx_call(sc, if_test) != sc->F) {endp = if_true; break;}
                        if (fx_call(sc, f_test) != sc->F) {endp = f_true; break;}
                        a1 = fx_call(sc, la);
                        sc->w = a1;
                        slot_set_value(laa_slot, fx_call(sc, laa));
                        slot_set_value(la_slot, a1);
                    }
                    return(op_tc_z(sc, endp));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdx), %r12
testl %esi, %esi
je 0xc35ed
movq 0x10(%r12), %rax
movq 0x8(%r12), %r12
movq 0x10(%r12), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %r13
movq 0x10(%rax), %rax
movq 0x10(%r13), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
jmp 0xc360c
movq 0x10(%r12), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r13
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rbp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %r14
movq 0x10(%rbp), %r15
movq 0x18(%r14), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
cmpq 0x120(%rbx), %rax
jne 0xc36a7
movq %r14, 0x18(%rsp)
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq *0x20(%r13)
cmpq 0x120(%rbx), %rax
jne 0xc36e4
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rbp)
movq %rax, %r14
movq %rax, 0x4d8(%rbx)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x20(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq 0x18(%rsp), %rax
movq %r14, 0x10(%rax)
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
cmpq 0x120(%rbx), %rax
je 0xc3648
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %ebp
testb $0x4, %bpl
je 0xc36c6
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, 0x20(%rbx)
jmp 0xc36cd
movq 0x8(%rax), %rax
movq %rax, (%rbx)
andl $0x4, %ebp
shrl $0x2, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rax
jmp 0xc36ac
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: op_tc_cond_a_z_a_laa_laa
static bool op_tc_cond_a_z_a_laa_laa(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer c1, c2, c3, la1, la2, laa1, laa2, la_slot, laa_slot;
                    c1 = cadr(code);
                    c2 = caddr(code);
                    la1 = cdadr(c2);
                    laa1 = cddadr(c2);
                    c3 = cadr(cadddr(code));
                    la2 = cdr(c3);
                    laa2 = cddr(c3);
                    la_slot = let_slots(sc->envir);
                    laa_slot = next_slot(la_slot);
                    while (true)
                    {
                        s7_pointer a1;
                        if (fx_call(sc, c1) != sc->F) {c1 = cdr(c1); break;}
                        if (fx_call(sc, c2) != sc->F)
                        {
                            a1 = fx_call(sc, la1);
                            sc->w = a1;
                            slot_set_value(laa_slot, fx_call(sc, laa1));
                        }
                        else
                        {
                            a1 = fx_call(sc, la2);
                            sc->w = a1;
                            slot_set_value(laa_slot, fx_call(sc, laa2));
                        }
                        slot_set_value(la_slot, a1);
                    }
                    return(op_tc_z(sc, c1));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdx), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq %rcx, 0x20(%rsp)
movq 0x10(%rcx), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r14
movq 0x18(%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsi), %rsi
callq *0x20(%r15)
cmpq 0x120(%rbx), %rax
jne 0xc37a8
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rbp
cmpq 0x120(%rbx), %rax
je 0xc3774
movq 0x8(%rsp), %rcx
movq (%rsp), %rbp
movq 0x8(%rcx), %rsi
movq %rbx, %rdi
callq *0x20(%rcx)
movq %rax, %r13
movq %rax, 0x4d8(%rbx)
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rbp)
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq %r13, 0x10(%r14)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
jmp 0xc373e
movq 0x10(%r15), %rax
movzwl 0x6(%rax), %ebp
testb $0x4, %bpl
je 0xc37c6
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, 0x20(%rbx)
jmp 0xc37cd
movq 0x8(%rax), %rax
movq %rax, (%rbx)
andl $0x4, %ebp
shrl $0x2, %ebp
movl %ebp, %eax
addq $0x28, %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: op_tc_if_a_z_if_a_laa_z
static bool op_tc_if_a_z_if_a_laa_z(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer if_test, if_true, if_false, f_test, f_true, f_false, la, la_slot, laa, laa_slot, endp;
                    if_test = cdr(code);
                    if_true = cdr(if_test);
                    if_false = cadr(if_true);
                    f_test = cdr(if_false);
                    f_true = cdr(f_test);
                    f_false = cdr(f_true);
                    la = cdar(f_true);
                    la_slot = let_slots(sc->envir);
                    laa = cdr(la);
                    laa_slot = next_slot(la_slot);

                    while (true)
                    {
                        s7_pointer a1;
                        if (fx_call(sc, if_test) != sc->F) {endp = if_true; break;}
                        if (fx_call(sc, f_test) == sc->F) {endp = f_false; break;}
                        a1 = fx_call(sc, la);
                        sc->w = a1;
                        slot_set_value(laa_slot, fx_call(sc, laa));
                        slot_set_value(la_slot, a1);
                    }
                    return(op_tc_z(sc, endp));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r13
movq 0x10(%r13), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rcx), %rbp
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rbp), %r12
movq %rax, 0x20(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
jne 0xc4a99
movq %r15, 0x8(%rsp)
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq *0x20(%r13)
cmpq 0x120(%rbx), %rax
je 0xc4a94
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rbp)
movq %rax, %r15
movq %rax, 0x4d8(%rbx)
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq 0x18(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq 0x20(%rsp), %rax
movq %r15, 0x10(%rax)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xc4a32
movq 0x8(%rsp), %r15
jmp 0xc4a99
movq 0x10(%rsp), %r15
movzwl 0x6(%r15), %ebp
testb $0x4, %bpl
je 0xc4ab5
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq %rax, 0x20(%rbx)
jmp 0xc4abc
movq 0x8(%r15), %rax
movq %rax, (%rbx)
andl $0x4, %ebp
shrl $0x2, %ebp
movl %ebp, %eax
addq $0x28, %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: closure_star_is_fine_1
static bool closure_star_is_fine_1(s7_scheme *sc, s7_pointer code, uint16_t type, int32_t args)
                {
                    s7_pointer val;
#if S7_DEBUGGING
                    if ((type & (T_ONE_FORM | T_MULTIFORM)) != 0) fprintf(stderr, "%s %s: type has body bits\n", __func__, DISPLAY(code));
#endif
                    val = lookup_unexamined(sc, car(code));
                    if ((val == opt1_lambda_unchecked(code)) ||
                            ((val) &&
                             ((typesflag(val) & (T_SAFE_CLOSURE | TYPE_MASK)) == type) &&
                             (star_arity_is_ok(sc, val, args)) &&
                             (set_opt1_lambda(code, val))))
                        return(true);
                    sc->last_function = val;
                    return(false);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdi
movq 0x20(%rax), %rsi
cmpq %rsi, %rdi
je 0xc578a
jle 0xc5785
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdi
cmpq %rdi, %rsi
jl 0xc5778
cmpq %rsi, %rdi
jne 0xc57d9
movq 0x18(%rax), %rsi
movq 0x10(%rsi), %r15
movb $0x1, %r12b
cmpq 0x18(%r14), %r15
je 0xc5816
testq %r15, %r15
je 0xc5809
movzwl (%r15), %eax
andl $0x10ff, %eax           # imm = 0x10FF
cmpw %dx, %ax
jne 0xc580c
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9a1d8
movl 0x28(%r15), %eax
testl %eax, %eax
sets %cl
addl %eax, %eax
cmpl %ebp, %eax
setge %al
orb %cl, %al
cmpb $0x1, %al
jne 0xc580c
movq %r15, 0x18(%r14)
jmp 0xc5816
cmpb $0x1c, (%rcx)
jne 0xc57f9
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0xc57f3
cmpq %rax, 0x8(%rsi)
je 0xc578e
movq 0x18(%rsi), %rsi
jmp 0xc57e2
movq 0x10(%rcx), %rcx
jmp 0xc57d9
movq 0x10(%rax), %rsi
cmpb $0x20, (%rsi)
je 0xc578e
cmpq $0x0, 0x18(%r14)
je 0xc5822
xorl %r15d, %r15d
movq %r15, 0x1ed8(%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r12b
jmp 0xc5816
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: improper_arglist_error
static void improper_arglist_error(s7_scheme *sc)
                {
                    /* sc->code is the last (dotted) arg, sc->args is the arglist reversed not including sc->code
                     *   the original was `(,@(reverse args) . ,code) essentially
                     */
                    if (sc->args == sc->nil)               /* (abs . 1) */
                        s7_error(sc, sc->syntax_error_symbol, set_elist_1(sc, wrap_string(sc, "function call is a dotted list?", 31)));
                    else s7_error(sc, sc->syntax_error_symbol,
                            set_elist_2(sc, wrap_string(sc, "improper list of arguments: ~S", 30),
                                append_in_place(sc, sc->args = safe_reverse_in_place(sc, sc->args), sc->code)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
leal 0x1(%rcx), %edx
andl $0x7, %edx
movq 0x820(%rdi), %rsi
movq (%rsi,%rcx,8), %r15
movq 0x1918(%rdi), %r14
cmpq 0x110(%rdi), %rax
movl %edx, 0x7dc(%rdi)
je 0xc5ac6
leaq 0x51db7(%rip), %rax     # 0x117836
movq %rax, 0x10(%r15)
movq $0x1e, 0x8(%r15)
movq 0x10(%rbx), %rdx
movq 0x110(%rbx), %rsi
movq %rbx, %rdi
callq 0x9975a
movq %rax, 0x10(%rbx)
movq (%rbx), %rcx
movq 0x110(%rbx), %rdx
cmpq %rax, %rdx
je 0xc5ae5
movq %rax, %rdi
movq %rdi, %rsi
movq 0x10(%rdi), %rdi
cmpq %rdx, %rdi
jne 0xc5ab4
movq %rcx, 0x10(%rsi)
jmp 0xc5ae8
leaq 0x52077(%rip), %rax     # 0x117b44
movq %rax, 0x10(%r15)
movq $0x1f, 0x8(%r15)
leaq 0x6d8(%rbx), %rdx
movq %rdx, %rcx
jmp 0xc5b08
movq %rcx, %rax
leaq 0x6e0(%rbx), %rcx
movq 0x6e0(%rbx), %rdx
movq %r15, 0x8(%rdx)
movq 0x6e0(%rbx), %rdx
addq $0x10, %rdx
movq %rax, %r15
movq (%rdx), %rax
movq %r15, 0x8(%rax)
movq (%rcx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x38dfa
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: activate_let
static void activate_let(s7_scheme *sc, s7_pointer e)
                {
                    if (!is_let(e))                    /* (with-let . "hi") */
                        eval_error_no_return(sc, sc->wrong_type_arg_symbol, "with-let takes an environment argument: ~A", 42, e);
                    if (e == sc->rootlet)
                        sc->envir = sc->nil;                             /* (with-let (rootlet) ...) */
                    else
                    {
                        set_with_let_let(e);
                        let_id(e) = ++sc->let_number;
                        sc->envir = e;
                        update_symbol_ids(sc, e);
                    }
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1c, (%rsi)
je 0xca160
movq 0x1940(%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 0x4e8be(%rip), %rcx     # 0x1189e9
movq %rcx, 0x10(%rax)
movq $0x2a, 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
callq 0x38dfa
cmpq %r14, 0x150(%rbx)
je 0xca1b9
orb $0x4, 0x2(%r14)
movq 0x250(%rbx), %rax
incq %rax
movq %rax, 0x250(%rbx)
movq %rax, 0x18(%r14)
movq %r14, 0x8(%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xca1c4
movq 0x8(%rax), %rcx
movq 0x20(%rcx), %rdx
cmpq 0x250(%rbx), %rdx
je 0xca1b3
movq %rax, 0x18(%rcx)
movq 0x250(%rbx), %rdx
movq %rdx, 0x20(%rcx)
incl 0x28(%rcx)
movq 0x18(%rax), %rax
jmp 0xca18b
movq 0x110(%rbx), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: apply_boolean_method
static s7_pointer apply_boolean_method(s7_scheme *sc, s7_pointer obj, s7_pointer method)
    {
        s7_pointer func;
        func = find_method(sc, find_let(sc, obj), method);
        if (func == sc->undefined) return(sc->F);
        return(s7_apply_function(sc, func, list_1(sc, obj)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8a63
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0xca382
movq %rax, %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xca34e
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r14, 0x8(%rdx)
movq %r12, 0x10(%rdx)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaee6
movq 0x120(%rbx), %rax
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: fx_cond_fx_fx
static inline s7_pointer fx_cond_fx_fx(s7_scheme *sc, s7_pointer code)  /* all tests are fxable, results are all fx, no =>, no missing results */
                {
                    s7_pointer p;
                    for (p = cdr(code); is_pair(p); p = cdr(p))
                    {
                        if (is_true(sc, fx_call(sc, car(p))))
                        {
                            for (p = cdar(p); is_pair(cdr(p)); p = cdr(p))
                                fx_call(sc, p);
                            return(fx_call(sc, p));
                        }
                    }
                    return(sc->unspecified);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
jne 0xcaa3b
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
cmpq 0x120(%rbx), %rax
je 0xca9f8
movq 0x8(%r14), %rax
movq 0x10(%rax), %r14
movq 0x10(%r14), %rax
cmpb $0x1, (%rax)
jne 0xcaa4a
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x10(%r14), %r14
jmp 0xcaa21
movq 0x130(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %rsi
movq 0x20(%r14), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_and_n
static s7_pointer fx_and_n(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p, x;
                    x = sc->T;
                    for (p = cdr(arg); is_pair(p); p = cdr(p)) /* in lg, 5/6 args appears to predominate */
                    {
                        x = fx_call(sc, p);
                        if (is_false(sc, x))
                            return(x);
                    }
                    return(x);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
cmpb $0x1, (%r14)
jne 0xcace5
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xcacec
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
je 0xcacc5
jmp 0xcacec
movq 0x118(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_or_s_2
static s7_pointer fx_or_s_2(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    set_car(sc->t1_1, lookup(sc, opt3_sym(cdr(arg)))); /* cadadr(arg); */
                    x = c_call(cadr(arg))(sc, sc->t1_1);
                    if (x != sc->F) return(x);
                    return(c_call(caddr(arg))(sc, sc->t1_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x28(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xcaf74
jle 0xcaf6f
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xcaf62
cmpq %rdx, %rsi
jne 0xcafad
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
cmpq 0x120(%rbx), %rax
je 0xcafcd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpb $0x1c, (%rcx)
jne 0xcaff0
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xcafc7
cmpq %rax, 0x8(%rdx)
je 0xcaf78
movq 0x18(%rdx), %rdx
jmp 0xcafb6
movq 0x10(%rcx), %rcx
jmp 0xcafad
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xcaf78
xorl %eax, %eax
jmp 0xcaf7c
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_or_3
static s7_pointer fx_or_3(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p, val;
                    p = cdr(arg);
                    val = fx_call(sc, p);
                    if (val != sc->F) return(val);
                    p = cdr(p);
                    val = fx_call(sc, p);
                    if (val != sc->F) return(val);
                    return(fx_call(sc, cdr(p)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x8(%r14), %rsi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
jne 0xcb0bf
movq 0x10(%r14), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xcb0c7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_or_n
static s7_pointer fx_or_n(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    for (p = cdr(arg); is_pair(p); p = cdr(p))
                    {
                        s7_pointer x;
                        x = fx_call(sc, p);
                        if (is_true(sc, x))
                            return(x);
                    }
                    return(sc->F);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
jne 0xcb109
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xcb0e9
jmp 0xcb110
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: op_case_g_s
static void op_case_g_s(s7_scheme *sc)
                {
                    s7_pointer x, selector;
                    selector = sc->value;
                    for (x = cddr(sc->code); is_pair(x); x = cdr(x))
                        if (s7_is_eqv(opt2_any(x), selector))
                        {
                            sc->code = opt1_clause(x);
                            return;
                        }
                    sc->code = opt3_any(cdr(sc->code));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rdi), %r14
movq 0x10(%rax), %r12
movq %r12, %r15
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0xcb396
movq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x40412
testb %al, %al
je 0xcb376
addq $0x18, %r15
jmp 0xcb39d
addq $0x28, %r12
movq %r12, %r15
movq (%r15), %rax
movq %rax, (%rbx)
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: op_error_hook_quit
static void op_error_hook_quit(s7_scheme *sc)
                {
                    sc->error_hook = sc->code;  /* restore old value */
                    /* now mimic the end of the normal error handler.  Since this error hook evaluation can happen
                     *   in an arbitrary s7_call nesting, we can't just return from the current evaluation --
                     *   we have to jump to the original (top-level) call.  Otherwise '#<unspecified> or whatever
                     *   is simply treated as the (non-error) return value, and the higher level evaluations
                     *   get confused.
                     */
                    stack_reset(sc);                                 /* is this necessary? is it a good idea?? */
                    push_stack_op(sc, OP_ERROR_QUIT);                /* added 3-Dec-16: try to make sure we actually exit! */
                    sc->cur_op = OP_ERROR_QUIT;
                    if (sc->longjmp_ok)
                        longjmp(sc->goto_start, ERROR_QUIT_JUMP);
                }

// Assembly:
movq (%rdi), %rax
movq 0x48(%rdi), %rcx
movq %rax, 0x208(%rdi)
movq %rcx, 0x50(%rdi)
movq $0x1df, 0x18(%rcx)      # imm = 0x1DF
movq 0x50(%rdi), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rdi)
movq $0x203, 0x38(%rax)      # imm = 0x203
movq 0x50(%rdi), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rdi)
movl $0x1ed, %ecx            # imm = 0x1ED
movq %rcx, 0x38(%rax)
addq $0x20, 0x50(%rdi)
movq %rcx, 0x18(%rdi)
cmpb $0x1, 0x678(%rdi)
je 0xcb52d
retq
pushq %rax
addq $0x5b0, %rdi            # imm = 0x5B0
movl $0x5, %esi
callq 0x8530
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: clear_all_optimizations
static void clear_all_optimizations(s7_scheme *sc, s7_pointer p)
    {
        /* I believe that we would not have been optimized to begin with if the tree were circular,
         *   and this tree is supposed to be a function call + args -- a circular list here is a bug.
         */
        if (is_pair(p))
        {
            if ((is_optimized(p)) &&
                    ((optimize_op(p) & 1) == 0)) /* protect possibly shared code?  Elsewhere we assume these aren't changed */
            {
                clear_optimized(p);     /* includes T_SYNTACTIC */
                clear_optimize_op(p);
            }
            clear_all_optimizations(sc, cdr(p));
            clear_all_optimizations(sc, car(p));
        }
    }

// Assembly:
cmpb $0x1, (%rdi)
jne 0xcc3c9
pushq %rbx
movq %rdi, %rbx
cmpw $0x801, (%rbx)          # imm = 0x801
jne 0xcc3b6
testb $0x1, 0x4(%rbx)
jne 0xcc3b6
movw $0x1, (%rbx)
movw $0x0, 0x4(%rbx)
movq 0x10(%rbx), %rdi
callq 0xcc395
movq 0x8(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0xcc39e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_cell_optimize
static s7_function s7_cell_optimize(s7_scheme *sc, s7_pointer expr, bool nr)
                {
#if WITH_GMP
                    return(NULL);
#endif
                    if (setjmp(sc->opt_exit) == 0)
                    {
                        sc->pc = 0;
                        reset_opts(sc);
                        if (cell_optimize(sc, expr))
                            return((nr) ? opt_cell_any_nr : opt_wrap_cell);
                    }
                    return(NULL);
                }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x2190, %rdi           # imm = 0x2190
callq 0x8350
testl %eax, %eax
je 0xcca7b
xorl %eax, %eax
jmp 0xccab0
movl $0x0, 0x2258(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa2000
leaq -0xf96d(%rip), %rcx     # 0xbd12b
leaq -0xf961(%rip), %rdx     # 0xbd13e
testb %bpl, %bpl
cmovneq %rcx, %rdx
xorl %ecx, %ecx
testb %al, %al
movl %ecx, %eax
cmovneq %rdx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: tree_has_setters
static bool tree_has_setters(s7_scheme *sc, s7_pointer tree)
                {
                    clear_symbol_list(sc);
                    add_symbol_to_list(sc, sc->set_symbol);
                    add_symbol_to_list(sc, sc->vector_set_symbol);
                    add_symbol_to_list(sc, sc->list_set_symbol);
                    add_symbol_to_list(sc, sc->let_set_symbol);
                    add_symbol_to_list(sc, sc->hash_table_set_symbol);
                    add_symbol_to_list(sc, sc->set_car_symbol);
                    add_symbol_to_list(sc, sc->set_cdr_symbol);
                    return(tree_set_memq(sc, tree));                /* TODO: if val is constant don't treat as a hit */
                }

// Assembly:
movl 0xa88(%rdi), %eax
incl %eax
movl %eax, 0xa88(%rdi)
jne 0xccada
movl $0x1, 0xa88(%rdi)
incl 0xa8c(%rdi)
movl $0x1, %eax
movq 0x18d8(%rdi), %rcx
movl %eax, 0x2c(%rcx)
movl 0xa8c(%rdi), %eax
movq 0x8(%rcx), %rcx
movq 0x20(%rcx), %rcx
movl %eax, 0xc(%rcx)
movq 0x1668(%rdi), %rax
movl 0xa88(%rdi), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%rdi), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0x1260(%rdi), %rax
movl 0xa88(%rdi), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%rdi), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0x1240(%rdi), %rax
movl 0xa88(%rdi), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%rdi), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0xf70(%rdi), %rax
movl 0xa88(%rdi), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%rdi), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0x14a8(%rdi), %rax
movl 0xa88(%rdi), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%rdi), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0x14b0(%rdi), %rax
movl 0xa88(%rdi), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%rdi), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
jmp 0xccbbd
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: tree_set_memq
static bool tree_set_memq(s7_scheme *sc, s7_pointer tree)
    {
        if (is_symbol(tree))
            return(symbol_is_in_list(sc, tree));
        if ((!is_pair(tree)) ||
                (car(tree) == sc->quote_symbol))
            return(false);
        return(pair_set_memq(sc, tree));
    }

// Assembly:
movzbl (%rsi), %eax
cmpl $0x1, %eax
je 0xccbea
cmpl $0xa, %eax
jne 0xccbf9
movl 0x2c(%rsi), %eax
cmpl 0xa88(%rdi), %eax
jne 0xccbf9
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%rdi), %eax
sete %al
retq
movq 0x8(%rsi), %rax
cmpq 0x17b0(%rdi), %rax
je 0xccbf9
jmp 0xccbfc
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: pair_set_memq
static inline bool pair_set_memq(s7_scheme *sc, s7_pointer tree)
    {
        while (true)
        {
            s7_pointer p;
            p = car(tree);
            if (is_symbol(p))
            {
                if (symbol_is_in_list(sc, p))
                    return(true);
            }
            if ((is_unquoted_pair(p)) &&
                    (pair_set_memq(sc, p)))
                return(true);
            tree = cdr(tree);
            if (!is_pair(tree)) break;
        }
        return((is_symbol(tree)) && (symbol_is_in_list(sc, tree)));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%r14), %rsi
movzbl (%rsi), %eax
cmpl $0x1, %eax
je 0xccc37
cmpl $0xa, %eax
jne 0xccc50
movl 0x2c(%rsi), %eax
cmpl 0xa88(%rbx), %eax
jne 0xccc50
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%rbx), %eax
jne 0xccc50
jmp 0xccc88
movq 0x8(%rsi), %rax
cmpq 0x17b0(%rbx), %rax
je 0xccc50
movq %rbx, %rdi
callq 0xccbfc
testb %al, %al
jne 0xccc88
movq 0x10(%r14), %r14
movzbl (%r14), %eax
cmpl $0x1, %eax
je 0xccc06
cmpl $0xa, %eax
jne 0xccc84
movl 0x2c(%r14), %eax
cmpl 0xa88(%rbx), %eax
jne 0xccc84
movq 0x8(%r14), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%rbx), %eax
sete %al
jmp 0xccc8a
xorl %eax, %eax
jmp 0xccc8a
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: closure_arity_to_int
static int32_t closure_arity_to_int(s7_scheme *sc, s7_pointer x)
                {
                    /* not lambda* here */
                    if (closure_arity_unknown(x))
                    {
                        int32_t i;
                        s7_pointer b;
                        for (i = 0, b = closure_args(x); is_pair(b); i++, b = cdr(b)) {};
                        if (is_null(b))
                            closure_set_arity(x, i);
                        else
                        {
                            if (i == 0)
                                return(-1);
                            closure_set_arity(x, -i);
                        }
                    }
                    return(closure_arity(x));
                }

// Assembly:
movl 0x28(%rsi), %eax
cmpl $0x40000000, %eax       # imm = 0x40000000
jne 0xccf83
movq 0x8(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0xccf75
xorl %edx, %edx
movq 0x10(%rcx), %rcx
decl %edx
cmpb $0x1, (%rcx)
je 0xccf5a
movl %edx, %eax
negl %eax
cmpq 0x110(%rdi), %rcx
cmovnel %edx, %eax
jmp 0xccf86
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq 0x110(%rdi), %rcx
je 0xccf84
retq
xorl %eax, %eax
movl %eax, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: unknown_unknown
static goto_t unknown_unknown(s7_scheme *sc)
                {
                    if ((is_symbol(car(sc->code))) &&
                            (!is_slot(symbol_to_slot(sc, car(sc->code)))))
                        eval_error_no_return(sc, sc->unbound_variable_symbol, "~A: unbound variable", 20, car(sc->code));
                    return(fall_through);
                }

// Assembly:
movq (%rdi), %rax
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
jne 0xccfc9
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %r8
movq 0x20(%rax), %rsi
movl $0x18, %ecx
cmpq %rsi, %r8
je 0xccfc0
jle 0xccfbb
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r8
cmpq %r8, %rsi
jl 0xccfae
cmpq %rsi, %r8
jne 0xcd02e
movq (%rax,%rcx), %rsi
cmpb $0x20, (%rsi)
jne 0xccfca
retq
movq 0x1958(%rdi), %rsi
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rdi)
leaq 0x4b5d0(%rip), %rcx     # 0x1185c5
movq %rcx, 0x10(%rax)
movq $0x14, 0x8(%rax)
movq (%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0x6e0(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%rdi), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%rdi), %rdx
jmp 0x38dfa
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xccfc0
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0xcd051
cmpq %rax, 0x8(%rsi)
je 0xccfc4
movq 0x18(%rsi), %rsi
jmp 0xcd03c
movq 0x10(%rdx), %rdx
jmp 0xcd033
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: is_immutable_and_stable
static bool is_immutable_and_stable(s7_scheme *sc, s7_pointer func)
                {
                    s7_pointer p;
                    if (symbol_ctr(func) != 1) /* protect against (define-constant (p) (define-constant (p) ...)) */
                        return(false);
                    if ((is_global(func)) && (is_immutable_slot(global_slot(func))))
                        return(true);
                    for (p = sc->envir; is_let(p); p = outlet(p))
                        if ((is_funclet(p)) && (funclet_function(p) != func))
                            return(false);
                    p = symbol_to_slot(sc, func);
                    return(is_immutable_slot(p));
                }

// Assembly:
cmpl $0x1, 0x28(%rsi)
jne 0xcd0c0
testb $0x1, 0x2(%rsi)
je 0xcd06f
movq 0x10(%rsi), %rcx
movb $0x1, %al
testb $0x1, 0x3(%rcx)
jne 0xcd0bf
movq 0x8(%rdi), %rax
cmpb $0x1c, (%rax)
jne 0xcd090
movq %rax, %rcx
testb $0x20, 0x3(%rcx)
je 0xcd087
cmpq %rsi, 0x20(%rcx)
jne 0xcd0c0
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xcd07b
movq 0x18(%rax), %rdi
movq 0x20(%rsi), %rdx
movl $0x18, %ecx
cmpq %rdx, %rdi
je 0xcd0b6
jle 0xcd0b1
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdi
cmpq %rdi, %rdx
jl 0xcd0a4
cmpq %rdx, %rdi
jne 0xcd0c3
movq (%rsi,%rcx), %rdx
movb 0x3(%rdx), %al
andb $0x1, %al
retq
xorl %eax, %eax
retq
movl $0x10, %ecx
cmpb $0x1c, (%rax)
jne 0xcd0b6
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0xcd0e2
cmpq %rsi, 0x8(%rdx)
je 0xcd0ba
movq 0x18(%rdx), %rdx
jmp 0xcd0d1
movq 0x10(%rax), %rax
jmp 0xcd0c8
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: is_fxable
static bool is_fxable(s7_scheme *sc, s7_pointer p)
                {
                    if (!is_pair(p)) return(true);
                    if ((is_optimized(p)) &&  /* this is needed */
                            (fx_function[optimize_op(p)]))
                        return(true);
                    return(is_proper_quote(sc, p));
                }

// Assembly:
movb $0x1, %al
cmpb $0x1, (%rsi)
jne 0xcd108
cmpw $0x801, (%rsi)          # imm = 0x801
jne 0xcd109
movzwl 0x4(%rsi), %ecx
leaq 0x85fdf(%rip), %rdx     # 0x1530e0
cmpq $0x0, (%rdx,%rcx,8)
je 0xcd109
retq
movq 0x8(%rsi), %rax
cmpq 0x17b0(%rdi), %rax
jne 0xcd12e
movq 0x10(%rsi), %rax
cmpb $0x1, (%rax)
jne 0xcd12e
movq 0x10(%rax), %rax
cmpq 0x110(%rdi), %rax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_tree
static void fx_tree(s7_scheme *sc, s7_pointer tree, s7_pointer var1, s7_pointer var2)
                {
#if 0
                    if (is_pair(tree))
                        fprintf(stderr, "%s[%d]: %s %s %d %s %s\n", func, line,
                                DISPLAY_80(tree), (is_optimized(tree)) ? op_names[optimize_op(tree)] : "unopt",
                                has_fx(tree), /* (has_fx(tree)) ? fx_name(sc, tree) : "", */
                                DISPLAY(var1), (var2) ? DISPLAY(var2) : "");
#endif
                    if ((!is_pair(tree)) ||
                            ((is_symbol(car(tree))) &&
                             (is_definer_or_binder(car(tree)))))
                        return;
                    if ((!has_fx(tree)) ||
                            (!fx_tree_in(sc, tree, var1, var2)))
                        fx_tree(sc, car(tree), var1, var2);
                    fx_tree(sc, cdr(tree), var1, var2);
                }

// Assembly:
cmpb $0x1, (%rdi)
jne 0xcd1db
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%r15), %rdi
cmpb $0xa, (%rdi)
jne 0xcd1a4
testb $0xc, 0x6(%rdi)
jne 0xcd1d6
testb $0x4, 0x6(%r15)
je 0xcd1c1
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xcd1dc
testb %al, %al
jne 0xcd1cc
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xcd182
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
je 0xcd195
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_c_ts
static s7_pointer fx_c_ts(s7_scheme *sc, s7_pointer arg)
                {
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    set_car(sc->t2_1, slot_value(let_slots(sc->envir)));
                    set_car(sc->t2_2, lookup(sc, opt2_sym(cdr(arg))));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x570(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %r8
movq 0x20(%rax), %rdx
cmpq %rdx, %r8
je 0xce547
jle 0xce542
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xce535
cmpq %rdx, %r8
jne 0xce567
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
movq 0x578(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rsi), %rax
movq 0x570(%rdi), %rsi
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xce587
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xce581
cmpq %rax, 0x8(%rdx)
je 0xce54b
movq 0x18(%rdx), %rdx
jmp 0xce570
movq 0x10(%rcx), %rcx
jmp 0xce567
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xce54b
xorl %eax, %eax
jmp 0xce54f
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_c_tcs
static s7_pointer fx_c_tcs(s7_scheme *sc, s7_pointer arg)
                {
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    set_car(sc->t3_1, slot_value(let_slots(sc->envir)));
                    set_car(sc->t3_3, lookup(sc, opt2_sym(cdr(arg)))); /* cadddr(arg) */
                    set_car(sc->t3_2, opt1_con(cdr(arg)));             /* caddr(arg) */
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x580(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %r8
movq 0x20(%rax), %rdx
cmpq %rdx, %r8
je 0xce5d8
jle 0xce5d3
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xce5c6
cmpq %rdx, %r8
jne 0xce60b
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
movq 0x590(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rsi), %rax
movq 0x18(%rax), %rax
movq 0x588(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rsi), %rax
movq 0x580(%rdi), %rsi
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xce62b
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xce625
cmpq %rax, 0x8(%rdx)
je 0xce5dc
movq 0x18(%rdx), %rdx
jmp 0xce614
movq 0x10(%rcx), %rcx
jmp 0xce60b
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xce5dc
xorl %eax, %eax
jmp 0xce5e0
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_subtract_tf
static s7_pointer fx_subtract_tf(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(sc->envir));
                    if (is_t_real(x)) return(make_real(sc, real(x) - real(caddr(arg))));
                    return(g_subtract_2f(sc, set_plist_2(sc, x, caddr(arg))));
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0xd, (%rax)
jne 0xce6b3
movsd 0x8(%rax), %xmm0
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
subsd 0x8(%rax), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xce692
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xa550
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq 0x10(%rsi), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq 0x708(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq 0x710(%rbx), %rax
movq %rcx, 0x8(%rax)
movq 0x708(%rbx), %rsi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xba07e
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_char_equal_2
static s7_pointer g_char_equal_2(s7_scheme *sc, s7_pointer args)
    {
        if (!s7_is_character(car(args)))
            return(method_or_bust(sc, car(args), sc->char_eq_symbol, args, T_CHARACTER, 1));
        if (car(args) == cadr(args))
            return(sc->T);
        if (!s7_is_character(cadr(args)))
            return(method_or_bust(sc, cadr(args), sc->char_eq_symbol, args, T_CHARACTER, 2));
        return(sc->F);
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rax
cmpb $0x8, (%rax)
jne 0xce784
movq 0x10(%rcx), %rdx
movq 0x8(%rdx), %rsi
cmpq %rsi, %rax
je 0xce79f
cmpb $0x8, (%rsi)
jne 0xce7a7
movq 0x120(%rdi), %rax
retq
movq 0xdb8(%rdi), %rdx
movq %rax, %rsi
movl $0x8, %r8d
movl $0x1, %r9d
jmp 0xe42d
movq 0x118(%rdi), %rax
retq
movq 0xdb8(%rdi), %rdx
movl $0x8, %r8d
movl $0x2, %r9d
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_char_equal_tc
static s7_pointer fx_char_equal_tc(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer c;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    c = slot_value(let_slots(sc->envir));
                    if (c == opt2_con(cdr(arg)))
                        return(sc->T);
                    if (s7_is_character(c))
                        return(sc->F);
                    return(method_or_bust(sc, cadr(arg), sc->char_eq_symbol, cdr(arg), T_CHARACTER, 1));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsi), %rcx
cmpq 0x20(%rcx), %rax
je 0xce7e2
cmpb $0x8, (%rax)
jne 0xce7ea
movq 0x120(%rdi), %rax
retq
movq 0x118(%rdi), %rax
retq
movq 0x8(%rcx), %rsi
movq 0xdb8(%rdi), %rdx
movl $0x8, %r8d
movl $0x1, %r9d
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_less_xf
static s7_pointer g_less_xf(s7_scheme *sc, s7_pointer args)
    {
        s7_double y;
        s7_pointer x;

        x = car(args);
        y = real(cadr(args));

        if (type(x) == T_REAL)
            return(make_boolean(sc, real(x) < y));
        if (type(x) == T_INTEGER)
            return(make_boolean(sc, integer(x) < y));
        if (type(x) == T_RATIO)
            return(make_boolean(sc, fraction(x) < y));
        return(method_or_bust(sc, x, sc->lt_symbol, args, T_REAL, 1));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
movsd 0x8(%rax), %xmm0
movzbl (%rsi), %eax
cmpl $0xb, %eax
je 0xce863
cmpl $0xc, %eax
je 0xce835
cmpl $0xd, %eax
jne 0xce87b
xorl %eax, %eax
ucomisd 0x8(%rsi), %xmm0
jmp 0xce86f
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rax, -0x8(%rsp)
fildll -0x8(%rsp)
movq %rcx, -0x10(%rsp)
fildll -0x10(%rsp)
fdivrp %st, %st(1)
movsd %xmm0, -0x18(%rsp)
fldl -0x18(%rsp)
xorl %eax, %eax
fucompi %st(1), %st
fstp %st(0)
jmp 0xce86f
cvtsi2sdq 0x8(%rsi), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setbe %al
movq 0x118(%rdi,%rax,8), %rax
retq
movq 0x12c0(%rdi), %rdx
movl $0xd, %r8d
movl $0x1, %r9d
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_lt_tf
static s7_pointer fx_lt_tf(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(sc->envir));
                    if (is_t_real(x)) return(make_boolean(sc, real(x) < real(opt2_con(cdr(arg)))));
                    return(g_less_xf(sc, set_plist_2(sc, x, caddr(arg))));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0xd, (%rax)
jne 0xce8c4
movq 0x10(%rsi), %rcx
movq 0x20(%rcx), %rcx
movsd 0x8(%rcx), %xmm0
xorl %ecx, %ecx
ucomisd 0x8(%rax), %xmm0
setbe %cl
movq 0x118(%rdi,%rcx,8), %rax
retq
movq 0x10(%rsi), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq 0x708(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x710(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x708(%rdi), %rsi
jmp 0xce806
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_less_xi
static s7_pointer g_less_xi(s7_scheme *sc, s7_pointer args)
    {
        s7_int y;
        s7_pointer x;

        x = car(args);
        y = integer(cadr(args));

        if (type(x) == T_INTEGER)
            return(make_boolean(sc, integer(x) < y));
        if (type(x) == T_REAL)
            return(make_boolean(sc, real(x) < y));
        if (type(x) == T_RATIO)
            return(make_boolean(sc, ratio_lt_pi(x, y)));
        return(method_or_bust(sc, x, sc->lt_symbol, args, T_REAL, 1));
    }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
movq 0x8(%rdx), %rdx
movq 0x8(%rdx), %rsi
movzbl (%rax), %edx
cmpl $0xd, %edx
je 0xce93d
cmpl $0xc, %edx
je 0xce926
cmpl $0xb, %edx
jne 0xce956
xorl %ecx, %ecx
cmpq %rsi, 0x8(%rax)
setge %cl
jmp 0xce94c
movq %rax, %rdi
callq 0xd13f5
xorb $0x1, %al
movzbl %al, %eax
movq 0x118(%rbx,%rax,8), %rax
jmp 0xce954
cvtsi2sd %rsi, %xmm0
xorl %ecx, %ecx
ucomisd 0x8(%rax), %xmm0
setbe %cl
movq 0x118(%rbx,%rcx,8), %rax
popq %rbx
retq
movq 0x12c0(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0xd, %r8d
movl $0x1, %r9d
popq %rbx
jmp 0xe42d