LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: file_display
static void file_display(s7_scheme *sc, const char *s, s7_pointer port)
    {
        if (s)
        {
            if (port_position(port) > 0)
            {
                if (fwrite((void *)(port_data(port)), 1, port_position(port), port_file(port)) != (size_t)port_position(port))
                    s7_warn(sc, 64, "fwrite trouble in display\n");
                port_position(port) = 0;
            }
            if (fputs(s, port_file(port)) == EOF)
                s7_warn(sc, 64, "write to %s: %s\n", port_filename(port), strerror(errno));
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xceee8
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jle 0xcee84
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x9660
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
je 0xcee77
movq 0x20(%rsp), %rdi
movl $0x40, %esi
leaq 0x11f62b(%rip), %rdx    # 0x1ee49b
movb $0x0, %al
callq 0x14df0
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x9250
cmpl $-0x1, %eax
jne 0xceee6
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x9090
movl (%rax), %edi
callq 0x96b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rcx
movq %rax, %r8
movl $0x40, %esi
leaq 0x11f5d7(%rip), %rdx    # 0x1ee4b6
movb $0x0, %al
callq 0x14df0
jmp 0xceee8
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xcef47
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rsi
callq 0xb230
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0xcefea
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jle 0xcefb5
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x9660
movq 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
je 0xcefb3
movq 0x10(%rsp), %rdi
movl $0x40, %esi
leaq 0x11f51b(%rip), %rdx    # 0x1ee4c7
movb $0x0, %al
callq 0x14df0
jmp 0xcefb5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x9490
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x9180
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
leaq 0x146bee(%rip), %rcx    # 0x215be8
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x1, 0x2(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x1(%rax)
je 0xcf281
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rsi
callq 0x9f60
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x1(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
leaq 0x146957(%rip), %rcx    # 0x215be8
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x1, 0x2(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
addq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jge 0xcf396
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
addq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x93e0
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0xcf3af
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0xcf5e0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: close_output_string
static void close_output_string(s7_scheme *sc, s7_pointer p)
    {
#if S7_DEBUGGING
        if (port_filename(p))
            fprintf(stderr, "%s: string has a filename\n", __func__);
#endif
        if (port_data(p))
        {
            port_data(p) = NULL;
            port_data_size(p) = 0;
        }
        port_port(p)->pf = &closed_port_functions;
        port_set_closed(p, true);
        port_position(p) = 0;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xcf450
movq -0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
leaq 0x146788(%rip), %rcx    # 0x215be8
movq %rcx, 0x48(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x1, 0x2(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jge 0xcf512
jmp 0xcf5d6
movq 0x30(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq 0x2c8(%rcx), %rax
jle 0xcf584
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x11efb1(%rip), %rsi    # 0x1ee4ec
callq 0xb400
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x11ef9e(%rip), %rsi    # 0x1ee4f9
movl $0x38, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xc3820
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rsi
movq 0x30(%rsp), %rdx
callq 0xbb60
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
addq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
shlq %rdx
callq 0xcf4e0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
addq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x93e0
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x29fa0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xcf9a3
movq 0x38(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0xaa80
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xcf994
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xcf97f
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x91a0
movq %rax, %rcx
movq (%rsp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xcf939
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rcx
movl $0x1000, %esi           # imm = 0x1000
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xabd0
jmp 0xcf960
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x30(%rsp), %r8
movl $0x1000, %esi           # imm = 0x1000
leaq 0x116d35(%rip), %rcx    # 0x1e6689
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0xabd0
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x9590
cmpl $0x0, %eax
jne 0xcf97d
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xcf9ac
jmp 0xcf97f
jmp 0xcf981
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xcf8b9
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb230
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xcfa36
movq 0x28(%rsp), %rdi
callq 0xa430
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xaa80
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x93e0
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
jmp 0xcfafe
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x9280
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xa430
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0xa430
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xaa80
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xcfad6
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %r8
leaq 0x116bcb(%rip), %rcx    # 0x1e6689
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0xabd0
movq 0x8(%rsp), %rdi
callq 0x9050
jmp 0xcfafc
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x93e0
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
jmp 0xcfafe
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4a4(%rcx), %eax
jg 0xcfb7c
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x498(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
callq 0xcfce0
testb $0x1, %al
jne 0xcfb60
jmp 0xcfb6d
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xcfcd0
jmp 0xcfb6f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xcfb26
movq 0x18(%rsp), %rax
movl 0x4a4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4a4(%rax)
movq 0x18(%rsp), %rax
movl 0x4a4(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4a0(%rcx), %eax
jl 0xcfc93
movl $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x4a0(%rax)
jne 0xcfbf8
movq 0x18(%rsp), %rax
movl $0x8, 0x4a0(%rax)
movq 0x18(%rsp), %rax
movslq 0x4a0(%rax), %rdi
movl $0x8, %esi
callq 0x9360
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x498(%rax)
jmp 0xcfc4a
movq 0x18(%rsp), %rax
movl 0x4a0(%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x4a0(%rax), %ecx
shll %ecx
movl %ecx, 0x4a0(%rax)
movq 0x18(%rsp), %rax
movq 0x498(%rax), %rdi
movq 0x18(%rsp), %rax
movslq 0x4a0(%rax), %rsi
shlq $0x3, %rsi
callq 0x9510
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x498(%rax)
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4a0(%rcx), %eax
jge 0xcfc91
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x498(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xcfc52
jmp 0xcfc93
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x147c0
movq %rax, %rdx
movq 0x18(%rsp), %rax
movq 0x498(%rax), %rax
movq 0x18(%rsp), %rcx
movslq 0x4a4(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movl 0x4a4(%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0xcfe7d
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xcff1b
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xcfebc
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xcffd8
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jne 0xcffa6
movq 0x18(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xcffbc
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
leaq -0xa3cb8(%rip), %rcx    # 0x2c310
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xcffe7
movq 0x10(%rsp), %rdi
callq 0xcfdf0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: shared_ref
static int32_t shared_ref(shared_info *ci, s7_pointer p)
    {
        /* from print after collecting refs, not called by equality check, only called in object_to_port_with_circle_check_1 */
        int32_t i;
        s7_pointer *objs;

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

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0xd137b
movq -0x28(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rsp), %rax
jne 0xd136c
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rsp)
cmpl $0x0, -0x2c(%rsp)
jle 0xd1362
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rsp), %rcx
xorl %edx, %edx
subl (%rax,%rcx,4), %edx
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xd1383
jmp 0xd136e
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xd12ff
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0xd1407
movq -0x20(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rsp), %rax
jne 0xd13f8
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rsp), %rcx
xorl %edx, %edx
subl (%rax,%rcx,4), %edx
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xd1407
jmp 0xd13fa
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xd13af
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movb %cl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movb %al, -0x19(%rsp)
movq -0x8(%rsp), %rax
addq $0xb30, %rax            # imm = 0xB30
addq $0x20, %rax
addq $-0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x28(%rsp)
movb $0x0, (%rax)
movsbl -0x19(%rsp), %eax
cmpl $0x0, %eax
je 0xd147c
movb -0x19(%rsp), %cl
movq -0x28(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x28(%rsp)
movb %cl, (%rax)
jmp 0xd147e
movq -0x10(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
leaq 0x11cb81(%rip), %rax    # 0x1ee015
movb (%rax,%rdx), %cl
movq -0x28(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x28(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xd147e
movq -0x30(%rsp), %rcx
movq -0x28(%rsp), %rax
subq %rax, %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x28(%rsp), %rax
addq $0x1, %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x6c0(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0xc(%rax)
jle 0xd159f
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0xc(%rax), %rsi
shlq $0x2, %rsi
callq 0xd2340
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x8(%rsp), %rax
movslq 0xc(%rax), %rsi
shlq $0x0, %rsi
callq 0xd2340
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0xd1593
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movabsq $-0x600000000a0001, %rcx # imm = 0xFF9FFFFFFFF5FFFF
andq (%rax), %rcx
movq %rcx, (%rax)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xd1557
movq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
cmpq $0x8, -0x10(%rsp)
jb 0xd23b0
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
shrq $0x3, %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x20(%rsp)
movq $0x0, (%rax)
movq -0x28(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, %rax
ja 0xd236a
movq -0x10(%rsp), %rax
andq $0x7, %rax
movq %rax, -0x10(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0xd23ba
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0xd23bc
cmpq $0x0, -0x10(%rsp)
jbe 0xd23e8
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rsp)
movb $0x0, (%rax)
movq -0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0xd23bc
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
movslq 0xc(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0xd24aa
movq -0x18(%rsp), %rax
movq (%rax), %rax
cmpq -0x8(%rsp), %rax
jne 0xd2495
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x24(%rsp)
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xd2493
movq -0x10(%rsp), %rax
movb $0x1, 0x18(%rax)
movq -0x10(%rsp), %rax
movl 0x10(%rax), %edx
addl $0x1, %edx
movl %edx, 0x10(%rax)
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xd24aa
jmp 0xd2497
movq -0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rsp)
jmp 0xd2424
movq -0x8(%rsp), %rax
movzwl 0x6(%rax), %ecx
orl $0x20, %ecx
movw %cx, 0x6(%rax)
movb $0x1, %al
andb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
shll %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
subl $0x2, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movslq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x9510
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rax
movslq 0x8(%rax), %rsi
shlq $0x2, %rsi
callq 0x9510
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x10(%rsp), %rax
movslq 0x8(%rax), %rsi
shlq $0x0, %rsi
callq 0x9510
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xd25ad
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0xc(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xd2568
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movb $0x0, 0x17(%rsp)
testb $0x1, 0x2f(%rsp)
je 0xd2618
movq 0x40(%rsp), %rax
movq 0x280(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jle 0xd2616
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0xd2626
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jge 0xd2716
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x14f829(%rip), %rax    # 0x221e90
testb $0x1, (%rax,%rcx)
je 0xd2701
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x15, %eax
jne 0xd2691
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0xd2701
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdx
movb 0x2f(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xd15c0
testb $0x1, %al
jne 0xd26b4
jmp 0xd2701
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %ecx
orl $0x20, %ecx
movw %cx, 0x6(%rax)
movb $0x1, 0x17(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x21, %eax
je 0xd26f0
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1d, %eax
je 0xd26f0
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x14, %eax
jne 0xd26ff
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xd23f0
jmp 0xd2701
jmp 0xd2703
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xd262f
testb $0x1, 0x17(%rsp)
je 0xd272d
movq 0x30(%rsp), %rax
movzwl 0x6(%rax), %ecx
orl $0x20, %ecx
movw %cx, 0x6(%rax)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
andq 0x8(%rcx), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xd282e
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0xd281c
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xd28a8
jmp 0xd281e
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xd27f6
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xd2897
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x8(%rsp), %rax
jne 0xd2885
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rdx
callq 0x3e930
testb $0x1, %al
jne 0xd2879
jmp 0xd2885
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xd28a8
jmp 0xd2887
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xd2844
movq 0x28(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0xd2928
movq -0x28(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rsp), %rax
jne 0xd2919
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rsp)
jmp 0xd2930
jmp 0xd291b
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xd28df
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: open_format_data
static format_data *open_format_data(s7_scheme *sc)
    {
        format_data *fdat;
        sc->format_depth++;
        if (sc->format_depth >= sc->num_fdats)
        {
            int32_t k, new_num_fdats;
            new_num_fdats = sc->format_depth * 2;
            sc->fdats = (format_data **)realloc(sc->fdats, sizeof(format_data *) * new_num_fdats);
            for (k = sc->num_fdats; k < new_num_fdats; k++) sc->fdats[k] = NULL;
            sc->num_fdats = new_num_fdats;
        }

        fdat = sc->fdats[sc->format_depth];
        if (!fdat)
        {
            fdat = (format_data *)malloc(sizeof(format_data));
            sc->fdats[sc->format_depth] = fdat;
            fdat->curly_len = 0;
            fdat->curly_str = NULL;
            fdat->ctr = 0;
        }
        else
        {
            if (fdat->port)
                close_format_port(sc, fdat->port);
            if (fdat->strport)
                close_format_port(sc, fdat->strport);
        }
        fdat->port = NULL;
        fdat->strport = NULL;
        fdat->loc = 0;
        fdat->curly_arg = sc->nil;
        return(fdat);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x2188(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2188(%rax)
movq 0x10(%rsp), %rax
movl 0x2188(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x6d0(%rcx), %eax
jl 0xd546d
movq 0x10(%rsp), %rax
movl 0x2188(%rax), %eax
shll %eax
movl %eax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x6c8(%rax), %rdi
movslq (%rsp), %rsi
shlq $0x3, %rsi
callq 0x9510
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x6c8(%rax)
movq 0x10(%rsp), %rax
movl 0x6d0(%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jge 0xd545f
movq 0x10(%rsp), %rax
movq 0x6c8(%rax), %rax
movslq 0x4(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xd5430
movl (%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x6d0(%rax)
movq 0x10(%rsp), %rax
movq 0x6c8(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x2188(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xd54ef
movl $0x48, %edi
callq 0x9480
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x6c8(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x2188(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0xd552f
movq 0x8(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0xd550e
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rsi
callq 0x2d1e0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0xd552d
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0x2d1e0
jmp 0xd552f
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x50(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0xd5662
movq 0x50(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0xd5676
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x145e0
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xd56da
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xd56b5
movq 0x70(%rsp), %rdi
movq 0x14d06e(%rip), %rsi    # 0x222708
movq 0x40(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x68(%rsp), %r8
callq 0xd7140
movq %rax, 0x48(%rsp)
jmp 0xd56d5
movq 0x70(%rsp), %rdi
movq 0x14d04f(%rip), %rsi    # 0x222710
movq 0x40(%rsp), %rdx
movq 0x68(%rsp), %rcx
callq 0xf240
movq %rax, 0x48(%rsp)
jmp 0xd57a8
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xd574f
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x14d020(%rip), %rax    # 0x222718
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rsi
addq $0x14, %rsi
callq 0x12430
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq %rax, %r8
movq 0x68(%rsp), %r9
callq 0xd71e0
movq %rax, 0x48(%rsp)
jmp 0xd57a6
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x14cfc0(%rip), %rax    # 0x222720
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rsi
addq $0x14, %rsi
callq 0x12430
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
movq 0x68(%rsp), %r8
callq 0xd7140
movq %rax, 0x48(%rsp)
jmp 0xd57a8
movq 0x50(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0xd57d4
movq 0x70(%rsp), %rdi
movq 0x50(%rsp), %rax
movq 0x38(%rax), %rsi
callq 0x2d1e0
movq 0x50(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x70(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x18f8(%rax), %rsi
movq 0x48(%rsp), %rdx
callq 0x2f940
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: format_nesting
static s7_int format_nesting(const char *str, char opener, char closer, s7_int start, s7_int end) /* start=i, end=str_len-1 */
    {
        s7_int k, nesting = 1;
        for (k = start + 2; k < end; k++)
            if (str[k] == '~')
            {
                if (str[k + 1] == closer)
                {
                    nesting--;
                    if (nesting == 0)
                        return(k - start - 1);
                }
                else
                {
                    if (str[k + 1] == opener)
                        nesting++;
                }
            }
        return(-1);
    }

// Assembly:
movb %dl, %al
movb %sil, %dl
movq %rdi, -0x10(%rsp)
movb %dl, -0x11(%rsp)
movb %al, -0x12(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq $0x1, -0x38(%rsp)
movq -0x20(%rsp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x28(%rsp), %rax
jge 0xd59ba
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7e, %eax
jne 0xd59a5
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movsbl 0x1(%rax,%rcx), %eax
movsbl -0x12(%rsp), %ecx
cmpl %ecx, %eax
jne 0xd597b
movq -0x38(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rsp)
cmpq $0x0, -0x38(%rsp)
jne 0xd5979
movq -0x30(%rsp), %rax
subq -0x20(%rsp), %rax
subq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0xd59c3
jmp 0xd59a3
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
movsbl 0x1(%rax,%rcx), %eax
movsbl -0x11(%rsp), %ecx
cmpl %ecx, %eax
jne 0xd59a1
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0xd59a3
jmp 0xd59a5
jmp 0xd59a7
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0xd5913
movq $-0x1, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)