LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_warn
static void s7_warn(s7_scheme *sc, s7_int len, const char *ctrl, ...) /* len = max size of output string (for vsnprintf) */
                {
                    if (sc->error_port != sc->F)
                    {
                        va_list ap;
                        s7_pointer warning;
                        char *str;

                        warning = make_empty_string(sc, len, 0);
                        string_value(warning)[0] = '\0';
                        str = (char *)string_value(warning);
                        va_start(ap, ctrl);
                        vsnprintf(str, len, ctrl, ap);
                        va_end(ap);

                        if (port_is_closed(sc->error_port))
                            sc->error_port = sc->standard_error;
                        s7_display(sc, warning, sc->error_port);
                    }
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xd615
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x190(%rdi), %rax
cmpq 0x120(%rdi), %rax
je 0xd6a7
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %edx, %edx
callq 0xd239
movq %rax, %r14
movq 0x10(%rax), %rax
movb $0x0, (%rax)
movq 0x10(%r14), %rdi
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rsp, %rcx
movq %rax, (%rcx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rcx)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rcx)
movq %r12, %rsi
movq %r15, %rdx
callq 0x8130
movq 0x190(%rbx), %rdx
movq 0x8(%rdx), %rax
cmpb $0x1, 0x2(%rax)
jne 0xd69c
movq 0x1d8(%rbx), %rdx
movq %rdx, 0x190(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c075
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_open_output_file
s7_pointer s7_open_output_file(s7_scheme *sc, const char *name, const char *mode)
    {
        FILE *fp;
        s7_pointer x;
        block_t *block, *b;
        /* see if we can open this file before allocating a port */

        errno = 0;
        fp = fopen(name, mode);
        if (!fp)
        {
#if (!MS_WINDOWS)
            if (errno == EINVAL)
                return(file_error(sc, "open-output-file", "invalid mode", mode));
#endif
            return(file_error(sc, "open-output-file", strerror(errno), name));
        }

        new_cell(sc, x, T_OUTPUT_PORT);
        b = mallocate_port(sc);
        port_block(x) = b;
        port_port(x) = (port_t *)block_data(b);
        port_type(x) = FILE_PORT;
        port_set_closed(x, false);
        port_filename_length(x) = safe_strlen(name);
        port_set_filename(sc, x, name, port_filename_length(x));
        port_line_number(x) = 1;
        port_file_number(x) = 0;
        port_file(x) = fp;
        port_needs_free(x) = true;  /* hmm -- I think these are freed via s7_close_output_port -> close_output_port */
        port_position(x) = 0;
        port_data_size(x) = PORT_DATA_SIZE;
        block = mallocate(sc, PORT_DATA_SIZE);
        port_data_block(x) = block;
        port_data(x) = (uint8_t *)(block_data(block));
        port_port(x)->pf = &output_file_functions;
        add_output_port(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8090
movq %rax, %r13
andl $0x0, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x85b0
testq %rax, %rax
je 0xd966
movq %rax, %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xd895
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x22, (%r15)
movq %rbx, %rdi
callq 0xda55
movq %rax, 0x28(%r15)
movq (%rax), %rax
movq %rax, 0x8(%r15)
andl $0x0, 0x4(%rax)
movq 0x8(%r15), %rax
movb $0x0, 0x2(%rax)
movq %r14, %rdi
callq 0x8d06
movq 0x8(%r15), %rcx
movq %rax, 0x30(%rcx)
movq 0x8(%r15), %rax
movq 0x30(%rax), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xdaaa
movq 0x8(%r15), %rax
movl $0x1, 0x20(%rax)
movq 0x8(%r15), %rax
andl $0x0, 0x24(%rax)
movq 0x8(%r15), %rax
movq %r12, 0x8(%rax)
movq 0x8(%r15), %rax
movb $0x1, (%rax)
andq $0x0, 0x20(%r15)
movq $0x100, 0x18(%r15)      # imm = 0x100
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
callq 0x9037
movq 0x8(%r15), %rcx
movq %rax, 0x38(%rcx)
movq (%rax), %rax
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rax
leaq 0x107a7a(%rip), %rcx    # 0x1153c0
movq %rcx, 0x48(%rax)
movq 0x750(%rbx), %rdi
movq %r15, %rsi
callq 0xb999
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl (%r13), %edi
cmpl $0x16, %edi
jne 0xd985
leaq 0xc86df(%rip), %rsi     # 0xd6055
leaq 0xc86e9(%rip), %rdx     # 0xd6066
movq %rbx, %rdi
movq %r15, %rcx
jmp 0xd99a
callq 0x86b0
leaq 0xc86c4(%rip), %rsi     # 0xd6055
movq %rbx, %rdi
movq %rax, %rdx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd9a5
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: file_error
static s7_pointer file_error(s7_scheme *sc, const char *caller, const char *descr, const char *name)
                {
                    return(s7_error(sc, sc->io_error_symbol,
                                set_elist_4(sc, wrap_string(sc, "~A: ~A ~S", 9),
                                    s7_make_string_wrapper(sc, caller),
                                    s7_make_string_wrapper(sc, descr),
                                    s7_make_string_wrapper(sc, name))));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movq 0x1930(%rdi), %r14
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %rbp
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0xd5b9b(%rip), %rax     # 0xe3580
movq %rax, 0x10(%rbp)
movq $0x9, 0x8(%rbp)
callq 0xd1ba
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd1ba
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd1ba
movq 0x6f0(%rbx), %rcx
movq %rbp, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %r13, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %r12, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6f0(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2cdc0
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: mallocate_port
static block_t *mallocate_port(s7_scheme *sc)
    {
#define PORT_LIST 8 /* sizeof(port_t): 160 */
        block_t *p;
        p = sc->block_lists[PORT_LIST];
        if (p)
        {
            sc->block_lists[PORT_LIST] = (block_t *)block_next(p);
            /* block_next(p) = NULL; */
        }
        else
        { /* this is mallocate without the index calc */
            p = mallocate_block(sc);
            block_data(p) = (void *)alloc_permanent_string(sc, (size_t)(1 << PORT_LIST));
            block_set_index(p, PORT_LIST);
        }
        block_set_size(p, sizeof(port_t));
        return(p);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x878(%rdi), %rbx
testq %rbx, %rbx
je 0xda75
movq 0x18(%rbx), %rax
movq %rax, 0x878(%r14)
jmp 0xda97
movq %r14, %rdi
callq 0xb93f
movq %rax, %rbx
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0xd3b1
movq %rax, (%rbx)
movl $0x8, 0x8(%rbx)
movq $0x60, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: port_set_filename
static inline void port_set_filename(s7_scheme *sc, s7_pointer p, const char *name, size_t len)
    {
        block_t *b;
        b = mallocate(sc, len + 1);
        port_filename_block(p) = b;
        port_filename(p) = (char *)block_data(b);
        memcpy((void *)block_data(b), (void *)name, len);
        port_filename(p)[len] = '\0';
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x1(%rcx), %rsi
callq 0x9037
movq 0x8(%r15), %rcx
movq %rax, 0x18(%rcx)
movq (%rax), %rdi
movq 0x8(%r15), %rax
movq %rdi, 0x10(%rax)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x83e0
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
movb $0x0, (%rax,%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: open_input_string
static s7_pointer open_input_string(s7_scheme *sc, const char *input_string, s7_int len)
    {
        s7_pointer x;
        block_t *b;
        new_cell(sc, x, T_INPUT_PORT);
        b = mallocate_port(sc);
        port_block(x) = b;
        port_port(x) = (port_t *)block_data(b);
        port_type(x) = STRING_PORT;
        port_set_closed(x, false);
        port_original_input_string(x) = sc->nil;
        port_data(x) = (uint8_t *)input_string;
        port_data_block(x) = NULL;
        port_data_size(x) = len;
        port_position(x) = 0;
        port_filename_block(x) = NULL;
        port_filename_length(x) = 0;
        port_filename(x) = NULL;
        port_file_number(x) = 0;
        port_line_number(x) = 0;
        port_needs_free(x) = false;
        port_needs_unprotect(x) = false;
#if S7_DEBUGGING
        if (input_string[len] != '\0')
        {
            fprintf(stderr, "read_white_space string is not terminated: %s", input_string);
            abort();
        }
#endif
        port_port(x)->pf = &input_string_functions;
        add_input_string_port(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xdb45
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x23, (%r14)
movq %rbx, %rdi
callq 0xda55
movq %rax, 0x28(%r14)
movq (%rax), %rax
movq %rax, 0x8(%r14)
movl $0x1, 0x4(%rax)
movq 0x8(%r14), %rax
xorl %ecx, %ecx
movb %cl, 0x2(%rax)
movq 0x110(%rbx), %rax
movq 0x8(%r14), %rdx
movq %rax, 0x40(%rdx)
movq %r12, 0x10(%r14)
movq 0x8(%r14), %rax
andq $0x0, 0x38(%rax)
movq %r15, 0x18(%r14)
andq $0x0, 0x20(%r14)
movq 0x8(%r14), %rax
andq $0x0, 0x18(%rax)
movq 0x8(%r14), %rax
andq $0x0, 0x30(%rax)
movq 0x8(%r14), %rax
andq $0x0, 0x10(%rax)
movq 0x8(%r14), %rax
andl $0x0, 0x24(%rax)
movq 0x8(%r14), %rax
andl $0x0, 0x20(%rax)
movq 0x8(%r14), %rax
movb %cl, (%rax)
movq 0x8(%r14), %rax
movb %cl, 0x1(%rax)
movq 0x8(%r14), %rax
leaq 0x1079ba(%rip), %rcx    # 0x1155a0
movq %rcx, 0x48(%rax)
movq 0x758(%rbx), %rdi
movq %r14, %rsi
callq 0xb999
movq %r14, %rax
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: s7_open_input_function
s7_pointer s7_open_input_function(s7_scheme *sc, s7_pointer (*function)(s7_scheme *sc, s7_read_t read_choice, s7_pointer port))
    {
        s7_pointer x;
        block_t *b;
        new_cell(sc, x, T_INPUT_PORT);
        b = mallocate_port(sc);
        port_block(x) = b;
        port_port(x) = (port_t *)block_data(b);
        port_type(x) = FUNCTION_PORT;
        port_set_closed(x, false);
        port_original_input_string(x) = sc->nil;
        port_data_block(x) = NULL;
        port_needs_free(x) = false;
        port_filename_block(x) = NULL;
        port_filename(x) = NULL;
        port_filename_length(x) = 0;
        port_file_number(x) = 0;
        port_line_number(x) = 0;
        port_input_function(x) = function;
        port_port(x)->pf = &input_function_functions;
        add_input_port(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xdd21
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x23, (%r15)
movq %rbx, %rdi
callq 0xda55
movq %rax, 0x28(%r15)
movq (%rax), %rax
movq %rax, 0x8(%r15)
movl $0x2, 0x4(%rax)
movq 0x8(%r15), %rax
xorl %ecx, %ecx
movb %cl, 0x2(%rax)
movq 0x110(%rbx), %rax
movq 0x8(%r15), %rdx
movq %rax, 0x40(%rdx)
movq 0x8(%r15), %rax
andq $0x0, 0x38(%rax)
movq 0x8(%r15), %rax
movb %cl, (%rax)
movq 0x8(%r15), %rax
andq $0x0, 0x18(%rax)
movq 0x8(%r15), %rax
andq $0x0, 0x10(%rax)
movq 0x8(%r15), %rax
andq $0x0, 0x30(%rax)
movq 0x8(%r15), %rax
andl $0x0, 0x24(%rax)
movq 0x8(%r15), %rax
andl $0x0, 0x20(%rax)
movq 0x8(%r15), %rax
movq %r14, 0x50(%rax)
movq 0x8(%r15), %rax
leaq 0x10765a(%rip), %rcx    # 0x115410
movq %rcx, 0x48(%rax)
movq 0x748(%rbx), %rdi
movq %r15, %rsi
callq 0xb999
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_open_output_function
s7_pointer s7_open_output_function(s7_scheme *sc, void (*function)(s7_scheme *sc, uint8_t c, s7_pointer port))
    {
        s7_pointer x;
        block_t *b;
        new_cell(sc, x, T_OUTPUT_PORT);
        b = mallocate_port(sc);
        port_block(x) = b;
        port_port(x) = (port_t *)block_data(b);
        port_type(x) = FUNCTION_PORT;
        port_data(x) = NULL;
        port_data_block(x) = NULL;
        port_set_closed(x, false);
        port_needs_free(x) = false;
        port_output_function(x) = function;
        port_port(x)->pf = &output_function_functions;
        add_output_port(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xddfc
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x22, (%r15)
movq %rbx, %rdi
callq 0xda55
movq %rax, 0x28(%r15)
movq (%rax), %rax
movq %rax, 0x8(%r15)
movl $0x2, 0x4(%rax)
andq $0x0, 0x10(%r15)
movq 0x8(%r15), %rax
andq $0x0, 0x38(%rax)
movq 0x8(%r15), %rax
xorl %ecx, %ecx
movb %cl, 0x2(%rax)
movq 0x8(%r15), %rax
movb %cl, (%rax)
movq 0x8(%r15), %rax
movq %r14, 0x58(%rax)
movq 0x8(%r15), %rax
leaq 0x107604(%rip), %rcx    # 0x115460
movq %rcx, 0x48(%rax)
movq 0x750(%rbx), %rdi
movq %r15, %rsi
callq 0xb999
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_peek_char
s7_pointer s7_peek_char(s7_scheme *sc, s7_pointer port)
    {
        int32_t c;              /* needs to be an int32_t so EOF=-1, but not 255 */
        if (is_string_port(port))
        {
            if (port_data_size(port) <= port_position(port))
                return(chars[EOF]);
            return(chars[(uint8_t)port_data(port)[port_position(port)]]);
        }
        c = port_read_character(port)(sc, port);
        if (c == EOF) return(eof_object);
        backchar(c, port);
        return(chars[c]);
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpl $0x1, 0x4(%rax)
jne 0xdef7
movq 0x20(%rbx), %rcx
movq 0x10bb75(%rip), %rax    # 0x119a58
cmpq %rcx, 0x18(%rbx)
jle 0xdf23
movq 0x10(%rbx), %rdx
movzbl (%rdx,%rcx), %ecx
leaq (%rax,%rcx,8), %rax
jmp 0xdf30
movq 0x48(%rax), %rax
movq %rbx, %rsi
callq *(%rax)
cmpl $-0x1, %eax
je 0xdf29
movl %eax, %ebp
movsbl %bpl, %edi
movq %rbx, %rsi
callq 0xdf3a
movslq %ebp, %rax
shlq $0x3, %rax
addq 0x10bb37(%rip), %rax    # 0x119a58
jmp 0xdf30
addq $-0x8, %rax
jmp 0xdf30
leaq 0x107830(%rip), %rax    # 0x115760
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: backchar
static void backchar(char c, s7_pointer pt)
    {
        if (c == '\n')
            port_line_number(pt)--;

        if (is_file_port(pt))
            ungetc(c, port_file(pt));
        else
        {
            if (port_position(pt) > 0)
                port_position(pt)--;
        }
    }

// Assembly:
cmpb $0xa, %dil
jne 0xdf47
movq 0x8(%rsi), %rax
decl 0x20(%rax)
movq 0x8(%rsi), %rax
cmpl $0x0, 0x4(%rax)
je 0xdf62
movq 0x20(%rsi), %rax
testq %rax, %rax
jle 0xdf61
decq %rax
movq %rax, 0x20(%rsi)
retq
movq 0x8(%rax), %rsi
jmp 0x84c0
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: push_input_port
static inline void push_input_port(s7_scheme *sc, s7_pointer new_port)
    {
#if S7_DEBUGGING
        if (!is_input_port(new_port)) fprintf(stderr, "push %s\n", DISPLAY(new_port));
#endif
        if (sc->input_port_stack_loc >= sc->input_port_stack_size)
        {
            sc->input_port_stack_size *= 2;
            sc->input_port_stack = (s7_pointer *)realloc(sc->input_port_stack, sc->input_port_stack_size * sizeof(s7_pointer));
        }
        sc->input_port_stack[sc->input_port_stack_loc++] = sc->input_port;
        sc->input_port = new_port;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x180(%rdi), %esi
movl 0x184(%rdi), %ecx
cmpl %esi, %ecx
jae 0xe15b
movq 0x178(%r14), %rax
jmp 0xe182
addl %esi, %esi
movl %esi, 0x180(%r14)
movq 0x178(%r14), %rdi
shlq $0x3, %rsi
callq 0x8510
movq %rax, 0x178(%r14)
movl 0x184(%r14), %ecx
movq 0x170(%r14), %rdx
leal 0x1(%rcx), %esi
movl %esi, 0x184(%r14)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq %rbx, 0x170(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: expand_cwd
static FILE *expand_cwd(s7_scheme *sc, const char *fname)
    {
        /* catch one special case, "~/..." since it causes 99.9% of the "can't load ..." errors */
        if ((fname[0] == '~') &&
                (fname[1] == '/'))
        {
            char *home;
            home = getenv("HOME");
            if (home)
            {
                block_t *b;
                char *filename;
                s7_int len;
                FILE *fp;

                len = safe_strlen(fname) + safe_strlen(home) + 1;
                b = mallocate(sc, len);
                filename = (char *)block_data(b);
                filename[0] = '\0';
                catstrs(filename, len, home, (char *)(fname + 1), NULL);
                fp = fopen(filename, "r");
                liberate(sc, b);

                return(fp);
            }
        }
        return(NULL);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x7e, (%rsi)
jne 0x29963
movq %rsi, %r15
cmpb $0x2f, 0x1(%rsi)
jne 0x29963
movq %rdi, %rbx
leaq 0xb8ed9(%rip), %rdi     # 0xe27c5
callq 0x8030
testq %rax, %rax
je 0x29963
movq %rax, %r14
leaq 0x1(%r15), %r12
movq %r15, %rdi
callq 0x8d06
movq %rax, %r15
movq %r14, %rdi
callq 0x8d06
addq %rax, %r15
incq %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9037
movq %rax, %r13
movq (%rax), %rbp
movb $0x0, (%rbp)
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x90f7
leaq 0xbcb9f(%rip), %rsi     # 0xe64e7
movq %rbp, %rdi
callq 0x85b0
movq %rax, %r14
movq %rbx, %rdi
movq %r13, %rsi
callq 0x9439
movq %r14, %rax
jmp 0x29965
xorl %eax, %eax
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: open_file_with_load_path
static FILE *open_file_with_load_path(s7_scheme *sc, const char *fname)
    {
        block_t *b;
        b = search_load_path(sc, fname);
        if (b)
        {
            FILE *fp;
            fp = fopen((const char *)block_data(b), "r");
            if ((fp) && (hook_has_functions(sc->load_hook)))
                s7_apply_function(sc, sc->load_hook, list_1(sc, sc->temp6 = s7_make_string(sc, (const char *)block_data(b))));
            liberate(sc, b);
            return(fp);
        }
        return(NULL);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7748c
testq %rax, %rax
je 0x29a32
movq %rax, %r14
movq (%rax), %rdi
leaq 0xbcb4a(%rip), %rsi     # 0xe64e7
callq 0x85b0
movq %rax, %r15
testq %rax, %rax
je 0x29a25
movq 0x1e8(%rbx), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x97c7
cmpb $0x1, (%rax)
jne 0x29a25
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xd1fd
movq %rax, %r13
movq %rax, 0x520(%rbx)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x299fc
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r13, 0x8(%rdx)
movq %rbp, 0x10(%rdx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa34c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9439
jmp 0x29a35
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: read_scheme_file
static s7_pointer read_scheme_file(s7_scheme *sc, FILE *fp, const char *fname)
    {
        s7_pointer port;
        port = read_file(sc, fp, fname, -1, "load");             /* -1 means always read its contents into a local string */
        port_file_number(port) = remember_file_name(sc, fname);
        set_loader_port(port);
        sc->temp6 = port;
        push_input_port(sc, port);
        sc->temp6 = sc->nil;
        return(port);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xb575a(%rip), %r8      # 0xdf1b3
pushq $-0x1
popq %rcx
callq 0x73eab
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7763a
movq 0x8(%r15), %rcx
movl %eax, 0x24(%rcx)
orb $0x4, 0x2(%r15)
movq %r15, 0x520(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0xe138
movq 0x110(%r14), %rax
movq %rax, 0x520(%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_add_to_load_path
s7_pointer s7_add_to_load_path(s7_scheme *sc, const char *dir)
    {
        s7_symbol_set_value(sc,
                sc->load_path_symbol,
                cons(sc,
                    s7_make_string(sc, dir),
                    s7_symbol_value(sc, sc->load_path_symbol)));
        return(s7_symbol_value(sc, sc->load_path_symbol));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1280(%rdi), %r14
callq 0xd1fd
movq %rax, %r15
movq 0x1280(%rbx), %rsi
movq %rbx, %rdi
callq 0x94b4
movq %rax, %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x2a39e
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r15, 0x8(%rdx)
movq %r12, 0x10(%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb0e7
movq 0x1280(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x94b4
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_autoload
s7_pointer s7_autoload(s7_scheme *sc, s7_pointer symbol, s7_pointer file_or_function)
    {
        /* add '(symbol . file) to s7's autoload table */
        if (is_null(sc->autoload_table))
            sc->autoload_table = s7_make_hash_table(sc, sc->default_hash_table_length);
        if (sc->safety >= MORE_SAFETY_WARNINGS)
        {
            s7_pointer p;
            p = s7_hash_table_ref(sc, sc->autoload_table, symbol);
            if ((p != sc->F) && (p != file_or_function))
                s7_warn(sc, 256, "'%s autoload value changed\n", symbol_name(symbol));
        }
        s7_hash_table_set(sc, sc->autoload_table, symbol, file_or_function);
        return(file_or_function);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2140(%rdi), %rsi
cmpq 0x110(%rdi), %rsi
jne 0x2a589
movq 0x270(%r15), %rsi
movq %r15, %rdi
callq 0x2a5ea
movq %rax, %rsi
movq %rax, 0x2140(%r15)
cmpq $0x2, 0x6a0(%r15)
jl 0x2a5cc
movq %r15, %rdi
movq %r14, %rdx
callq *0x18(%rsi)
movq 0x20(%rax), %rax
cmpq %rbx, %rax
je 0x2a5cc
cmpq 0x120(%r15), %rax
je 0x2a5cc
movq 0x8(%r14), %rax
movq 0x10(%rax), %rcx
leaq 0xabab6(%rip), %rdx     # 0xd6073
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
xorl %eax, %eax
callq 0xd5c7
movq 0x2140(%r15), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2a7e4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_eval_c_string_with_environment
s7_pointer s7_eval_c_string_with_environment(s7_scheme *sc, const char *str, s7_pointer e)
    {
        s7_pointer code, port, result;
        TRACK(sc);
        push_stack(sc, OP_GC_PROTECT, sc->args, sc->code);
        /* maybe this should just use locals? (GC protection is not the issue here),
         *   but this is way down in the noise -- read/eval below are 99% of the computing
         */
        port = s7_open_input_string(sc, str);
        code = s7_read(sc, port);
        s7_close_input_port(sc, port);
        result = s7_eval(sc, T_Pos(code), e);
        pop_stack(sc);
        return(result);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, (%rcx)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rdi), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%rdi)
callq 0xdaf1
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0xdf6b
movq %rax, %r12
movq 0x8(%r15), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x48(%rax)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2ad8f
movq 0x50(%rbx), %rcx
leaq -0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movups -0x20(%rcx), %xmm0
movups -0x10(%rcx), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%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: rootlet_iterate
static s7_pointer rootlet_iterate(s7_scheme *sc, s7_pointer iterator)
    {
        s7_pointer slot;
        slot = iterator_current(iterator);
        if (is_slot(slot))
        {
            if (iterator_position(iterator) < sc->rootlet_entries)
            {
                iterator_position(iterator)++;
                iterator_current(iterator) = rootlet_element(sc->rootlet, iterator_position(iterator));
            }
            else iterator_current(iterator) = sc->nil;
            return(cons(sc, slot_symbol(slot), slot_value(slot)));
        }
        return(iterator_quit(iterator));
    }

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

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

// Assembly:
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x2b12e
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rcx), %rax
movq %rax, 0x18(%rsi)
movq 0x10(%rsi), %rax
movq 0x8(%rcx), %r14
testq %rax, %rax
je 0x2b145
movq %r14, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x2b189
leaq 0x2ee(%rip), %rax       # 0x2b423
movq %rax, 0x28(%rsi)
andb $0x7f, 0x3(%rsi)
movq 0xea61c(%rip), %rax     # 0x115760
retq
movq %rdi, %rbx
movq 0x10(%rcx), %r15
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x2b16b
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 %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: pair_iterate
static s7_pointer pair_iterate(s7_scheme *sc, s7_pointer obj)
    {
        if (is_pair(iterator_current(obj)))
        {
            s7_pointer result;
            result = car(iterator_current(obj));
            iterator_current(obj) = cdr(iterator_current(obj));
            if (iterator_current(obj) == iterator_slow(obj))
                iterator_current(obj) = sc->nil;
            iterator_next(obj) = pair_iterate_1;
            return(result);
        }
        return(iterator_quit(obj));
    }

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
movq 0x1218(%rdi), %rdx
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x2b4e1
movq %rax, %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x2b4a9
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r14, 0x8(%rdx)
movq %r12, 0x10(%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa34c
movq %rax, %rcx
xorl %eax, %eax
cmpb $0xb, (%rcx)
jne 0x2b4e4
movl 0x8(%rcx), %eax
jmp 0x2b4e4
pushq $-0x1
popq %rax
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: c_object_length_to_int
static s7_int c_object_length_to_int(s7_scheme *sc, s7_pointer obj)
                {
                    if (c_object_len(sc, obj))
                    {
                        s7_pointer res;
                        res = (*(c_object_len(sc, obj)))(sc, set_clist_1(sc, obj));
                        if (s7_is_integer(res))
                            return(s7_integer(res));
                    }
                    return(-1);
                }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rsi), %rax
cmpq 0x20(%rsi), %rax
jge 0x2b591
movq %rdi, %r14
movq 0x8(%rbx), %r12
movq 0x10(%rbx), %r15
movq 0x4e0(%rdi), %rax
movq 0x598(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x4f0(%rdi), %rax
movq 0x5a0(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq %r12, 0x8(%r15)
movq 0x18(%rbx), %r13
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0x2b5ac
leaq 0xea3c5(%rip), %rax     # 0x115950
movq (%rax,%r13,8), %rax
jmp 0x2b5e5
leaq -0x175(%rip), %rax      # 0x2b423
movq %rax, 0x28(%rbx)
andb $0x7f, 0x3(%rbx)
movq 0xea1b9(%rip), %rax     # 0x115760
jmp 0x2b646
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x2b5cb
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r13, 0x8(%rax)
movq 0x10(%r15), %rcx
movq %rax, 0x8(%rcx)
movq 0x8d8(%r14), %rax
movq 0x8(%r12), %rcx
movq (%rax,%rcx,8), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x48(%rax)
movq 0x598(%r14), %rcx
movq 0x5a0(%r14), %rdx
movq 0x8(%rcx), %rcx
movq %rcx, 0x4e0(%r14)
movq 0x8(%rdx), %rcx
movq %rcx, 0x4f0(%r14)
incq 0x18(%rbx)
cmpq 0xea12b(%rip), %rax     # 0x115760
jne 0x2b646
leaq -0x21b(%rip), %rcx      # 0x2b423
movq %rcx, 0x28(%rbx)
andb $0x7f, 0x3(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: heap_location
static int64_t heap_location(s7_scheme *sc, s7_pointer p)
    {
        heap_block_t *hp;
        for (hp = sc->heap_blocks; hp; hp = hp->next)
        {
            if (((intptr_t)p >= hp->start) && ((intptr_t)p < hp->end))
                return(hp->offset + (((intptr_t)p - hp->start) / sizeof(s7_cell)));
        }
        return(((s7_big_pointer)p)->big_hloc);
    }

// Assembly:
addq $0x2a68, %rdi           # imm = 0x2A68
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2b700
movq (%rdi), %rax
cmpq %rsi, %rax
jg 0x2b6fa
cmpq %rsi, 0x8(%rdi)
jg 0x2b705
addq $0x18, %rdi
jmp 0x2b6e4
movq 0x30(%rsi), %rax
retq
subq %rax, %rsi
pushq $0x30
popq %rcx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
addq 0x10(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_show_let
void s7_show_let(s7_scheme *sc) /* debugging convenience */
    {
        s7_pointer olet;
        for (olet = sc->envir; is_let(T_Lid(olet)); olet = outlet(olet))
        {
            if (olet == sc->owlet)
                fprintf(stderr, "(owlet): ");
            else
            {
                if (is_funclet(olet))
                    fprintf(stderr, "(%s funclet): ", DISPLAY(funclet_function(olet)));
                else
                {
                    if (olet == sc->shadow_rootlet)
                        fprintf(stderr, "(shadow rootlet): ");
                }
            }
            fprintf(stderr, "%s\n", DISPLAY(olet));
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0xe98c7(%rip), %r12     # 0x114ff8
pushq $0x1
popq %r13
leaq 0xb8023(%rip), %rbp     # 0xe375f
movq (%r14), %r14
cmpb $0x1c, (%r14)
jne 0x2b7db
cmpq 0x198(%rbx), %r14
jne 0x2b76a
movq (%r12), %rcx
leaq 0xaa96e(%rip), %rdi     # 0xd60cb
pushq $0x9
popq %rsi
movq %r13, %rdx
callq 0x8660
jmp 0x2b7b0
testb $0x20, 0x3(%r14)
jne 0x2b789
cmpq 0x158(%rbx), %r14
jne 0x2b7b0
movq (%r12), %rcx
leaq 0xaa95f(%rip), %rdi     # 0xd60e4
pushq $0x12
jmp 0x2b75f
movq (%r12), %r15
movq 0x20(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2b7ea
movq 0x10(%rax), %rdx
movq %r15, %rdi
leaq 0xaa92c(%rip), %rsi     # 0xd60d5
xorl %eax, %eax
callq 0x8390
movq (%r12), %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2b7ea
movq 0x10(%rax), %rdx
movq %r15, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x8390
addq $0x10, %r14
jmp 0x2b73c
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_object_to_string
s7_pointer s7_object_to_string(s7_scheme *sc, s7_pointer obj, bool use_write) /* unavoidable backwards compatibility rigidity here */
    {
        s7_pointer strport, res;

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

        strport = open_format_port(sc);
        object_out(sc, obj, strport, (use_write) ? P_WRITE : P_DISPLAY);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x6a0(%rdi)
jle 0x2b832
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2b68b
testb %al, %al
jne 0x2b832
leaq 0xaa902(%rip), %rdx     # 0xd611b
leaq 0xaa924(%rip), %rcx     # 0xd6144
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %r15, %r8
xorl %eax, %eax
callq 0xd5c7
movq %rbx, %rdi
callq 0x2b99b
movq %rax, %r14
movzbl %bpl, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2ba5b
movq 0x8(%r14), %rax
movq 0x20(%r14), %rdx
movq 0x38(%rax), %rsi
cmpq 0x18(%r14), %rdx
jge 0x2b866
movq %rbx, %rdi
jmp 0x2b87b
incq %rdx
movq %rbx, %rdi
callq 0x9859
movq 0x20(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2bf22
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bfa4
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_object_to_c_string
char *s7_object_to_c_string(s7_scheme *sc, s7_pointer obj)
    {
        char *str;
        s7_pointer strport;
        s7_int len;

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

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

        return(str);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x6a0(%rdi)
jle 0x2b92b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b68b
testb %al, %al
jne 0x2b92b
leaq 0xaa809(%rip), %rdx     # 0xd611b
leaq 0xaa815(%rip), %rcx     # 0xd612e
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %r14, %r8
xorl %eax, %eax
callq 0xd5c7
movq %rbx, %rdi
callq 0x2b99b
movq %rax, %r15
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2ba5b
movq 0x20(%r15), %r12
testq %r12, %r12
je 0x2b989
leaq 0x1(%r12), %rdi
callq 0x8480
movq %rax, %r14
movq 0x10(%r15), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x83e0
movb $0x0, (%r14,%r12)
movq 0x7e8(%rbx), %rax
movq 0x28(%r15), %rcx
movq %rax, 0x18(%rcx)
movq %r15, 0x7e8(%rbx)
jmp 0x2b98c
xorl %r14d, %r14d
movq %r14, %rax
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: open_format_port
static s7_pointer open_format_port(s7_scheme *sc)
    {
        s7_pointer x;
        s7_int len;
        block_t *block, *b;

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x7e8(%rdi), %rbx
testq %rbx, %rbx
je 0x2b9ce
movq 0x28(%rbx), %rax
movq 0x18(%rax), %rax
movq %rax, 0x7e8(%r14)
andq $0x0, 0x20(%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax)
jmp 0x2ba53
movq %r14, %rdi
callq 0xd35f
movq %rax, %rbx
movq $0x22, (%rax)
movq %r14, %rdi
callq 0xda55
movq %rax, 0x28(%rbx)
movq (%rax), %rax
movq %rax, 0x8(%rbx)
movl $0x1, 0x4(%rax)
movq 0x8(%rbx), %rax
xorl %ebp, %ebp
movb %bpl, 0x2(%rax)
movq $0x80, 0x18(%rbx)
movq 0x28(%rbx), %rax
andq $0x0, 0x18(%rax)
movl $0x80, %esi
movq %r14, %rdi
callq 0x9037
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
movq 0x8(%rbx), %rcx
movq %rax, 0x38(%rcx)
movq 0x10(%rbx), %rax
movb %bpl, (%rax)
andq $0x0, 0x20(%rbx)
movq 0x8(%rbx), %rax
movb %bpl, (%rax)
movq 0x8(%rbx), %rax
leaq 0xe9ba1(%rip), %rcx     # 0x1155f0
movq %rcx, 0x48(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: block_to_string
static s7_pointer block_to_string(s7_scheme *sc, block_t *block, s7_int len)
    {
        s7_pointer x;
        new_cell(sc, x, T_STRING | T_SAFE_PROCEDURE);
        string_block(x) = block;
        string_value(x) = (char *)block_data(block);
        string_length(x) = len;
        string_value(x)[len] = '\0';
        string_hash(x) = 0;
        add_string(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x2bf52
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0x200013, (%r12)       # imm = 0x200013
movq %r15, 0x20(%r12)
movq (%r15), %rax
movq %rax, 0x10(%r12)
movq %r14, 0x8(%r12)
movb $0x0, (%rax,%r14)
andq $0x0, 0x18(%r12)
movq 0x738(%rbx), %rdi
movq %r12, %rsi
callq 0xb999
movq %r12, %rax
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: restore_format_port
static inline void restore_format_port(s7_scheme *sc, s7_pointer strport)
    {
        block_t *block;
        block = mallocate(sc, FORMAT_PORT_LENGTH);
        port_data(strport) = (uint8_t *)(block_data(block));
        port_data_block(strport) = block;
        port_data(strport)[0] = '\0';
        port_position(strport) = 0;
        port_data_size(strport) = FORMAT_PORT_LENGTH;
        port_needs_free(strport) = false;
        close_format_port(sc, strport);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x80, %esi
callq 0x9037
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
movq 0x8(%rbx), %rcx
movq %rax, 0x38(%rcx)
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
andq $0x0, 0x20(%rbx)
movq $0x80, 0x18(%rbx)
movq 0x8(%rbx), %rax
movb %cl, (%rax)
movq 0x7e8(%r14), %rax
movq 0x28(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rbx, 0x7e8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_write
s7_pointer s7_write(s7_scheme *sc, s7_pointer obj, s7_pointer port)
    {
        if (port != sc->F)
        {
            if (port_is_closed(port))
                s7_wrong_type_arg_error(sc, "write", 2, port, "an open output port");
            object_out(sc, obj, port, P_WRITE);
        }
        return(obj);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq %rdx, 0x120(%rdi)
je 0x2c06c
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x2c05b
leaq 0xaa112(%rip), %rsi     # 0xd6158
leaq 0xbaed8(%rip), %r8      # 0xe6f25
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0xc2b0
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2ba5b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq