LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
cmpq $0x0, 0x10(%rax)
je 0x76ffd
movq 0x18(%rax), %rsi
movq %r14, %rdi
callq 0x9439
movq 0x8(%rbx), %rax
andq $0x0, 0x10(%rax)
movq 0x8(%rbx), %rax
andq $0x0, 0x30(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x7705c
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
jle 0x77035
movq 0x10(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x8660
cmpq 0x20(%rbx), %rax
je 0x77035
leaq 0x6b97f(%rip), %rdx     # 0xe29a7
pushq $0x40
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0xd5c7
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x8490
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x8180
movq 0x8(%rbx), %rax
andq $0x0, 0x8(%rax)
movq 0x8(%rbx), %rax
leaq 0x9e4ed(%rip), %rcx     # 0x115550
movq %rcx, 0x48(%rax)
movq 0x8(%rbx), %rax
movb $0x1, 0x2(%rax)
andq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpb $0x1, 0x1(%rax)
jne 0x771c9
movq 0x28(%rax), %rsi
callq 0x8b00
movq 0x8(%rbx), %rax
movb $0x0, 0x1(%rax)
movq 0x8(%rbx), %rax
leaq 0x9e380(%rip), %rcx     # 0x115550
movq %rcx, 0x48(%rax)
movq 0x8(%rbx), %rax
movb $0x1, 0x2(%rax)
andq $0x0, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %rax
movq 0x20(%rcx), %rdi
leaq (%rdi,%rdx), %rcx
cmpq 0x18(%rbx), %rcx
jge 0x77251
addq 0x10(%rbx), %rdi
movq %r14, %rdx
callq 0x83e0
addq %r14, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7736d
// File: /workspace/github_c_makefile_star2_O2/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 0x7736c
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq %rdx, 0x2c8(%rdi)
jge 0x77341
leaq 0x6b6e1(%rip), %rsi     # 0xe29cc
movq %r15, %rdi
callq 0x94d4
movq 0x820(%r15), %rcx
movslq 0x7dc(%r15), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%r15)
leaq 0x6b6c1(%rip), %rdx     # 0xe29d9
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 0x2cdc0
movq 0x8(%r14), %rax
movq 0x38(%rax), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x9859
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_O2/BernardTatin[P]s7sh/s7.c
// Function: string_write_string_resized
static void string_write_string_resized(s7_scheme *sc, const char *str, s7_int len, s7_pointer pt)
    {
        s7_int new_len;  /* len is known to be non-zero, str may not be 0-terminated */
        new_len = port_position(pt) + len;
        resize_port_data(sc, pt, new_len * 2);
        memcpy((void *)(port_data(pt) + port_position(pt)), (void *)str, len);
        port_position(pt) = new_len;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x20(%rcx), %r12
addq %rdx, %r12
leaq (%r12,%r12), %rdx
movq %rcx, %rsi
callq 0x772c3
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_O2/BernardTatin[P]s7sh/s7.c
// Function: search_load_path
static block_t *search_load_path(s7_scheme *sc, const char *name)
    {
        s7_pointer lst;

        lst = s7_load_path(sc);
        if (is_pair(lst))
        {
            block_t *b;
            char *filename;
            s7_pointer dir_names;
            /* linux: PATH_MAX: 4096, windows: MAX_PATH: unlimited?, Mac: 1016?, BSD: MAX_PATH_LENGTH: 1024 */
#if MS_WINDOWS || defined(__linux__)
#define FILENAME_MAX 4096
#else
#define FILENAME_MAX 1024
#endif
            b = mallocate(sc, FILENAME_MAX);
            filename = (char *)block_data(b);

            for (dir_names = lst; is_pair(dir_names); dir_names = cdr(dir_names))
            {
                const char *new_dir;
                new_dir = string_value(car(dir_names));
                if (new_dir)
                {
                    filename[0] = '\0';
                    if (new_dir[strlen(new_dir) - 1] == '/')
                        catstrs(filename, FILENAME_MAX, new_dir, name, NULL);
                    else catstrs(filename, FILENAME_MAX, new_dir, "/", name, NULL);
                    if (access(filename, F_OK) == 0)
                        return(b);
                }
            }
            liberate(sc, b);
        }
        return(NULL);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2a347
cmpb $0x1, (%rax)
jne 0x77543
movq %rax, %r12
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
callq 0x9037
movq %rax, %r15
movq (%rax), %r13
cmpb $0x1, (%r12)
jne 0x77538
movq 0x8(%r12), %rax
movq 0x10(%rax), %rbp
testq %rbp, %rbp
je 0x77531
movb $0x0, (%r13)
movq %rbp, %rdi
callq 0x81a0
cmpb $0x2f, -0x1(%rbp,%rax)
jne 0x77504
movl $0x1000, %esi           # imm = 0x1000
movq %r13, %rdi
movq %rbp, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x90f7
jmp 0x77523
movl $0x1000, %esi           # imm = 0x1000
movq %r13, %rdi
movq %rbp, %rdx
leaq 0x6363e(%rip), %rcx     # 0xdab54
movq %r14, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x90f7
movq %r13, %rdi
xorl %esi, %esi
callq 0x8590
testl %eax, %eax
je 0x77546
movq 0x10(%r12), %r12
jmp 0x774c1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9439
xorl %r15d, %r15d
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_O2/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, %r14
cmpb $0x2f, (%rsi)
jne 0x775a3
movq %rbx, %rdi
callq 0x8d06
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x9037
movq %rax, %r14
movq (%rax), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x83e0
movb $0x0, -0x1(%r12,%r15)
jmp 0x77628
xorl %edi, %edi
xorl %esi, %esi
callq 0x8280
movq %rax, %r15
movq %rax, %rdi
callq 0x8d06
movq %rax, %r12
movq %rbx, %rdi
callq 0x8d06
movq %rax, %r13
movq %r12, (%rsp)
addq %rax, %r12
incq %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x9037
movq %rax, %r14
movq (%rax), %rbp
testq %r15, %r15
je 0x77610
movb $0x0, (%rbp)
leaq 0x63564(%rip), %rcx     # 0xdab54
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x90f7
movq %r15, %rdi
callq 0x8050
jmp 0x77628
addq (%rsp), %r13
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x83e0
movb $0x0, (%rbp,%r13)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x4a4(%rdi), %r13
xorl %r15d, %r15d
cmpq %r13, %r15
jg 0x7767c
movq 0x498(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x7772a
testb %al, %al
jne 0x7771d
incq %r15
jmp 0x77653
incl %r13d
movl %r13d, 0x4a4(%rbx)
movslq 0x4a0(%rbx), %r12
cmpl %r12d, %r13d
jl 0x77700
testl %r12d, %r12d
je 0x776c4
leal (%r12,%r12), %eax
movl %eax, 0x4a0(%rbx)
movq 0x498(%rbx), %rdi
movq %r12, %rsi
shlq $0x4, %rsi
callq 0x8510
movq %rax, 0x498(%rbx)
movslq 0x4a0(%rbx), %r15
jmp 0x776fb
movl $0x8, 0x4a0(%rbx)
pushq $0x8
popq %r15
movq %r15, %rdi
movq %r15, %rsi
callq 0x8360
movq %rax, 0x498(%rbx)
jmp 0x776fb
movq 0x120(%rbx), %rax
movq 0x498(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r15, %r12
jl 0x776e6
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2df
movq 0x498(%rbx), %rcx
movslq 0x4a4(%rbx), %r15
movq %rax, (%rcx,%r15,8)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x777c7
movq %rdx, %rax
movq %r15, 0x8(%rdx)
movq 0x20(%rsi), %r14
jmp 0x77807
movq %rdi, %rbx
movq 0x20(%rsi), %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x777ed
movq %rbx, %rdi
callq 0x9c27
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_O2/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 0x7785b
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 -0x4c47c(%rip), %rcx    # 0x2b3da
movq %rcx, 0x28(%rsi)
retq
leaq -0x4c43f(%rip), %rax    # 0x2b423
movq %rax, 0x28(%rsi)
andb $0x7f, 0x3(%rsi)
movq 0x9deef(%rip), %rax     # 0x115760
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: flip_ref
static void flip_ref(shared_info *ci, s7_pointer p)
    {
        int32_t i;
        s7_pointer *objs;

        objs = ci->objs;
        for (i = 0; i < ci->top; i++)
            if (objs[i] == p)
            {
                ci->refs[i] = -ci->refs[i];
                break;
            }
    }

// Assembly:
movq (%rdi), %rax
movl 0xc(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x77c9d
leaq 0x1(%rdx), %r8
cmpq %rsi, (%rax,%rdx,8)
movq %r8, %rdx
jne 0x77c82
movq 0x20(%rdi), %rax
negl -0x4(%rax,%r8,4)
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: pos_int_to_str
static char *pos_int_to_str(s7_scheme *sc, s7_int num, s7_int *len, char endc)
    {
        char *p, *op;

        p = (char *)(sc->int_to_str3 + INT_TO_STR_SIZE - 1);
        op = p;
        *p-- = '\0';
        if (endc != '\0') *p-- = endc;
        do {*p-- = "0123456789"[num % 10]; num /= 10;} while (num);
        (*len) = op - p;           /* this includes the trailing #\null */
        return((char *)(p + 1));
    }

// Assembly:
movq %rdx, %r9
movb $0x0, 0xb4f(%rdi)
testb %cl, %cl
je 0x77cbb
leaq 0xb4d(%rdi), %r8
movb %cl, 0xb4e(%rdi)
jmp 0x77cc2
leaq 0xb4e(%rdi), %r8
subq %r8, %rdi
incq %r8
addq $0xb4f, %rdi            # imm = 0xB4F
leaq 0x6a80a(%rip), %rcx     # 0xe24e0
pushq $0xa
popq %r10
movq %rsi, %rax
xorl %edx, %edx
divq %r10
movb (%rdx,%rcx), %dl
movb %dl, -0x1(%r8)
decq %r8
incq %rdi
cmpq $0x9, %rsi
movq %rax, %rsi
ja 0x77cda
movq %rdi, (%r9)
movq %r8, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x6c0(%rdi), %rbx
movslq 0xc(%rbx), %rsi
testq %rsi, %rsi
jle 0x77d52
movq 0x20(%rbx), %rdi
shlq $0x2, %rsi
callq 0x78377
movq 0x48(%rbx), %rdi
movslq 0xc(%rbx), %rsi
callq 0x78377
xorl %eax, %eax
movabsq $-0x600000000a0001, %rcx # imm = 0xFF9FFFFFFFF5FFFF
movslq 0xc(%rbx), %rdx
cmpq %rdx, %rax
jge 0x77d4e
movq (%rbx), %rdx
movq (%rdx,%rax,8), %rdx
andq %rcx, (%rdx)
incq %rax
jmp 0x77d36
andl $0x0, 0xc(%rbx)
andl $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: memclr
static void memclr(void *s, size_t n)
    {
        uint8_t *s2;
#if S7_ALIGNED
        s2 = (uint8_t *)s;
#else
#if (defined(__x86_64__) || defined(__i386__))
        if (n >= 8)
        {
            int64_t *s1 = (int64_t *)s;
            size_t n8 = n >> 3;
            do {*s1++ = 0;} while (--n8 > 0);
            n &= 7;
            s2 = (uint8_t *)s1;
        }
        else s2 = (uint8_t *)s;
#else
        s2 = (uint8_t *)s;
#endif
#endif
        while (n > 0)
        {
            *s2++ = 0;
            n--;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x8, %rsi
jb 0x783a2
movq %rbx, %r15
andq $-0x8, %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x8270
addq %r15, %r14
andl $0x7, %ebx
xorl %eax, %eax
cmpq %rax, %rbx
je 0x783b3
movb $0x0, (%r14,%rax)
incq %rax
jmp 0x783a4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq (%rsi), %rcx
movslq 0xc(%rsi), %rax
leaq (%rcx,%rax,8), %rdx
xorl %eax, %eax
movabsq $0x100000000, %r8       # imm = 0x100000000
cmpq %rdx, %rcx
jae 0x78400
cmpq %rdi, (%rcx)
je 0x783e3
addq $0x8, %rcx
addq %r8, %rax
jmp 0x783d0
movq 0x20(%rsi), %rcx
sarq $0x20, %rax
cmpl $0x0, (%rcx,%rax,4)
jne 0x78400
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_O2/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
movslq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jge 0x78474
movq 0x20(%rbx), %rcx
andl $0x0, (%rcx,%rax,4)
movq (%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x78456
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, 0x10(%rsp)
je 0x784a7
movq 0x280(%rdi), %rax
movq 0x8(%rbx), %r15
cmpq %r15, %rax
cmovlq %rax, %r15
jmp 0x784ab
movq 0x8(%rbx), %r15
xorl %edx, %edx
testq %r15, %r15
movl $0x0, %eax
movq %rax, 0x8(%rsp)
cmovleq %rdx, %r15
leaq 0xa8e7b(%rip), %r12     # 0x121340
movzbl %cl, %eax
movl %eax, 0x4(%rsp)
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x78541
movq 0x10(%rbx), %rax
movq (%rax,%rbp,8), %r13
movzbl (%r13), %eax
cmpb $0x1, (%rax,%r12)
jne 0x7853c
cmpb $0x15, %al
jne 0x784f2
testb $0x1, 0x7(%r13)
jne 0x7853c
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
movl 0x4(%rsp), %ecx
callq 0x77d5f
testb %al, %al
je 0x7853c
orb $0x20, 0x6(%r13)
movzbl (%r13), %eax
movb $0x1, %cl
movq %rcx, 0x8(%rsp)
cmpq $0x21, %rax
ja 0x7853c
movabsq $0x220100000, %rcx      # imm = 0x220100000
btq %rax, %rcx
jae 0x7853c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x783b9
incq %rbp
jmp 0x784ce
movq 0x8(%rsp), %rax
testb $0x1, %al
je 0x7854e
orb $0x20, 0x6(%rbx)
andb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r13
andq %rax, %r13
shlq $0x3, %r13
addq 0x10(%r12), %r13
movq %r13, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x785b2
cmpq %rbx, (%rax)
je 0x785f1
addq $0x18, %rax
jmp 0x7859f
leaq 0xa9907(%rip), %r12     # 0x121ec0
movq (%r13), %r13
testq %r13, %r13
je 0x785e5
cmpq %r15, 0x10(%r13)
jne 0x785df
movq (%r13), %rsi
movzbl (%rsi), %eax
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq *(%r12,%rax,8)
testb %al, %al
jne 0x785ee
addq $0x18, %r13
jmp 0x785b9
movq 0x490(%r14), %rax
jmp 0x785f1
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: peek_shared_ref_1
static int32_t peek_shared_ref_1(shared_info *ci, s7_pointer p)
    {
        /* returns 0 if not found, otherwise the ref value for p */
        int32_t i;
        s7_pointer *objs;

        objs = ci->objs;
        for (i = 0; i < ci->top; i++)
            if (objs[i] == p)
                return(ci->refs[i]);
        return(0);
    }

// Assembly:
movq (%rdi), %rcx
movl 0xc(%rdi), %edx
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x78626
leaq 0x1(%r8), %r9
cmpq %rsi, (%rcx,%r8,8)
movq %r9, %r8
jne 0x7860b
movq 0x20(%rdi), %rax
movl -0x4(%rax,%r9,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%r8), %rax
testq %rax, %rax
jne 0x79d9f
movq %r14, %rdi
movq %rdx, %rsi
callq 0xd1ba
movq (%rbx), %rcx
movb (%r12), %dl
testq %rcx, %rcx
je 0x79df0
addq $0x14, %rcx
movq 0x1f00(%r14), %rsi
cmpb $0x1, %dl
jne 0x79e10
movq 0xa7e06(%rip), %rdx     # 0x121bc8
movq %rcx, 0x8(%rsi)
movq %r12, %rsi
movq 0x1f00(%r14), %r12
leaq 0x6f8(%r14), %rcx
movq 0x6f8(%r14), %rdi
movq %rdx, 0x8(%rdi)
movq 0x10(%rdi), %rdx
movq %rax, 0x8(%rdx)
addq $0x10, %rdx
jmp 0x79e51
cmpb $0x1, %dl
jne 0x79e3d
movq 0xa7dbc(%rip), %rsi     # 0x121bb8
leaq 0x6f0(%r14), %rcx
movq 0x6f0(%r14), %rdx
movq %rsi, 0x8(%rdx)
jmp 0x79e34
movq 0xa7db9(%rip), %rdi     # 0x121bd0
movq %rcx, 0x8(%rsi)
movq 0x1f00(%r14), %r12
leaq 0x6f0(%r14), %rcx
movq 0x6f0(%r14), %rdx
movq %rdi, 0x8(%rdx)
addq $0x10, %rdx
movq %rax, %rsi
jmp 0x79e51
movq 0xa7d7c(%rip), %rsi     # 0x121bc0
leaq 0x6e8(%r14), %rdx
movq %rax, %r12
movq %rdx, %rcx
movq (%rdx), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r12, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r15, 0x8(%rax)
movq (%rcx), %rdx
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x79e8f
movq 0x7e8(%r14), %rcx
movq 0x28(%rax), %rsi
movq %rcx, 0x18(%rsi)
movq %rax, 0x7e8(%r14)
andq $0x0, 0x38(%rbx)
movq 0x18f8(%r14), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2cdc0
// File: /workspace/github_c_makefile_star2_O2/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 0x7a636
movq %rdi, %r14
cmpb $0x1, 0x24c(%rdi)
jne 0x7a636
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %rbp
movq %r14, %rdi
movq %r12, %rsi
callq 0x88f3
movq 0xf20(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%r14), %rax
je 0x7a636
movq %rax, %r13
leaq 0xd(%rsp), %rsi
movb $0x7e, (%rsi)
movb (%rbp), %al
movb %al, 0x1(%rsi)
movb $0x0, 0x2(%rsi)
movq %r14, %rdi
callq 0xd1ba
movq 0x90(%r14), %rdx
movq 0x110(%r14), %rbp
cmpq 0x98(%r14), %rdx
ja 0x7a5b6
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x9c27
movq 0x10(%rsp), %rax
movq 0x90(%r14), %rdx
leaq -0x8(%rdx), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rdx), %rdi
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rdi)
movq %r12, 0x8(%rdi)
movq %rbp, 0x10(%rdi)
movq 0x90(%r14), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%r14)
movq -0x8(%rdx), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
movq %rdi, 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 %r13, %rsi
callq 0xa34c
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rbx)
incq 0x10(%rbx)
movb $0x1, %al
jmp 0x7a638
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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rcx, %rax
movq %rsi, %r9
movq (%r8), %rcx
decq %rdx
cmpq %rdx, %rcx
movq %rdx, %rsi
cmovgq %rcx, %rsi
xorl %ebx, %ebx
leaq 0xa9ff6(%rip), %r11     # 0x124660
movq %rcx, %r10
cmpq %rdx, %r10
jge 0x7a694
movzbl (%r9,%r10), %r14d
movslq (%r11,%r14,4), %r14
cmpq $0x9, %r14
jg 0x7a691
imulq $0xa, %rbx, %rbx
jo 0x7a691
addq %r14, %rbx
jo 0x7a691
incq %r10
jmp 0x7a66d
movq %r10, %rsi
movq %rsi, (%r8)
testq %rbx, %rbx
js 0x7a6e7
cmpq 0x2c0(%rdi), %rbx
jle 0x7a75c
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 0x7a73a
leaq 0x688b9(%rip), %rcx     # 0xe2f92
movq %rcx, 0x10(%rsi)
movq $0x14, 0x8(%rsi)
jmp 0x7a74d
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 0x7a725
leaq 0x68853(%rip), %rcx     # 0xe2f6a
movq %rcx, 0x10(%rsi)
movq $0x16, 0x8(%rsi)
jmp 0x7a74d
leaq 0x6882b(%rip), %rcx     # 0xe2f57
movq %rcx, 0x10(%rsi)
movq $0x12, 0x8(%rsi)
jmp 0x7a74d
leaq 0x68840(%rip), %rcx     # 0xe2f81
movq %rcx, 0x10(%rsi)
movq $0x10, 0x8(%rsi)
movq 0x20(%rax), %rcx
movq %r9, %rdx
movq %rax, %r8
callq 0x79d77
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7a7d3
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 0x687f5(%rip), %rax     # 0xe2fa7
movq %rax, 0x10(%rsi)
movq $0x15, 0x8(%rsi)
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x79d77
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
je 0x7a82f
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 0x687b8(%rip), %rax     # 0xe2fbd
movq %rax, 0x10(%rsi)
movq $0x1e, 0x8(%rsi)
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x79d77
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x7a844
movq 0x8(%rax), %r13
testq %r13, %r13
jns 0x7a847
pushq $0x16
popq %rax
leaq 0x6879a(%rip), %rcx     # 0xe2fdc
jmp 0x7a85b
xorl %r13d, %r13d
cmpq 0x2c0(%r12), %r13
jle 0x7a896
pushq $0x14
popq %rax
leaq 0x68798(%rip), %rcx     # 0xe2ff3
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 0x79d77
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_O2/BernardTatin[P]s7sh/s7.c
// Function: format_append_chars
static void format_append_chars(s7_scheme *sc, format_data *fdat, char pad, s7_int chars, s7_pointer port)
    {
        if (is_string_port(port))
        {
            if ((port_position(port) + chars) < port_data_size(port))
            {
                local_memset((char *)port_data(port) + port_position(port), pad, chars);
                port_position(port) += chars;
            }
            else
            {
                s7_int new_len;
                new_len = port_position(port) + chars;
                resize_port_data(sc, port, new_len * 2);
                local_memset((char *)port_data(port) + port_position(port), pad, chars);
                port_position(port) = new_len;
            }
            fdat->loc += chars;
            sc->format_column += chars;
        }
        else
        {
            block_t *b;
            char *str;
            b = mallocate(sc, chars + 1);
            str = (char *)block_data(b);
            local_memset((void *)str, pad, chars);
            str[chars] = '\0';
            format_append_string(sc, fdat, str, chars, port);
            liberate(sc, b);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %rbx
movq 0x8(%r8), %rax
cmpl $0x1, 0x4(%rax)
jne 0x7a8f9
movq 0x20(%r15), %rdi
leaq (%rdi,%r14), %r12
cmpq 0x18(%r15), %r12
jge 0x7a951
addq 0x10(%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x73e47
movq 0x20(%r15), %r12
addq %r14, %r12
jmp 0x7a974
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x9037
movq %r13, (%rsp)
movq %rax, %r13
movq (%rax), %r12
movzbl %bpl, %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x73e47
movb $0x0, (%r12,%r14)
movq %rbx, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x79ea9
movq %rbx, %rdi
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9439
leaq (%r12,%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x772c3
movq 0x10(%r15), %rdi
addq 0x20(%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x73e47
movq %r12, 0x20(%r15)
addq %r14, (%r13)
addl %r14d, 0x238(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7ab50
movq %rdx, %r14
movq %rsi, %r15
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2f187
movq 0x110(%rbx), %rax
movq 0x9ef5b(%rip), %rcx     # 0x119a58
movq %rax, 0x4d0(%rbx)
testq %r14, %r14
jle 0x7ab40
movzbl -0x1(%r15,%r14), %edx
decq %r14
movq (%rcx,%rdx,8), %rdx
movq 0x90(%rbx), %rsi
leaq -0x8(%rsi), %rdi
movq %rdi, 0x90(%rbx)
movq -0x8(%rsi), %rsi
movq $0x200001, (%rsi)       # imm = 0x200001
movq %rdx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %rsi, %rax
jmp 0x7aafd
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d0(%rbx)
jmp 0x7ab57
movq 0x110(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7ac67
xorl %ecx, %ecx
pushq $0x1
popq %rax
movq %rsi, %rdx
testb $0x8, 0x6(%rsi)
jne 0x7ac5d
testb $0x1, %cl
jne 0x7ac1c
movq 0x8(%rsi), %r8
cmpb $0x1, (%r8)
jne 0x7ac1c
movq 0x8(%r8), %r8
cmpq 0x17b0(%rdi), %r8
movzbl %cl, %ecx
cmovnel %eax, %ecx
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
jne 0x7ac5e
testb $0x8, 0x6(%rsi)
jne 0x7ac5d
testb $0x1, %cl
jne 0x7ac4b
movq 0x8(%rsi), %r8
cmpb $0x1, (%r8)
jne 0x7ac4b
movq 0x8(%r8), %r8
cmpq 0x17b0(%rdi), %r8
movzbl %cl, %ecx
cmovnel %eax, %ecx
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
jne 0x7ac5e
movq 0x10(%rdx), %rdx
cmpq %rdx, %rsi
jne 0x7abf6
retq
testb $0x1, %cl
je 0x7ac67
pushq $0x2
popq %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x40
popq %r15
movb (%rbx), %bpl
cmpb $0x1, %bpl
jne 0x7ad73
orb $0x8, 0x6(%rbx)
movl 0x7d4(%r14), %ecx
cmpl 0x7d0(%r14), %ecx
jne 0x7acd0
testl %ecx, %ecx
je 0x7acd9
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 0x7acf5
movq 0x7c8(%r14), %rax
jmp 0x7acf5
movl $0x8, 0x7d0(%r14)
movq %r15, %rdi
callq 0x8480
movq %rax, 0x7c8(%r14)
xorl %ecx, %ecx
leal 0x1(%rcx), %r13d
movl %r13d, 0x7d4(%r14)
movslq %ecx, %rcx
movq %rbx, (%rax,%rcx,8)
movq 0x8(%rbx), %r12
cmpb $0x1, (%r12)
jne 0x7ad6a
movq 0x8(%r12), %rax
cmpq 0x17b0(%r14), %rax
je 0x7ad6a
movq %r14, %rdi
movq %r12, %rsi
callq 0x7abe9
cmpl $0x1, %eax
je 0x7ad73
movq %r14, %rdi
movq %r12, %rsi
callq 0x7ac6a
testb %al, %al
jne 0x7ad73
movslq %r13d, %rax
movslq 0x7d4(%r14), %rcx
cmpq %rcx, %rax
jge 0x7ad63
movq 0x7c8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
andw $-0x9, 0x6(%rcx)
incq %rax
jmp 0x7ad42
movl %r13d, 0x7d4(%r14)
movq 0x10(%rbx), %rbx
jmp 0x7ac7f
cmpb $0x1, %bpl
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movslq %esi, %r15
movq %r15, %rsi
callq 0x2f187
movq 0x110(%rbx), %rax
movq %rax, 0x4d0(%rbx)
xorl %ecx, %ecx
testl %r15d, %r15d
cmovgl %r15d, %ecx
subl $0x1, %ecx
jb 0x7ae41
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r14, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %rdx, 0x4d0(%rbx)
movq %rdx, %rax
jmp 0x7ae0b
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: memclr64
static void memclr64(void *p, size_t bytes)
    {
        size_t i, n;
        int64_t *vals;
        vals = (int64_t *)p;
        n = bytes >> 3;
        for (i = 0; i < n; )
            LOOP_8(vals[i++] = 0);
    }

// Assembly:
shrq $0x3, %rsi
xorl %eax, %eax
xorps %xmm0, %xmm0
cmpq %rsi, %rax
jae 0x7ae7c
movups %xmm0, 0x20(%rdi,%rax,8)
movups %xmm0, 0x10(%rdi,%rax,8)
movups %xmm0, (%rdi,%rax,8)
movups %xmm0, 0x30(%rdi,%rax,8)
addq $0x8, %rax
jmp 0x7ae5e
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7aefa
movq 0x8(%rbx), %rax
movq 0x10(%rsi), %rcx
movq %rax, (%rcx,%rdx,8)
jmp 0x7af13
leaq 0x63a24(%rip), %rsi     # 0xde925
leaq 0x6820a(%rip), %r8      # 0xe3112
pushq $0x3
popq %rdx
movq %rbx, %rcx
callq 0xc2b0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7af48
movq 0x8(%rcx), %rax
cmpq $0xff, %rax
ja 0x7af58
movq 0x10(%rsi), %rsi
movb %al, (%rsi,%rdx)
movq %rcx, %rax
retq
leaq 0x63ba4(%rip), %rsi     # 0xdeaf3
leaq 0x681bc(%rip), %r8      # 0xe3112
jmp 0x7af66
leaq 0x63b94(%rip), %rsi     # 0xdeaf3
leaq 0x68101(%rip), %r8      # 0xe3067
pushq $0x3
popq %rdx
jmp 0xc2b0