LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: rootlet_iterate
static s7_pointer rootlet_iterate(s7_scheme *sc, s7_pointer iterator)
    {
        s7_pointer slot;
        slot = iterator_current(iterator);
        if (is_slot(slot))
        {
            if (iterator_position(iterator) < sc->rootlet_entries)
            {
                iterator_position(iterator)++;
                iterator_current(iterator) = rootlet_element(sc->rootlet, iterator_position(iterator));
            }
            else iterator_current(iterator) = sc->nil;
            return(cons(sc, slot_symbol(slot), slot_value(slot)));
        }
        return(iterator_quit(iterator));
    }

// Assembly:
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
jne 0x3970e
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rsi), %rcx
cmpq 0x160(%rdi), %rcx
jge 0x39725
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rsi)
movq 0x150(%rbx), %rdx
leaq 0x8(,%rcx,8), %rcx
addq 0x10(%rdx), %rcx
jmp 0x3972c
leaq 0x4fa(%rip), %rax       # 0x39c0f
movq %rax, 0x28(%rsi)
andb $0x7f, 0x3(%rsi)
movq 0x11503c(%rip), %rax    # 0x14e760
retq
leaq 0x110(%rbx), %rcx
movq (%rcx), %rcx
movq %rcx, 0x10(%rsi)
movups 0x8(%rax), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x39757
movq %rbx, %rdi
movaps %xmm0, (%rsp)
callq 0xb389
movaps (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movups %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: iterator_method
static s7_pointer iterator_method(s7_scheme *sc, s7_pointer e)
    {
        s7_pointer func;
        if ((has_active_methods(sc, e)) &&
                ((func = find_method(sc, find_let(sc, e), sc->make_iterator_symbol)) != sc->undefined))
        {
            s7_pointer it;
            it = s7_apply_function(sc, func, list_1(sc, e));
            if (!is_iterator(it))
                return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "make-iterator method must return an interator: ~S", 49), it)));
            return(it);
        }
        return(NULL);
    }

// Assembly:
testb $0x40, 0x3(%rsi)
jne 0x39787
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x24c(%rdi)
jne 0x39888
movq %rsi, %r14
movq %rbx, %rdi
callq 0x9a55
movq 0x12f8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%rbx), %rax
je 0x39888
movq %rax, %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x397eb
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
callq 0xbd41
cmpb $0x1d, (%rax)
je 0x3988a
movq 0xea8(%rbx), %r14
movq 0x820(%rbx), %rcx
movslq 0x7dc(%rbx), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rbx)
leaq 0xe61a1(%rip), %rdx     # 0x11f9ec
movq %rdx, 0x10(%rcx)
movq $0x31, 0x8(%rcx)
movq 0x6e0(%rbx), %rdx
movq %rcx, 0x8(%rdx)
movq 0x6e0(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b366
movq %r14, %rax
jmp 0x3988a
xorl %eax, %eax
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: let_iterate
static s7_pointer let_iterate(s7_scheme *sc, s7_pointer iterator)
    {
        s7_pointer slot;
        slot = iterator_current_slot(iterator);
        if (tis_slot(slot))
        {
            iterator_set_current_slot(iterator, next_slot(slot));
            if (iterator_let_cons(iterator))
            {
                s7_pointer p;
                p = iterator_let_cons(iterator);
                set_car(p, slot_symbol(slot));
                set_cdr(p, slot_value(slot));
                return(p);
            }
            return(cons(sc, slot_symbol(slot), slot_value(slot)));
        }
        return(iterator_quit(iterator));
    }

// Assembly:
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x398c7
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rcx), %rax
movq %rax, 0x18(%rsi)
movq 0x10(%rsi), %rax
movq 0x8(%rcx), %r14
testq %rax, %rax
je 0x398de
movq %r14, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x39922
leaq 0x341(%rip), %rax       # 0x39c0f
movq %rax, 0x28(%rsi)
andb $0x7f, 0x3(%rsi)
movq 0x114e83(%rip), %rax    # 0x14e760
retq
movq %rdi, %rbx
movq 0x10(%rcx), %r15
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x398fd
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 %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: hash_table_iterate
static s7_pointer hash_table_iterate(s7_scheme *sc, s7_pointer iterator)
    {
        s7_pointer table;
        s7_int loc, len;
        hash_entry_t **elements;
        hash_entry_t *lst;

        lst = iterator_hash_current(iterator);
        if (lst)
        {
            iterator_hash_current(iterator) = hash_entry_next(lst);
            return(hash_entry_to_cons(sc, lst, iterator_current(iterator)));
        }
        table = iterator_sequence(iterator); /* using iterator_length and hash_table_entries here was slightly slower */
        len = hash_table_mask(table) + 1;
        elements = hash_table_elements(table);

        for (loc = iterator_position(iterator) + 1; loc < len;  loc++)
        {
            hash_entry_t *x;
            x = elements[loc];
            if (x)
            {
                iterator_position(iterator) = loc;
                iterator_hash_current(iterator) = hash_entry_next(x);
                return(hash_entry_to_cons(sc, x, iterator_current(iterator)));
            }
        }
        if (is_weak_hash_table(table))
        {
            clear_weak_hash_iterator(iterator);
            weak_hash_iters(table)--;
        }
        return(iterator_quit(iterator));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x39964
movq 0x18(%rsi), %rax
movq %rax, 0x20(%rbx)
movq 0x10(%rbx), %rdx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9b7a1
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %r13
movq 0x8(%rax), %rbp
movq %rax, (%rsp)
movq 0x10(%rax), %r12
cmpq %rbp, %r13
jge 0x399ac
movq 0x8(%r12,%r13,8), %r15
incq %r13
testq %r15, %r15
je 0x399a5
movq %r13, 0x18(%rbx)
movq 0x18(%r15), %rax
movq %rax, 0x20(%rbx)
movq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x9b7a1
testq %r15, %r15
je 0x39978
jmp 0x399d7
movq (%rsp), %rax
testb $0x8, 0x3(%rax)
je 0x399c1
andb $-0x5, 0x6(%rbx)
movq 0x28(%rax), %rax
decl 0xc(%rax)
leaq 0x247(%rip), %rax       # 0x39c0f
movq %rax, 0x28(%rbx)
andb $0x7f, 0x3(%rbx)
movq 0x114d89(%rip), %rax    # 0x14e760
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: pair_iterate
static s7_pointer pair_iterate(s7_scheme *sc, s7_pointer obj)
    {
        if (is_pair(iterator_current(obj)))
        {
            s7_pointer result;
            result = car(iterator_current(obj));
            iterator_current(obj) = cdr(iterator_current(obj));
            if (iterator_current(obj) == iterator_slow(obj))
                iterator_current(obj) = sc->nil;
            iterator_next(obj) = pair_iterate_1;
            return(result);
        }
        return(iterator_quit(obj));
    }

// Assembly:
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x39bf8
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsi)
cmpq 0x20(%rsi), %rcx
jne 0x39bec
movq 0x110(%rdi), %rcx
movq %rcx, 0x10(%rsi)
leaq 0x61c12(%rip), %rcx     # 0x9b805
movq %rcx, 0x28(%rsi)
retq
leaq 0x10(%rip), %rax        # 0x39c0f
movq %rax, 0x28(%rsi)
andb $0x7f, 0x3(%rsi)
movq 0x114b52(%rip), %rax    # 0x14e760
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: closure_iterate
static s7_pointer closure_iterate(s7_scheme *sc, s7_pointer obj)
    {
        s7_pointer result;
        result = s7_call(sc, iterator_sequence(obj), sc->nil);
        /* this can't use s7_apply_function -- we need to catch the error handler's longjmp here */
        if (result == ITERATOR_END)
        {
            iterator_next(obj) = iterator_finished;
            clear_iter_ok(obj);
        }
        return(result);
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
movq 0x110(%rdi), %rdx
callq 0x466aa
cmpq 0x114b2e(%rip), %rax    # 0x14e760
jne 0x39c43
leaq -0x2c(%rip), %rcx       # 0x39c0f
movq %rcx, 0x28(%rbx)
andb $0x7f, 0x3(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: closure_length
static int32_t closure_length(s7_scheme *sc, s7_pointer e)
    {
        /* we can't use let_length(sc, closure_let(e)) because the closure_let(closure)
         *   changes.  So the open bit is not always on.  Besides, the fallbacks need to be for closures, not environments.
         */
        s7_pointer length_func;
        length_func = find_method(sc, closure_let(e), sc->length_symbol);
        if (length_func != sc->undefined)
            return((int32_t)s7_integer(s7_apply_function(sc, length_func, list_1(sc, e))));

        /* there are cases where this should raise a wrong-type-arg error, but for now... */
        return(-1);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
movq 0x1218(%rdi), %rdx
callq 0x99ef
cmpq 0x128(%rbx), %rax
je 0x39ccd
movq %rax, %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x39c8e
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
callq 0xbd41
movq %rax, %rcx
xorl %eax, %eax
cmpb $0xb, (%rcx)
jne 0x39cd2
movl 0x8(%rcx), %eax
jmp 0x39cd2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
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: c_object_length_to_int
static s7_int c_object_length_to_int(s7_scheme *sc, s7_pointer obj)
                {
                    if (c_object_len(sc, obj))
                    {
                        s7_pointer res;
                        res = (*(c_object_len(sc, obj)))(sc, set_clist_1(sc, obj));
                        if (s7_is_integer(res))
                            return(s7_integer(res));
                    }
                    return(-1);
                }

// Assembly:
movq 0x8d8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq (%rax,%rcx,8), %rax
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x39d23
pushq %rax
movq 0x730(%rdi), %rcx
movq %rsi, 0x8(%rcx)
movq 0x730(%rdi), %rsi
callq *%rax
movq %rax, %rcx
movb (%rax), %dl
cmpb $0xb, %dl
jne 0x39d19
movq 0x8(%rcx), %rax
cmpb $0xb, %dl
leaq 0x8(%rsp), %rsp
je 0x39d2a
movq $-0x1, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: c_object_iterate
static s7_pointer c_object_iterate(s7_scheme *sc, s7_pointer obj)
    {
        if (iterator_position(obj) < iterator_length(obj))
        {
            s7_pointer result, p, cur;
            p = iterator_sequence(obj);
            cur = iterator_current(obj);
            set_car(sc->z2_1, sc->x);
            set_car(sc->z2_2, sc->z); /* is this necessary? */
            set_car(cur, p);
            set_car(cdr(cur), make_integer(sc, iterator_position(obj)));
            result = (*(c_object_ref(sc, p)))(sc, cur);
            sc->x = car(sc->z2_1);
            sc->z = car(sc->z2_2);
            iterator_position(obj)++;
            if (result == ITERATOR_END)
            {
                iterator_next(obj) = iterator_finished;
                clear_iter_ok(obj);
            }
            return(result);
        }
        return(iterator_quit(obj));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rsi), %rax
cmpq 0x20(%rsi), %rax
jge 0x39d8e
movq %rdi, %r14
movq 0x8(%rbx), %r12
movq 0x10(%rbx), %r15
movq 0x4e0(%rdi), %rax
movq 0x598(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x4f0(%rdi), %rax
movq 0x5a0(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq %r12, 0x8(%r15)
movq 0x18(%rbx), %r13
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0x39da9
leaq 0x114bc8(%rip), %rax    # 0x14e950
movq (%rax,%r13,8), %rax
jmp 0x39de2
leaq -0x186(%rip), %rax      # 0x39c0f
movq %rax, 0x28(%rbx)
andb $0x7f, 0x3(%rbx)
movq 0x1149bc(%rip), %rax    # 0x14e760
jmp 0x39e43
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x39dc1
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r13, 0x8(%rax)
movq 0x10(%r15), %rcx
movq %rax, 0x8(%rcx)
movq 0x8d8(%r14), %rax
movq 0x8(%r12), %rcx
movq (%rax,%rcx,8), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x48(%rax)
movq 0x598(%r14), %rcx
movq 0x5a0(%r14), %rdx
movq 0x8(%rcx), %rcx
movq %rcx, 0x4e0(%r14)
movq 0x8(%rdx), %rcx
movq %rcx, 0x4f0(%r14)
incq 0x18(%rbx)
cmpq 0x11492e(%rip), %rax    # 0x14e760
jne 0x39e43
leaq -0x22c(%rip), %rcx      # 0x39c0f
movq %rcx, 0x28(%rbx)
andb $0x7f, 0x3(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_iterator_is_at_end
bool s7_iterator_is_at_end(s7_scheme *sc, s7_pointer obj)
    {
        if (iter_ok(obj))
            return(false);
        if (!is_iterator(obj))
            simple_wrong_type_argument(sc, sc->iterator_is_at_end_symbol, obj, T_ITERATOR);
        return(true);
    }

// Assembly:
pushq %rbx
movq (%rsi), %rbx
testl %ebx, %ebx
js 0x39e7b
movq %rsi, %rdx
cmpb $0x1d, (%rsi)
je 0x39e7b
movq 0x11d0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0x118cd2(%rip), %r8     # 0x152b48
callq 0xfac8
testl %ebx, %ebx
setns %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_is_valid
bool s7_is_valid(s7_scheme *sc, s7_pointer arg)
    {
        bool result = false;
        if (!arg) return(false);

#if TRAP_SEGFAULT
        if (sigsetjmp(senv, 1) == 0)
        {
            void (*old_segv)(int32_t sig);
            can_jump = 1;
            old_segv = signal(SIGSEGV, segv);
#endif
            if ((unchecked_type(arg) > T_FREE) &&
                    (unchecked_type(arg) < NUM_TYPES))
            {
                if (not_in_heap(arg))
                    result = true;
                else
                {
                    int64_t loc;
                    loc = heap_location(sc, arg);
                    if ((loc >= 0) && (loc < sc->heap_size))
                        result = (sc->heap[loc] == arg);
#if S7_DEBUGGING
                    if (!result)
                        check_heap_location(sc, arg, loc, __func__, __LINE__);
#endif
                }
            }
#if TRAP_SEGFAULT
            signal(SIGSEGV, old_segv);
        }
        else result = false;
        can_jump = 0;
#endif
        return(result);
    }

// Assembly:
testq %rsi, %rsi
je 0x39ef5
movb (%rsi), %al
decb %al
cmpb $0x32, %al
ja 0x39ef5
movb $0x1, %al
testb $0x40, 0x7(%rsi)
jne 0x39ef4
movq 0x2a68(%rdi), %rcx
testq %rcx, %rcx
je 0x39eb7
movq (%rcx), %rdx
cmpq %rsi, %rdx
jg 0x39eb1
cmpq %rsi, 0x8(%rcx)
jg 0x39ebd
movq 0x18(%rcx), %rcx
jmp 0x39e9e
movq 0x30(%rsi), %rdx
jmp 0x39ed8
movq %rsi, %rax
subq %rdx, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq $0x5, %rdx
addq 0x10(%rcx), %rdx
testq %rdx, %rdx
js 0x39ef5
cmpq 0xa8(%rdi), %rdx
jge 0x39ef5
movq 0x80(%rdi), %rax
cmpq %rsi, (%rax,%rdx,8)
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_show_let
void s7_show_let(s7_scheme *sc) /* debugging convenience */
    {
        s7_pointer olet;
        for (olet = sc->envir; is_let(T_Lid(olet)); olet = outlet(olet))
        {
            if (olet == sc->owlet)
                fprintf(stderr, "(owlet): ");
            else
            {
                if (is_funclet(olet))
                    fprintf(stderr, "(%s funclet): ", DISPLAY(funclet_function(olet)));
                else
                {
                    if (olet == sc->shadow_rootlet)
                        fprintf(stderr, "(shadow rootlet): ");
                }
            }
            fprintf(stderr, "%s\n", DISPLAY(olet));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r14
cmpb $0x1c, (%r14)
jne 0x39f7a
movq %rdi, %rbx
movq 0x1140e3(%rip), %r13    # 0x14dff8
leaq 0xe6793(%rip), %r15     # 0x1206af
cmpq 0x198(%rbx), %r14
jne 0x39f2c
callq 0x9832
jmp 0x39f4e
testb $0x20, 0x3(%r14)
jne 0x39f43
cmpq 0x158(%rbx), %r14
jne 0x39f4e
callq 0x9816
jmp 0x39f4e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x97e4
movq (%r13), %r12
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x39f84
movq 0x10(%rax), %rdx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x9390
movq 0x10(%r14), %r14
cmpb $0x1c, (%r14)
je 0x39f1c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_object_to_c_string
char *s7_object_to_c_string(s7_scheme *sc, s7_pointer obj)
    {
        char *str;
        s7_pointer strport;
        s7_int len;

        TRACK(sc);
        if ((sc->safety > NO_SAFETY) &&
                (!s7_is_valid(sc, obj)))
            s7_warn(sc, 256, "bad arg to %s: %p\n", __func__, obj);

        strport = open_format_port(sc);
        object_out(sc, obj, strport, P_WRITE);
        len = port_position(strport);
        if (len == 0) return(NULL);
        str = (char *)malloc(len + 1);
        memcpy((void *)str, (void *)port_data(strport), len);
        str[len] = '\0';
        close_format_port(sc, strport);

        return(str);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x6a0(%rdi)
jle 0x3a1cf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39e82
testb %al, %al
jne 0x3a1cf
leaq 0xd8eb5(%rip), %rdx     # 0x11306b
leaq 0xd8ec1(%rip), %rcx     # 0x11307e
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %r14, %r8
xorl %eax, %eax
callq 0xfc3d
movq %rbx, %rdi
callq 0x3a285
movq %rax, %r15
movzbl (%r14), %eax
leaq 0x12015b(%rip), %rcx    # 0x15a340
cmpb $0x1, (%rax,%rcx)
jne 0x3a215
cmpl $0x15, %eax
jne 0x3a1f7
testb $0x1, 0x7(%r14)
jne 0x3a215
cmpq %r14, 0x150(%rbx)
je 0x3a215
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x9b866
jmp 0x3a231
leaq 0x120164(%rip), %r9     # 0x15a380
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *(%r9,%rax,8)
movq 0x20(%r15), %r12
testq %r12, %r12
je 0x3a273
leaq 0x1(%r12), %rdi
callq 0x9480
movq %rax, %r14
movq 0x10(%r15), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x93e0
movb $0x0, (%r14,%r12)
movq 0x7e8(%rbx), %rax
movq 0x28(%r15), %rcx
movq %rax, 0x18(%rcx)
movq %r15, 0x7e8(%rbx)
jmp 0x3a276
xorl %r14d, %r14d
movq %r14, %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: open_format_port
static s7_pointer open_format_port(s7_scheme *sc)
    {
        s7_pointer x;
        s7_int len;
        block_t *block, *b;

        if (sc->format_ports)
        {
            x = sc->format_ports;
            sc->format_ports = (s7_pointer)(port_next(x));
            port_position(x) = 0;
            port_data(x)[0] = '\0';
            return(x);
        }

        len = FORMAT_PORT_LENGTH;
        x = alloc_pointer(sc);
#if S7_DEBUGGING
        permanent_ports++;
#endif
        set_type(x, T_OUTPUT_PORT);
        b = mallocate_port(sc);
        port_block(x) = b;
        port_port(x) = (port_t *)block_data(b);
        port_type(x) = STRING_PORT;
        port_set_closed(x, false);
        port_data_size(x) = len;
        port_next(x) = NULL;
        block = mallocate(sc, len);
        port_data(x) = (uint8_t *)(block_data(block));
        port_data_block(x) = block;
        port_data(x)[0] = '\0';
        port_position(x) = 0;
        port_needs_free(x) = false;
        port_port(x)->pf = &output_string_functions;
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x7e8(%rdi), %rbx
testq %rbx, %rbx
je 0x3a2bc
movq 0x28(%rbx), %rax
movq 0x18(%rax), %rax
movq %rax, 0x7e8(%r14)
movq $0x0, 0x20(%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax)
jmp 0x3a410
movq %r14, %rdi
callq 0xfa3b
movq %rax, %rbx
movq $0x22, (%rax)
movq %r14, %rdi
callq 0x10332
movq %rax, 0x28(%rbx)
movq (%rax), %rax
movq %rax, 0x8(%rbx)
movl $0x1, 0x4(%rax)
movq 0x8(%rbx), %rax
movb $0x0, 0x2(%rax)
movq $0x80, 0x18(%rbx)
movq 0x28(%rbx), %rax
movq $0x0, 0x18(%rax)
movq 0x870(%r14), %r15
testq %r15, %r15
je 0x3a320
movq 0x18(%r15), %rax
movq %rax, 0x870(%r14)
jmp 0x3a3d4
cmpq $0x0, 0x838(%r14)
jne 0x3a366
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, 0x838(%r14)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x3a344
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%r14), %r15
movq 0x18(%r15), %rax
movq %rax, 0x838(%r14)
movl $0x0, 0x8(%r15)
movq 0x8c8(%r14), %rax
subq $-0x80, %rax
cmpq $0x10001, %rax          # imm = 0x10001
jb 0x3a3b4
movl $0x10000, %edi          # imm = 0x10000
callq 0x9480
movq %rax, 0x8d0(%r14)
movq $0x0, 0x8c8(%r14)
movl $0x80, %eax
movq 0x8d0(%r14), %rcx
addq 0x8c8(%r14), %rcx
movq %rax, 0x8c8(%r14)
movq %rcx, (%r15)
movl $0x7, 0x8(%r15)
movq $0x80, 0x10(%r15)
movq (%r15), %rax
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rax
movq %r15, 0x38(%rax)
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movq $0x0, 0x20(%rbx)
movq 0x8(%rbx), %rax
movb %cl, (%rax)
movq 0x8(%rbx), %rax
leaq 0x1141e4(%rip), %rcx    # 0x14e5f0
movq %rcx, 0x48(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: block_to_string
static s7_pointer block_to_string(s7_scheme *sc, block_t *block, s7_int len)
    {
        s7_pointer x;
        new_cell(sc, x, T_STRING | T_SAFE_PROCEDURE);
        string_block(x) = block;
        string_value(x) = (char *)block_data(block);
        string_length(x) = len;
        string_value(x)[len] = '\0';
        string_hash(x) = 0;
        add_string(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x3a442
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200013, (%rbx)       # imm = 0x200013
movq %r12, 0x20(%rbx)
movq (%r12), %rax
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movb $0x0, (%rax,%r15)
movq $0x0, 0x18(%rbx)
movq 0x738(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x3a4a4
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
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: s7_write
s7_pointer s7_write(s7_scheme *sc, s7_pointer obj, s7_pointer port)
    {
        if (port != sc->F)
        {
            if (port_is_closed(port))
                s7_wrong_type_arg_error(sc, "write", 2, port, "an open output port");
            object_out(sc, obj, port, P_WRITE);
        }
        return(obj);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq %rdx, 0x120(%rdi)
je 0x3a57e
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x3a529
leaq 0xd8b96(%rip), %rsi     # 0x1130a8
leaq 0xe995c(%rip), %r8      # 0x123e75
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0xe25f
movzbl (%rbx), %eax
leaq 0x11fe0d(%rip), %rcx    # 0x15a340
cmpb $0x1, (%rax,%rcx)
jne 0x3a562
cmpl $0x15, %eax
jne 0x3a544
testb $0x1, 0x7(%rbx)
jne 0x3a562
cmpq %rbx, 0x150(%r15)
je 0x3a562
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x9b866
jmp 0x3a57e
leaq 0x11fe17(%rip), %r9     # 0x15a380
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *(%r9,%rax,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_display
s7_pointer s7_display(s7_scheme *sc, s7_pointer obj, s7_pointer port)
    {
        if (port != sc->F)
        {
            if (port_is_closed(port))
                s7_wrong_type_arg_error(sc, "display", 2, port, "an open output port");
            object_out(sc, obj, port, P_DISPLAY);
        }
        return(obj);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq %rdx, 0x120(%rdi)
je 0x3a615
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x3a5c6
leaq 0xd8aff(%rip), %rsi     # 0x1130ae
leaq 0xe98bf(%rip), %r8      # 0x123e75
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0xe25f
movzbl (%rbx), %eax
leaq 0x11fd70(%rip), %rcx    # 0x15a340
cmpb $0x1, (%rax,%rcx)
jne 0x3a5fc
cmpl $0x15, %eax
jne 0x3a5e1
testb $0x1, 0x7(%rbx)
jne 0x3a5fc
cmpq %rbx, 0x150(%r15)
je 0x3a5fc
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9b866
jmp 0x3a615
leaq 0x11fd7d(%rip), %r9     # 0x15a380
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *(%r9,%rax,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_cons
s7_pointer s7_cons(s7_scheme *sc, s7_pointer a, s7_pointer b)
    {
        s7_pointer x;
        new_cell(sc, x, T_PAIR | T_SAFE_PROCEDURE);
        set_car(x, a);
        set_cdr(x, b);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x3a722
movq %r15, %rdi
callq 0xb389
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_signature
s7_pointer s7_make_signature(s7_scheme *sc, s7_int len, ...)
    {
        va_list ap;
        s7_int i;
        s7_pointer p, res;

        res = permanent_list(sc, len);
        va_start(ap, len);
        for (p = res, i = 0; is_pair(p); p = cdr(p), i++)
        {
            set_car(p, va_arg(ap, s7_pointer));
            check_sig_entry(sc, p, i, false);
        }
        va_end(ap);

        return((s7_pointer)res);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x3a7b0
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x110(%rdi), %r12
testq %rsi, %rsi
jle 0x3a7f0
movq %rsi, %r15
movabsq $0x4000000001000001, %r13 # imm = 0x4000000001000001
movq 0x110(%rbx), %rbp
movq %rbx, %rdi
callq 0xfa3b
movq %rax, %r14
movq %r13, (%rax)
movq %rbp, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, %r12
decq %r15
jne 0x3a7c9
jmp 0x3a7f3
movq %r12, %r14
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
cmpb $0x1, (%r14)
jne 0x3a872
xorl %r15d, %r15d
movq %r14, %r12
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x3a83d
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x3a84b
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%r12)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x3a887
movq 0x10(%r12), %r12
incq %r15
cmpb $0x1, (%r12)
je 0x3a824
movq %r14, %rax
addq $0xd8, %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: check_sig_entry
static void check_sig_entry(s7_scheme *sc, s7_pointer p, s7_int pos, bool circle)
    {
        if ((!is_normal_symbol(car(p))) &&
                (!s7_is_boolean(car(p))) &&
                (!is_pair(car(p))))
        {
            s7_warn(sc, 512, "s7_make_%ssignature got an invalid entry at position %" print_s7_int ": (", (circle) ? "circular_" : "", pos);
            set_car(p, sc->nil);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r8
movq 0x8(%rsi), %rdx
movzbl (%rdx), %eax
cmpl $0x1, %eax
je 0x3a8f4
cmpl $0x7, %eax
je 0x3a8f4
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xa, %eax
jne 0x3a8bc
movzwl 0x6(%rdx), %edx
testb %dl, %dl
jns 0x3a8f4
cmpl $0x1, %eax
je 0x3a8f4
cmpl $0x7, %eax
je 0x3a8f4
leaq 0xe56d1(%rip), %rdx     # 0x11ff94
leaq 0xeaaf4(%rip), %rax     # 0x1253be
testb %cl, %cl
cmovneq %rdx, %rax
leaq 0xe5681(%rip), %rdx     # 0x11ff58
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xfc3d
movq 0x110(%r14), %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: s7_make_circular_signature
s7_pointer s7_make_circular_signature(s7_scheme *sc, s7_int cycle_point, s7_int len, ...)
    {
        va_list ap;
        s7_int i;
        s7_pointer p, res, back = NULL, end = NULL;

        res = permanent_list(sc, len);
        va_start(ap, len);
        for (p = res, i = 0; is_pair(p); p = cdr(p), i++)
        {
            set_car(p, va_arg(ap, s7_pointer));
            check_sig_entry(sc, p, i, true);
            if (i == cycle_point) back = p;
            if (i == (len - 1)) end = p;
        }
        va_end(ap);
        if (end) set_cdr(end, back);
        if (i < len)
            s7_warn(sc, 256, "s7_make_circular_signature got too few entries: %s\n", s7_object_to_c_string(sc, res));
        return((s7_pointer)res);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, 0x38(%rsp)
movq %rdi, %rbx
movq %rcx, 0x58(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x68(%rsp)
testb %al, %al
je 0x3a965
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq 0x110(%rdi), %r14
testq %rdx, %rdx
movq %rdx, 0x8(%rsp)
jle 0x3a9aa
movabsq $0x4000000001000001, %r12 # imm = 0x4000000001000001
movq %rdx, %r13
movq 0x110(%rbx), %rbp
movq %rbx, %rdi
callq 0xfa3b
movq %rax, %r15
movq %r12, (%rax)
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, %r14
decq %r13
jne 0x3a983
jmp 0x3a9ad
movq %r14, %r15
leaq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x130(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
cmpb $0x1, (%r15)
movl $0x0, %r12d
movl $0x0, %r14d
jne 0x3aa63
movq 0x8(%rsp), %rax
decq %rax
movq %rax, 0x30(%rsp)
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %r15, %rbp
movl 0x10(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x3aa1c
movq %rcx, %rax
addq 0x20(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x10(%rsp)
jmp 0x3aa2a
movq 0x18(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rbp)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x3a887
cmpq %r13, 0x38(%rsp)
cmoveq %rbp, %r12
cmpq %r13, 0x30(%rsp)
cmoveq %rbp, %r14
movq 0x10(%rbp), %rbp
incq %r13
cmpb $0x1, (%rbp)
je 0x3aa01
testq %r14, %r14
je 0x3aa6c
movq %r12, 0x10(%r14)
cmpq 0x8(%rsp), %r13
jge 0x3aa97
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a188
leaq 0xd8631(%rip), %rdx     # 0x1130b6
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xfc3d
movq %r15, %rax
addq $0xf8, %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: s7_apply_n_2
s7_pointer s7_apply_n_2(s7_scheme *sc, s7_pointer args, s7_pointer (*f2)(s7_pointer a1, s7_pointer a2))
    {
        if (is_pair(args))
        {
            if (is_pair(cdr(args)))
                return(f2(car(args), cadr(args)));
            return(f2(car(args), sc->undefined));
        }
        return(f2(sc->undefined, sc->undefined));
    }

// Assembly:
cmpb $0x1, (%rsi)
jne 0x3ae1b
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x3ae27
movq 0x8(%rcx), %rsi
jmp 0x3ae2e
movq 0x128(%rdi), %rdi
movq %rdi, %rsi
jmpq *%rdx
movq 0x128(%rdi), %rsi
movq %rax, %rdi
jmpq *%rdx
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_n_3
s7_pointer s7_apply_n_3(s7_scheme *sc, s7_pointer args, s7_pointer (*f3)(s7_pointer a1, s7_pointer a2, s7_pointer a3))
    {
        if (is_pair(args))
        {
            s7_pointer a1;
            a1 = car(args); args = cdr(args);
            if (is_pair(args))
            {
                s7_pointer a2;
                a2 = car(args);
                if (is_pair(cdr(args)))
                    return(f3(a1, a2, cadr(args)));
                return(f3(a1, a2, sc->undefined));
            }
            return(f3(a1, sc->undefined, sc->undefined));
        }
        return(f3(sc->undefined, sc->undefined, sc->undefined));
    }

// Assembly:
movq %rdx, %rax
cmpb $0x1, (%rsi)
jne 0x3ae5b
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
cmpb $0x1, (%rdx)
jne 0x3ae6a
movq 0x8(%rdx), %rsi
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
jne 0x3ae79
movq 0x8(%rdx), %rdx
jmp 0x3ae80
movq 0x128(%rdi), %rdi
movq %rdi, %rsi
movq %rdi, %rdx
jmpq *%rax
movq 0x128(%rdi), %rdx
movq %rcx, %rdi
movq %rdx, %rsi
jmpq *%rax
movq 0x128(%rdi), %rdx
movq %rcx, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_n_4
s7_pointer s7_apply_n_4(s7_scheme *sc, s7_pointer args, s7_pointer (*f4)(s7_pointer a1, s7_pointer a2, s7_pointer a3, s7_pointer a4))
    {
        if (is_pair(args))
        {
            s7_pointer a1;
            a1 = car(args); args = cdr(args);
            if (is_pair(args))
            {
                s7_pointer a2;
                a2 = car(args); args = cdr(args);
                if (is_pair(args))
                {
                    s7_pointer a3;
                    a3 = car(args);
                    if (is_pair(cdr(args)))
                        return(f4(a1, a2, a3, cadr(args)));
                    return(f4(a1, a2, a3, sc->undefined));
                }
                return(f4(a1, a2, sc->undefined, sc->undefined));
            }
            return(f4(a1, sc->undefined, sc->undefined, sc->undefined));
        }
        return(f4(sc->undefined, sc->undefined, sc->undefined, sc->undefined));
    }

// Assembly:
movq %rdx, %rax
cmpb $0x1, (%rsi)
jne 0x3aeba
movq 0x8(%rsi), %r8
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x3aec6
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x3aed8
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x3aee4
movq 0x8(%rcx), %rcx
jmp 0x3aeeb
movq 0x128(%rdi), %rcx
movq %rcx, %rdi
jmp 0x3aed0
movq 0x128(%rdi), %rcx
movq %r8, %rdi
movq %rcx, %rsi
movq %rcx, %rdx
jmpq *%rax
movq 0x128(%rdi), %rcx
movq %r8, %rdi
jmp 0x3aed3
movq 0x128(%rdi), %rcx
movq %r8, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_n_5
s7_pointer s7_apply_n_5(s7_scheme *sc, s7_pointer args,
            s7_pointer (*f5)(s7_pointer a1, s7_pointer a2, s7_pointer a3, s7_pointer a4, s7_pointer a5))
    {
        if (is_pair(args))
        {
            s7_pointer a1;
            a1 = car(args); args = cdr(args);
            if (is_pair(args))
            {
                s7_pointer a2;
                a2 = car(args); args = cdr(args);
                if (is_pair(args))
                {
                    s7_pointer a3;
                    a3 = car(args); args = cdr(args);
                    if (is_pair(args))
                    {
                        s7_pointer a4;
                        a4 = car(args);
                        if (is_pair(cdr(args)))
                            return(f5(a1, a2, a3, a4, cadr(args)));
                        return(f5(a1, a2, a3, a4, sc->undefined));
                    }
                    return(f5(a1, a2, a3, sc->undefined, sc->undefined));
                }
                return(f5(a1, a2, sc->undefined, sc->undefined, sc->undefined));
            }
            return(f5(a1, sc->undefined, sc->undefined, sc->undefined, sc->undefined));
        }
        return(f5(sc->undefined, sc->undefined, sc->undefined, sc->undefined, sc->undefined));
    }

// Assembly:
movq %rdx, %rax
movq %rdi, %r8
cmpb $0x1, (%rsi)
jne 0x3af37
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x3af43
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x3af55
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %r9
cmpb $0x1, (%r9)
jne 0x3af5e
movq 0x8(%r9), %rcx
movq 0x10(%r9), %r9
cmpb $0x1, (%r9)
jne 0x3af67
movq 0x8(%r9), %r8
jmpq *%rax
movq 0x128(%r8), %rcx
movq %rcx, %rdi
jmp 0x3af4a
movq 0x128(%r8), %rcx
movq %rcx, %rsi
movq %rcx, %rdx
movq %rcx, %r8
jmpq *%rax
movq 0x128(%r8), %rcx
jmp 0x3af4d
movq 0x128(%r8), %rcx
jmp 0x3af50
movq 0x128(%r8), %r8
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_n_6
s7_pointer s7_apply_n_6(s7_scheme *sc, s7_pointer args,
            s7_pointer (*f6)(s7_pointer a1, s7_pointer a2, s7_pointer a3, s7_pointer a4, s7_pointer a5, s7_pointer a6))
    {
        s7_pointer a1, a2, a3, a4, a5, a6, a7, a8, a9;
        a7 = sc->undefined; a8 = a7; a9 = a8;
        a1 = a9; a2 = a9; a3 = a9; a4 = a9; a5 = a9; a6 = a9;
        apply_set_args(args)
            return(f6(a1, a2, a3, a4, a5, a6));
    }

// Assembly:
movq %rdx, %rax
movq 0x128(%rdi), %r9
cmpb $0x1, (%rsi)
jne 0x3afc9
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x3afcc
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x3afcf
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %r8
cmpb $0x1, (%r8)
jne 0x3afd2
movq 0x8(%r8), %rcx
movq 0x10(%r8), %r10
cmpb $0x1, (%r10)
jne 0x3afd5
movq 0x8(%r10), %r8
movq 0x10(%r10), %r10
cmpb $0x1, (%r10)
jne 0x3afd8
movq 0x8(%r10), %r9
jmpq *%rax
movq %r9, %rdi
movq %r9, %rsi
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_list_ref
s7_pointer s7_list_ref(s7_scheme *sc, s7_pointer lst, s7_int num)
    {
        s7_int i;
        s7_pointer x;
        for (x = lst, i = 0; (i < num) && (is_pair(x)); i++, x = cdr(x)) {}
        if ((i == num) && (is_pair(x)))
            return(car(x));
        return(sc->nil);
    }

// Assembly:
xorl %eax, %eax
testq %rdx, %rdx
jle 0x3b1bd
cmpb $0x1, (%rsi)
jne 0x3b1bd
incq %rax
movq 0x10(%rsi), %rsi
cmpq %rax, %rdx
jne 0x3b1a9
movq %rdx, %rax
cmpq %rdx, %rax
jne 0x3b1d0
cmpb $0x1, (%rsi)
jne 0x3b1d0
addq $0x8, %rsi
movq %rsi, %rdi
jmp 0x3b1d7
addq $0x110, %rdi            # imm = 0x110
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_list_set
s7_pointer s7_list_set(s7_scheme *sc, s7_pointer lst, s7_int num, s7_pointer val)
    {
        s7_int i;
        s7_pointer x;
        for (x = lst, i = 0; (i < num) && (is_pair(x)); i++, x = cdr(x)) {}
        if ((i == num) &&
                (is_pair(x)))
            set_car(x, T_Pos(val));
        return(val);
    }

// Assembly:
movq %rcx, %rax
xorl %ecx, %ecx
testq %rdx, %rdx
jle 0x3b1f9
cmpb $0x1, (%rsi)
jne 0x3b1f9
incq %rcx
movq 0x10(%rsi), %rsi
cmpq %rcx, %rdx
jne 0x3b1e5
movq %rdx, %rcx
cmpq %rdx, %rcx
jne 0x3b207
cmpb $0x1, (%rsi)
jne 0x3b207
movq %rax, 0x8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_member
s7_pointer s7_member(s7_scheme *sc, s7_pointer sym, s7_pointer lst)
    {
        s7_pointer x;
        for (x = lst; is_pair(x); x = cdr(x))
            if (s7_is_equal(sc, sym, car(x)))
                return(x);
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpb $0x1, (%rdx)
jne 0x3b246
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x11fafb(%rip), %r12    # 0x15ad20
movq 0x8(%rbx), %rdx
movzbl (%r15), %eax
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq *(%r12,%rax,8)
testb %al, %al
jne 0x3b24d
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0x3b225
movq 0x120(%r14), %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: s7_tree_memq
bool s7_tree_memq(s7_scheme *sc, s7_pointer sym, s7_pointer tree)
    {
        if (sym == tree) return(true);
        if (!is_pair(tree)) return(false);
        if ((sc->safety > NO_SAFETY) &&
                (tree_is_cyclic(sc, tree)))
            s7_error(sc, sc->wrong_type_arg_symbol, wrap_string(sc, "tree-memq: tree is cyclic", 25));
        return(tree_memq_1(sc, sym, tree));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rdx, %rsi
je 0x3b2f3
movq %rdx, %rbx
cmpb $0x1, (%rdx)
jne 0x3b2f7
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x6a0(%rdi)
jle 0x3b2e0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3b2ff
testb %al, %al
je 0x3b2e0
movq 0x1940(%r15), %rsi
movq 0x820(%r15), %rax
movslq 0x7dc(%r15), %rcx
movq (%rax,%rcx,8), %rdx
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%r15)
leaq 0xd7e1e(%rip), %rax     # 0x1130ea
movq %rax, 0x10(%rdx)
movq $0x19, 0x8(%rdx)
movq %r15, %rdi
callq 0x3b366
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3bdf1
movb $0x1, %al
jmp 0x3b2f9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: tree_is_cyclic
static bool tree_is_cyclic(s7_scheme *sc, s7_pointer tree)
    {
        int32_t i, result;

        result = tree_is_cyclic_or_has_pairs(sc, tree);
        if (result == TREE_NOT_CYCLIC) return(false);
        if (result == TREE_CYCLIC) return(true);

#if S7_DEBUGGING
        if (sc->tree_pointers_top != 0)
            fprintf(stderr, "top: %d\n", sc->tree_pointers_top);
#endif

        result = tree_is_cyclic_1(sc, tree);
        for (i = 0; i < sc->tree_pointers_top; i++)
            tree_clear_collected(sc->tree_pointers[i]);
        sc->tree_pointers_top = 0;

        return(result);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9fe76
testl %eax, %eax
je 0x3b31b
cmpl $0x1, %eax
jne 0x3b31f
movb $0x1, %al
jmp 0x3b35e
xorl %eax, %eax
jmp 0x3b35e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9fefb
cmpl $0x0, 0x7d4(%rbx)
jle 0x3b354
xorl %ecx, %ecx
movq 0x7c8(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
andw $-0x9, 0x6(%rdx)
incq %rcx
movslq 0x7d4(%rbx), %rdx
cmpq %rdx, %rcx
jl 0x3b335
movl $0x0, 0x7d4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: tree_memq_1
static inline bool tree_memq_1(s7_scheme *sc, s7_pointer sym, s7_pointer tree)    /* sym need not be a symbol */
    {
        if (car(tree) == sc->quote_symbol)
        {
            if ((is_symbol(sym)) || (is_pair(sym)) || (!is_pair(cdr(tree))))
                return(false);
            return(sym == cadr(tree));
        }
        do {
            if (sym == car(tree))
                return(true);

            if (is_pair(car(tree)))
            {
                s7_pointer cp;
                cp = car(tree);
                if (car(cp) == sc->quote_symbol)
                {
                    if ((!is_symbol(sym)) && (!is_pair(sym)) && (is_pair(cdr(cp))) && (sym == cadr(cp)))
                        return(true);
                }
                else
                {
                    do {
                        if (sym == car(cp))
                            return(true);
                        if ((is_pair(car(cp))) &&
                                (tree_memq_1(sc, sym, car(cp))))
                            return(true);
                        cp = cdr(cp);
                        if (sym == cp)
                            return(true);
                    } while (is_pair(cp));
                }
            }

            tree = cdr(tree);
            if (sym == tree)
                return(true);
        } while (is_pair(tree));
        return(false);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq 0x17b0(%rdi), %r13
cmpq %r13, 0x8(%rdx)
je 0x3be89
movq %rdi, %r12
movq 0x8(%r15), %rbp
movb $0x1, %bl
cmpq %r14, %rbp
je 0x3bead
cmpb $0x1, (%rbp)
jne 0x3be78
cmpq %r13, 0x8(%rbp)
je 0x3be5b
movq 0x8(%rbp), %rdx
cmpq %r14, %rdx
je 0x3bead
cmpb $0x1, (%rdx)
jne 0x3be4a
movq %r12, %rdi
movq %r14, %rsi
callq 0x3bdf1
testb %al, %al
jne 0x3bead
movq 0x10(%rbp), %rbp
cmpq %r14, %rbp
je 0x3bead
cmpb $0x1, (%rbp)
je 0x3be2d
jmp 0x3be78
movzbl (%r14), %eax
cmpl $0x1, %eax
je 0x3be78
cmpl $0xa, %eax
je 0x3be78
movq 0x10(%rbp), %rax
cmpb $0x1, (%rax)
jne 0x3be78
cmpq %r14, 0x8(%rax)
je 0x3bead
movq 0x10(%r15), %r15
cmpq %r14, %r15
je 0x3bead
cmpb $0x1, (%r15)
je 0x3be12
jmp 0x3beab
movzbl (%r14), %eax
xorl %ebx, %ebx
cmpl $0x1, %eax
je 0x3bead
cmpl $0xa, %eax
je 0x3bead
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0x3beab
cmpq %r14, 0x8(%rax)
sete %bl
jmp 0x3bead
xorl %ebx, %ebx
movl %ebx, %eax
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: s7_assoc
s7_pointer s7_assoc(s7_scheme *sc, s7_pointer sym, s7_pointer lst)
                {
                    s7_pointer x, y;

                    if (!is_pair(lst))
                        return(sc->F);

                    x = lst;
                    y = lst;
                    while (true)
                    {
                        if ((is_pair(car(x))) && (s7_is_equal(sc, sym, caar(x)))) return(car(x));
                        x = cdr(x);
                        if (!is_pair(x)) return(sc->F);

                        if ((is_pair(car(x))) && (s7_is_equal(sc, sym, caar(x)))) return(car(x));
                        x = cdr(x);
                        if (!is_pair(x)) return(sc->F);

                        y = cdr(y);
                        if (x == y) return(sc->F);
                    }
                    return(sc->F);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, (%rdx)
jne 0x3bf3e
movq %rdx, %r15
movq %rsi, %r14
leaq 0x11ee44(%rip), %r12    # 0x15ad20
movq %rdx, %r13
movq 0x8(%r15), %rax
cmpb $0x1, (%rax)
jne 0x3bf00
movq 0x8(%rax), %rdx
movzbl (%r14), %eax
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq *(%r12,%rax,8)
testb %al, %al
jne 0x3bf52
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x3bf3e
movq 0x8(%r15), %rax
cmpb $0x1, (%rax)
jne 0x3bf2b
movq 0x8(%rax), %rdx
movzbl (%r14), %eax
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq *(%r12,%rax,8)
testb %al, %al
jne 0x3bf52
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x3bf3e
movq 0x10(%r13), %r13
cmpq %r13, %r15
jne 0x3bedf
addq $0x120, %rbx            # imm = 0x120
movq (%rbx), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq $0x8, %r15
movq %r15, %rbx
jmp 0x3bf45