LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rcx
movabsq $0x80000000, %rax       # imm = 0x80000000
andq (%rcx), %rax
cmpq $0x0, %rax
je 0x2ca1b
movb $0x0, 0x17(%rsp)
jmp 0x2ca5d
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1d, %eax
je 0x2ca58
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x11d0(%rax), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1edc25(%rip), %r8     # 0x21a678
callq 0x14a60
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2ca95
movb $0x0, 0x27(%rsp)
jmp 0x2cb25
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jle 0x2cb1b
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x34, %eax
jge 0x2cb1b
movq 0x10(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x2cac9
movb $0x1, 0xf(%rsp)
jmp 0x2cb19
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2cb30
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jl 0x2cb17
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0xa8(%rcx), %rax
jge 0x2cb17
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x10(%rsp), %rax
sete %al
andb $0x1, %al
movb %al, 0xf(%rsp)
jmp 0x2cb19
jmp 0x2cb1b
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: heap_location
static int64_t heap_location(s7_scheme *sc, s7_pointer p)
    {
        heap_block_t *hp;
        for (hp = sc->heap_blocks; hp; hp = hp->next)
        {
            if (((intptr_t)p >= hp->start) && ((intptr_t)p < hp->end))
                return(hp->offset + (((intptr_t)p - hp->start) / sizeof(s7_cell)));
        }
        return(((s7_big_pointer)p)->big_hloc);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x2a68(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0x2cbbb
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq (%rcx), %rax
jl 0x2cba9
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x2cba9
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
subq (%rcx), %rax
movl $0x30, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x28(%rsp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x2cbc9
jmp 0x2cbab
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x2cb4b
movq -0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0x2ccf2
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x198(%rcx), %rax
jne 0x2cc28
movq 0x1e83e6(%rip), %rax    # 0x214ff8
movq (%rax), %rdi
leaq 0x1b4ff7(%rip), %rsi    # 0x1e1c13
movb $0x0, %al
callq 0x9390
jmp 0x2cca8
movq 0x18(%rsp), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0x2cc79
movq 0x1e83b5(%rip), %rax    # 0x214ff8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rsi
xorl %edx, %edx
callq 0x2cd00
movq 0x10(%rsp), %rdi
movq 0x10(%rax), %rdx
leaq 0x1b4fad(%rip), %rsi    # 0x1e1c1d
movb $0x0, %al
callq 0x9390
jmp 0x2cca6
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x158(%rcx), %rax
jne 0x2cca4
movq 0x1e8365(%rip), %rax    # 0x214ff8
movq (%rax), %rdi
leaq 0x1b4f8f(%rip), %rsi    # 0x1e1c2c
movb $0x0, %al
callq 0x9390
jmp 0x2cca6
jmp 0x2cca8
movq 0x1e8349(%rip), %rax    # 0x214ff8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x2cd00
movq 0x8(%rsp), %rdi
movq 0x10(%rax), %rdx
leaq 0x1c2899(%rip), %rsi    # 0x1ef571
movb $0x0, %al
callq 0x9390
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x2cbe7
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_object_to_string
s7_pointer s7_object_to_string(s7_scheme *sc, s7_pointer obj, bool use_write) /* unavoidable backwards compatibility rigidity here */
    {
        s7_pointer strport, res;

        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, (use_write) ? P_WRITE : P_DISPLAY);

        if (port_position(strport) >= port_data_size(strport))
            res = block_to_string(sc, reallocate(sc, port_data_block(strport), port_position(strport) + 1), port_position(strport));
        else res = block_to_string(sc, port_data_block(strport), port_position(strport));
        restore_format_port(sc, strport);
        return(res);
    }

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x6a0(%rax)
jle 0x2cd5c
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2ca70
testb $0x1, %al
jne 0x2cd5c
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x1b4f15(%rip), %rdx    # 0x1e1c63
leaq 0x1b4f37(%rip), %rcx    # 0x1e1c8c
movb $0x0, %al
callq 0x14df0
movq 0x30(%rsp), %rdi
callq 0x2cfa0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
movb 0x27(%rsp), %r8b
xorl %ecx, %ecx
movl $0x1, %eax
testb $0x1, %r8b
cmovnel %eax, %ecx
callq 0x2d120
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jl 0x2cdf1
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdx
addq $0x1, %rdx
callq 0xbb60
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdx
callq 0x2d220
movq %rax, 0x10(%rsp)
jmp 0x2ce16
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdx
callq 0x2d220
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2d300
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x6a0(%rax)
jle 0x2cef4
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2ca70
testb $0x1, %al
jne 0x2cef4
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x1b4d7d(%rip), %rdx    # 0x1e1c63
leaq 0x1b4d89(%rip), %rcx    # 0x1e1c76
movb $0x0, %al
callq 0x14df0
movq 0x28(%rsp), %rdi
callq 0x2cfa0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl $0x1, %ecx
callq 0x2d120
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2cf3d
movq $0x0, 0x30(%rsp)
jmp 0x2cf8f
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
callq 0x9480
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x93e0
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2d1e0
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x7e8(%rax)
je 0x2d00a
movq 0x28(%rsp), %rax
movq 0x7e8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x7e8(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movb $0x0, (%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2d112
movq $0x80, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x148a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x22, (%rax)
movq 0x28(%rsp), %rdi
callq 0x15570
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x4(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x2(%rax)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq $0x0, 0x18(%rax)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xaa80
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movb $0x0, (%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
leaq 0x1e8b84(%rip), %rcx    # 0x215c88
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: object_out
static inline s7_pointer object_out(s7_scheme *sc, s7_pointer obj, s7_pointer strport, use_write_t choice)
    {
        if ((has_structure(obj)) &&
                (obj != sc->rootlet))
            object_out_1(sc, obj, strport, choice);
        else object_to_port(sc, obj, strport, choice, NULL);
        return(obj);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1f4d48(%rip), %rax    # 0x221e90
testb $0x1, (%rax,%rcx)
je 0x2d19b
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x15, %eax
jne 0x2d16e
movq 0x18(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x2d19b
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x150(%rcx), %rax
je 0x2d19b
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0xd0000
jmp 0x2d1c8
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1f4d24(%rip), %rax    # 0x221ed0
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
xorl %r8d, %r8d
callq *%rax
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x2d257
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x200013, (%rax)       # imm = 0x200013
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x738(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x11230
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: restore_format_port
static inline void restore_format_port(s7_scheme *sc, s7_pointer strport)
    {
        block_t *block;
        block = mallocate(sc, FORMAT_PORT_LENGTH);
        port_data(strport) = (uint8_t *)(block_data(block));
        port_data_block(strport) = block;
        port_data(strport)[0] = '\0';
        port_position(strport) = 0;
        port_data_size(strport) = FORMAT_PORT_LENGTH;
        port_needs_free(strport) = false;
        close_format_port(sc, strport);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x80, %esi
callq 0xaa80
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movb $0x0, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x80, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2d1e0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x120(%rcx), %rax
je 0x2d44b
movq (%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x2d433
movq 0x10(%rsp), %rdi
movq (%rsp), %rcx
leaq 0x1b487e(%rip), %rsi    # 0x1e1ca0
movl $0x2, %edx
leaq 0x1c5ab2(%rip), %r8     # 0x1f2ee0
callq 0x12540
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movl $0x1, %ecx
callq 0x2d120
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x120(%rcx), %rax
je 0x2d4c8
movq (%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x2d4b3
movq 0x10(%rsp), %rdi
movq (%rsp), %rcx
leaq 0x1b4804(%rip), %rsi    # 0x1e1ca6
movl $0x2, %edx
leaq 0x1c5a32(%rip), %r8     # 0x1f2ee0
callq 0x12540
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
xorl %ecx, %ecx
callq 0x2d120
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_format
const char *s7_format(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer result;
        result = g_format(sc, args);
        if (is_string(result))
            return(string_value(result));
        return(NULL);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2d540
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
jne 0x2d51f
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x2d528
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x2d757
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x118, %rsp            # imm = 0x118
testb %al, %al
je 0x2d7f2
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 %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq 0x110(%rsp), %rdi
movq 0x108(%rsp), %rsi
callq 0x2d950
movq %rax, 0xd8(%rsp)
leaq 0xf0(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x120(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xd8(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq $0x0, 0xe8(%rsp)
movq 0xe0(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2d93f
leaq 0xf0(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0xf0(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x28, %eax
ja 0x2d8c6
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, 0x8(%rsp)
jmp 0x2d8df
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0xe0(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x110(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x2d9d0
movq 0xe0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xe0(%rsp)
movq 0xe8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xe8(%rsp)
jmp 0x2d879
movq 0xd8(%rsp), %rax
addq $0x118, %rsp            # imm = 0x118
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: permanent_list
static s7_pointer permanent_list(s7_scheme *sc, s7_int len)
    {
        s7_int j;
        s7_pointer p;
        p = sc->nil;
        for (j = 0; j < len; j++)
            p = permanent_cons(sc, sc->nil, p, T_PAIR | T_IMMUTABLE);
        return(p);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jge 0x2d9b9
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rsi
movq 0x8(%rsp), %rdx
movl $0x1000001, %ecx        # imm = 0x1000001
callq 0x60af0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2d978
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x2da13
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movzwl 0x6(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x2da81
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x9c50
testb $0x1, %al
jne 0x2da81
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x2da81
movq 0x20(%rsp), %rdi
movb 0xf(%rsp), %dl
leaq 0x1c6a73(%rip), %rcx    # 0x1f44b9
leaq 0x1c1117(%rip), %rax    # 0x1eeb64
testb $0x1, %dl
cmovneq %rax, %rcx
movq 0x10(%rsp), %r8
movl $0x200, %esi            # imm = 0x200
leaq 0x1c10c3(%rip), %rdx    # 0x1eeb28
movb $0x0, %al
callq 0x14df0
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x138, %rsp            # imm = 0x138
testb %al, %al
je 0x2dad2
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 %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq $0x0, 0xe0(%rsp)
movq $0x0, 0xd8(%rsp)
movq 0x130(%rsp), %rdi
movq 0x120(%rsp), %rsi
callq 0x2d950
movq %rax, 0xe8(%rsp)
leaq 0x100(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x140(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0xe8(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq $0x0, 0xf8(%rsp)
movq 0xf0(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2dc8a
leaq 0x100(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x100(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x28, %eax
ja 0x2dbc1
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, 0x8(%rsp)
jmp 0x2dbda
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x130(%rsp), %rdi
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movl $0x1, %ecx
callq 0x2d9d0
movq 0xf8(%rsp), %rax
cmpq 0x128(%rsp), %rax
jne 0x2dc32
movq 0xf0(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xf8(%rsp), %rax
movq 0x120(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x2dc5b
movq 0xf0(%rsp), %rax
movq %rax, 0xd8(%rsp)
jmp 0x2dc5d
movq 0xf0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xf0(%rsp)
movq 0xf8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xf8(%rsp)
jmp 0x2db74
leaq 0x100(%rsp), %rax
cmpq $0x0, 0xd8(%rsp)
je 0x2dcb1
movq 0xe0(%rsp), %rcx
movq 0xd8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0xf8(%rsp), %rax
cmpq 0x120(%rsp), %rax
jge 0x2dcfe
movq 0x130(%rsp), %rax
movq %rax, (%rsp)
movq 0x130(%rsp), %rdi
movq 0xe8(%rsp), %rsi
callq 0x2cea0
movq (%rsp), %rdi
movq %rax, %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x1b3fb7(%rip), %rdx    # 0x1e1cae
movb $0x0, %al
callq 0x14df0
movq 0xe8(%rsp), %rax
addq $0x138, %rsp            # imm = 0x138
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2e768
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2e745
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rdi
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0x2e78c
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rdi
movq 0x18(%rsp), %rcx
movq 0x128(%rcx), %rsi
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0x2e78c
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x128(%rcx), %rdi
movq 0x18(%rsp), %rcx
movq 0x128(%rcx), %rsi
callq *%rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2e880
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2e855
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2e831
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
callq *%rax
movq %rax, 0x30(%rsp)
jmp 0x2e8b0
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rdx
callq *%rax
movq %rax, 0x30(%rsp)
jmp 0x2e8b0
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rsi
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rdx
callq *%rax
movq %rax, 0x30(%rsp)
jmp 0x2e8b0
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rdi
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rsi
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rdx
callq *%rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2ea16
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2e9df
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2e9af
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2e984
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
callq *%rax
movq %rax, 0x30(%rsp)
jmp 0x2ea52
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rcx
callq *%rax
movq %rax, 0x30(%rsp)
jmp 0x2ea52
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rdx
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rcx
callq *%rax
movq %rax, 0x30(%rsp)
jmp 0x2ea52
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rsi
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rdx
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rcx
callq *%rax
movq %rax, 0x30(%rsp)
jmp 0x2ea52
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rdi
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rsi
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rdx
movq 0x28(%rsp), %rcx
movq 0x128(%rcx), %rcx
callq *%rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2ee99
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2ee97
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2ee95
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2ee93
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2ee91
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2ee8f
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2ee8d
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2ee8b
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2ee89
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2ee8b
jmp 0x2ee8d
jmp 0x2ee8f
jmp 0x2ee91
jmp 0x2ee93
jmp 0x2ee95
jmp 0x2ee97
jmp 0x2ee99
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r9
callq *%rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_n_7
s7_pointer s7_apply_n_7(s7_scheme *sc, s7_pointer args,
            s7_pointer (*f7)(s7_pointer a1, s7_pointer a2, s7_pointer a3, s7_pointer a4,
                s7_pointer a5, s7_pointer a6, s7_pointer a7))
    {
        s7_pointer a1, a2, a3, a4, a5, a6, a7, a8, a9;
        a8 = sc->undefined; a9 = a8;
        a1 = a9; a2 = a9; a3 = a9; a4 = a9; a5 = a9; a6 = a9, a7 = a9;
        apply_set_args(args)
            return(f7(a1, a2, a3, a4, a5, a6, a7));
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f0c9
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f0c7
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f0c5
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f0c3
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f0c1
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f0bf
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f0bd
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f0bb
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f0b9
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2f0bb
jmp 0x2f0bd
jmp 0x2f0bf
jmp 0x2f0c1
jmp 0x2f0c3
jmp 0x2f0c5
jmp 0x2f0c7
jmp 0x2f0c9
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r9
movq 0x18(%rsp), %r10
movq %r10, (%rsp)
callq *%rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rcx
xorl %eax, %eax
cmpq -0x20(%rsp), %rcx
movb %al, -0x31(%rsp)
jge 0x2f5d6
movq -0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
sete %al
movb %al, -0x31(%rsp)
movb -0x31(%rsp), %al
testb $0x1, %al
jne 0x2f5e0
jmp 0x2f600
jmp 0x2f5e2
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
jmp 0x2f5b2
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jne 0x2f629
movq -0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f629
movq -0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x2f63a
movq -0x10(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rcx
xorl %eax, %eax
cmpq -0x18(%rsp), %rcx
movb %al, -0x31(%rsp)
jge 0x2f68b
movq -0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
sete %al
movb %al, -0x31(%rsp)
movb -0x31(%rsp), %al
testb $0x1, %al
jne 0x2f695
jmp 0x2f6b5
jmp 0x2f697
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
jmp 0x2f667
movq -0x28(%rsp), %rax
cmpq -0x18(%rsp), %rax
jne 0x2f6dc
movq -0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f6dc
movq -0x20(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2f750
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x2f770
testb $0x1, %al
jne 0x2f735
jmp 0x2f740
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2f761
jmp 0x2f742
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x2f70c
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x2f7c9
movb $0x1, 0x37(%rsp)
jmp 0x2f861
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x2f7e0
movb $0x0, 0x37(%rsp)
jmp 0x2f861
movq 0x28(%rsp), %rax
cmpq $0x0, 0x6a0(%rax)
jle 0x2f847
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f870
testb $0x1, %al
jne 0x2f804
jmp 0x2f847
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x1940(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x1b24b7(%rip), %rsi    # 0x1e1ce2
movl $0x19, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x30d60
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xd7700
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x2f8a2
movb $0x0, 0x27(%rsp)
jmp 0x2f92b
cmpl $0x1, 0x8(%rsp)
jne 0x2f8b0
movb $0x1, 0x27(%rsp)
jmp 0x2f92b
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xd7890
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x7d4(%rcx), %eax
jge 0x2f90e
movq 0x18(%rsp), %rax
movq 0x7c8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movzwl 0x6(%rax), %ecx
andl $-0x9, %ecx
movw %cx, 0x6(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2f8d0
movq 0x18(%rsp), %rax
movl $0x0, 0x7d4(%rax)
cmpl $0x0, 0x8(%rsp)
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)