LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_recur_cond_a_a_a_a_oplaa_laaq
static void opinit_cond_a_a_a_a_oplaa_laaq(s7_scheme *sc)
                {
                    s7_pointer caller;
                    rec_set_test(sc, cadr(sc->code));
                    rec_set_res(sc, cdadr(sc->code));
                    rec_set_f1(sc, caddr(sc->code));
                    rec_set_f2(sc, cdaddr(sc->code));

                    caller = opt3_pair(sc->code);  /* cadr(cadddr(sc->code)) = (cfunc laa laa) */

                    sc->rec_f3p = cdadr(caller);
                    rec_set_f4(sc, cdr(sc->rec_f3p));
                    sc->rec_f3f = c_callee(sc->rec_f3p);
                    sc->rec_f3p = car(sc->rec_f3p);
                    sc->rec_f5p = opt3_pair(caller);
                    rec_set_f6(sc, cdr(sc->rec_f5p));
                    sc->rec_f5f = c_callee(sc->rec_f5p);
                    sc->rec_f5p = car(sc->rec_f5p);
                    sc->rec_slot1 = let_slots(sc->envir);
                    sc->rec_slot2 = next_slot(sc->rec_slot1);
                    sc->rec_call = c_callee(caller);
                }

// Assembly:
movq (%rdi), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f0(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x360(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f0(%rdi)
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x340(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x3b0(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x340(%rdi)
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f8(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x368(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f8(%rdi)
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x300(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x370(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x300(%rdi)
movq 0x28(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x308(%rdi)
movq 0x10(%rcx), %rdx
movq %rdx, 0x310(%rdi)
movq 0x20(%rdx), %rsi
movq %rsi, 0x380(%rdi)
movq 0x8(%rdx), %rdx
movq %rdx, 0x310(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x378(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x308(%rdi)
movq 0x28(%rax), %rcx
movq %rcx, 0x318(%rdi)
movq 0x10(%rcx), %rdx
movq %rdx, 0x320(%rdi)
movq 0x20(%rdx), %rsi
movq %rsi, 0x390(%rdi)
movq 0x8(%rdx), %rdx
movq %rdx, 0x320(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x388(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x318(%rdi)
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x348(%rdi)
movq 0x18(%rcx), %rcx
movq %rcx, 0x350(%rdi)
movq 0x20(%rax), %rax
movq %rax, 0x3b8(%rdi)
jmp 0xa7d41
// File: /workspace/github_c_makefile_star2_O2/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
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0x7d158
cmpq 0x18(%r15), %rax
je 0x9b392
movq %rax, %r14
testq %rax, %rax
je 0x9b384
movzwl (%r14), %eax
andl $0x10ff, %eax           # imm = 0x10FF
cmpw %r12w, %ax
jne 0x9b384
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa274b
testl %eax, %eax
sets %cl
addl %eax, %eax
cmpl %ebp, %eax
setge %al
orb %cl, %al
je 0x9b384
addq $0x18, %r15
movb $0x1, %al
movq %r15, %rbx
jmp 0x9b38d
addq $0x1ed8, %rbx           # imm = 0x1ED8
xorl %eax, %eax
movq %r14, (%rbx)
jmp 0x9b394
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9b62b
leaq 0x481f7(%rip), %rax     # 0xe37d6
movq %rax, 0x10(%r15)
movq $0x1e, 0x8(%r15)
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0xa833
movq %rax, 0x10(%rbx)
movq (%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa9c37
movq 0x6e0(%rbx), %rcx
movq %r15, 0x8(%rcx)
leaq 0x6e0(%rbx), %rdx
movq 0x6e0(%rbx), %rcx
addq $0x10, %rcx
movq %rax, %r15
jmp 0x9b648
leaq 0x484b2(%rip), %rax     # 0xe3ae4
movq %rax, 0x10(%r15)
movq $0x1f, 0x8(%r15)
leaq 0x6d8(%rbx), %rcx
movq %rcx, %rdx
movq (%rcx), %rax
movq %r15, 0x8(%rax)
movq (%rdx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2cdc0
// File: /workspace/github_c_makefile_star2_O2/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 0x9fc7a
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 0x44d44(%rip), %rcx     # 0xe4989
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 0x2cdc0
cmpq %r14, 0x150(%rbx)
je 0x9fcb3
orb $0x4, 0x2(%r14)
movq 0x250(%rbx), %rax
incq %rax
movq %rax, 0x250(%rbx)
movq %rax, 0x18(%r14)
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xafce
movq 0x110(%rbx), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x88f3
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x9fe7c
movq %rax, %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x9fe48
movq %rbx, %rdi
callq 0x9c27
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 0xa34c
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
jne 0xa04fa
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
cmpq 0x120(%rbx), %rax
je 0xa04b1
movq 0x8(%r14), %r14
addq $0x10, %r14
movq (%r14), %rax
leaq 0x10(%rax), %r14
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rcx
movb (%rcx), %bpl
movq %rbx, %rdi
callq *0x20(%rax)
cmpb $0x1, %bpl
je 0xa04da
jmp 0xa0501
movq 0x130(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
movq 0x118(%rdi), %rax
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
jne 0xa077a
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq *0x20(%rbx)
cmpq 0x120(%r14), %rax
jne 0xa075e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: check_or
static bool check_or(s7_scheme *sc)
                {
                    s7_pointer p, form;
                    bool any_nils = false;

                    form = sc->code;
                    sc->code = cdr(sc->code);

                    if (is_null(sc->code))
                    {
                        sc->value = sc->F;
                        return(true);
                    }

                    for (p = sc->code; is_pair(p); p = cdr(p))
                    {
                        s7_function callee;
                        callee = fx_choose(sc, p, sc->envir, let_symbol_is_safe);
                        if (!callee) any_nils = true;
                        set_c_call_checked(p, callee);
                    }

                    if (is_not_null(p))
                        eval_error_no_return(sc, sc->syntax_error_symbol, "or: stray dot?: ~A", 18, form);

                    if ((c_callee(sc->code)) &&
                            (is_proper_list_1(sc, cdr(sc->code)))) /* list_1 of cdr so there are 2 exprs */
                        pair_set_syntax_op(form, (any_nils) ? OP_OR_AP : OP_OR_SAFE_AA);
                    else pair_set_syntax_op(form, (any_nils) ? OP_OR_P : OP_OR_N);
                    sc->code = form;
                    return(false);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x110(%rdi), %rcx
movq 0x10(%rax), %r15
movq %r15, (%rdi)
cmpq %rcx, %r15
je 0xa0938
movq %rax, 0x8(%rsp)
movq %rcx, (%rsp)
xorl %ebp, %ebp
leaq -0x13095(%rip), %r14    # 0x8d79b
pushq $0x1
popq %r13
movq %r15, 0x10(%rsp)
cmpb $0x1, (%r15)
movzbl %bpl, %r12d
jne 0xa087e
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x8c0ba
xorl %ecx, %ecx
testq %rax, %rax
cmovel %r13d, %r12d
setne %cl
movq %rax, 0x20(%r15)
movzwl 0x6(%r15), %eax
andl $-0x5, %eax
leal (%rax,%rcx,4), %eax
movw %ax, 0x6(%r15)
movq 0x10(%r15), %r15
movl %r12d, %ebp
jmp 0xa0839
cmpq 0x110(%rbx), %r15
movq 0x8(%rsp), %r14
je 0xa08ec
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 0x448a5(%rip), %rcx     # 0xe515c
movq %rcx, 0x10(%rax)
movq $0x12, 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 0x2cdc0
movq (%rbx), %rax
cmpq $0x0, 0x20(%rax)
movq 0x10(%rsp), %r15
je 0xa0911
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa0911
movq 0x10(%rax), %rax
cmpq 0x110(%rbx), %rax
je 0xa0958
testb $0x1, %bpl
movl $0x292, %eax            # imm = 0x292
movl $0x298, %r12d           # imm = 0x298
cmovnel %eax, %r12d
movq (%rsp), %rcx
movw %r12w, 0x4(%r14)
movw $0x201, (%r14)          # imm = 0x201
movq %r14, (%rbx)
jmp 0xa0943
movq 0x120(%rbx), %rax
movq %rax, 0x20(%rbx)
cmpq %rcx, %r15
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andl $0x1, %r12d
xorl $0x295, %r12d           # imm = 0x295
jmp 0xa0924
// File: /workspace/github_c_makefile_star2_O2/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), %rsi
callq 0x7d158
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 0xa09ad
addq $0x8, %rsp
popq %rbx
popq %r14
retq
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
// File: /workspace/github_c_makefile_star2_O2/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 0xa0a4d
movq 0x10(%r14), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xa0a55
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_O2/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 0xa0a97
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xa0a77
jmp 0xa0a9e
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_case_e_s
static void op_case_e_s(s7_scheme *sc)
                {
                    s7_pointer x, selector;
                    selector = sc->value;
                    if (is_simple(selector))
                    {
                        for (x = cddr(sc->code); is_pair(x); x = cdr(x))
                            if (opt2_any(x) == selector)
                            {
                                sc->code = opt1_clause(x);
                                return;
                            }
                    }
                    sc->code = opt3_any(cdr(sc->code));
                }

// Assembly:
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movzbl (%rcx), %edx
leaq 0x81421(%rip), %rsi     # 0x1220a0
movq 0x10(%rax), %rax
cmpb $0x1, (%rdx,%rsi)
jne 0xa0ca4
movq %rax, %rdx
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
jne 0xa0ca4
cmpq %rcx, 0x20(%rdx)
jne 0xa0c8c
addq $0x18, %rdx
movq %rdx, %rax
jmp 0xa0ca8
addq $0x28, %rax
movq (%rax), %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_case_s_s
static void op_case_s_s(s7_scheme *sc)
                {
                    s7_pointer x, selector;
                    selector = sc->value;
                    if (is_symbol(selector))
                    {
                        for (x = cddr(sc->code); is_pair(x); x = cdr(x))
                            if (opt2_any(x) == selector)
                            {
                                sc->code = opt1_clause(x);
                                return;
                            }
                    }
                    sc->code = opt3_any(cdr(sc->code));
                }

// Assembly:
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
cmpb $0xa, (%rcx)
movq 0x10(%rax), %rax
jne 0xa0cda
movq %rax, %rdx
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
jne 0xa0cda
cmpq %rcx, 0x20(%rdx)
jne 0xa0cc2
addq $0x18, %rdx
movq %rdx, %rax
jmp 0xa0cde
addq $0x28, %rax
movq (%rax), %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa0d93
movq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x32e3b
testb %al, %al
je 0xa0d73
addq $0x18, %r15
jmp 0xa0d9a
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_O2/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:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, (%rbx)
jne 0xa1bbe
cmpw $0x801, (%rbx)          # imm = 0x801
jne 0xa1baf
testb $0x1, 0x4(%rbx)
jne 0xa1baf
movw $0x1, (%rbx)
andw $0x0, 0x4(%rbx)
movq 0x10(%rbx), %rdi
callq 0xa1b8f
movq 0x8(%rbx), %rbx
jmp 0xa1b93
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa2201
xorl %eax, %eax
jmp 0xa2233
andl $0x0, 0x2258(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x80a38
leaq -0xd37a(%rip), %rcx     # 0x94ea1
leaq -0xd371(%rip), %rdx     # 0x94eb1
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_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7c981
movq 0x18d8(%r14), %rax
movl 0xa88(%r14), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%r14), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0x1668(%r14), %rax
movl 0xa88(%r14), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%r14), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0x1260(%r14), %rax
movl 0xa88(%r14), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%r14), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0x1240(%r14), %rax
movl 0xa88(%r14), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%r14), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0xf70(%r14), %rax
movl 0xa88(%r14), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%r14), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0x14a8(%r14), %rax
movl 0xa88(%r14), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%r14), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0x14b0(%r14), %rax
movl 0xa88(%r14), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%r14), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa234b
// File: /workspace/github_c_makefile_star2_O2/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 0xa2378
cmpl $0xa, %eax
jne 0xa2387
movl 0x2c(%rsi), %eax
cmpl 0xa88(%rdi), %eax
jne 0xa2387
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 0xa2387
jmp 0xa238a
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa23c5
cmpl $0xa, %eax
jne 0xa23de
movl 0x2c(%rsi), %eax
cmpl 0xa88(%rbx), %eax
jne 0xa23de
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%rbx), %eax
jne 0xa23de
jmp 0xa2416
movq 0x8(%rsi), %rax
cmpq 0x17b0(%rbx), %rax
je 0xa23de
movq %rbx, %rdi
callq 0xa238a
testb %al, %al
jne 0xa2416
movq 0x10(%r14), %r14
movzbl (%r14), %eax
cmpl $0x1, %eax
je 0xa2394
cmpl $0xa, %eax
jne 0xa2412
movl 0x2c(%r14), %eax
cmpl 0xa88(%rbx), %eax
jne 0xa2412
movq 0x8(%r14), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%rbx), %eax
sete %al
jmp 0xa2418
xorl %eax, %eax
jmp 0xa2418
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: symbol_is_in_arg_list
static bool symbol_is_in_arg_list(s7_pointer sym, s7_pointer lst)
    {
        s7_pointer x;
        for (x = lst; is_pair(x); x = cdr(x))
            if ((sym == car(x)) ||
                    ((is_pair(car(x))) &&
                     (sym == caar(x))))
                return(true);
        return(sym == x);
    }

// Assembly:
movb $0x1, %al
cmpb $0x1, (%rsi)
jne 0xa24a6
movq 0x8(%rsi), %rcx
cmpq %rdi, %rcx
je 0xa24ac
cmpb $0x1, (%rcx)
jne 0xa24a0
cmpq %rdi, 0x8(%rcx)
je 0xa24ac
movq 0x10(%rsi), %rsi
jmp 0xa2487
cmpq %rdi, %rsi
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: make_goto
static inline s7_pointer make_goto(s7_scheme *sc)
    {
        s7_pointer x;
        new_cell(sc, x, T_GOTO);
        call_exit_goto_loc(x) = s7_stack_top(sc);
        call_exit_op_loc(x) = (int32_t)(sc->op_stack_now - sc->op_stack);
        call_exit_active(x) = true;
        return(x);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa24d0
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x26, (%rax)
movq 0x50(%rbx), %rcx
subq 0x48(%rbx), %rcx
sarq $0x3, %rcx
movq %rcx, 0x8(%rax)
movq 0x68(%rbx), %rcx
subq 0x60(%rbx), %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: set_c_function_star_defaults
static s7_pointer set_c_function_star_defaults(s7_scheme *sc, int32_t num)
                {
                    s7_pointer call_args, func, par;
                    int32_t n_args;

                    func = sc->code;
                    n_args = c_function_all_args(func);

                    if (is_safe_procedure(func))
                        call_args = c_function_call_args(func);
                    else call_args = protected_make_list(sc, n_args, sc->F);

                    par = call_args;
                    if (num == 1)
                    {
                        set_car(par, car(sc->args));
                        par = cdr(par);
                    }
                    fill_star_defaults(sc, func, num, n_args, par);
                    return(call_args);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r12
movq (%rdi), %r15
movq 0x28(%r15), %r14
testb $0x20, 0x2(%r15)
jne 0xa2543
movslq %r14d, %rsi
movq 0x120(%r12), %rdx
movq %r12, %rdi
callq 0x7d146
movq %rax, %r13
jmp 0xa254b
movq 0x8(%r15), %rax
movq 0x60(%rax), %r13
movq %r13, %r8
cmpl $0x1, %ebx
jne 0xa2564
movq 0x10(%r12), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%r13)
movq 0x10(%r13), %r8
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
movl %r14d, %ecx
callq 0x7d9ae
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0xa25b3
leaq 0x8(%rsi), %rcx
xorl %eax, %eax
movq (%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xa25a1
incl %eax
addq $0x10, %rcx
jmp 0xa2591
cmpq 0x110(%rdi), %rcx
je 0xa25b0
testl %eax, %eax
je 0xa25b4
negl %eax
movl %eax, 0x28(%rsi)
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rsi
cmpb $0xa, (%rsi)
jne 0xa25d2
movq %rdi, %rbx
callq 0xb00b
cmpb $0x20, (%rax)
jne 0xa25d4
popq %rbx
retq
movq 0x1958(%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 0x41f66(%rip), %rcx     # 0xe4565
movq %rcx, 0x10(%rax)
movq $0x14, 0x8(%rax)
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
movq 0x6e0(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x2cdc0
// File: /workspace/github_c_makefile_star2_O2/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 0xa2673
pushq %rax
testb $0x1, 0x2(%rsi)
je 0xa2655
movq 0x10(%rsi), %rcx
movb $0x1, %al
testb $0x1, 0x3(%rcx)
jne 0xa2684
leaq 0x8(%rdi), %rax
movq (%rax), %rax
cmpb $0x1c, (%rax)
jne 0xa2676
testb $0x20, 0x3(%rax)
je 0xa266d
cmpq %rsi, 0x20(%rax)
jne 0xa2682
addq $0x10, %rax
jmp 0xa2659
xorl %eax, %eax
retq
callq 0xb00b
movb 0x3(%rax), %al
andb $0x1, %al
jmp 0xa2684
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpb $0x1, (%rsi)
jne 0xa26af
cmpw $0x801, (%rsi)          # imm = 0x801
jne 0x86533
movzwl 0x4(%rsi), %eax
leaq 0x7fa3c(%rip), %rcx     # 0x1220e0
cmpq $0x0, (%rcx,%rax,8)
je 0x86533
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, (%r15)
jne 0xa2745
movq 0x8(%r15), %rdi
cmpb $0xa, (%rdi)
jne 0xa2717
testb $0xc, 0x6(%rdi)
jne 0xa2745
testb $0x4, 0x6(%r15)
je 0xa2734
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa2783
testb %al, %al
jne 0xa273f
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa26f4
movq 0x10(%r15), %r15
jmp 0xa2702
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: arglist_has_rest
static bool arglist_has_rest(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer p;
                    for (p = args; is_pair(p); p = cdr(p))
                        if (car(p) == sc->key_rest_symbol)
                            return(true);
                    return(!is_null(p));
                }

// Assembly:
cmpb $0x1, (%rsi)
jne 0xa2775
movq 0x8(%rsi), %rax
cmpq 0x1890(%rdi), %rax
je 0xa2780
movq 0x10(%rsi), %rsi
jmp 0xa275d
cmpq 0x110(%rdi), %rsi
setne %al
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa38ea
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 0xa38c9
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
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 0x92375
// File: /workspace/github_c_makefile_star2_O2/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 0xa39bb
movq 0x10(%rcx), %rdx
movq 0x8(%rdx), %rsi
cmpq %rsi, %rax
je 0xa39d2
cmpb $0x8, (%rsi)
jne 0xa39da
movq 0x120(%rdi), %rax
retq
movq 0xdb8(%rdi), %rdx
pushq $0x8
popq %r8
pushq $0x1
popq %r9
movq %rax, %rsi
jmp 0xcd70
movq 0x118(%rdi), %rax
retq
movq 0xdb8(%rdi), %rdx
pushq $0x8
popq %r8
pushq $0x2
popq %r9
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/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 0xa3a11
cmpb $0x8, (%rax)
jne 0xa3a19
movq 0x120(%rdi), %rax
retq
movq 0x118(%rdi), %rax
retq
movq 0x8(%rcx), %rsi
movq 0xdb8(%rdi), %rdx
pushq $0x8
popq %r8
pushq $0x1
popq %r9
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/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 0xa3a8e
cmpl $0xc, %eax
je 0xa3a60
cmpl $0xd, %eax
jne 0xa3aa6
xorl %eax, %eax
ucomisd 0x8(%rsi), %xmm0
jmp 0xa3a9a
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 0xa3a9a
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 0xcd70
// File: /workspace/github_c_makefile_star2_O2/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 0xa3aef
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 0xa3a31
// File: /workspace/github_c_makefile_star2_O2/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 0xa3b68
cmpl $0xc, %edx
je 0xa3b51
cmpl $0xb, %edx
jne 0xa3b81
xorl %ecx, %ecx
cmpq %rsi, 0x8(%rax)
setge %cl
jmp 0xa3b77
movq %rax, %rdi
callq 0xa5c4e
xorb $0x1, %al
movzbl %al, %eax
movq 0x118(%rbx,%rax,8), %rax
jmp 0xa3b7f
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
pushq $0xd
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_less_x0
static s7_pointer g_less_x0(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer x;
        x = car(args);
        if (is_t_integer(x))
            return(make_boolean(sc, integer(x) < 0));
        if (is_real(x))
            return(make_boolean(sc, s7_is_negative(x)));
        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), %rsi
movzbl (%rsi), %eax
cmpq $0xb, %rax
jne 0xa3bbc
xorl %eax, %eax
cmpq $0x0, 0x8(%rsi)
setns %al
jmp 0xa3bd6
leaq 0x75ded(%rip), %rdx     # 0x1199b0
cmpb $0x1, (%rax,%rdx)
jne 0xa3be0
movq %rsi, %rdi
callq 0xa5cc2
xorb $0x1, %al
movzbl %al, %eax
movq 0x118(%rbx,%rax,8), %rax
popq %rbx
retq
movq 0x12c0(%rbx), %rdx
pushq $0xd
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
popq %rbx
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_lt_ti
static s7_pointer fx_lt_ti(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_integer(x)) return(make_boolean(sc, integer(x) < integer(opt2_con(cdr(arg)))));
                    return(g_less_xi(sc, set_plist_2(sc, x, caddr(arg))));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0xb, (%rax)
jne 0xa3c27
movq 0x8(%rax), %rax
movq 0x10(%rsi), %rcx
movq 0x20(%rcx), %rcx
xorl %edx, %edx
cmpq 0x8(%rcx), %rax
setge %dl
movq 0x118(%rdi,%rdx,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 0xa3b1d
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_geq_xf
static s7_pointer g_geq_xf(s7_scheme *sc, s7_pointer args)
    {
        s7_double y;
        s7_pointer x;

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

        if (is_t_real(x))
            return(make_boolean(sc, real(x) >= y));
        return(g_geq_2(sc, args));
    }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0xd, (%rax)
jne 0x8df56
movq 0x10(%rsi), %rcx
movq 0x8(%rcx), %rcx
movsd 0x8(%rax), %xmm0
xorl %eax, %eax
ucomisd 0x8(%rcx), %xmm0
setb %al
movq 0x118(%rdi,%rax,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_geq_tf
static s7_pointer fx_geq_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_geq_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 0xa3cb3
movsd 0x8(%rax), %xmm0
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rax
xorl %ecx, %ecx
ucomisd 0x8(%rax), %xmm0
setb %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 0xa3c55
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_geq_xi
static s7_pointer g_geq_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->geq_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 0xa3d2a
cmpl $0xc, %edx
je 0xa3d1d
cmpl $0xb, %edx
jne 0xa3d47
xorl %ecx, %ecx
cmpq %rsi, 0x8(%rax)
setl %cl
movq 0x118(%rbx,%rcx,8), %rax
jmp 0xa3d45
movq %rax, %rdi
callq 0xa5c4e
movzbl %al, %eax
jmp 0xa3d3d
movsd 0x8(%rax), %xmm0
cvtsi2sd %rsi, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setb %al
movq 0x118(%rbx,%rax,8), %rax
popq %rbx
retq
movq 0xf48(%rbx), %rdx
pushq $0xd
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_leq_xi
static s7_pointer g_leq_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_leq_pi(x, y)));
        return(method_or_bust(sc, x, sc->leq_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 0xa3e0a
cmpl $0xc, %edx
je 0xa3df3
cmpl $0xb, %edx
jne 0xa3e23
xorl %ecx, %ecx
cmpq %rsi, 0x8(%rax)
setg %cl
jmp 0xa3e19
movq %rax, %rdi
callq 0xa5ce5
xorb $0x1, %al
movzbl %al, %eax
movq 0x118(%rbx,%rax,8), %rax
jmp 0xa3e21
cvtsi2sd %rsi, %xmm0
xorl %ecx, %ecx
ucomisd 0x8(%rax), %xmm0
setb %cl
movq 0x118(%rbx,%rcx,8), %rax
popq %rbx
retq
movq 0x1220(%rbx), %rdx
pushq $0xd
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0xcd70