LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq 0x1930(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x1d9bb7(%rip), %rsi    # 0x1ef0a0
movl $0x9, %edx
callq 0xb880
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x145e0
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x145e0
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x145e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %rax, %r8
callq 0xd7140
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x878(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x155a9
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x878(%rax)
jmp 0x155de
movq 0x10(%rsp), %rdi
callq 0x11020
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x14930
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x8, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x60, 0x10(%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: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
callq 0xaa80
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x93e0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x15717
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x23, (%rax)
movq 0x20(%rsp), %rdi
callq 0x15570
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x4(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x2(%rax)
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x40(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x38(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x0, 0x24(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x1(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
leaq 0x2003db(%rip), %rcx    # 0x215c38
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rax
movq 0x758(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x11230
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: open_output_string
static s7_pointer open_output_string(s7_scheme *sc, s7_int len)
    {
        s7_pointer x;
        block_t *block, *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) = STRING_PORT;
        port_set_closed(x, false);
        port_data_size(x) = len;
        block = mallocate(sc, len);
        port_data_block(x) = block;
        port_data(x) = (uint8_t *)(block_data(block));
        port_data(x)[0] = '\0';        /* in case s7_get_output_string before any output */
        port_position(x) = 0;
        port_needs_free(x) = true;
        port_filename_block(x) = NULL;
        port_filename_length(x) = 0;   /* protect against (port-filename (open-output-string)) */
        port_filename(x) = NULL;
        port_port(x)->pf = &output_string_functions;
        add_output_port(sc, x);
        return(x);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x158e2
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x22, (%rax)
movq 0x20(%rsp), %rdi
callq 0x15570
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x4(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x2(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xaa80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x1, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x30(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
leaq 0x200282(%rip), %rcx    # 0x215c88
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rax
movq 0x750(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11230
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x15a92
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x23, (%rax)
movq 0x20(%rsp), %rdi
callq 0x15570
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x2, 0x4(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x2(%rax)
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x38(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x30(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x0, 0x24(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x0, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x50(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
leaq 0x1ff859(%rip), %rcx    # 0x215410
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rax
movq 0x748(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11230
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x15c12
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x22, (%rax)
movq 0x20(%rsp), %rdi
callq 0x15570
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x2, 0x4(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x38(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x2(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x58(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
leaq 0x1ff788(%rip), %rcx    # 0x215460
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rax
movq 0x750(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11230
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0x15e4e
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jg 0x15e26
movq 0x204770(%rip), %rax    # 0x21a588
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x15ea9
movq 0x20475b(%rip), %rax    # 0x21a588
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rsp), %rdx
movq 0x20(%rdx), %rdx
movzbl (%rcx,%rdx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
jmp 0x15ea9
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x15e83
movq 0x200414(%rip), %rax    # 0x216290
movq %rax, 0x20(%rsp)
jmp 0x15ea9
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rsi
movsbl %al, %edi
callq 0x15ec0
movq 0x2046ed(%rip), %rax    # 0x21a588
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x18, %rsp
movb %dil, %al
movb %al, 0x17(%rsp)
movq %rsi, 0x8(%rsp)
movsbl 0x17(%rsp), %eax
cmpl $0xa, %eax
jne 0x15eec
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x15f14
movsbl 0x17(%rsp), %edi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x94c0
jmp 0x15f33
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jle 0x15f31
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x15f33
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x184(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x180(%rcx), %eax
jb 0x1637a
movq 0x10(%rsp), %rax
movl 0x180(%rax), %ecx
shll %ecx
movl %ecx, 0x180(%rax)
movq 0x10(%rsp), %rax
movq 0x178(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x180(%rax), %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x9510
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x178(%rax)
movq 0x10(%rsp), %rax
movq 0x170(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x178(%rax), %rax
movq 0x10(%rsp), %rsi
movl 0x184(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x184(%rsi)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x170(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0x27f29
movq 0x30(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x27f29
leaq 0x1c6492(%rip), %rdi    # 0x1ee2fa
callq 0x9030
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x27f27
movq 0x30(%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, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xaa80
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
addq $0x1, %rcx
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xabd0
movq 0x18(%rsp), %rdi
leaq 0x1ca56b(%rip), %rsi    # 0x1f246d
callq 0x95b0
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb230
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x27f32
jmp 0x27f29
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xcf860
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x280aa
movq 0x38(%rsp), %rax
movq (%rax), %rdi
leaq 0x1ca4f0(%rip), %rsi    # 0x1f246d
callq 0x95b0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2808f
movq 0x48(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x1e8(%rax), %rsi
callq 0xba20
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2808f
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rax
movq 0x1e8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rax
movq (%rax), %rsi
callq 0x14630
movq 0x48(%rsp), %rcx
movq %rax, 0x520(%rcx)
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x28027
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdx
callq 0xda50
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xb230
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x280b3
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq $-0x1, %rcx
leaq 0x1c2bf8(%rip), %r8     # 0x1eace8
callq 0xc8720
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xcfb10
movl %eax, %ecx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl %ecx, 0x24(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
orq $0x40000, %rcx          # imm = 0x40000
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x520(%rax)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x16310
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x520(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq 0x1280(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x14630
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x1280(%rax), %rsi
callq 0xb3a0
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x40(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x2a03c
movq 0x40(%rsp), %rdi
callq 0xc670
movq 0x40(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
callq 0xffd0
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x1280(%rax), %rsi
callq 0xb3a0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x2140(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x2a392
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x270(%rax), %rsi
callq 0x2a440
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x2140(%rax)
movq 0x20(%rsp), %rax
cmpq $0x2, 0x6a0(%rax)
jl 0x2a407
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x2140(%rax), %rsi
movq 0x18(%rsp), %rdx
callq 0x2a770
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x120(%rcx), %rax
je 0x2a405
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x2a405
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x1b77bd(%rip), %rdx    # 0x1e1bbb
movb $0x0, %al
callq 0x14df0
jmp 0x2a407
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x2140(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2a7b0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_memq
static bool is_memq(s7_pointer sym, s7_pointer lst)
    {
        s7_pointer x;
        for (x = lst; is_pair(x); x = cdr(x))
            if (sym == car(x))
                return(true);
        return(false);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2b03a
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x2b028
movb $0x1, -0x1(%rsp)
jmp 0x2b03f
jmp 0x2b02a
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x2b004
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1, %ecx
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x15690
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x15f40
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x14ce0
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2b5c0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x30(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x50(%rcx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x2ba93
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x160(%rcx), %rax
jge 0x2b9dd
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rax
movq 0x150(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2b9f2
movq 0x38(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x2ba32
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)
jmp 0x2baa2
movq 0x30(%rsp), %rdi
callq 0xcfdf0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_let_make_iterator
static s7_pointer s7_let_make_iterator(s7_scheme *sc, s7_pointer iter)
                {
                    iterator_position(iter) = SL_NO_FIELD;
                    iterator_next(iter) = s7_let_iterate;
                    iterator_let_cons(iter) = NULL;
                    return(iter);
                }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rsp), %rax
leaq 0x16f59d(%rip), %rcx    # 0x19b070
movq %rcx, 0x28(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x2bcaf
movq 0x68(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x2bcaf
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x9a10
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movq 0x68(%rsp), %rax
movq 0x12f8(%rax), %rdx
callq 0x98d0
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x2bcaf
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x2bbc4
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdx
callq 0xda50
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1d, %eax
je 0x2bca3
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rax
movq 0xea8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rdi
leaq 0x1c294d(%rip), %rsi    # 0x1ee5bc
movl $0x31, %edx
callq 0xb880
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x50(%rsp), %rdx
callq 0xb830
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x70(%rsp)
jmp 0x2bcb8
movq 0x50(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x2bcb8
movq $0x0, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x2be36
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2bd97
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x2be45
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x2bdd7
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, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x2be45
movq 0x30(%rsp), %rdi
callq 0xcfdf0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_table_iterate
static s7_pointer hash_table_iterate(s7_scheme *sc, s7_pointer iterator)
    {
        s7_pointer table;
        s7_int loc, len;
        hash_entry_t **elements;
        hash_entry_t *lst;

        lst = iterator_hash_current(iterator);
        if (lst)
        {
            iterator_hash_current(iterator) = hash_entry_next(lst);
            return(hash_entry_to_cons(sc, lst, iterator_current(iterator)));
        }
        table = iterator_sequence(iterator); /* using iterator_length and hash_table_entries here was slightly slower */
        len = hash_table_mask(table) + 1;
        elements = hash_table_elements(table);

        for (loc = iterator_position(iterator) + 1; loc < len;  loc++)
        {
            hash_entry_t *x;
            x = elements[loc];
            if (x)
            {
                iterator_position(iterator) = loc;
                iterator_hash_current(iterator) = hash_entry_next(x);
                return(hash_entry_to_cons(sc, x, iterator_current(iterator)));
            }
        }
        if (is_weak_hash_table(table))
        {
            clear_weak_hash_iterator(iterator);
            weak_hash_iters(table)--;
        }
        return(iterator_quit(iterator));
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2bea8
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0xcfe30
movq %rax, 0x40(%rsp)
jmp 0x2bfa1
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jge 0x2bf5c
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2bf4a
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x38(%rsp), %rdi
movq (%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0xcfe30
movq %rax, 0x40(%rsp)
jmp 0x2bfa1
jmp 0x2bf4c
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2bee8
movq 0x28(%rsp), %rax
movq (%rax), %rax
andq $0x8000000, %rax        # imm = 0x8000000
cmpq $0x0, %rax
je 0x2bf92
movq 0x30(%rsp), %rax
movzwl 0x6(%rax), %ecx
andl $-0x5, %ecx
movw %cx, 0x6(%rax)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
movq 0x30(%rsp), %rdi
callq 0xcfdf0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
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 0x2c39c
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 0x2c380
movq 0x18(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
leaq 0xa3ba4(%rip), %rcx     # 0xcff30
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2c3ab
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: is_iterable_closure
static bool is_iterable_closure(s7_scheme *sc, s7_pointer x)
    {
        s7_pointer iter;
        if (!is_thunk(sc, x))
            wrong_type_argument_with_type(sc, sc->make_iterator_symbol, 1, x, a_thunk_string);
        iter = funclet_entry(sc, x, sc->local_iterator_symbol);
        return((iter) && (iter != sc->F));
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x26, %eax
jl 0x2c416
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3cbf0
testb $0x1, %al
jne 0x2c513
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq 0x12f8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x1, 0x38(%rsp)
movq 0x38(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x2c466
movq 0x38(%rsp), %rcx
leaq 0x1ea025(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x2c4dd
jmp 0x2c468
movq 0x50(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x50(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x2c48c
movq 0x50(%rsp), %rdi
callq 0xc670
movq 0x50(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq $0xb, (%rax)
movq 0x38(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x1f597a(%rip), %r9     # 0x221e88
callq 0xc560
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rax
movq 0x16d8(%rax), %rdx
callq 0x3a500
movq %rax, 0x40(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x40(%rsp)
movb %al, 0x7(%rsp)
je 0x2c559
movq 0x40(%rsp), %rax
movq 0x50(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x110(%rax), %rdx
callq 0x45890
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x1e9ce4(%rip), %rax    # 0x216290
jne 0x2c5d3
movq 0x8(%rsp), %rax
leaq -0x1fa(%rip), %rcx      # 0x2c3c0
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movabsq $-0x80000001, %rcx      # imm = 0xFFFFFFFF7FFFFFFF
andq (%rax), %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x48(%rsp), %rax
movq 0x1218(%rax), %rdx
callq 0x98d0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x2c6f3
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x2c67c
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
callq 0xda50
movq %rax, %rdi
callq 0x10790
movl %eax, 0x54(%rsp)
jmp 0x2c6fb
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8d8(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x58(%rax)
je 0x2c7b0
movq 0x28(%rsp), %rax
movq 0x8d8(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x58(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xd7610
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rax
callq *%rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0x2c79d
jmp 0x2c7ae
movq 0x18(%rsp), %rdi
callq 0x10790
movq %rax, 0x30(%rsp)
jmp 0x2c7b9
jmp 0x2c7b0
movq $-0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)