LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_call_with_location
s7_pointer s7_call_with_location(s7_scheme *sc, s7_pointer func, s7_pointer args, const char *caller, const char *file, s7_int line)
                {
                    s7_pointer result;

                    if (caller)
                    {
                        sc->s7_call_name = caller;
                        sc->s7_call_file = file;
                        sc->s7_call_line = line;
                    }
                    result = s7_call(sc, func, args);
                    if (caller)
                    {
                        sc->s7_call_name = NULL;
                        sc->s7_call_file = NULL;
                        sc->s7_call_line = -1;
                    }
                    return(result);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
testq %rcx, %rcx
je 0x471e6
movq %r14, 0x6b8(%rbx)
movq %r8, 0x6b0(%rbx)
movq %r9, 0x698(%rbx)
movq %rbx, %rdi
callq 0x466aa
testq %r14, %r14
je 0x47208
xorps %xmm0, %xmm0
movups %xmm0, 0x6b0(%rbx)
movq $-0x1, 0x698(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_quit
void s7_quit(s7_scheme *sc)
                {
                    sc->longjmp_ok = false;
                    pop_input_port(sc);
                    stack_reset(sc);
                    push_stack_op_let(sc, OP_EVAL_DONE);
                }

// Assembly:
movb $0x0, 0x678(%rdi)
movl 0x184(%rdi), %eax
testl %eax, %eax
je 0x47242
decl %eax
movl %eax, 0x184(%rdi)
shlq $0x3, %rax
addq 0x178(%rdi), %rax
jmp 0x47249
leaq 0x1c8(%rdi), %rax
movq (%rax), %rax
movq %rax, 0x170(%rdi)
movq 0x48(%rdi), %rax
movq %rax, 0x50(%rdi)
movl $0x1df, %ecx            # imm = 0x1DF
movq %rcx, 0x18(%rax)
movq 0x50(%rdi), %rax
leaq 0x20(%rax), %rdx
movq %rdx, 0x50(%rdi)
movq $0x203, 0x38(%rax)      # imm = 0x203
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rdx
leaq 0x20(%rdx), %rsi
movq %rsi, 0x50(%rdi)
movq %rax, 0x28(%rdx)
movq 0x50(%rdi), %rax
movq %rcx, 0x18(%rax)
addq $0x20, 0x50(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_d_function
static void *opt_func(s7_pointer f, opt_func_t typ)
                {
                    if (is_c_function(f))
                    {
                        opt_funcs *p;
                        for (p = c_function_opt_data(f); p; p = p->next)
                            if (p->typ == typ)
                                return(p->func);
                    }
#if S7_DEBUGGING
                    else fprintf(stderr, "%s[%d]: 'f' is not a c_function\n", __func__, __LINE__);
#endif
                    return(NULL);
                }

// Assembly:
cmpb $0x30, (%rdi)
jb 0x472ff
movq 0x8(%rdi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
sete %cl
je 0x472f5
cmpl $0xb, (%rax)
je 0x472f7
movq 0x10(%rax), %rax
jmp 0x472e2
jmp 0x472fb
movq 0x8(%rax), %rax
testb %cl, %cl
je 0x47301
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_float_optimize
s7_float_function s7_float_optimize(s7_scheme *sc, s7_pointer expr)
                {
#if WITH_GMP
                    return(NULL);
#endif
                    if (setjmp(sc->opt_exit) == 0)
                    {
                        sc->pc = 0;
                        reset_opts(sc);
                        if (float_optimize(sc, expr))
                            return(opt_float_any);
                    }
                    return(NULL);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x2190, %rdi           # imm = 0x2190
callq 0x9350
testl %eax, %eax
jne 0x47b8c
movl $0x0, 0x2258(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x47b96
testb %al, %al
je 0x47b8c
leaq 0x967(%rip), %rax       # 0x484f1
jmp 0x47b8e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_optimize_1
static s7_function s7_optimize_1(s7_scheme *sc, s7_pointer expr, bool nr)
                {
#if WITH_GMP
                    return(NULL);
#endif
                    if ((!is_pair(expr)) || (no_cell_opt(expr)))
                        return(NULL);

                    if (setjmp(sc->opt_exit) == 0)
                    {
                        sc->pc = 0;
                        reset_opts(sc);
                        if (!no_int_opt(expr))
                        {
                            if (int_optimize(sc, expr))
                                return((nr) ? opt_int_any_nr : opt_wrap_int);
                            pc_fallback(sc, 0);
                            set_no_int_opt(expr);
                        }
                        if (!no_float_opt(expr))
                        {
                            if (float_optimize(sc, expr))
                                return((nr) ? opt_float_any_nr : opt_wrap_float);
                            pc_fallback(sc, 0);
                            set_no_float_opt(expr);
                        }
                        if (!no_bool_opt(expr))
                        {
                            if (bool_optimize_nw(sc, expr))
                                return((nr) ? opt_bool_any_nr : opt_wrap_bool);
                            pc_fallback(sc, 0);
                            set_no_bool_opt(expr);
                        }
                        if (cell_optimize(sc, expr))
                            return((nr) ? opt_cell_any_nr : opt_wrap_cell);
                        set_no_cell_opt(expr); /* checked elsewhere */
                    }
                    return(NULL);
                }

// Assembly:
cmpb $0x1, (%rsi)
jne 0x48536
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
testb $0x4, 0x3(%rsi)
jne 0x4852f
movl %edx, %ebp
movq %rdi, %r14
addq $0x2190, %rdi           # imm = 0x2190
callq 0x9350
testl %eax, %eax
je 0x48539
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
movl $0x0, 0x2258(%r14)
testb $0x2, 0x3(%rbx)
jne 0x4857b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa66f0
testb %al, %al
je 0x4856c
leaq 0x7c80c(%rip), %rax     # 0xc4d6c
leaq 0x7c81d(%rip), %rcx     # 0xc4d84
jmp 0x48600
movl $0x0, 0x2258(%r14)
orb $0x2, 0x3(%rbx)
testb $-0x80, 0x2(%rbx)
jne 0x485af
movq %r14, %rdi
movq %rbx, %rsi
callq 0x47b96
testb %al, %al
je 0x485a0
leaq 0x7c860(%rip), %rax     # 0xc4df7
leaq 0x7c871(%rip), %rcx     # 0xc4e0f
jmp 0x48600
movl $0x0, 0x2258(%r14)
orb $-0x80, 0x2(%rbx)
testb $0x8, 0x3(%rbx)
jne 0x485e3
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb0bfb
testb %al, %al
je 0x485d4
leaq 0x7c8ab(%rip), %rax     # 0xc4e76
leaq 0x7c8bc(%rip), %rcx     # 0xc4e8e
jmp 0x48600
movl $0x0, 0x2258(%r14)
orb $0x8, 0x3(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa8bbb
testb %al, %al
je 0x4860f
leaq 0x7c8bb(%rip), %rax     # 0xc4eb4
leaq 0x7c8c7(%rip), %rcx     # 0xc4ec7
testb %bpl, %bpl
cmovneq %rax, %rcx
movq %rcx, %rax
jmp 0x48531
orb $0x4, 0x3(%rbx)
jmp 0x4852f
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_values
s7_pointer s7_values(s7_scheme *sc, s7_pointer args)
                {
#define H_values "(values obj ...) splices its arguments into whatever list holds it (its 'continuation')"
#define Q_values s7_make_circular_signature(sc, 1, 2, sc->values_symbol, sc->T)

                    if (is_null(args))         /* ((lambda () (let ((x 1)) (set! x (boolean? (values)))))) */
                        return(sc->no_value);
                    if (is_null(cdr(args)))
                        return(car(args));
                    set_needs_copied_args(args);
                    return(splice_in_values(sc, args));
                }

// Assembly:
movq 0x110(%rdi), %rax
cmpq %rsi, %rax
je 0x4863d
cmpq %rax, 0x10(%rsi)
je 0x48645
orb $0x10, 0x3(%rsi)
jmp 0x37e41
movq 0x138(%rdi), %rax
retq
movq 0x8(%rsi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_unique
static s7_pointer make_unique(s7_scheme *sc, const char* name, uint64_t typ)
                {
                    s7_pointer p;
                    p = alloc_pointer(sc);
                    set_type(p, typ | T_IMMUTABLE | T_UNHEAP);
                    unique_name_length(p) = safe_strlen(name);
                    unique_name(p) = copy_string_with_length(name, unique_name_length(p));
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
callq 0xfa3b
movq %rax, %rbx
movabsq $0x4000000001000000, %rax # imm = 0x4000000001000000
orq %r15, %rax
movq %rax, (%rbx)
testq %r14, %r14
je 0x612e7
cmpb $0x0, (%r14)
je 0x612e7
movq $-0x1, %rax
leaq 0x1(%rax), %r15
cmpb $0x0, 0x1(%r14,%rax)
movq %r15, %rax
jne 0x612d6
jmp 0x612ea
xorl %r15d, %r15d
movq %r15, 0x28(%rbx)
leaq 0x1(%r15), %rdi
callq 0x9480
movq %rax, %r12
testq %r15, %r15
je 0x6130d
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x93e0
movb $0x0, (%r12,%r15)
movq %r12, 0x20(%rbx)
movq %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: define_bool_function
static s7_pointer define_bool_function(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int optional_args, const char *doc, s7_pointer signature, int32_t sym_to_type,
                        void (*marker)(s7_pointer p, s7_int top),
                        bool simple, s7_function bool_setter)
                {
                    s7_pointer func, sym;
                    func = s7_make_typed_function(sc, name, fnc, 1, optional_args, false, doc, signature);
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    if (sym_to_type != T_FREE)
                        symbol_set_type(sym, sym_to_type);
                    c_function_symbol(func) = sym;
                    c_function_set_marker(func, marker);
                    if (simple) c_function_set_has_simple_elements(func);
                    c_function_set_bool_setter(func, s7_make_function(sc, name, bool_setter, 2, 0, false, NULL));
                    c_function_set_has_bool_setter(func);
                    return(sym);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %rcx, %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %r8, (%rsp)
movl $0x1, %ecx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x403e5
movq %rax, %r15
orb $0x20, 0x2(%rax)
testq %r12, %r12
je 0x61554
movq 0x8(%r15), %rax
movq %r12, 0x38(%rax)
movb 0x50(%rsp), %r13b
movq 0x48(%rsp), %rbp
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaa9f
movq %rax, %r12
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xce9d
movl 0x40(%rsp), %ecx
testl %ecx, %ecx
je 0x61595
movq 0x8(%r12), %rax
movq 0x20(%rax), %rax
movb %cl, 0x10(%rax)
movq 0x58(%rsp), %rdx
movq 0x8(%r15), %rax
movq %r12, 0x58(%rax)
movq 0x8(%r15), %rax
movq %rbp, 0x60(%rax)
testb %r13b, %r13b
je 0x615b4
orb $0x1, 0x7(%r15)
movq $0x0, (%rsp)
movl $0x2, %ecx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x403e5
movq 0x8(%r15), %rcx
movq %rax, 0x50(%rcx)
orb $0x2, 0x6(%r15)
movq %r12, %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: mark_symbol_vector
static void mark_symbol_vector(s7_pointer p, s7_int len)
    {
        set_mark(p);
        if (mark_function[T_SYMBOL] != mark_noop) /* else no gensyms */
        {
            s7_int i;
            s7_pointer *e;
            e = vector_elements(p);
            for (i = 0; i < len; i++)
                if (is_gensym(e[i]))
                    set_mark(e[i]);
        }
    }

// Assembly:
orb $-0x80, 0x7(%rdi)
leaq 0x312a2(%rip), %rax     # 0x928d2
cmpq %rax, 0xed189(%rip)     # 0x14e7c0
je 0x6166a
testq %rsi, %rsi
jle 0x6166a
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq 0x10(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rdi
movq (%rdi), %r8
btl $0x1d, %r8d
jae 0x61662
orq %rax, %r8
movq %r8, (%rdi)
incq %rdx
cmpq %rdx, %rsi
jne 0x6164e
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: mark_vector_1
static void mark_vector_1(s7_pointer p, s7_int top)
    {
        s7_pointer *tp, *tend, *tend4;

        set_mark(p);

        tp = (s7_pointer *)(vector_elements(p));
        if (!tp) return;
        tend = (s7_pointer *)(tp + top);

        tend4 = (s7_pointer *)(tend - 8);
        while (tp <= tend4)
            LOOP_8(gc_mark(*tp++));
        while (tp < tend)
            gc_mark(*tp++);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
orb $-0x80, 0x7(%rdi)
movq 0x10(%rdi), %r13
testq %r13, %r13
je 0x61b52
leaq (,%rsi,8), %rbx
addq %r13, %rbx
leaq -0x40(,%rsi,8), %r14
addq %r13, %r14
cmpq %r14, %r13
ja 0x61b2c
leaq 0xecceb(%rip), %r15     # 0x14e770
movq %r13, %r12
movq (%r13), %rdi
cmpq $0x0, (%rdi)
js 0x61a99
movzbl (%rdi), %eax
callq *(%r15,%rax,8)
movq 0x8(%r12), %rdi
cmpq $0x0, (%rdi)
js 0x61aab
movzbl (%rdi), %eax
callq *(%r15,%rax,8)
movq 0x10(%r12), %rdi
cmpq $0x0, (%rdi)
js 0x61abd
movzbl (%rdi), %eax
callq *(%r15,%rax,8)
movq 0x18(%r12), %rdi
cmpq $0x0, (%rdi)
js 0x61acf
movzbl (%rdi), %eax
callq *(%r15,%rax,8)
movq 0x20(%r12), %rdi
cmpq $0x0, (%rdi)
js 0x61ae1
movzbl (%rdi), %eax
callq *(%r15,%rax,8)
movq 0x28(%r12), %rdi
cmpq $0x0, (%rdi)
js 0x61af3
movzbl (%rdi), %eax
callq *(%r15,%rax,8)
movq 0x30(%r12), %rdi
cmpq $0x0, (%rdi)
js 0x61b05
movzbl (%rdi), %eax
callq *(%r15,%rax,8)
movq 0x38(%r12), %rdi
cmpq $0x0, (%rdi)
js 0x61b17
movzbl (%rdi), %eax
callq *(%r15,%rax,8)
leaq 0x40(%r12), %r13
cmpq %r14, %r13
jbe 0x61a85
addq $0x40, %r12
movq %r12, %r13
cmpq %rbx, %r13
jae 0x61b52
leaq 0xecc38(%rip), %r14     # 0x14e770
movq (%r13), %rdi
cmpq $0x0, (%rdi)
js 0x61b49
movzbl (%rdi), %eax
callq *(%r14,%rax,8)
addq $0x8, %r13
cmpq %rbx, %r13
jb 0x61b38
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_openlet
static s7_pointer g_is_openlet(s7_scheme *sc, s7_pointer args)
    {
#define H_is_openlet "(openlet? obj) returns #t is 'obj' has methods."
#define Q_is_openlet sc->pl_bt
        s7_pointer e;

        e = car(args);  /* if e is not a let, should this raise an error? -- no, easier to use this way in cond */
        check_method(sc, e, sc->is_openlet_symbol, args);
        return(make_boolean(sc, has_methods(e)));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movb $0x1, %bpl
testb $0x40, 0x3(%r14)
je 0x61d58
cmpb $0x1, 0x24c(%rbx)
jne 0x61d58
movq %rsi, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9a55
movq 0x1130(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%rbx), %rax
je 0x61d58
cmpb $0x1, (%r13)
jne 0x61d7e
movq %rax, 0x10(%rsp)
movq %r13, 0x4c8(%rbx)
movq 0x8(%r13), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r15
cmpq 0x98(%rbx), %rax
ja 0x61c9c
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rax, 0x4e8(%rbx)
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
jne 0x61d37
movq 0x8(%rsp), %rbp
movq 0x8(%r13), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x61d00
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x10(%rbp)
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
movq %rax, %rbp
je 0x61cdd
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
jmp 0x61d85
testb %bpl, %bpl
je 0x61d6f
xorl %eax, %eax
testb $0x40, 0x3(%r14)
sete %al
movq 0x118(%rbx,%rax,8), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbd41
xorl %ebp, %ebp
jmp 0x61d58
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_c_pointer
static s7_pointer g_is_c_pointer(s7_scheme *sc, s7_pointer args)
    {
#define H_is_c_pointer "(c-pointer? obj type) returns #t if obj is a C pointer being held in s7.  If type is given, the c_pointer's type is also checked."
#define Q_is_c_pointer s7_make_signature(sc, 3, sc->is_boolean_symbol, sc->T, sc->T)

        s7_pointer p;
        p = car(args);
        if (!is_c_pointer(p))
        {
            if (!has_active_methods(sc, p)) return(sc->F);
            return(apply_boolean_method(sc, p, sc->is_c_pointer_symbol));
        }
        if (is_pair(cdr(args)))
            return(make_boolean(sc, c_pointer_type(p) == cadr(args)));
        return(sc->T);
    }

// Assembly:
movq %rsi, %rax
movq 0x8(%rsi), %rsi
cmpb $0x21, (%rsi)
jne 0x62091
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x620b4
movq 0x10(%rsi), %rcx
xorl %edx, %edx
cmpq 0x8(%rax), %rcx
setne %dl
movq 0x118(%rdi,%rdx,8), %rax
retq
testb $0x40, 0x3(%rsi)
je 0x620ac
cmpb $0x0, 0x24c(%rdi)
je 0x620ac
movq 0x1000(%rdi), %rdx
jmp 0xd2a3a
movq 0x120(%rdi), %rax
retq
movq 0x118(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: mark_simple_vector
static void mark_simple_vector(s7_pointer p, s7_int len)
    {
        s7_int i;
        s7_pointer *e;
        set_mark(p);
        e = vector_elements(p);
        for (i = 0; i < len; i++)
            set_mark(e[i]);
    }

// Assembly:
orb $-0x80, 0x7(%rdi)
testq %rsi, %rsi
jle 0x6229e
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq 0x10(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rdi
orq %rax, (%rdi)
incq %rdx
cmpq %rdx, %rsi
jne 0x6228f
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_rational
static s7_pointer g_is_rational(s7_scheme *sc, s7_pointer args)
    {
#define H_is_rational "(rational? obj) returns #t if obj is a rational number (either an integer or a ratio)"
#define Q_is_rational sc->pl_bt
        check_boolean_method(sc, s7_is_rational, sc->is_rational_symbol, args);
        /* in the non-gmp case, (rational? 455702434782048082459/86885567283849955830) -> #f, not #t, and similarly for exact? etc. */
    }

// Assembly:
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
leaq 0xeff4c(%rip), %rcx     # 0x1529f0
cmpb $0x1, (%rax,%rcx)
jne 0x62ab2
movq 0x118(%rdi), %rax
retq
testb $0x40, 0x3(%rsi)
je 0x62acd
cmpb $0x0, 0x24c(%rdi)
je 0x62acd
movq 0x1178(%rdi), %rdx
jmp 0xd2a3a
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_list
static s7_pointer g_is_list(s7_scheme *sc, s7_pointer args)
                {
#define H_is_list "(list? obj) returns #t if obj is a pair or null"
#define Q_is_list sc->pl_bt
#define is_a_list(p) s7_is_list(sc, p)
                    check_boolean_method(sc, is_a_list, sc->is_list_symbol, args);
                }

// Assembly:
movq 0x8(%rsi), %rsi
movb (%rsi), %al
decb %al
cmpb $0x1, %al
ja 0x62e60
movq 0x118(%rdi), %rax
retq
testb $0x40, 0x3(%rsi)
je 0x62e7b
cmpb $0x0, 0x24c(%rdi)
je 0x62e7b
movq 0x10f0(%rdi), %rdx
jmp 0xd2a3a
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: b_is_proper_list_setter
static s7_pointer b_is_proper_list_setter(s7_scheme *sc, s7_pointer args)
                {
                    if (s7_is_proper_list(sc, car(args)))
                        return(cadr(args));
                    return(s7_error(sc, sc->wrong_type_arg_symbol,
                                set_elist_5(sc, wrap_string(sc, "set! ~S, ~S is ~A but should be ~A", 34),
                                    car(args), cadr(args), prepackaged_type_names[type(cadr(args))], wrap_string(sc, "a proper list", 13))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0x3c2fb
testb %al, %al
je 0x63931
movq 0x10(%r15), %rax
movq 0x8(%rax), %r14
jmp 0x639f2
movq 0x1940(%rbx), %r14
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0xc0a47(%rip), %rcx     # 0x1243a3
movq %rcx, 0x10(%rax)
movq $0x22, 0x8(%rax)
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rdx
movq 0x8(%rdx), %rdx
movzbl (%rdx), %esi
leaq 0xef0e2(%rip), %rdi     # 0x152a60
movq (%rdi,%rsi,8), %rsi
movq 0x820(%rbx), %rdi
movslq 0x7dc(%rbx), %r8
movq (%rdi,%r8,8), %rdi
incl %r8d
andl $0x7, %r8d
movl %r8d, 0x7dc(%rbx)
leaq 0xbee35(%rip), %r8      # 0x1227de
movq %r8, 0x10(%rdi)
movq $0xd, 0x8(%rdi)
movq 0x6f8(%rbx), %r8
movq %rax, 0x8(%r8)
movq 0x10(%r8), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x6f8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b366
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_c_object
static s7_pointer g_is_c_object(s7_scheme *sc, s7_pointer args)
                {
#define H_is_c_object "(c-object? obj) returns #t is obj is a c-object."
#define Q_is_c_object sc->pl_bt
                    s7_pointer obj;
                    obj = car(args);
                    if (is_c_object(obj)) return(sc->T);
                    if (!has_active_methods(sc, obj)) return(sc->F);
                    return(apply_boolean_method(sc, obj, sc->is_c_object_symbol));
                }

// Assembly:
movq 0x8(%rsi), %rsi
cmpb $0x14, (%rsi)
jne 0x63dd0
movq 0x118(%rdi), %rax
retq
testb $0x40, 0x3(%rsi)
je 0x63deb
cmpb $0x0, 0x24c(%rdi)
je 0x63deb
movq 0xff0(%rdi), %rdx
jmp 0xd2a3a
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_table
static s7_pointer g_symbol_table(s7_scheme *sc, s7_pointer args)
    {
#define H_symbol_table "(symbol-table) returns a vector containing the current symbol-table symbols"
#define Q_symbol_table s7_make_signature(sc, 1, sc->is_vector_symbol)

        s7_pointer lst, x;
        s7_pointer *els;
        int32_t i, j, syms = 0;

        /* this can't be optimized by returning the actual symbol-table (a vector of lists), because
         *    gensyms can cause the table's lists and symbols to change at any time.  This wreaks havoc
         *    on traversals like for-each.  So, symbol-table returns a snap-shot of the table contents
         *    at the time it is called, and we call gc before making the list.  I suppose the next step
         *    is to check that we have room, and increase the heap here if necessary!
         *
         *    (define (for-each-symbol func num) (for-each (lambda (sym) (if (> num 0) (for-each-symbol func (- num 1)) (func sym))) (symbol-table)))
         *    (for-each-symbol (lambda (sym) (gensym) 1))
         */

        for (i = 0; i < SYMBOL_TABLE_SIZE; i++)
            for (x = vector_element(sc->symbol_table, i); is_not_null(x); x = cdr(x))
                syms++;
        sc->w = make_simple_vector(sc, syms);
        els = vector_elements(sc->w);

        for (i = 0, j = 0; i < SYMBOL_TABLE_SIZE; i++)
            for (x = vector_element(sc->symbol_table, i); is_not_null(x); x = cdr(x))
                els[j++] = car(x);

        lst = sc->w;
        sc->w = sc->nil;
        return(lst);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x110(%rdi), %rax
movq 0x148(%rdi), %rcx
movq 0x10(%rcx), %rcx
xorl %edx, %edx
xorl %esi, %esi
movq (%rcx,%rdx,8), %rdi
cmpq %rax, %rdi
je 0x6443f
incl %esi
movq 0x10(%rdi), %rdi
jmp 0x64432
incq %rdx
cmpq $0x7fed, %rdx           # imm = 0x7FED
jne 0x6442e
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x3e258
movq %rax, 0x4d8(%rbx)
movq 0x10(%rax), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movq 0x148(%rbx), %rsi
movq 0x10(%rsi), %rsi
movq (%rsi,%rcx,8), %rsi
cmpq 0x110(%rbx), %rsi
je 0x6449e
movslq %edx, %rdi
leaq (%rax,%rdi,8), %rdi
movq 0x8(%rsi), %r8
movq %r8, (%rdi)
movq 0x10(%rsi), %rsi
addq $0x8, %rdi
incl %edx
cmpq 0x110(%rbx), %rsi
jne 0x64484
incq %rcx
cmpq $0x7fed, %rcx           # imm = 0x7FED
jne 0x64465
movq 0x4d8(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_to_string
static s7_pointer g_symbol_to_string(s7_scheme *sc, s7_pointer args)
    {
#define H_symbol_to_string "(symbol->string sym) returns the symbol sym converted to a string"
#define Q_symbol_to_string s7_make_signature(sc, 2, sc->is_string_symbol, sc->is_symbol_symbol)
        s7_pointer sym;

        sym = car(args);
        if (!is_symbol(sym))
            return(method_or_bust_one_arg(sc, sym, sc->symbol_to_string_symbol, args, T_SYMBOL));
        /* s7_make_string uses strlen which stops at an embedded null */
        return(make_string_with_length(sc, symbol_name(sym), symbol_name_length(sym)));    /* return a copy */
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0x645a3
movq 0x8(%rsi), %rax
movq 0x8(%rax), %r15
movq 0x10(%rax), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x64500
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x200013, (%r14)       # imm = 0x200013
leaq 0x1(%r15), %rsi
movq %rbx, %rdi
callq 0xa305
movq %rax, 0x20(%r14)
movq (%rax), %rdi
movq %rdi, 0x10(%r14)
testq %r15, %r15
jle 0x64544
movq %r12, %rsi
movq %r15, %rdx
callq 0x93e0
movq 0x10(%r14), %rax
movb $0x0, (%rax,%r15)
movq %r15, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq 0x738(%rbx), %rbx
movq 0x8(%rbx), %rsi
cmpq %rsi, 0x10(%rbx)
jne 0x64581
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movq %r14, (%rax,%rcx,8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x15c0(%rbx), %rdx
movq %rbx, %rdi
movl $0xa, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9b739
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_to_value
static s7_pointer g_symbol_to_value(s7_scheme *sc, s7_pointer args)
    {
#define H_symbol_to_value "(symbol->value sym (env (curlet))) returns the binding of (the value associated with) the \
        symbol sym in the given environment: (let ((x 32)) (symbol->value 'x)) -> 32"
#define Q_symbol_to_value s7_make_signature(sc, 3, sc->T, sc->is_symbol_symbol, sc->is_let_symbol)
        /* (symbol->value 'x e) => (e 'x)? */

        s7_pointer sym;
        sym = car(args);

        if (!is_symbol(sym))
            return(method_or_bust(sc, sym, sc->symbol_to_value_symbol, args, T_SYMBOL, 1));

        if (is_not_null(cdr(args)))
        {
            s7_pointer local_env;

            local_env = cadr(args);
            if (local_env == sc->unlet_symbol)
                return((is_slot(initial_slot(sym))) ? slot_value(initial_slot(sym)) : sc->undefined);

            if (!is_let(local_env))
                return(method_or_bust_with_type(sc, local_env, sc->symbol_to_value_symbol, args, a_let_string, 2));

            if (local_env == sc->s7_let)
                return(g_s7_let_ref_fallback(sc, set_qlist_2(sc, local_env, sym)));

            return(s7_symbol_local_value(sc, sym, local_env));
        }

        if (is_global(sym))
            return(slot_value(global_slot(sym)));

        return(s7_symbol_value(sc, sym));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0x64995
movq 0x10(%rcx), %rax
cmpq 0x110(%rdi), %rax
je 0x649ad
movq 0x8(%rax), %rax
cmpq 0x1630(%rdi), %rax
je 0x649c0
cmpb $0x1c, (%rax)
jne 0x649e2
cmpq 0x2150(%rdi), %rax
je 0x649fe
movq %rax, %rdx
jmp 0xcd2c
movq 0x15c8(%rdi), %rdx
movl $0xa, %r8d
movl $0x1, %r9d
jmp 0xf1ae
testb $0x1, 0x2(%rsi)
je 0xaa24
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
retq
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
addq $0x128, %rdi            # imm = 0x128
cmpb $0x20, (%rax)
leaq 0x10(%rax), %rax
cmoveq %rax, %rdi
movq (%rdi), %rax
retq
movq 0x15c8(%rdi), %rdx
movq 0xedf68(%rip), %r8      # 0x152958
movq %rax, %rsi
movl $0x2, %r9d
jmp 0xf3da
movq 0x720(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x720(%rdi), %rax
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x720(%rdi), %rsi
jmp 0x91ba2
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_to_dynamic_value
static s7_pointer g_symbol_to_dynamic_value(s7_scheme *sc, s7_pointer args)
    {
#define H_symbol_to_dynamic_value "(symbol->dynamic-value sym) returns the dynamic binding of the symbol sym"
#define Q_symbol_to_dynamic_value s7_make_signature(sc, 2, sc->T, sc->is_symbol_symbol)

        s7_pointer sym, val;
        int64_t i, top_id;

        sym = car(args);
        if (!is_symbol(sym))
            return(method_or_bust(sc, sym, sc->symbol_to_dynamic_value_symbol, args, T_SYMBOL, 1));

        if (is_global(sym))
            return(slot_value(global_slot(sym)));

        if (let_id(sc->envir) == symbol_id(sym))
            return(slot_value(local_slot(sym)));

        top_id = -1;
        val = find_dynamic_value(sc, sc->envir, sym, &top_id);
        if (top_id == symbol_id(sym))
            return(val);

        for (i = s7_stack_top(sc) - 1; i > 0; i -= 4)
            if (is_let_unchecked(stack_let(sc->stack, i))) /* OP_GC_PROTECT envir slot can be anything (even free) */
            {
                s7_pointer cur_val;
                cur_val = find_dynamic_value(sc, stack_let(sc->stack, i), sym, &top_id);
                if (cur_val != sc->unused)
                    val = cur_val;
                if (top_id == symbol_id(sym))
                    return(val);
            }

        if (val == sc->unused)
            return(s7_symbol_value(sc, sym));
        return(val);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x8(%rsi), %rbx
cmpb $0xa, (%rbx)
jne 0x64a58
testb $0x1, 0x2(%rbx)
jne 0x64a87
movq 0x8(%r14), %rsi
movq 0x20(%rbx), %rbp
cmpq %rbp, 0x18(%rsi)
jne 0x64aa1
movq 0x18(%rbx), %rax
jmp 0x64a8b
movq %rsi, %rcx
movq 0x15b0(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movl $0xa, %r8d
movl $0x1, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf1ae
movq 0x10(%rbx), %rax
movq 0x10(%rax), %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %r12
movq $-0x1, (%r12)
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x102f8a
movq %rax, %r15
cmpq %rbp, (%r12)
jne 0x64aca
movq %r15, %r12
jmp 0x64a8f
movq 0x50(%r14), %r13
subq 0x48(%r14), %r13
sarq $0x3, %r13
cmpq $0x2, %r13
jl 0x64b30
movq %rbp, 0x10(%rsp)
movq 0x38(%r14), %rax
movq 0x10(%rax), %rbp
addq $0x3, %r13
movq -0x30(%rbp,%r13,8), %rsi
cmpb $0x1c, (%rsi)
jne 0x64b26
movq %r14, %rdi
movq %rbx, %rdx
leaq 0x8(%rsp), %rcx
callq 0x102f8a
cmpq 0x140(%r14), %rax
cmovneq %rax, %r15
movq 0x10(%rsp), %rax
cmpq %rax, 0x8(%rsp)
cmoveq %r15, %r12
je 0x64a8f
addq $-0x4, %r13
cmpq $0x4, %r13
jg 0x64aed
movq %r15, %r12
cmpq 0x140(%r14), %r15
jne 0x64a8f
movq %r14, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaa24
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_immutable
static s7_pointer g_immutable(s7_scheme *sc, s7_pointer args)
    {
#define H_immutable "(immutable! sequence) declares that the sequence's entries can't be changed. The sequence is returned."
#define Q_immutable s7_make_signature(sc, 2, sc->T, sc->T)
        s7_pointer p;
        p = car(args);
        if (is_symbol(p))
        {
            s7_pointer slot;
            slot = symbol_to_slot(sc, p);
            if (is_slot(slot))
            {
                set_immutable(slot);
                return(p);  /* symbol is not set immutable ? */
            }
        }
        return(s7_immutable(p));
    }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0xa, (%rax)
jne 0x64bcc
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rax), %rsi
movl $0x18, %ecx
cmpq %rsi, %rdi
je 0x64bc3
jle 0x64b87
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rsi
jl 0x64b7a
cmpq %rsi, %rdi
je 0x64bc3
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0x64bc3
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
sete %r8b
je 0x64baf
cmpq %rax, 0x8(%rsi)
je 0x64bb2
movq 0x18(%rsi), %rsi
jmp 0x64b9a
movq %rdi, %rsi
testb %r8b, %r8b
je 0x64bc7
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %rsi, %rdi
je 0x64b96
movq (%rax,%rcx), %rsi
cmpb $0x20, (%rsi)
je 0x64bcf
movq %rax, %rsi
orb $0x1, 0x3(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_string_to_keyword
static s7_pointer g_string_to_keyword(s7_scheme *sc, s7_pointer args)
    {
#define H_string_to_keyword "(string->keyword str) prepends ':' to str and defines that as a keyword"
#define Q_string_to_keyword s7_make_signature(sc, 2, sc->is_keyword_symbol, sc->is_string_symbol)

        s7_pointer str;
        str = car(args);
        if (!is_string(str))
            return(method_or_bust_one_arg(sc, str, sc->string_to_keyword_symbol, args, T_STRING));
        if ((string_length(str) == 0) ||
                (string_value(str)[0] == '\0'))
            return(s7_error(sc, sc->out_of_range_symbol, set_elist_2(sc, wrap_string(sc, "string->keyword wants a non-null string: ~S", 43), str)));
        return(s7_make_keyword(sc, string_value(str)));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x64ca8
cmpq $0x0, 0x8(%rsi)
je 0x64cba
movq 0x10(%rsi), %rax
cmpb $0x0, (%rax)
je 0x64cba
movq %rax, %rsi
jmp 0xd108
movq 0x1300(%rdi), %rdx
movl $0x13, %r8d
jmp 0x9b739
movq 0x1948(%rdi), %rax
movq 0x820(%rdi), %rcx
movslq 0x7dc(%rdi), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rdi)
leaq 0xbf764(%rip), %rdx     # 0x124449
movq %rdx, 0x10(%rcx)
movq $0x2b, 0x8(%rcx)
movq 0x6e0(%rdi), %rdx
movq %rcx, 0x8(%rdx)
movq 0x6e0(%rdi), %rcx
movq 0x10(%rcx), %rcx
movq %rsi, 0x8(%rcx)
movq 0x6e0(%rdi), %rdx
movq %rax, %rsi
jmp 0x3b366
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_keyword_to_symbol
static s7_pointer g_keyword_to_symbol(s7_scheme *sc, s7_pointer args)
    {
#define H_keyword_to_symbol "(keyword->symbol key) returns a symbol with the same name as key but no prepended colon"
#define Q_keyword_to_symbol s7_make_signature(sc, 2, sc->is_symbol_symbol, sc->is_keyword_symbol)

        s7_pointer sym;
        sym = car(args);
        if (!is_keyword(sym))
            return(method_or_bust_with_type_one_arg(sc, sym, sc->keyword_to_symbol_symbol, args, wrap_string(sc, "a keyword", 9)));
        return(keyword_symbol(sym));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
testb $-0x80, 0x6(%rsi)
jne 0x64d90
movq 0x1208(%rdi), %rdx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r9
movq (%rax,%r9,8), %r8
leal 0x1(%r9), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0xb0519(%rip), %rax     # 0x115298
movq %rax, 0x10(%r8)
movq $0x9, 0x8(%r8)
jmp 0x103001
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_outlet
static s7_pointer g_outlet(s7_scheme *sc, s7_pointer args)
    {
#define H_outlet "(outlet env) is the environment that contains env."
#define Q_outlet s7_make_signature(sc, 2, sc->is_let_symbol, sc->is_let_symbol)

        s7_pointer env;

        env = car(args);
        if (!is_let(env))
            return(s7_wrong_type_arg_error(sc, "outlet", 1, env, "a let")); /* not a method call here! */

        if ((env == sc->rootlet) ||
                (is_null(outlet(env))))
            return(sc->rootlet);
        return(outlet(env));
    }

// Assembly:
movq 0x8(%rsi), %rcx
cmpb $0x1c, (%rcx)
jne 0x64dc0
movq 0x150(%rdi), %rdx
cmpq %rdx, %rcx
je 0x64dd8
movq 0x10(%rcx), %rax
cmpq 0x110(%rdi), %rax
je 0x64dd8
retq
leaq 0xc0151(%rip), %rsi     # 0x124f18
leaq 0xbb451(%rip), %r8      # 0x12021f
movl $0x1, %edx
jmp 0xe25f
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_unlet
static s7_pointer g_unlet(s7_scheme *sc, s7_pointer args)
    {
        /* add sc->unlet bindings to the current environment */
#define H_unlet "(unlet) returns a let that establishes the original bindings of all the predefined functions"
#define Q_unlet s7_make_signature(sc, 1, sc->is_let_symbol)

        /* slightly confusing:
         *    ((unlet) 'abs) -> #<undefined>
         *    (defined? 'abs (unlet)) -> #t
         * this is because unlet sets up a local environment of unshadowed symbols, and s7_let_ref only looks at the local env chain
         *   (that is, if env is not the global env, then the global env is not searched).
         */
        int32_t i;
        s7_pointer *inits;
        s7_pointer x;

        sc->w = new_frame_in_env(sc, sc->envir);
        inits = vector_elements(sc->unlet);

        for (i = 0; (i < UNLET_ENTRIES) && (is_slot(inits[i])); i++)
        {
            s7_pointer sym;
            x = slot_value(inits[i]);
            sym = slot_symbol(inits[i]);
            if ((x != slot_value(global_slot(sym))) || /* it has been changed globally */
                    ((!is_global(sym)) &&                  /* it might be shadowed locally */
                     (s7_symbol_local_value(sc, sym, sc->envir) != slot_value(global_slot(sym)))))
                make_slot_1(sc, sc->w, sym, x);
        }
        /* if (set! + -) then + needs to be overridden, but the local bit isn't set, so we have to check the actual values in the non-local case.
         *   (define (f x) (with-let (unlet) (+ x 1)))
         */
        x = sc->w;
        sc->w = sc->nil;
        return(x);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x64e26
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x20001c, (%rax)       # imm = 0x20001C
movq 0x250(%rbx), %rcx
incq %rcx
movq %rcx, 0x250(%rbx)
movq %rcx, 0x18(%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x4d8(%rbx)
movq 0x168(%rbx), %rax
movq 0x10(%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rax
cmpb $0x20, (%rax)
jne 0x64ed5
movq 0x8(%rax), %r15
movq 0x10(%rax), %r14
movq 0x10(%r15), %rax
movq 0x10(%rax), %rbp
cmpq %rbp, %r14
je 0x64eae
movq 0x4d8(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0xb169
jmp 0x64ec9
testb $0x1, 0x2(%r15)
jne 0x64ec9
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xcd2c
cmpq %rbp, %rax
jne 0x64e97
incq %r13
cmpq $0x200, %r13            # imm = 0x200
jne 0x64e79
movq 0x4d8(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
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: g_sublet
static s7_pointer g_sublet(s7_scheme *sc, s7_pointer args)
    {
#define H_sublet "(sublet env ...) adds its arguments (each a let or a cons: '(symbol . value)) to env, and returns the new environment."
#define Q_sublet Q_varlet
        s7_pointer e;

        e = car(args);
        if (is_null(e))
            e = sc->rootlet;
        else
        {
            check_method(sc, e, sc->sublet_symbol, args);
            if (!is_let(e))
                return(wrong_type_argument_with_type(sc, sc->sublet_symbol, 1, e, a_let_string));
        }
        return(sublet_1(sc, e, cdr(args), sc->sublet_symbol));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rbx
movq 0x110(%rdi), %rbp
cmpq %rbp, %rbx
je 0x6509f
movb $0x1, %r13b
testb $0x40, 0x3(%rbx)
je 0x6505c
cmpb $0x1, 0x24c(%r14)
jne 0x6505c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a55
movq 0x1578(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%r14), %rax
je 0x6505c
cmpb $0x1, (%r15)
jne 0x650d9
movq %rax, 0x8(%rsp)
movq %r15, 0x4c8(%r14)
movq 0x8(%r15), %r12
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x64f98
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r12, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq %rax, (%rsp)
movq %rax, 0x4e8(%r14)
movq %r15, 0x10(%rsp)
movq 0x10(%r15), %rbp
cmpb $0x1, (%rbp)
jne 0x65034
movq (%rsp), %r13
movq 0x8(%rbp), %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %r15
cmpq 0x98(%r14), %rax
ja 0x64ffe
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
movq %rax, %r13
je 0x64fdb
movq 0x110(%r14), %rax
movq %rax, 0x4e8(%r14)
movq %rax, 0x4c8(%r14)
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %rax
movq (%rsp), %rdx
jmp 0x650dc
testb %r13b, %r13b
je 0x650ca
cmpb $0x1c, (%rbx)
je 0x650a6
movq 0x1578(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xe98e0(%rip), %rdx     # 0x14e958
movq 0x140(%r14), %r8
movq 0xed8d2(%rip), %r9      # 0x152958
movq %r14, %rdi
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb31d
movq 0x150(%r14), %rbx
movq 0x10(%r15), %rdx
movq 0x1578(%r14), %rcx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb3d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xbd41
xorl %r13d, %r13d
jmp 0x6505c
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_coverlet
static s7_pointer g_coverlet(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer e;
#define H_coverlet "(coverlet e) undoes an earlier openlet."
#define Q_coverlet sc->pcl_e

        e = car(args);
        sc->temp3 = e;
        check_method_uncopied(sc, e, sc->coverlet_symbol, list_1(sc, e));
        sc->temp3 = sc->nil;
        if ((e == sc->rootlet) || (e == sc->s7_let))
            s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't coverlet ~S", 17), e));

        if ((is_let(e)) ||
                (has_closure_let(e)) ||
                ((is_c_object(e)) && (c_object_let(e) != sc->nil)) ||
                ((is_c_pointer(e)) && (is_let(c_pointer_info(e)))))
        {
            clear_has_methods(e);
            return(e);
        }
        return(simple_wrong_type_argument_with_type(sc, sc->coverlet_symbol, e, a_let_string));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rbx
movq %rbx, 0x508(%rdi)
movb $0x1, %bpl
testb $0x40, 0x3(%rbx)
je 0x661d6
cmpb $0x1, 0x24c(%r14)
jne 0x661d6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a55
movq 0xe38(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%r14), %rax
je 0x661d6
movq %rax, %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x661a2
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %rbx, 0x8(%rdx)
movq %r12, 0x10(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0xbd41
xorl %ebp, %ebp
jmp 0x661d6
testb %bpl, %bpl
je 0x6627d
movq 0x110(%r14), %rax
movq %rax, 0x508(%r14)
cmpq 0x150(%r14), %rbx
je 0x661ff
cmpq 0x2150(%r14), %rbx
jne 0x66260
movq 0xea8(%r14), %rsi
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0xbe286(%rip), %rcx     # 0x1244b1
movq %rcx, 0x10(%rax)
movq $0x11, 0x8(%rax)
movq 0x6e0(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%r14), %rax
movq 0x10(%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x6e0(%r14), %rdx
movq %r14, %rdi
callq 0x3b366
movzbl (%rbx), %eax
cmpq $0x1c, %rax
je 0x66276
leaq 0xe86a0(%rip), %rcx     # 0x14e910
cmpb $0x0, (%rax,%rcx)
je 0x66286
andb $-0x41, 0x3(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x21, %rax
je 0x662a3
cmpl $0x14, %eax
jne 0x662ac
movq 0x18(%rbx), %rcx
cmpq 0x110(%r14), %rcx
jne 0x66276
cmpl $0x21, %eax
jne 0x662ac
movq 0x18(%rbx), %rax
cmpb $0x1c, (%rax)
je 0x66276
movq 0xe38(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xec693(%rip), %r8      # 0x152958
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_openlet
static s7_pointer g_openlet(s7_scheme *sc, s7_pointer args)
    {
#define H_openlet "(openlet e) tells the built-in generic functions that the let 'e might have an over-riding method."
#define Q_openlet sc->pcl_e
        s7_pointer e, elet, func;

        e = car(args);
        if ((e == sc->rootlet) || (e == sc->nil))
            s7_error(sc, sc->error_symbol, set_elist_1(sc, wrap_string(sc, "can't openlet rootlet", 21)));
        elet = find_let(sc, e); /* returns nil if no let found, so has to follow error check above */
        if (!is_let(elet))
            return(simple_wrong_type_argument_with_type(sc, sc->openlet_symbol, e, a_let_string));

        if ((has_active_methods(sc, e)) &&
                ((func = find_method(sc, elet, sc->openlet_symbol)) != sc->undefined))
            return(s7_apply_function(sc, func, args));

        set_has_methods(e);
        return(e);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rbx
cmpq 0x150(%rdi), %rbx
je 0x662fc
cmpq 0x110(%r14), %rbx
jne 0x6634e
movq 0xea8(%r14), %rsi
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0xbe19b(%rip), %rcx     # 0x1244c3
movq %rcx, 0x10(%rax)
movq $0x15, 0x8(%rax)
movq 0x6d8(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x6d8(%r14), %rdx
movq %r14, %rdi
callq 0x3b366
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a55
cmpb $0x1c, (%rax)
jne 0x663a6
movq (%rbx), %r12
btl $0x1e, %r12d
jae 0x663d5
cmpb $0x1, 0x24c(%r14)
jne 0x663d5
movq 0x13b0(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%r14), %rax
je 0x663d5
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbd41
movq 0x13b0(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xec599(%rip), %r8      # 0x152958
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfac8
orq $0x40000000, %r12       # imm = 0x40000000
movq %r12, (%rbx)
movq %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: g_iterator_is_at_end
static s7_pointer g_iterator_is_at_end(s7_scheme *sc, s7_pointer args)
    {
#define H_iterator_is_at_end "(iterator-at-end? iter) returns #t if the iterator has reached the end of its sequence."
#define Q_iterator_is_at_end s7_make_signature(sc, 2, sc->is_boolean_symbol, sc->is_iterator_symbol)
        s7_pointer iter;

        iter = car(args);
        if (iter_ok(iter))
            return(sc->F);
        if (!is_iterator(iter))
            return(method_or_bust_one_arg(sc, iter, sc->iterator_is_at_end_symbol, args, T_ITERATOR));
        return(sc->T);
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
testb $-0x80, 0x3(%rsi)
jne 0x665eb
cmpb $0x1d, (%rsi)
jne 0x665f3
movq 0x118(%rdi), %rax
retq
movq 0x120(%rdi), %rax
retq
movq 0x11d0(%rdi), %rdx
movl $0x1d, %r8d
jmp 0x9b739