LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
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 0xcdf11
jle 0xcdf0c
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdi
cmpq %rdi, %rsi
jl 0xcdeff
cmpq %rsi, %rdi
jne 0xcdf7b
movq 0x18(%rax), %rax
movq 0x10(%rax), %r15
cmpq 0x18(%r14), %r15
je 0xcdf6e
testq %r15, %r15
je 0xcdf60
movzwl (%r15), %eax
andl $0x10ff, %eax           # imm = 0x10FF
cmpw %dx, %ax
jne 0xcdf60
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa0ae3
movl 0x28(%r15), %eax
testl %eax, %eax
sets %cl
addl %eax, %eax
cmpl %ebp, %eax
setge %al
orb %cl, %al
je 0xcdf60
addq $0x18, %r14
movb $0x1, %al
movq %r14, %rbx
jmp 0xcdf69
addq $0x1ed8, %rbx           # imm = 0x1ED8
xorl %eax, %eax
movq %r15, (%rbx)
jmp 0xcdf70
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1c, (%rcx)
jne 0xcdfaf
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %sil
je 0xcdf9d
cmpq %rax, 0x8(%rdi)
je 0xcdf99
movq 0x18(%rdi), %rdi
jmp 0xcdf84
movq 0x10(%rdi), %r15
testb %sil, %sil
je 0xcdf19
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xcdf80
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xcdf15
xorl %r15d, %r15d
jmp 0xcdf19
// File: /workspace/github_c_makefile_star2_O1/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 0xce267
leaq 0x52506(%rip), %rax     # 0x120726
movq %rax, 0x10(%r15)
movq $0x1e, 0x8(%r15)
movq 0x10(%rbx), %rdx
movq 0x110(%rbx), %rsi
movq %rbx, %rdi
callq 0xa000b
movq %rax, 0x10(%rbx)
movq (%rbx), %rcx
movq 0x110(%rbx), %rdx
cmpq %rax, %rdx
je 0xce28e
movq %rax, %rdi
movq %rdi, %rsi
movq 0x10(%rdi), %rdi
cmpq %rdx, %rdi
jne 0xce255
movq %rcx, 0x10(%rsi)
jmp 0xce291
leaq 0x527c6(%rip), %rax     # 0x120a34
movq %rax, 0x10(%r15)
movq $0x1f, 0x8(%r15)
movq 0x6d8(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x6d8(%rbx), %rdx
jmp 0xce2b2
movq %rcx, %rax
movq 0x6e0(%rbx), %rcx
movq %r15, 0x8(%rcx)
movq 0x6e0(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3b366
// File: /workspace/github_c_makefile_star2_O1/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 0xd28a2
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 0x4f06c(%rip), %rcx     # 0x1218d9
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 0x3b366
cmpq %r14, 0x150(%rbx)
je 0xd28fb
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 0xd2906
movq 0x8(%rax), %rcx
movq 0x20(%rcx), %rdx
cmpq 0x250(%rbx), %rdx
je 0xd28f5
movq %rax, 0x18(%rcx)
movq 0x250(%rbx), %rdx
movq %rdx, 0x20(%rcx)
incl 0x28(%rcx)
movq 0x18(%rax), %rax
jmp 0xd28cd
movq 0x110(%rbx), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9a55
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x99ef
cmpq 0x128(%rbx), %rax
je 0xd2ac4
movq %rax, %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xd2a89
movq %rbx, %rdi
callq 0xb389
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 0xbd41
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd31df
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
cmpq 0x120(%rbx), %rax
je 0xd319c
movq 0x8(%r14), %rax
movq 0x10(%rax), %r14
movq 0x10(%r14), %rax
cmpb $0x1, (%rax)
jne 0xd31ee
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x10(%r14), %r14
jmp 0xd31c5
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_O1/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 0xd348e
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xd3495
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
je 0xd346e
jmp 0xd3495
movq 0x118(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd372b
jle 0xd3726
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xd3719
cmpq %rdx, %rsi
jne 0xd3787
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x568(%rbx), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
cmpq 0x120(%rbx), %rax
je 0xd3764
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
cmpb $0x1c, (%rcx)
jne 0xd37b7
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %sil
je 0xd37a9
cmpq %rax, 0x8(%rdi)
je 0xd37a5
movq 0x18(%rdi), %rdi
jmp 0xd3790
movq 0x10(%rdi), %rdx
testb %sil, %sil
je 0xd3733
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xd378c
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xd372f
xorl %edx, %edx
jmp 0xd3733
// File: /workspace/github_c_makefile_star2_O1/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 0xd3897
movq 0x10(%r14), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xd389f
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_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0xd38e6
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq *0x20(%r15)
cmpq 0x120(%r14), %rax
cmovneq %rax, %rbx
je 0xd38c2
jmp 0xd38ed
movq 0x120(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20(%rdi), %rcx
movzbl (%rcx), %eax
leaq 0x8757a(%rip), %rdx     # 0x15b0a0
cmpb $0x1, (%rax,%rdx)
jne 0xd3b48
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xd3b48
cmpq %rcx, 0x20(%rax)
jne 0xd3b33
addq $0x18, %rax
jmp 0xd3b53
movq (%rdi), %rax
movq 0x10(%rax), %rax
addq $0x28, %rax
movq (%rax), %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20(%rdi), %rcx
cmpb $0xa, (%rcx)
jne 0xd3b7f
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xd3b7f
cmpq %rcx, 0x20(%rax)
jne 0xd3b6a
addq $0x18, %rax
jmp 0xd3b8a
movq (%rdi), %rax
movq 0x10(%rax), %rax
addq $0x28, %rax
movq (%rax), %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd3c3f
movq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x42c67
testb %al, %al
je 0xd3c1f
addq $0x18, %r15
jmp 0xd3c46
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_O1/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 0xd3dc9
retq
pushq %rax
addq $0x5b0, %rdi            # imm = 0x5B0
movl $0x5, %esi
callq 0x9530
// File: /workspace/github_c_makefile_star2_O1/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 0xd4d3e
cmpw $0x801, (%rbx)          # imm = 0x801
jne 0xd4d2f
testb $0x1, 0x4(%rbx)
jne 0xd4d2f
movw $0x1, (%rbx)
movw $0x0, 0x4(%rbx)
movq 0x10(%rbx), %rdi
callq 0xd4d0e
movq 0x8(%rbx), %rbx
jmp 0xd4d12
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9350
testl %eax, %eax
je 0xd545e
xorl %eax, %eax
jmp 0xd5493
movl $0x0, 0x2258(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa8bbb
leaq -0x105c7(%rip), %rcx    # 0xc4eb4
leaq -0x105bb(%rip), %rdx    # 0xc4ec7
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_O1/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:
incl 0xa88(%rdi)
jne 0xd54b0
movl $0x1, 0xa88(%rdi)
incl 0xa8c(%rdi)
movq 0x18d8(%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 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 0xd5599
// File: /workspace/github_c_makefile_star2_O1/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 0xd55c6
cmpl $0xa, %eax
jne 0xd55d5
movl 0x2c(%rsi), %eax
cmpl 0xa88(%rdi), %eax
jne 0xd55d5
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 0xd55d5
jmp 0xd55d8
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd561a
cmpl $0xa, %eax
jne 0xd5638
movl 0x2c(%rsi), %ecx
cmpl 0xa88(%rbx), %ecx
jne 0xd5616
movq 0x8(%rsi), %rcx
movq 0x20(%rcx), %rcx
movl 0xc(%rcx), %edx
movl $0x1, %ecx
cmpl 0xa8c(%rbx), %edx
je 0xd5648
cmpb $0x1, %al
jne 0xd5638
movq 0x8(%rsi), %rax
cmpq 0x17b0(%rbx), %rax
je 0xd5638
movq %rbx, %rdi
callq 0xd55d8
movl $0x1, %ecx
testb %al, %al
jne 0xd5648
movq 0x10(%r14), %r14
xorl %eax, %eax
cmpb $0x1, (%r14)
setne %al
leal (%rax,%rax,2), %ecx
testl %ecx, %ecx
je 0xd55e2
cmpl $0x1, %ecx
jne 0xd5655
movb $0x1, %al
jmp 0xd567f
cmpb $0xa, (%r14)
jne 0xd567d
movl 0x2c(%r14), %eax
cmpl 0xa88(%rbx), %eax
jne 0xd567d
movq 0x8(%r14), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%rbx), %eax
sete %al
jmp 0xd567f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %rbx
movq 0x28(%rbx), %r14
testb $0x20, 0x2(%rbx)
jne 0xd5724
movq 0x120(%r15), %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x3c5b5
movq %rax, 0x520(%r15)
jmp 0xd572c
movq 0x8(%rbx), %rax
movq 0x60(%rax), %rax
movq %rax, %r12
cmpl $0x1, %ebp
jne 0xd5744
movq 0x10(%r15), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %r12
movq %rax, (%rsp)
movq 0x8(%rbx), %rax
movq 0x50(%rax), %r13
testb $0x4, 0x2(%rbx)
jne 0xd5817
cmpl %ebp, %r14d
jle 0xd5839
movslq %ebp, %rbp
movq (%r13,%rbp,8), %rsi
movzbl (%rsi), %eax
cmpl $0x1, %eax
je 0xd57b4
cmpl $0xa, %eax
jne 0xd57c5
movq 0x8(%r15), %rcx
movq 0x18(%rcx), %rdx
movq 0x20(%rsi), %rax
cmpq %rax, %rdx
je 0xd579d
jle 0xd5798
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdx
cmpq %rdx, %rax
jl 0xd578b
cmpq %rax, %rdx
jne 0xd57dc
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xd57c8
movq %r15, %rdi
callq 0xa2ee9
jmp 0xd57c8
movq 0x110(%r15), %rdx
movq %r15, %rdi
callq 0x39527
jmp 0xd57c8
movq %rsi, %rax
movq %rax, 0x8(%r12)
incq %rbp
movq 0x10(%r12), %r12
cmpl %r14d, %ebp
jne 0xd5766
jmp 0xd5839
cmpb $0x1c, (%rcx)
jne 0xd580a
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %dl
je 0xd57fd
cmpq %rsi, 0x8(%rdi)
je 0xd57f9
movq 0x18(%rdi), %rdi
jmp 0xd57e5
movq 0x10(%rdi), %rax
testb %dl, %dl
je 0xd57a5
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xd57e1
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
je 0xd57a1
xorl %eax, %eax
jmp 0xd57a5
cmpl %ebp, %r14d
jle 0xd5839
movslq %ebp, %rax
movslq %r14d, %rcx
movq (%r13,%rax,8), %rdx
movq %rdx, 0x8(%r12)
incq %rax
movq 0x10(%r12), %r12
cmpq %rax, %rcx
jne 0xd5822
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x40000000, 0x28(%rsi) # imm = 0x40000000
jne 0xd587f
movq 0x8(%rsi), %rcx
xorl %eax, %eax
cmpb $0x1, (%rcx)
jne 0xd586d
xorl %eax, %eax
incl %eax
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
je 0xd5862
cmpq 0x110(%rdi), %rcx
je 0xd587c
testl %eax, %eax
je 0xd5883
negl %eax
movl %eax, 0x28(%rsi)
movl 0x28(%rsi), %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd58ff
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %r8
movq 0x20(%rax), %rsi
movl $0x18, %ecx
cmpq %rsi, %r8
je 0xd58f6
jle 0xd58ba
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r8
cmpq %r8, %rsi
jl 0xd58ad
cmpq %rsi, %r8
je 0xd58f6
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xd58f6
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
sete %r9b
je 0xd58e2
cmpq %rax, 0x8(%rsi)
je 0xd58e5
movq 0x18(%rsi), %rsi
jmp 0xd58cd
movq %r8, %rsi
testb %r9b, %r9b
je 0xd58fa
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %rsi, %r8
je 0xd58c9
movq (%rax,%rcx), %rsi
cmpb $0x20, (%rsi)
jne 0xd5900
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 0x4bb8a(%rip), %rcx     # 0x1214b5
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 0x3b366
// File: /workspace/github_c_makefile_star2_O1/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 0xd5997
testb $0x1, 0x2(%rsi)
je 0xd597c
movq 0x10(%rsi), %rcx
movb $0x1, %al
testb $0x1, 0x3(%rcx)
jne 0xd5999
movq 0x8(%rdi), %rax
cmpb $0x1c, (%rax)
jne 0xd599a
testb $0x20, 0x3(%rax)
je 0xd5991
cmpq %rsi, 0x20(%rax)
jne 0xd5997
movq 0x10(%rax), %rax
jmp 0xd5980
xorl %eax, %eax
retq
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdi
movq 0x20(%rsi), %rdx
movl $0x18, %eax
cmpq %rdx, %rdi
je 0xd59fb
jle 0xd59bf
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdi
cmpq %rdi, %rdx
jl 0xd59b2
cmpq %rdx, %rdi
je 0xd59fb
movl $0x10, %eax
cmpb $0x1c, (%rcx)
jne 0xd59fb
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
sete %r8b
je 0xd59e7
cmpq %rsi, 0x8(%rdx)
je 0xd59ea
movq 0x18(%rdx), %rdx
jmp 0xd59d2
movq %rdi, %rdx
testb %r8b, %r8b
je 0xd59ff
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
movq %rdx, %rdi
je 0xd59ce
movq (%rsi,%rax), %rdx
movb 0x3(%rdx), %al
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd5a25
cmpw $0x801, (%rsi)          # imm = 0x801
jne 0xd5a26
movzwl 0x4(%rsi), %ecx
leaq 0x856c2(%rip), %rdx     # 0x15b0e0
cmpq $0x0, (%rdx,%rcx,8)
je 0xd5a26
retq
cmpb $0x1, (%rsi)
jne 0xd5a50
movq 0x8(%rsi), %rax
cmpq 0x17b0(%rdi), %rax
jne 0xd5a50
movq 0x10(%rsi), %rax
cmpb $0x1, (%rax)
jne 0xd5a50
movq 0x10(%rax), %rax
cmpq 0x110(%rdi), %rax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd5aef
movq 0x8(%r15), %rax
cmpb $0xa, (%rax)
jne 0xd5ac1
testb $0xc, 0x6(%rax)
jne 0xd5aef
testb $0x4, 0x6(%r15)
je 0xd5ada
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd5af5
testb %al, %al
jne 0xd5ae9
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd5a9e
movq 0x10(%r15), %r15
jmp 0xd5aac
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd6b77
jle 0xd6b72
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xd6b65
cmpq %rdx, %r8
jne 0xd6b97
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x578(%rdi), %rax
movq %rdx, 0x8(%rax)
movq 0x20(%rsi), %rax
movq 0x570(%rdi), %rsi
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xd6bc7
movq 0x8(%rcx), %r9
testq %r9, %r9
sete %r8b
je 0xd6bb9
cmpq %rax, 0x8(%r9)
je 0xd6bb5
movq 0x18(%r9), %r9
jmp 0xd6ba0
movq 0x10(%r9), %rdx
testb %r8b, %r8b
je 0xd6b7f
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xd6b9c
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xd6b7b
xorl %edx, %edx
jmp 0xd6b7f
// File: /workspace/github_c_makefile_star2_O1/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 0xd6c18
jle 0xd6c13
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xd6c06
cmpq %rdx, %r8
jne 0xd6c4b
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x590(%rdi), %rax
movq %rdx, 0x8(%rax)
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 0xd6c7b
movq 0x8(%rcx), %r9
testq %r9, %r9
sete %r8b
je 0xd6c6d
cmpq %rax, 0x8(%r9)
je 0xd6c69
movq 0x18(%r9), %r9
jmp 0xd6c54
movq 0x10(%r9), %rdx
testb %r8b, %r8b
je 0xd6c20
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xd6c50
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xd6c1c
xorl %edx, %edx
jmp 0xd6c20
// File: /workspace/github_c_makefile_star2_O1/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 0xd6d03
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 0xd6cdb
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
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 0xc1df8
// File: /workspace/github_c_makefile_star2_O1/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 0xd6dd4
movq 0x10(%rcx), %rdx
movq 0x8(%rdx), %rsi
cmpq %rsi, %rax
je 0xd6def
cmpb $0x8, (%rsi)
jne 0xd6df7
movq 0x120(%rdi), %rax
retq
movq 0xdb8(%rdi), %rdx
movq %rax, %rsi
movl $0x8, %r8d
movl $0x1, %r9d
jmp 0xf1ae
movq 0x118(%rdi), %rax
retq
movq 0xdb8(%rdi), %rdx
movl $0x8, %r8d
movl $0x2, %r9d
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 0xd6e32
cmpb $0x8, (%rax)
jne 0xd6e3a
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 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 0xd6eb3
cmpl $0xc, %eax
je 0xd6e85
cmpl $0xd, %eax
jne 0xd6ecb
xorl %eax, %eax
ucomisd 0x8(%rsi), %xmm0
jmp 0xd6ebf
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 0xd6ebf
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 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 0xd6f14
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 0xd6e56
// File: /workspace/github_c_makefile_star2_O1/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 0xd6f8d
cmpl $0xc, %edx
je 0xd6f76
cmpl $0xb, %edx
jne 0xd6fa6
xorl %ecx, %ecx
cmpq %rsi, 0x8(%rax)
setge %cl
jmp 0xd6f9c
movq %rax, %rdi
callq 0xd9bd7
xorb $0x1, %al
movzbl %al, %eax
movq 0x118(%rbx,%rax,8), %rax
jmp 0xd6fa4
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 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
cmpq $0xb, %rax
jne 0xd6fe1
xorl %eax, %eax
cmpq $0x0, 0x8(%rsi)
setns %al
jmp 0xd702c
leaq 0x7b9c8(%rip), %rdx     # 0x1529b0
cmpb $0x1, (%rax,%rdx)
jne 0xd7003
cmpq $0xc, %rax
je 0xd6ff9
cmpl $0xb, %eax
jne 0xd701b
movq 0x8(%rsi), %rax
shrq $0x3f, %rax
jmp 0xd7027
movq 0x12c0(%rdi), %rdx
movl $0xd, %r8d
movl $0x1, %r9d
jmp 0xf1ae
xorpd %xmm0, %xmm0
ucomisd 0x8(%rsi), %xmm0
seta %al
xorb $0x1, %al
movzbl %al, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd7064
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 0xd6f42
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%rax), %rax
cmpb $0xd, (%rsi)
movq 0x8(%rax), %rdx
jne 0xd70bb
movsd 0x8(%rsi), %xmm0
xorl %eax, %eax
ucomisd 0x8(%rdx), %xmm0
setb %al
jmp 0xd70c8
movq %rbx, %rdi
callq 0x906bc
xorb $0x1, %al
movzbl %al, %eax
leaq 0x118(,%rax,8), %rax
movq (%rbx,%rax), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd7107
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 0xd7092
// File: /workspace/github_c_makefile_star2_O1/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 0xd717e
cmpl $0xc, %edx
je 0xd7171
cmpl $0xb, %edx
jne 0xd719b
xorl %ecx, %ecx
cmpq %rsi, 0x8(%rax)
setl %cl
movq 0x118(%rbx,%rcx,8), %rax
jmp 0xd7199
movq %rax, %rdi
callq 0xd9bd7
movzbl %al, %eax
jmp 0xd7191
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
movq %rbx, %rdi
movq %rax, %rsi
movl $0xd, %r8d
movl $0x1, %r9d
popq %rbx
jmp 0xf1ae