LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: close_output_file
static void close_output_file(s7_scheme *sc, s7_pointer p)
    {
        if (port_filename(p)) /* only a file output port has a filename(?) */
        {
            liberate(sc, port_filename_block(p));
            port_filename(p) = NULL;
            port_filename_length(p) = 0;
        }
        if (port_file(p))
        {
            if (port_position(p) > 0)
            {
                if (fwrite((void *)(port_data(p)), 1, port_position(p), port_file(p)) != (size_t)port_position(p))
                    s7_warn(sc, 64, "fwrite trouble in close-output-port\n");
            }
            fflush(port_file(p));
            fclose(port_file(p));
            port_file(p) = NULL;
        }
        port_port(p)->pf = &closed_port_functions;
        port_set_closed(p, true);
        port_position(p) = 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
cmpq $0x0, 0x10(%rax)
je 0x944ee
movq 0x18(%rax), %r15
movslq 0x8(%r15), %rax
cmpq $0x11, %rax
jne 0x944c4
movq (%r15), %rdi
testq %rdi, %rdi
je 0x944b3
callq 0x8050
movq $0x0, (%r15)
movl $0x0, 0x8(%r15)
leaq 0x838(%r14), %rax
jmp 0x944ce
leaq (%r14,%rax,8), %rax
addq $0x838, %rax            # imm = 0x838
movq (%rax), %rcx
movq %rcx, 0x18(%r15)
movq %r15, (%rax)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq 0x8(%rbx), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x94554
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
jle 0x9452a
movq 0x10(%rbx), %rdi
movl $0x1, %esi
callq 0x8660
cmpq 0x20(%rbx), %rax
je 0x9452a
leaq 0x824ec(%rip), %rdx     # 0x116a07
movl $0x40, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0xeea2
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x8490
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x8180
movq 0x8(%rbx), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rbx), %rax
leaq 0xb1ff5(%rip), %rcx     # 0x146550
movq %rcx, 0x48(%rax)
movq 0x8(%rbx), %rax
movb $0x1, 0x2(%rax)
movq $0x0, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: close_simple_input_string
static void close_simple_input_string(s7_scheme *sc, s7_pointer p)
    {
#if S7_DEBUGGING
        if (port_filename(p))
            fprintf(stderr, "%s: port has a filename\n", __func__);
        if (port_needs_free(p))
            fprintf(stderr, "%s: port needs free\n", __func__);
#endif
        if (port_needs_unprotect(p))
        {
            s7_gc_unprotect_at(sc, port_gc_loc(p));
            port_needs_unprotect(p) = false;
        }
        port_port(p)->pf = &closed_port_functions;
        port_set_closed(p, true);
        port_position(p) = 0;
    }

// Assembly:
movq 0x8(%rsi), %rcx
cmpb $0x1, 0x1(%rcx)
jne 0x949ec
movq 0x28(%rcx), %rax
cmpq %rax, 0xf0(%rdi)
jle 0x949e4
movq 0xd0(%rdi), %rdx
movq 0x140(%rdi), %rcx
movq 0x10(%rdx), %r8
cmpq %rcx, (%r8,%rax,8)
je 0x949dc
movq 0xe8(%rdi), %r8
movq 0x108(%rdi), %r9
leaq 0x1(%r9), %r10
movq %r10, 0x108(%rdi)
movq %rax, 0x8(%r8,%r9,8)
movq 0x10(%rdx), %r8
movq %rcx, (%r8,%rax,8)
movq 0x8(%rsi), %rcx
movb $0x0, 0x1(%rcx)
movq 0x8(%rsi), %rcx
leaq 0xb1b5d(%rip), %rax     # 0x146550
movq %rax, 0x48(%rcx)
movq 0x8(%rsi), %rax
movb $0x1, 0x2(%rax)
movq $0x0, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: string_write_string
static void string_write_string(s7_scheme *sc, const char *str, s7_int len, s7_pointer pt)
    {
#if S7_DEBUGGING
        if (len == 0) {fprintf(stderr, "string_write_string len == 0\n"); abort();}
#endif
        if (port_position(pt) + len < port_data_size(pt))
        {
            memcpy((void *)(port_data(pt) + port_position(pt)), (void *)str, len);
            /* memcpy is much faster than the equivalent while loop, and faster than using the 4-bytes-at-a-time shuffle */
            port_position(pt) += len;
        }
        else string_write_string_resized(sc, str, len, pt);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x20(%rcx), %rax
leaq (%rax,%rdx), %r12
cmpq 0x18(%rcx), %r12
jge 0x94a7d
addq 0x10(%rbx), %rax
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x83e0
addq 0x20(%rbx), %r14
movq %r14, %r12
jmp 0x94a9c
leaq (%r12,%r12), %rdx
movq %rbx, %rsi
callq 0x94b07
movq 0x10(%rbx), %rdi
addq 0x20(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x83e0
movq %r12, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: resize_port_data
static void resize_port_data(s7_scheme *sc, s7_pointer pt, s7_int new_size)
    {
        s7_int loc;
        block_t *nb;

        loc = port_data_size(pt);
        if (new_size < loc) return;
        if (new_size > sc->max_port_data_size)
            s7_error(sc, make_symbol(sc, "port-too-big"),
                    set_elist_1(sc, wrap_string(sc, "port data size has grown past (*s7* 'max-port-data-size)", 56)));

        nb = reallocate(sc, port_data_block(pt), new_size);
        port_data_block(pt) = nb;
        port_data(pt) = (uint8_t *)(block_data(nb));
        port_data_size(pt) = new_size;
    }

// Assembly:
cmpq %rdx, 0x18(%rsi)
jg 0x94bb0
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq %rdx, 0x2c8(%rdi)
jge 0x94b85
leaq 0x81efd(%rip), %rsi     # 0x116a2c
movq %r15, %rdi
callq 0x9afc
movq 0x820(%r15), %rcx
movslq 0x7dc(%r15), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%r15)
leaq 0x81edd(%rip), %rdx     # 0x116a39
movq %rdx, 0x10(%rcx)
movq $0x38, 0x8(%rcx)
movq 0x6d8(%r15), %rdx
movq %rcx, 0x8(%rdx)
movq 0x6d8(%r15), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x38dfa
movq 0x8(%r14), %rax
movq 0x38(%rax), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x9fd6
movq 0x8(%r14), %rcx
movq %rax, 0x38(%rcx)
movq (%rax), %rax
movq %rax, 0x10(%r14)
movq %rbx, 0x18(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: full_filename
static block_t *full_filename(s7_scheme *sc, const char *filename)
    {
        s7_int len;
        char *rtn;
        block_t *block;
        if (filename[0] == '/')
        {
            len = safe_strlen(filename);
            block = mallocate(sc, len);
            rtn = (char *)block_data(block);
            memcpy((void *)rtn, (void *)filename, len);
            rtn[len - 1] = '\0';
        }
        else
        {
            char *pwd = getcwd(NULL, 0); /* docs say this means it will return a new string of the right size */
            len = safe_strlen(pwd) + safe_strlen(filename) + 1;
            block = mallocate(sc, len);
            rtn = (char *)block_data(block);
            if (pwd)
            {
                rtn[0] = '\0';
                catstrs(rtn, len, pwd, "/", filename, NULL);
                free(pwd);
            }
            else
            {
                memcpy((void *)rtn, (void *)filename, len);
                rtn[len - 1] = '\0';
            }
        }
        return(block);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x2f, (%rsi)
jne 0x94e94
xorl %r14d, %r14d
cmpb $0x0, 0x1(%rbx,%r14)
leaq 0x1(%r14), %r14
jne 0x94e5e
movq %r15, %rdi
movq %r14, %rsi
callq 0x9357
movq %rax, %r15
movq (%rax), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x83e0
movb $0x0, -0x1(%r12,%r14)
jmp 0x94f3f
xorl %ebp, %ebp
xorl %edi, %edi
xorl %esi, %esi
callq 0x8280
movq %rax, %r14
testq %rax, %rax
je 0x94ec2
cmpb $0x0, (%r14)
je 0x94ec0
xorl %eax, %eax
leaq 0x1(%rax), %rbp
cmpb $0x0, 0x1(%r14,%rax)
movq %rbp, %rax
jne 0x94eaf
jmp 0x94ec2
xorl %ebp, %ebp
cmpb $0x0, (%rbx)
je 0x94ed9
xorl %eax, %eax
leaq 0x1(%rax), %r12
cmpb $0x0, 0x1(%rbx,%rax)
movq %r12, %rax
jne 0x94ec9
jmp 0x94edc
xorl %r12d, %r12d
leaq (%r12,%rbp), %rsi
incq %rsi
movq %r15, %rdi
movq %rsi, (%rsp)
callq 0x9357
movq %rax, %r15
movq (%rax), %r13
testq %r14, %r14
je 0x94f27
movb $0x0, (%r13)
leaq 0x79cae(%rip), %rcx     # 0x10ebb4
movq %r13, %rdi
movq (%rsp), %rsi
movq %r14, %rdx
movq %rbx, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x9517
movq %r14, %rdi
callq 0x8050
jmp 0x94f3f
addq %rbp, %r12
movq %r13, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
callq 0x83e0
movb $0x0, (%r13,%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: remember_file_name
static int32_t remember_file_name(s7_scheme *sc, const char *file)
    {
        int32_t i;

        for (i = 0; i <= sc->file_names_top; i++)
            if (safe_strcmp(file, string_value(sc->file_names[i])))
                return(i);

        sc->file_names_top++;
        if (sc->file_names_top >= sc->file_names_size)
        {
            int32_t old_size = 0;
            if (sc->file_names_size == 0)
            {
                sc->file_names_size = INITIAL_FILE_NAMES_SIZE;
                sc->file_names = (s7_pointer *)calloc(sc->file_names_size, sizeof(s7_pointer));
            }
            else
            {
                old_size = sc->file_names_size;
                sc->file_names_size *= 2;
                sc->file_names = (s7_pointer *)realloc(sc->file_names, sc->file_names_size * sizeof(s7_pointer));
            }
            for (i = old_size; i < sc->file_names_size; i++)
                sc->file_names[i] = sc->F;
        }
        sc->file_names[sc->file_names_top] = s7_make_permanent_string(sc, file);
        return(sc->file_names_top);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4a4(%rdi), %ecx
testl %ecx, %ecx
js 0x94fb8
movq 0x498(%rbx), %rdx
incq %rcx
xorl %eax, %eax
movq (%rdx,%rax,8), %rsi
movq 0x10(%rsi), %rsi
testq %r14, %r14
je 0x94fa5
testq %rsi, %rsi
je 0x94fa5
xorl %edi, %edi
movb (%r14,%rdi), %r8b
movb (%rsi,%rdi), %r9b
testb %r8b, %r8b
je 0x94f9b
incq %rdi
cmpb %r9b, %r8b
je 0x94f86
cmpb %r9b, %r8b
jne 0x94fae
jmp 0x95063
cmpq %r14, %rsi
je 0x95063
incq %rax
cmpq %rcx, %rax
jne 0x94f72
jmp 0x94fba
incl %ecx
movl %ecx, 0x4a4(%rbx)
movslq 0x4a0(%rbx), %r15
cmpl %r15d, %ecx
jl 0x95043
testl %r15d, %r15d
je 0x95002
leal (%r15,%r15), %eax
movl %eax, 0x4a0(%rbx)
movq 0x498(%rbx), %rdi
movq %r15, %rsi
shlq $0x4, %rsi
callq 0x8510
movq %rax, 0x498(%rbx)
movl 0x4a0(%rbx), %eax
cmpl %eax, %r15d
jl 0x95027
jmp 0x95043
movl $0x8, 0x4a0(%rbx)
movl $0x8, %edi
movl $0x8, %esi
callq 0x8360
movq %rax, 0x498(%rbx)
movl $0x8, %eax
cltq
movq 0x120(%rbx), %rcx
movq 0x498(%rbx), %rdx
movq %rcx, (%rdx,%r15,8)
incq %r15
cmpq %r15, %rax
jne 0x95030
movq %rbx, %rdi
movq %r14, %rsi
callq 0xebb7
movq %rax, %rcx
movq 0x498(%rbx), %rdx
movslq 0x4a4(%rbx), %rax
movq %rcx, (%rdx,%rax,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_entry_to_cons
static s7_pointer hash_entry_to_cons(s7_scheme *sc, hash_entry_t *entry, s7_pointer p)
    {
        if (p)
        {
            set_car(p, hash_entry_key(entry));
            set_cdr(p, hash_entry_value(entry));
            return(p);
        }
        return(cons(sc, hash_entry_key(entry), hash_entry_value(entry)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %r15
testq %rdx, %rdx
je 0x950eb
movq %rdx, %rax
movq %r15, 0x8(%rdx)
movq 0x20(%rsi), %r14
jmp 0x9512b
movq %rdi, %rbx
movq 0x20(%rsi), %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x95111
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: pair_iterate_1
static s7_pointer pair_iterate_1(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;
            else iterator_set_slow(obj, cdr(iterator_slow(obj)));
            iterator_next(obj) = pair_iterate;
            return(result);
        }
        return(iterator_quit(obj));
    }

// Assembly:
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x9517f
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsi)
movq 0x20(%rsi), %rdx
leaq 0x10(%rdx), %r8
addq $0x110, %rdi            # imm = 0x110
xorl %r9d, %r9d
cmpq %rdx, %rcx
setne %r9b
cmovneq %r8, %rdi
shll $0x4, %r9d
movq (%rdi), %rcx
movq %rcx, 0x10(%r9,%rsi)
leaq -0x5daa5(%rip), %rcx    # 0x376d5
movq %rcx, 0x28(%rsi)
retq
leaq -0x5da68(%rip), %rax    # 0x3771e
movq %rax, 0x28(%rsi)
andb $0x7f, 0x3(%rsi)
movq 0xb15cb(%rip), %rax     # 0x146760
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: new_shared_info
static inline shared_info *new_shared_info(s7_scheme *sc)
    {
        shared_info *ci;
        ci = sc->circle_info;
        if (ci->top > 0)
        {
            int32_t i;
            memclr((void *)(ci->refs), ci->top * sizeof(int32_t));
            memclr((void *)(ci->defined), ci->top * sizeof(bool));
            for (i = 0; i < ci->top; i++)
                clear_cyclic_bits(ci->objs[i]); /* LOOP_4 is not faster */
            ci->top = 0;
        }
        ci->ref = 0;
        ci->has_hits = false;
        return(ci);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0xc(%rdi), %r13
testq %r13, %r13
jle 0x96056
movq 0x20(%rbx), %r15
movq %r13, %r14
shlq $0x2, %r14
cmpl $0x1, %r13d
je 0x95fd9
movabsq $0x1fffffff8, %r12      # imm = 0x1FFFFFFF8
andq %r14, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x8270
andq $0x4, %r14
je 0x95fea
addq %r12, %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x8270
movl 0xc(%rbx), %r13d
movq 0x48(%rbx), %r15
movslq %r13d, %r14
cmpl $0x8, %r14d
jb 0x96012
movq %r14, %r12
andq $-0x8, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x8270
addq %r12, %r15
andl $0x7, %r14d
testq %r14, %r14
je 0x96028
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x8270
movl 0xc(%rbx), %r13d
testl %r13d, %r13d
jle 0x9604f
xorl %eax, %eax
movabsq $-0x600000000a0001, %rcx # imm = 0xFF9FFFFFFFF5FFFF
movq (%rbx), %rdx
movq (%rdx,%rax,8), %rdx
andq %rcx, (%rdx)
incq %rax
movslq 0xc(%rbx), %rdx
cmpq %rdx, %rax
jl 0x96039
movl $0x0, 0xc(%rbx)
movl $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: check_collected
static bool check_collected(s7_pointer top, shared_info *ci)
    {
        s7_pointer *p, *objs_end;
        int32_t i;

        objs_end = (s7_pointer *)(ci->objs + ci->top);
        for (p = ci->objs; p < objs_end; p++)
            if ((*p) == top)
            {
                i = (int32_t)(p - ci->objs);
                if (ci->refs[i] == 0)
                {
                    ci->has_hits = true;
                    ci->refs[i] = ++ci->ref;  /* if found, set the ref number */
                }
                break;
            }
        set_cyclic(top);
        return(true);
    }

// Assembly:
movslq 0xc(%rsi), %rax
testq %rax, %rax
jle 0x967f5
movq (%rsi), %rcx
leaq (%rcx,%rax,8), %rdx
xorl %eax, %eax
movabsq $0x100000000, %r8       # imm = 0x100000000
cmpq %rdi, (%rcx)
je 0x967d8
addq $0x8, %rcx
addq %r8, %rax
cmpq %rdx, %rcx
jb 0x967c5
jmp 0x967f5
movq 0x20(%rsi), %rcx
sarq $0x20, %rax
cmpl $0x0, (%rcx,%rax,4)
jne 0x967f5
movb $0x1, 0x18(%rsi)
movl 0x10(%rsi), %edx
incl %edx
movl %edx, 0x10(%rsi)
movl %edx, (%rcx,%rax,4)
orb $0x20, 0x6(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: enlarge_shared_info
static void enlarge_shared_info(shared_info *ci)
    {
        int32_t i;
        ci->size *= 2;
        ci->size2 = ci->size - 2;
        ci->objs = (s7_pointer *)realloc(ci->objs, ci->size * sizeof(s7_pointer));
        ci->refs = (int32_t *)realloc(ci->refs, ci->size * sizeof(int32_t));
        ci->defined = (bool *)realloc(ci->defined, ci->size * sizeof(bool));
        /* this clearing is needed */
        for (i = ci->top; i < ci->size; i++)
        {
            ci->refs[i] = 0;
            ci->objs[i] = NULL;
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x8(%rdi), %rsi
leal (%rsi,%rsi), %eax
movl %eax, 0x8(%rdi)
leal -0x2(,%rsi,2), %eax
movl %eax, 0x14(%rdi)
movq (%rdi), %rdi
shlq $0x4, %rsi
callq 0x8510
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
movslq 0x8(%rbx), %rsi
shlq $0x2, %rsi
callq 0x8510
movq %rax, 0x20(%rbx)
movq 0x48(%rbx), %rdi
movslq 0x8(%rbx), %rsi
callq 0x8510
movq %rax, 0x48(%rbx)
movslq 0xc(%rbx), %rax
cmpl 0x8(%rbx), %eax
jge 0x96872
movq 0x20(%rbx), %rcx
movl $0x0, (%rcx,%rax,4)
movq (%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
movslq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jl 0x96850
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: collect_vector_info
static bool collect_vector_info(s7_scheme *sc, shared_info *ci, s7_pointer top, bool stop_at_print_length)
    {
        s7_int i, plen;
        bool cyclic = false;

        if (stop_at_print_length)
        {
            plen = sc->print_length;
            if (plen > vector_length(top))
                plen = vector_length(top);
        }
        else plen = vector_length(top);

        for (i = 0; i < plen; i++)
        {
            s7_pointer vel;
            vel = unchecked_vector_element(top, i);   /* "unchecked" because top might be rootlet, I think */
            if ((has_structure(vel)) &&
                    (collect_shared_info(sc, ci, vel, stop_at_print_length)))
            {
                set_cyclic(vel);
                cyclic = true;
                if ((is_c_pointer(vel)) ||
                        (is_iterator(vel)) ||
                        (is_c_object(vel)))
                    check_collected(top, ci);
            }
        }
        if (cyclic) set_cyclic(top);
        return(cyclic);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
testl %ecx, %ecx
je 0x968a0
movq 0x280(%rdi), %rax
movq 0x8(%rbx), %r13
cmpq %r13, %rax
cmovlq %rax, %r13
jmp 0x968a4
movq 0x8(%rbx), %r13
testq %r13, %r13
jle 0x9694d
movq %rdi, 0x10(%rsp)
xorl %r15d, %r15d
leaq 0xbba84(%rip), %rbp     # 0x152340
movzbl %cl, %eax
movl %eax, 0x4(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %r12
movzbl (%r12), %eax
cmpb $0x1, (%rax,%rbp)
jne 0x96936
cmpb $0x15, %al
jne 0x968eb
testb $0x1, 0x7(%r12)
jne 0x96936
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movl 0x4(%rsp), %ecx
callq 0x9606e
testb %al, %al
je 0x96936
orb $0x20, 0x6(%r12)
movzbl (%r12), %eax
movb $0x1, %cl
movq %rcx, 0x8(%rsp)
cmpq $0x21, %rax
ja 0x96936
movabsq $0x220100000, %rcx      # imm = 0x220100000
btq %rax, %rcx
jae 0x96936
movq %rbx, %rdi
movq %r14, %rsi
callq 0x967a9
incq %r15
cmpq %r15, %r13
jne 0x968cc
testb $0x1, 0x8(%rsp)
je 0x9694d
orb $0x20, 0x6(%rbx)
movb $0x1, %al
jmp 0x9694f
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_equivalent
static hash_entry_t *hash_equivalent(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    hash_entry_t *x;
                    s7_int hash, loc;

                    hash = hash_loc(sc, table, key);
                    loc = hash & hash_table_mask(table);
                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if (hash_entry_key(x) == key)
                            return(x);

                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if ((hash_entry_raw_hash(x) == hash) &&
                                (s7_is_equivalent(sc, hash_entry_key(x), key)))
                            return(x);
                    return(sc->unentry);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x20(%rsi), %rax
movzbl (%rdx), %ecx
callq *(%rax,%rcx,8)
movq %rax, %r15
movq 0x8(%r12), %rax
andq %r15, %rax
movq 0x10(%r12), %rcx
movq (%rcx,%rax,8), %r12
testq %r12, %r12
je 0x969d9
movq %r12, %rax
cmpq %rbx, (%rax)
je 0x969e0
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x96996
testq %r12, %r12
je 0x969d9
leaq 0xbc510(%rip), %r13     # 0x152ec0
cmpq %r15, 0x10(%r12)
jne 0x969cf
movq (%r12), %rsi
movzbl (%rsi), %eax
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq *(%r13,%rax,8)
testb %al, %al
jne 0x969ea
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x969b0
movq 0x490(%r14), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rax
jmp 0x969e0
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: format_error_1
static s7_pointer format_error_1(s7_scheme *sc, s7_pointer msg, const char *str, s7_pointer args, format_data *fdat)
    {
        s7_pointer x = NULL, ctrl_str;

        if (fdat->orig_str)
            ctrl_str = fdat->orig_str;
        else ctrl_str = s7_make_string_wrapper(sc, str);

        if (fdat->loc == 0)
        {
            if (is_pair(args))
                x = set_elist_4(sc, format_string_1, ctrl_str, args, msg);
            else x = set_elist_3(sc, format_string_2, ctrl_str, msg);
        }
        else
        {
            if (is_pair(args))
                x = set_elist_5(sc, format_string_3, ctrl_str, args, wrap_integer1(sc, fdat->loc + 20), msg);
            else x = set_elist_4(sc, format_string_4, ctrl_str, wrap_integer1(sc, fdat->loc + 20), msg);
        }
        if (fdat->port)
        {
            close_format_port(sc, fdat->port);
            fdat->port = NULL;
        }
        return(s7_error(sc, sc->format_error_symbol, x));
    }

// Assembly:
movq 0x28(%r8), %rax
testq %rax, %rax
jne 0x985ea
testq %rdx, %rdx
je 0x985bf
cmpb $0x0, (%rdx)
je 0x985bf
xorl %eax, %eax
leaq 0x1(%rax), %r9
cmpb $0x0, 0x1(%rdx,%rax)
movq %r9, %rax
jne 0x985af
jmp 0x985c2
xorl %r9d, %r9d
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r10
movq (%rax,%r10,8), %rax
incl %r10d
andl $0x7, %r10d
movl %r10d, 0x7dc(%rdi)
movq %rdx, 0x10(%rax)
movq %r9, 0x8(%rax)
movq (%r8), %rdx
movb (%rcx), %r9b
testq %rdx, %rdx
je 0x9863b
addq $0x14, %rdx
movq 0x1f00(%rdi), %r10
cmpb $0x1, %r9b
jne 0x9865c
movq 0xba5bb(%rip), %r9      # 0x152bc8
movq %rdx, 0x8(%r10)
movq %rcx, %r10
movq 0x1f00(%rdi), %rcx
leaq 0x6f8(%rdi), %rdx
movq 0x6f8(%rdi), %r11
movq %r9, 0x8(%r11)
movq 0x10(%r11), %r9
movq %rax, 0x8(%r9)
addq $0x10, %r9
jmp 0x9869d
cmpb $0x1, %r9b
jne 0x98689
movq 0xba570(%rip), %r10     # 0x152bb8
leaq 0x6f0(%rdi), %rdx
movq 0x6f0(%rdi), %r9
movq %r10, 0x8(%r9)
jmp 0x98680
movq 0xba56d(%rip), %r11     # 0x152bd0
movq %rdx, 0x8(%r10)
movq 0x1f00(%rdi), %rcx
leaq 0x6f0(%rdi), %rdx
movq 0x6f0(%rdi), %r9
movq %r11, 0x8(%r9)
addq $0x10, %r9
movq %rax, %r10
jmp 0x9869d
movq 0xba530(%rip), %r10     # 0x152bc0
leaq 0x6e8(%rdi), %r9
movq %rax, %rcx
movq %r9, %rdx
movq (%r9), %rax
movq %r10, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq (%rdx), %rdx
movq 0x38(%r8), %rax
testq %rax, %rax
je 0x986de
movq 0x7e8(%rdi), %rcx
movq 0x28(%rax), %rsi
movq %rcx, 0x18(%rsi)
movq %rax, 0x7e8(%rdi)
movq $0x0, 0x38(%r8)
movq 0x18f8(%rdi), %rsi
jmp 0x38dfa
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: format_method
static bool format_method(s7_scheme *sc, const char *str, format_data *fdat, s7_pointer port)
    {
        s7_pointer func, obj;
        char ctrl_str[3];

        obj = car(fdat->args);
        if ((!has_active_methods(sc, obj)) ||
                ((func = find_method(sc, find_let(sc, obj), sc->format_symbol)) == sc->undefined))
            return(false);

        ctrl_str[0] = '~';
        ctrl_str[1] = str[0];
        ctrl_str[2] = '\0';
        s7_apply_function(sc, func, list_3(sc, port, s7_make_string_wrapper(sc, ctrl_str), obj));

        fdat->args = cdr(fdat->args);
        fdat->ctr++;
        return(true);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x20(%rdx), %rax
movq 0x8(%rax), %r12
testb $0x40, 0x3(%r12)
je 0x98eba
movq %rdi, %r14
cmpb $0x1, 0x24c(%rdi)
jne 0x98eba
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %rbp
movq %r14, %rdi
movq %r12, %rsi
callq 0x8a63
movq 0xf20(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%r14), %rax
je 0x98eba
movq %rax, %r8
movb $0x7e, 0xd(%rsp)
movb (%rbp), %al
movb %al, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
xorl %eax, %eax
cmpb $0x0, 0xe(%rsp,%rax)
leaq 0x1(%rax), %rax
jne 0x98dd3
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdx
movq (%rcx,%rdx,8), %rbp
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0xd(%rsp), %rcx
movq %rcx, 0x10(%rbp)
movq %rax, 0x8(%rbp)
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x98e3a
movq %r14, %rdi
movq %r8, 0x10(%rsp)
callq 0xa550
movq 0x10(%rsp), %r8
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%r14), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%r14)
movq -0x8(%rdx), %rsi
movq %rcx, (%rsi)
movq %rbp, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rdx
movq %rdx, 0x90(%r14)
movq -0x8(%rax), %rdx
movq %rcx, (%rdx)
movq %r15, 0x8(%rdx)
movq %rsi, 0x10(%rdx)
movq %r14, %rdi
movq %r8, %rsi
callq 0xaee6
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rbx)
incq 0x10(%rbx)
movb $0x1, %al
jmp 0x98ebc
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: format_numeric_arg
static s7_int format_numeric_arg(s7_scheme *sc, const char *str, s7_int str_len, format_data *fdat, s7_int *i)
    {
        s7_int width, old_i;
        old_i = *i;
        width = format_read_integer(i, str_len, str);
        if (width < 0)
        {
            if (str[old_i - 1] != ',') /* need branches here, not if-expr because just_format_error creates the permanent string */
                just_format_error(sc, "width is negative?", 18, str, fdat->args, fdat);
            else just_format_error(sc, "precision is negative?", 22, str, fdat->args, fdat);
        }
        else
        {
            if (width > sc->max_format_length)
            {
                if (str[old_i - 1] != ',')
                    just_format_error(sc, "width is too big", 16, str, fdat->args, fdat);
                else just_format_error(sc, "precision is too big", 20, str, fdat->args, fdat);
            }
        }
        return(width);
    }

// Assembly:
pushq %rbx
movq %rcx, %rax
movq %rsi, %r9
movq (%r8), %rcx
decq %rdx
xorl %ebx, %ebx
cmpq %rdx, %rcx
jge 0x98f16
leaq 0xbc77a(%rip), %r10     # 0x155660
movq %rcx, %rsi
movzbl (%r9,%rsi), %r11d
movslq (%r10,%r11,4), %r11
cmpq $0x9, %r11
jg 0x98f0e
imulq $0xa, %rbx, %rbx
jo 0x98f0e
addq %r11, %rbx
jo 0x98f0e
incq %rsi
cmpq %rsi, %rdx
jne 0x98ee9
movq %rdx, %rsi
movq %rsi, (%r8)
testq %rbx, %rbx
js 0x98f76
cmpq 0x2c0(%rdi), %rbx
jle 0x98fd6
movslq 0x7dc(%rdi), %rdx
leal 0x1(%rdx), %r8d
andl $0x7, %r8d
cmpb $0x2c, -0x1(%r9,%rcx)
movq 0x820(%rdi), %rcx
movq (%rcx,%rdx,8), %rsi
movl %r8d, 0x7dc(%rdi)
jne 0x98f61
leaq 0x7e09f(%rip), %rcx     # 0x116ff2
movq %rcx, 0x10(%rsi)
movq $0x14, 0x8(%rsi)
jmp 0x98fc7
leaq 0x7e079(%rip), %rcx     # 0x116fe1
movq %rcx, 0x10(%rsi)
movq $0x10, 0x8(%rsi)
jmp 0x98fc7
movslq 0x7dc(%rdi), %rdx
leal 0x1(%rdx), %r8d
andl $0x7, %r8d
cmpb $0x2c, -0x1(%r9,%rcx)
movq 0x820(%rdi), %rcx
movq (%rcx,%rdx,8), %rsi
movl %r8d, 0x7dc(%rdi)
jne 0x98fb4
leaq 0x7e024(%rip), %rcx     # 0x116fca
movq %rcx, 0x10(%rsi)
movq $0x16, 0x8(%rsi)
jmp 0x98fc7
leaq 0x7dffc(%rip), %rcx     # 0x116fb7
movq %rcx, 0x10(%rsi)
movq $0x12, 0x8(%rsi)
movq 0x20(%rax), %rcx
movq %r9, %rdx
movq %rax, %r8
callq 0x9859a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: format_n_arg
static s7_int format_n_arg(s7_scheme *sc, const char *str, format_data *fdat, s7_pointer args)
    {
        s7_int n;

        if (is_null(fdat->args))          /* (format #f "~nT") */
            just_format_error(sc, "~~N: missing argument", 21, str, args, fdat);
        if (!s7_is_integer(car(fdat->args)))
            just_format_error(sc, "~~N: integer argument required", 30, str, args, fdat);
        n = s7_integer(car(fdat->args));

        if (n < 0)
            just_format_error(sc, "~~N value is negative?", 22, str, args, fdat);
        else
        {
            if (n > sc->max_format_length)
                just_format_error(sc, "~~N value is too big", 20, str, args, fdat);
        }
        fdat->args = cdr(fdat->args);    /* I don't think fdat->ctr should be incremented here -- it's for *vector-print-length* etc */
        return(n);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rdx), %rax
cmpq 0x110(%rdi), %rax
jne 0x99047
movq 0x820(%r12), %rax
movslq 0x7dc(%r12), %rcx
movq (%rax,%rcx,8), %rsi
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%r12)
leaq 0x7dfe1(%rip), %rax     # 0x117007
movq %rax, 0x10(%rsi)
movq $0x15, 0x8(%rsi)
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x9859a
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
je 0x990a3
movq 0x820(%r12), %rax
movslq 0x7dc(%r12), %rcx
movq (%rax,%rcx,8), %rsi
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%r12)
leaq 0x7dfa4(%rip), %rax     # 0x11701d
movq %rax, 0x10(%rsi)
movq $0x1e, 0x8(%rsi)
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x9859a
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x990ba
movq 0x8(%rax), %r13
testq %r13, %r13
jns 0x990bd
movl $0x16, %eax
leaq 0x7df84(%rip), %rcx     # 0x11703c
jmp 0x990d3
xorl %r13d, %r13d
cmpq 0x2c0(%r12), %r13
jle 0x9910e
movl $0x14, %eax
leaq 0x7df80(%rip), %rcx     # 0x117053
movq 0x820(%r12), %rdx
movslq 0x7dc(%r12), %rdi
movq (%rdx,%rdi,8), %rsi
leal 0x1(%rdi), %edx
andl $0x7, %edx
movl %edx, 0x7dc(%r12)
movq %rcx, 0x10(%rsi)
movq %rax, 0x8(%rsi)
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x9859a
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rbx)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_string_to_list
static s7_pointer s7_string_to_list(s7_scheme *sc, const char *str, s7_int len)
    {
        s7_int i;
        s7_pointer result;
        if (len == 0)
            return(sc->nil);
        check_heap_size(sc, len);
        sc->v = sc->nil;
        for (i = len - 1; i >= 0; i--)
            sc->v = cons_unchecked(sc, s7_make_character(sc, ((uint8_t)str[i])), sc->v);
        result = sc->v;
        sc->v = sc->nil;
        return(result);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
je 0x99517
movq %rdx, %r14
movq %rsi, %r15
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3bbd4
movq 0x110(%rbx), %rax
movq %rax, 0x4d0(%rbx)
testq %r14, %r14
jle 0x99520
movq 0xb158f(%rip), %rcx     # 0x14aa58
incq %r14
movq %rax, %rdx
movzbl -0x2(%r15,%r14), %eax
movq (%rcx,%rax,8), %rsi
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rdi
movq %rdi, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rsi, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rax, 0x4d0(%rbx)
decq %r14
cmpq $0x1, %r14
ja 0x994cc
movq 0x110(%rbx), %rcx
jmp 0x99523
movq 0x110(%rbx), %rax
jmp 0x9952a
movq %rax, %rcx
movq %rcx, 0x4d0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: tree_is_cyclic_or_has_pairs
static int tree_is_cyclic_or_has_pairs(s7_scheme *sc, s7_pointer tree)
    {
        s7_pointer fast, slow;
        bool has_pairs = false;

        if (!is_pair(tree)) return(TREE_NOT_CYCLIC);
        slow = tree;
        fast = tree;
        while (true)
        {
            if (tree_is_collected(fast)) return(TREE_CYCLIC);
            if ((!has_pairs) &&
                    (is_unquoted_pair(car(fast))))
                has_pairs = true;
            fast = cdr(fast);
            if (!is_pair(fast))
            {
                if (!has_pairs) return(TREE_NOT_CYCLIC);
                break;
            }
            if (tree_is_collected(fast)) return(TREE_CYCLIC);
            if ((!has_pairs) &&
                    (is_unquoted_pair(car(fast))))
                has_pairs = true;
            fast = cdr(fast);
            if (!is_pair(fast))
            {
                if (!has_pairs) return(TREE_NOT_CYCLIC);
                break;
            }
            slow = cdr(slow);
            if (fast == slow) return(TREE_CYCLIC);
        }
#if S7_DEBUGGING
        if (!has_pairs) fprintf(stderr, "at end but no pairs: %s\n", DISPLAY(tree));
#endif
        return(TREE_HAS_PAIRS);
    }

// Assembly:
cmpb $0x1, (%rsi)
jne 0x9963e
xorl %ecx, %ecx
movl $0x1, %eax
movq %rsi, %rdx
testb $0x8, 0x6(%rsi)
jne 0x99632
testb $0x1, %cl
jne 0x995f1
movq 0x8(%rsi), %r8
cmpb $0x1, (%r8)
jne 0x995f1
movq 0x8(%r8), %r8
cmpq 0x17b0(%rdi), %r8
movzbl %cl, %ecx
cmovnel %eax, %ecx
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
jne 0x99633
testb $0x8, 0x6(%rsi)
jne 0x99632
testb $0x1, %cl
jne 0x99620
movq 0x8(%rsi), %r8
cmpb $0x1, (%r8)
jne 0x99620
movq 0x8(%r8), %r8
cmpq 0x17b0(%rdi), %r8
movzbl %cl, %ecx
cmovnel %eax, %ecx
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
jne 0x99633
movq 0x10(%rdx), %rdx
cmpq %rdx, %rsi
jne 0x995cb
retq
testb $0x1, %cl
je 0x9963e
movl $0x2, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: tree_is_cyclic_1
static bool tree_is_cyclic_1(s7_scheme *sc, s7_pointer tree)
    {
        s7_pointer p;
        for (p = tree; is_pair(p); p = cdr(p))
        {
            tree_set_collected(p);
            if (sc->tree_pointers_top == sc->tree_pointers_size)
            {
                if (sc->tree_pointers_size == 0)
                {
                    sc->tree_pointers_size = 8;
                    sc->tree_pointers = (s7_pointer *)malloc(sc->tree_pointers_size * sizeof(s7_pointer));
                }
                else
                {
                    sc->tree_pointers_size *= 2;
                    sc->tree_pointers = (s7_pointer *)realloc(sc->tree_pointers, sc->tree_pointers_size * sizeof(s7_pointer));
                }
            }
            sc->tree_pointers[sc->tree_pointers_top++] = p;
            if (is_unquoted_pair(car(p)))
            {
                int32_t i, old_top, result;
                old_top = sc->tree_pointers_top;
                result = tree_is_cyclic_or_has_pairs(sc, car(p));
                if ((result == TREE_CYCLIC) ||
                        (tree_is_cyclic_1(sc, car(p))))
                    return(true);
                for (i = old_top; i < sc->tree_pointers_top; i++)
                    tree_clear_collected(sc->tree_pointers[i]);
                sc->tree_pointers_top = old_top;
            }
        }
        return(false);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x1, (%rsi)
jne 0x9974d
movq %rsi, %rbx
movq %rdi, %r14
orb $0x8, 0x6(%rbx)
movl 0x7d4(%r14), %ecx
cmpl 0x7d0(%r14), %ecx
jne 0x9969c
testl %ecx, %ecx
je 0x996a5
movslq %ecx, %rsi
addl %ecx, %ecx
movl %ecx, 0x7d0(%r14)
movq 0x7c8(%r14), %rdi
shlq $0x4, %rsi
callq 0x8510
movq %rax, 0x7c8(%r14)
movl 0x7d4(%r14), %ecx
jmp 0x996c3
movq 0x7c8(%r14), %rax
jmp 0x996c3
movl $0x8, 0x7d0(%r14)
movl $0x40, %edi
callq 0x8480
movq %rax, 0x7c8(%r14)
xorl %ecx, %ecx
leal 0x1(%rcx), %r12d
movl %r12d, 0x7d4(%r14)
movslq %ecx, %rcx
movq %rbx, (%rax,%rcx,8)
movq 0x8(%rbx), %r15
cmpb $0x1, (%r15)
jne 0x99740
movq 0x8(%r15), %rax
cmpq 0x17b0(%r14), %rax
je 0x99740
movq %r14, %rdi
movq %r15, %rsi
callq 0x995bc
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x9974f
movq %r14, %rdi
movq %r15, %rsi
callq 0x99641
testb %al, %al
jne 0x9974f
cmpl 0x7d4(%r14), %r12d
jge 0x99739
movslq %r12d, %rax
movq 0x7c8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
andw $-0x9, 0x6(%rcx)
incq %rax
movslq 0x7d4(%r14), %rcx
cmpq %rcx, %rax
jl 0x9971a
movl %r12d, 0x7d4(%r14)
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0x99658
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: make_big_list
static s7_pointer make_big_list(s7_scheme *sc, int32_t len, s7_pointer init)
                {
                    s7_pointer result;
                    int32_t i;

                    check_heap_size(sc, len);
                    sc->v = sc->nil;
                    for (i = 0; i < len; i++)
                        sc->v = cons_unchecked(sc, init, sc->v);
                    result = sc->v;
                    sc->v = sc->nil;
                    return(result);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r15
movq %r15, %rsi
callq 0x3bbd4
movq 0x110(%rbx), %rax
movq %rax, 0x4d0(%rbx)
testl %r15d, %r15d
jle 0x99820
movq %rax, %rcx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r14, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, 0x4d0(%rbx)
decl %ebp
jne 0x997e4
movq 0x110(%rbx), %rcx
jmp 0x99823
movq %rax, %rcx
movq %rcx, 0x4d0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: int_vector_setter
static s7_pointer int_vector_setter(s7_scheme *sc, s7_pointer vec, s7_int loc, s7_pointer val)
                {
                    if (s7_is_integer(val))
                        int_vector(vec, loc) = s7_integer(val);
                    else s7_wrong_type_arg_error(sc, "int-vector-set!", 3, val, "an integer");
                    return(val);
                }

// Assembly:
pushq %rbx
movq %rcx, %rbx
cmpb $0xb, (%rcx)
jne 0x998b2
movq 0x8(%rbx), %rax
movq 0x10(%rsi), %rcx
movq %rax, (%rcx,%rdx,8)
jmp 0x998cd
leaq 0x790cc(%rip), %rsi     # 0x112985
leaq 0x7d8b2(%rip), %r8      # 0x117172
movl $0x3, %edx
movq %rbx, %rcx
callq 0xd4e5
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: byte_vector_setter
static s7_pointer byte_vector_setter(s7_scheme *sc, s7_pointer str, s7_int loc, s7_pointer val)
                {
                    if (s7_is_integer(val))
                    {
                        s7_int byte;
                        byte = s7_integer(val);
                        if ((byte >= 0) && (byte < 256))
                        {
                            byte_vector(str, loc) = (uint8_t)byte;
                            return(val);
                        }
                        return(s7_wrong_type_arg_error(sc, "byte-vector-set!", 3, val, "a byte"));
                    }
                    return(s7_wrong_type_arg_error(sc, "byte-vector-set!", 3, val, "an integer"));
                }

// Assembly:
cmpb $0xb, (%rcx)
jne 0x99902
movq 0x8(%rcx), %rax
cmpq $0xff, %rax
ja 0x99912
movq 0x10(%rsi), %rsi
movb %al, (%rsi,%rdx)
movq %rcx, %rax
retq
leaq 0x7924a(%rip), %rsi     # 0x112b53
leaq 0x7d862(%rip), %r8      # 0x117172
jmp 0x99920
leaq 0x7923a(%rip), %rsi     # 0x112b53
leaq 0x7d7a7(%rip), %r8      # 0x1170c7
movl $0x3, %edx
jmp 0xd4e5
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: float_vector_fill
static void float_vector_fill(s7_scheme *sc, s7_pointer vec, s7_double x)
                {
                    s7_int len;
                    len = vector_length(vec);
                    if (len == 0) return;
                    if (x == 0.0)
                    {
                        if (STEP_8(len))
                            memclr64((void *)float_vector_floats(vec), len * sizeof(s7_double));
                        else memclr((void *)float_vector_floats(vec), len * sizeof(s7_double));
                    }
                    else
                    {
                        s7_int i, left;
                        s7_double *orig;
                        left = len - 8;
                        i = 0;
                        orig = float_vector_floats(vec);
                        while (i <= left)
                            LOOP_8(orig[i++] = x);
                        for (; i < len; i++)
                            orig[i] = x;
                    }
                }

// Assembly:
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x99a74
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9995b
jp 0x9995b
testb $0x7, %dl
je 0x99969
shlq $0x3, %rdx
testq %rdx, %rdx
je 0x99a74
movq 0x10(%rdi), %rdi
jmp 0x9999d
movq 0x10(%rdi), %rcx
cmpq $0x8, %rdx
jge 0x999a4
xorl %esi, %esi
jmp 0x999d5
movabsq $0x1ffffffffffffff8, %rax # imm = 0x1FFFFFFFFFFFFFF8
andq %rax, %rdx
je 0x99a74
movq 0x10(%rdi), %rdi
cmpq $0x9, %rdx
movl $0x8, %eax
cmovaeq %rdx, %rax
leaq -0x8(,%rax,8), %rdx
andq $-0x40, %rdx
addq $0x40, %rdx
xorl %esi, %esi
jmp 0x8270
leaq -0x8(%rdx), %rax
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
xorl %edi, %edi
movupd %xmm1, (%rcx,%rdi,8)
movupd %xmm1, 0x10(%rcx,%rdi,8)
leaq 0x8(%rdi), %rsi
movupd %xmm1, 0x20(%rcx,%rdi,8)
movupd %xmm1, 0x30(%rcx,%rdi,8)
movq %rsi, %rdi
cmpq %rax, %rsi
jle 0x999b2
subq %rsi, %rdx
jle 0x99a74
leaq 0x1(%rdx), %rax
andq $-0x2, %rax
decq %rdx
movq %rdx, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
leaq (%rcx,%rsi,8), %rcx
addq $0x8, %rcx
xorl %edx, %edx
movdqa 0x704cb(%rip), %xmm2    # 0x109ed0
movdqa 0x704d3(%rip), %xmm3    # 0x109ee0
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
por %xmm2, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm1, %xmm6
pcmpeqd %xmm1, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x99a57
movsd %xmm0, -0x8(%rcx,%rdx,8)
pxor %xmm4, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x99a6b
movsd %xmm0, (%rcx,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rax
jne 0x99a15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: int_vector_fill
static void int_vector_fill(s7_scheme *sc, s7_pointer vec, s7_int k)
                {
                    s7_int len;
                    len = vector_length(vec);
                    if (len == 0) return;
                    if (k == 0)
                    {
                        if (STEP_8(len))
                            memclr64((void *)int_vector_ints(vec), len * sizeof(s7_int));
                        else memclr((void *)int_vector_ints(vec), len * sizeof(s7_int));
                    }
                    else
                    {
                        s7_int i, left;
                        s7_int* orig;
                        left = len - 8;
                        i = 0;
                        orig = int_vector_ints(vec);
                        while (i <= left)
                            LOOP_8(orig[i++] = k);
                        for (; i < len; i++)
                            orig[i] = k;
                    }
                }

// Assembly:
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x99b87
testq %rsi, %rsi
je 0x99a95
movq 0x10(%rdi), %rcx
cmpq $0x8, %rdx
jge 0x99ab4
xorl %edi, %edi
jmp 0x99aea
testb $0x7, %dl
je 0x99b88
shlq $0x3, %rdx
testq %rdx, %rdx
je 0x99b87
movq 0x10(%rdi), %rdi
jmp 0x99bb8
leaq -0x8(%rdx), %rax
xorl %edi, %edi
movq %rsi, (%rcx,%rdi,8)
movq %rsi, 0x8(%rcx,%rdi,8)
movq %rsi, 0x10(%rcx,%rdi,8)
movq %rsi, 0x18(%rcx,%rdi,8)
movq %rsi, 0x20(%rcx,%rdi,8)
movq %rsi, 0x28(%rcx,%rdi,8)
movq %rsi, 0x30(%rcx,%rdi,8)
movq %rsi, 0x38(%rcx,%rdi,8)
addq $0x8, %rdi
cmpq %rax, %rdi
jle 0x99aba
subq %rdi, %rdx
jle 0x99b87
leaq 0x1(%rdx), %rax
andq $-0x2, %rax
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rcx,%rdi,8), %rcx
addq $0x8, %rcx
xorl %edx, %edx
movdqa 0x703b6(%rip), %xmm1    # 0x109ed0
movdqa 0x703be(%rip), %xmm2    # 0x109ee0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x99b6b
movq %rsi, -0x8(%rcx,%rdx,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x99b7e
movq %rsi, (%rcx,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rax
jne 0x99b2a
retq
movabsq $0x1ffffffffffffff8, %rax # imm = 0x1FFFFFFFFFFFFFF8
andq %rax, %rdx
je 0x99b87
movq 0x10(%rdi), %rdi
cmpq $0x9, %rdx
movl $0x8, %eax
cmovaeq %rdx, %rax
leaq -0x8(,%rax,8), %rdx
andq $-0x40, %rdx
addq $0x40, %rdx
xorl %esi, %esi
jmp 0x8270
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: make_type_name
static const char *make_type_name(s7_scheme *sc, const char *name, article_t article)
                {
                    s7_int i, slen, len;

                    slen = safe_strlen(name);
                    len = slen + 8;
                    if (len > sc->typnam_len)
                    {
                        if (sc->typnam) free(sc->typnam);
                        sc->typnam = (char *)malloc(len);
                        sc->typnam_len = len;
                    }
                    if (article == INDEFINITE_ARTICLE)
                    {
                        i = 1;
                        sc->typnam[0] = 'a';
                        if ((name[0] == 'a') || (name[0] == 'e') || (name[0] == 'i') || (name[0] == 'o') || (name[0] == 'u'))
                            sc->typnam[i++] = 'n';
                        sc->typnam[i++] = ' ';
                    }
                    else i = 0;
                    memcpy((void *)(sc->typnam + i), (void *)name, slen);
                    sc->typnam[i + slen] = '\0';
                    return(sc->typnam);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x99bed
cmpb $0x0, (%r14)
je 0x99bed
xorl %eax, %eax
leaq 0x1(%rax), %r15
cmpb $0x0, 0x1(%r14,%rax)
movq %r15, %rax
jne 0x99bdc
jmp 0x99bf0
xorl %r15d, %r15d
leaq 0x8(%r15), %r12
movslq 0x480(%rbx), %rax
cmpq %rax, %r12
jle 0x99c27
movq 0x478(%rbx), %rdi
testq %rdi, %rdi
je 0x99c11
callq 0x8050
movq %r12, %rdi
callq 0x8480
movq %rax, 0x478(%rbx)
movl %r12d, 0x480(%rbx)
cmpl $0x1, %ebp
jne 0x99c76
movq 0x478(%rbx), %rax
movb $0x61, (%rax)
movb (%r14), %al
addb $-0x61, %al
rorb %al
movl $0x1, %r12d
cmpb $0xa, %al
ja 0x99c65
movzbl %al, %eax
movl $0x495, %ecx            # imm = 0x495
btl %eax, %ecx
jae 0x99c65
movq 0x478(%rbx), %rax
movb $0x6e, 0x1(%rax)
movl $0x2, %r12d
movq 0x478(%rbx), %rax
movb $0x20, (%rax,%r12)
incq %r12
jmp 0x99c79
xorl %r12d, %r12d
movq 0x478(%rbx), %rdi
addq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x83e0
addq 0x478(%rbx), %r12
movb $0x0, (%r15,%r12)
movq 0x478(%rbx), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq