LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_make_permanent_string
s7_pointer s7_make_permanent_string(s7_scheme *sc, const char *str)
    {
        /* for the symbol table which is never GC'd */
        s7_pointer x;
        x = alloc_pointer(sc);
#if S7_DEBUGGING
        permanent_strings++;
#endif
        set_type(x, T_STRING | T_IMMUTABLE | T_UNHEAP);
        if (str)
        {
            s7_int len;
            len = safe_strlen(str);
            string_length(x) = len;
            /* string_block(x) = mallocate_block(); */
            string_block(x) = NULL;
            string_value(x) = (char *)alloc_permanent_string(sc, len + 1);
            memcpy((void *)string_value(x), (void *)str, len);
            string_value(x)[len] = 0;
        }
        else
        {
            string_value(x) = NULL;
            string_length(x) = 0;
        }
        string_hash(x) = 0;
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xec9f
movq %rax, %rbx
movabsq $0x4000000001000013, %rax # imm = 0x4000000001000013
movq %rax, (%rbx)
testq %r14, %r14
je 0xebf9
cmpb $0x0, (%r14)
je 0xec05
xorl %eax, %eax
leaq 0x1(%rax), %r12
cmpb $0x0, 0x1(%r14,%rax)
movq %r12, %rax
jne 0xebe8
jmp 0xec08
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0xec8a
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
leaq 0x8(%r12), %rax
movq %rax, %r13
andq $-0x8, %r13
movq 0x8c8(%r15), %rdi
leaq (%rdi,%r13), %rcx
cmpq $0x10000, %rcx          # imm = 0x10000
jbe 0xec49
cmpq $0x200, %rax            # imm = 0x200
jb 0xec52
movq %r13, %rdi
callq 0x8480
movq %rax, %rdi
jmp 0xec72
movq 0x8d0(%r15), %rax
jmp 0xec68
movl $0x10000, %edi          # imm = 0x10000
callq 0x8480
movq %rax, 0x8d0(%r15)
xorl %edi, %edi
movq %r13, %rcx
addq %rax, %rdi
movq %rcx, 0x8c8(%r15)
movq %rdi, 0x10(%rbx)
movq %r14, %rsi
movq %r12, %rdx
callq 0x83e0
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r12)
movq $0x0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: alloc_pointer
static s7_cell *alloc_pointer(s7_scheme *sc)
    {
        if (sc->alloc_pointer_k == ALLOC_POINTER_SIZE)     /* if either no current block or the block is used up, make a new block */
        {
            sc->permanent_cells += ALLOC_POINTER_SIZE;
            sc->alloc_pointer_cells = (s7_cell *)calloc(ALLOC_POINTER_SIZE, sizeof(s7_cell));
            sc->alloc_pointer_k = 0;
        }
        return(&(sc->alloc_pointer_cells[sc->alloc_pointer_k++]));
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x7f0(%rdi), %ecx
cmpl $0x100, %ecx            # imm = 0x100
jne 0xecd5
addl $0x100, 0x7d8(%rbx)     # imm = 0x100
movl $0x100, %edi            # imm = 0x100
movl $0x30, %esi
callq 0x8360
movq %rax, 0x800(%rbx)
xorl %ecx, %ecx
jmp 0xecdc
movq 0x800(%rbx), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x7f0(%rbx)
movl %ecx, %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_port_filename
const char *s7_port_filename(s7_scheme *sc, s7_pointer x)
    {
        if (((is_input_port(x)) ||
                    (is_output_port(x))) &&
                (!port_is_closed(x)))
            return(port_filename(x));
        return(NULL);
    }

// Assembly:
movb (%rsi), %al
andb $-0x2, %al
cmpb $0x22, %al
jne 0xedae
movq 0x8(%rsi), %rax
cmpb $0x0, 0x2(%rax)
je 0xedb1
xorl %eax, %eax
retq
movq 0x10(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_flush_output_port
void s7_flush_output_port(s7_scheme *sc, s7_pointer p)
    {
        if ((!is_output_port(p)) ||
                (!is_file_port(p)) ||
                (port_is_closed(p)) ||
                (p == sc->F))
            return;

        if (port_file(p))
        {
            if (port_position(p) > 0)
            {
                if (fwrite((void *)(port_data(p)), 1, port_position(p), port_file(p)) != (size_t)port_position(p))
                    s7_warn(sc, 64, "fwrite trouble in flush-output-port\n");
                port_position(p) = 0;
            }
            fflush(port_file(p));
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x22, (%rsi)
jne 0xee9a
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpl $0x0, 0x4(%rax)
jne 0xee9a
cmpb $0x0, 0x2(%rax)
jne 0xee9a
movq %rdi, %r14
cmpq %rbx, 0x120(%rdi)
je 0xee9a
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xee9a
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
jle 0xee8b
movq 0x10(%rbx), %rdi
movl $0x1, %esi
callq 0x8660
cmpq 0x20(%rbx), %rax
je 0xee7b
leaq 0xfb214(%rip), %rdx     # 0x10a080
movl $0x40, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0xeea2
movq $0x0, 0x20(%rbx)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
movq %rcx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8490
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeef0
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 0xef82
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %edx, %edx
callq 0xeab0
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 0xef77
movq 0x1d8(%rbx), %rdx
movq %rdx, 0x190(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3802c
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rsi, %rax
movq 0x1930(%rdi), %rsi
movq 0x820(%rdi), %r8
movslq 0x7dc(%rdi), %r9
movq (%r8,%r9,8), %r8
incl %r9d
andl $0x7, %r9d
movl %r9d, 0x7dc(%rdi)
leaq 0x1081a9(%rip), %r9     # 0x1175e0
movq %r9, 0x10(%r8)
movq $0x9, 0x8(%r8)
testq %rax, %rax
je 0xf461
cmpb $0x0, (%rax)
je 0xf461
xorl %r9d, %r9d
leaq 0x1(%r9), %r10
cmpb $0x0, 0x1(%rax,%r9)
movq %r10, %r9
jne 0xf450
jmp 0xf464
xorl %r10d, %r10d
movq 0x820(%rdi), %r9
movslq 0x7dc(%rdi), %r11
movq (%r9,%r11,8), %r9
incl %r11d
andl $0x7, %r11d
movl %r11d, 0x7dc(%rdi)
movq %rax, 0x10(%r9)
movq %r10, 0x8(%r9)
testq %rdx, %rdx
je 0xf4a8
cmpb $0x0, (%rdx)
je 0xf4a8
xorl %eax, %eax
leaq 0x1(%rax), %r10
cmpb $0x0, 0x1(%rdx,%rax)
movq %r10, %rax
jne 0xf498
jmp 0xf4ab
xorl %r10d, %r10d
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r11
movq (%rax,%r11,8), %rax
incl %r11d
andl $0x7, %r11d
movl %r11d, 0x7dc(%rdi)
movq %rdx, 0x10(%rax)
movq %r10, 0x8(%rax)
testq %rcx, %rcx
je 0xf4f1
cmpb $0x0, (%rcx)
je 0xf4f1
xorl %r10d, %r10d
leaq 0x1(%r10), %rdx
cmpb $0x0, 0x1(%rcx,%r10)
movq %rdx, %r10
jne 0xf4e0
jmp 0xf4f3
xorl %edx, %edx
movq 0x820(%rdi), %r10
movslq 0x7dc(%rdi), %r11
movq (%r10,%r11,8), %r10
incl %r11d
andl $0x7, %r11d
movl %r11d, 0x7dc(%rdi)
movq %rcx, 0x10(%r10)
movq %rdx, 0x8(%r10)
movq 0x6f0(%rdi), %rcx
movq %r8, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %r9, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %r10, 0x8(%rax)
movq 0x6f0(%rdi), %rdx
jmp 0x38dfa
// File: /workspace/github_c_makefile_star2_O3/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 0xf56d
movq 0x18(%rbx), %rax
movq %rax, 0x878(%r14)
jmp 0xf60f
movq 0x838(%r14), %rbx
testq %rbx, %rbx
jne 0xf5b8
movl $0x2800, %edi           # imm = 0x2800
callq 0x8480
movq %rax, %rbx
movq %rax, 0x838(%r14)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0xf596
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x18(%rbx), %rax
movq %rax, 0x838(%r14)
movq 0x8c8(%r14), %rcx
leaq 0x100(%rcx), %rdx
cmpq $0x10000, %rdx          # imm = 0x10000
jbe 0xf5f4
movl $0x10000, %edi          # imm = 0x10000
callq 0x8480
movq %rax, 0x8d0(%r14)
movl $0x100, %edx            # imm = 0x100
xorl %ecx, %ecx
jmp 0xf5fb
movq 0x8d0(%r14), %rax
addq %rax, %rcx
movq %rdx, 0x8c8(%r14)
movq %rcx, (%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_O3/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, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xf672
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x23, (%rbx)
movq %r14, %rdi
callq 0xf54a
movq %rax, 0x28(%rbx)
movq (%rax), %rax
movq %rax, 0x8(%rbx)
movl $0x1, 0x4(%rax)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movb %cl, 0x2(%rax)
movq 0x110(%r14), %rax
movq 0x8(%rbx), %rdx
movq %rax, 0x40(%rdx)
movq %r12, 0x10(%rbx)
movq 0x8(%rbx), %rax
movq %rcx, 0x38(%rax)
movq %r15, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
movq 0x8(%rbx), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rbx), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rbx), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rbx), %rax
movl %ecx, 0x24(%rax)
movq 0x8(%rbx), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rbx), %rax
movb %cl, (%rax)
movq 0x8(%rbx), %rax
movb %cl, 0x1(%rax)
movq 0x8(%rbx), %rax
leaq 0x136e94(%rip), %rcx    # 0x1465a0
movq %rcx, 0x48(%rax)
movq 0x758(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0xf73f
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xf89e
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x23, (%rbx)
movq %r14, %rdi
callq 0xf54a
movq %rax, 0x28(%rbx)
movq (%rax), %rax
movq %rax, 0x8(%rbx)
movl $0x2, 0x4(%rax)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movb %cl, 0x2(%rax)
movq 0x110(%r14), %rax
movq 0x8(%rbx), %rdx
movq %rax, 0x40(%rdx)
movq 0x8(%rbx), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rbx), %rax
movb %cl, (%rax)
movq 0x8(%rbx), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rbx), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rbx), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rbx), %rax
movl %ecx, 0x24(%rax)
movq 0x8(%rbx), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rbx), %rax
movq %r15, 0x50(%rax)
movq 0x8(%rbx), %rax
leaq 0x136ae3(%rip), %rcx    # 0x146410
movq %rcx, 0x48(%rax)
movq 0x748(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0xf960
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xf99f
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x22, (%rbx)
movq %r14, %rdi
callq 0xf54a
movq %rax, 0x28(%rbx)
movq (%rax), %rax
movq %rax, 0x8(%rbx)
movl $0x2, 0x4(%rax)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rcx
movq %rax, 0x38(%rcx)
movq 0x8(%rbx), %rcx
movb %al, 0x2(%rcx)
movq 0x8(%rbx), %rcx
movb %al, (%rcx)
movq 0x8(%rbx), %rax
movq %r15, 0x58(%rax)
movq 0x8(%rbx), %rax
leaq 0x136a63(%rip), %rcx    # 0x146460
movq %rcx, 0x48(%rax)
movq 0x750(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0xfa30
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xfac4
movq 0x20(%rbx), %rcx
movq 0x13afa8(%rip), %rax    # 0x14aa58
cmpq %rcx, 0x18(%rbx)
jle 0xfaf0
movq 0x10(%rbx), %rdx
movzbl (%rdx,%rcx), %ecx
leaq (%rax,%rcx,8), %rax
jmp 0xfafd
movq 0x48(%rax), %rax
movq %rbx, %rsi
callq *(%rax)
cmpl $-0x1, %eax
je 0xfaf6
movl %eax, %ebp
movsbl %bpl, %edi
movq %rbx, %rsi
callq 0xfb07
movslq %ebp, %rax
shlq $0x3, %rax
addq 0x13af6a(%rip), %rax    # 0x14aa58
jmp 0xfafd
addq $-0x8, %rax
jmp 0xfafd
leaq 0x136c63(%rip), %rax    # 0x146760
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xfb14
movq 0x8(%rsi), %rax
decl 0x20(%rax)
movq 0x8(%rsi), %rax
cmpl $0x0, 0x4(%rax)
je 0xfb2f
movq 0x20(%rsi), %rax
testq %rax, %rax
jle 0xfb2e
decq %rax
movq %rax, 0x20(%rsi)
retq
movq 0x8(%rax), %rsi
jmp 0x84c0
// File: /workspace/github_c_makefile_star2_O3/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 0x357bc
movq %rsi, %r12
cmpb $0x2f, 0x1(%rsi)
jne 0x357bc
movq %rdi, %rbx
leaq 0xe10a4(%rip), %rdi     # 0x116825
callq 0x8030
testq %rax, %rax
je 0x357bc
movq %rax, %r14
leaq 0x1(%r12), %r15
movl $0x1, %eax
cmpb $0x0, (%r12,%rax)
leaq 0x1(%rax), %rax
jne 0x35798
cmpb $0x0, (%r14)
je 0x357d1
xorl %ecx, %ecx
leaq 0x1(%rcx), %r13
cmpb $0x0, 0x1(%r14,%rcx)
movq %r13, %rcx
jne 0x357ab
jmp 0x357d4
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
addq %rax, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x9357
movq %rax, %r12
movq (%rax), %rbp
movb $0x0, (%rbp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x9517
leaq 0xe4d3e(%rip), %rsi     # 0x11a547
movq %rbp, %rdi
callq 0x85b0
movq %rax, %r14
movslq 0x8(%r12), %rax
cmpq $0x11, %rax
jne 0x35847
movq (%r12), %rdi
testq %rdi, %rdi
je 0x35835
callq 0x8050
movq $0x0, (%r12)
movl $0x0, 0x8(%r12)
addq $0x838, %rbx            # imm = 0x838
jmp 0x35852
leaq (%rbx,%rax,8), %rbx
addq $0x838, %rbx            # imm = 0x838
movq (%rbx), %rax
movq %rax, 0x18(%r12)
movq %r12, (%rbx)
jmp 0x357bf
// File: /workspace/github_c_makefile_star2_O3/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 0x94c90
testq %rax, %rax
je 0x3594f
movq %rax, %r14
movq (%rax), %rdi
leaq 0xe4cbc(%rip), %rsi     # 0x11a547
callq 0x85b0
movq %rax, %r15
testq %rax, %rax
je 0x35920
movq 0x1e8(%rbx), %r12
movq 0x18e0(%rbx), %rsi
movq 0x18(%r12), %rdx
movq %rbx, %rdi
callq 0xbe9a
cmpb $0x1, (%rax)
jne 0x35920
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xe9af
movq %rax, %r13
movq %rax, 0x520(%rbx)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x358f7
movq %rbx, %rdi
callq 0xa550
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 0xaee6
movslq 0x8(%r14), %rax
cmpq $0x11, %rax
jne 0x35954
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3593e
callq 0x8050
movq $0x0, (%r14)
movl $0x0, 0x8(%r14)
addq $0x838, %rbx            # imm = 0x838
jmp 0x3595f
xorl %r15d, %r15d
jmp 0x35969
leaq (%rbx,%rax,8), %rbx
addq $0x838, %rbx            # imm = 0x838
movq (%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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, %r15
movq %rdi, %rbx
leaq 0xdd886(%rip), %r8      # 0x113213
movq $-0x1, %rcx
callq 0x9060c
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x94f51
movq 0x8(%r14), %rcx
movl %eax, 0x24(%rcx)
orb $0x4, 0x2(%r14)
movq %r14, 0x520(%rbx)
movl 0x180(%rbx), %esi
movl 0x184(%rbx), %ecx
cmpl %esi, %ecx
jae 0x359d3
movq 0x178(%rbx), %rax
jmp 0x359f8
addl %esi, %esi
movl %esi, 0x180(%rbx)
movq 0x178(%rbx), %rdi
shlq $0x3, %rsi
callq 0x8510
movq %rax, 0x178(%rbx)
movl 0x184(%rbx), %ecx
movq 0x170(%rbx), %rdx
leal 0x1(%rcx), %esi
movl %esi, 0x184(%rbx)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq %r14, 0x170(%rbx)
movq 0x110(%rbx), %rax
movq %rax, 0x520(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe9af
movq %rax, %r15
movq 0x1280(%rbx), %rsi
movq %rbx, %rdi
callq 0x9a93
movq %rax, %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x364a9
movq %rbx, %rdi
callq 0xa550
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 0xbf0f
movq 0x1280(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9a93
// File: /workspace/github_c_makefile_star2_O3/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 0x3669a
movq 0x270(%r15), %rsi
movq %r15, %rdi
callq 0x366fb
movq %rax, %rsi
movq %rax, 0x2140(%r15)
cmpq $0x2, 0x6a0(%r15)
jl 0x366dd
movq %r15, %rdi
movq %r14, %rdx
callq *0x18(%rsi)
movq 0x20(%rax), %rax
cmpq %rbx, %rax
je 0x366dd
cmpq 0x120(%r15), %rax
je 0x366dd
movq 0x8(%r14), %rax
movq 0x10(%rax), %rcx
leaq 0xd3a05(%rip), %rdx     # 0x10a0d3
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
xorl %eax, %eax
callq 0xeea2
movq 0x2140(%r15), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x36924
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x37270
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rsi), %rcx
cmpq 0x160(%rdi), %rcx
jge 0x37287
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rsi)
movq 0x150(%rbx), %rdx
leaq 0x8(,%rcx,8), %rcx
addq 0x10(%rdx), %rcx
jmp 0x3728e
leaq 0x4a7(%rip), %rax       # 0x3771e
movq %rax, 0x28(%rsi)
andb $0x7f, 0x3(%rsi)
movq 0x10f4da(%rip), %rax    # 0x146760
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 0x372c0
movq %rbx, %rdi
movaps %xmm0, (%rsp)
callq 0xa550
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_O3/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 0x372e9
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x24c(%rdi)
jne 0x373ea
movq %rsi, %r14
movq %rbx, %rdi
callq 0x8a63
movq 0x12f8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x373ea
movq %rax, %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x37354
movq %rbx, %rdi
callq 0xa550
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 0xaee6
cmpb $0x1d, (%rax)
je 0x373ec
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 0xdf74f(%rip), %rdx     # 0x116afc
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 0x38dfa
movq %r14, %rax
jmp 0x373ec
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 0x37429
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 0x37440
movq %r14, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x37484
leaq 0x2ee(%rip), %rax       # 0x3771e
movq %rax, 0x28(%rsi)
andb $0x7f, 0x3(%rsi)
movq 0x10f321(%rip), %rax    # 0x146760
retq
movq %rdi, %rbx
movq 0x10(%rcx), %r15
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x37466
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x37707
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsi)
cmpq 0x20(%rsi), %rcx
jne 0x376fb
movq 0x110(%rdi), %rcx
movq %rcx, 0x10(%rsi)
leaq 0x5da33(%rip), %rcx     # 0x95135
movq %rcx, 0x28(%rsi)
retq
leaq 0x10(%rip), %rax        # 0x3771e
movq %rax, 0x28(%rsi)
andb $0x7f, 0x3(%rsi)
movq 0x10f043(%rip), %rax    # 0x146760
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x43bf0
cmpq 0x10f01f(%rip), %rax    # 0x146760
jne 0x37752
leaq -0x2c(%rip), %rcx       # 0x3771e
movq %rcx, 0x28(%rbx)
andb $0x7f, 0x3(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x89ff
cmpq 0x128(%rbx), %rax
je 0x377dc
movq %rax, %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x377a4
movq %rbx, %rdi
callq 0xa550
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 0xaee6
movq %rax, %rcx
xorl %eax, %eax
cmpb $0xb, (%rcx)
jne 0x377e1
movl 0x8(%rcx), %eax
jmp 0x377e1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 0x37850
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 0x3786b
leaq 0x10f106(%rip), %rax    # 0x146950
movq (%rax,%r13,8), %rax
jmp 0x378a4
leaq -0x139(%rip), %rax      # 0x3771e
movq %rax, 0x28(%rbx)
andb $0x7f, 0x3(%rbx)
movq 0x10eefa(%rip), %rax    # 0x146760
jmp 0x37905
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x3788a
movq %r14, %rdi
callq 0xa550
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 0x10ee6c(%rip), %rax    # 0x146760
jne 0x37905
leaq -0x1df(%rip), %rcx      # 0x3771e
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_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_is_valid
bool s7_is_valid(s7_scheme *sc, s7_pointer arg)
    {
        bool result = false;
        if (!arg) return(false);

#if TRAP_SEGFAULT
        if (sigsetjmp(senv, 1) == 0)
        {
            void (*old_segv)(int32_t sig);
            can_jump = 1;
            old_segv = signal(SIGSEGV, segv);
#endif
            if ((unchecked_type(arg) > T_FREE) &&
                    (unchecked_type(arg) < NUM_TYPES))
            {
                if (not_in_heap(arg))
                    result = true;
                else
                {
                    int64_t loc;
                    loc = heap_location(sc, arg);
                    if ((loc >= 0) && (loc < sc->heap_size))
                        result = (sc->heap[loc] == arg);
#if S7_DEBUGGING
                    if (!result)
                        check_heap_location(sc, arg, loc, __func__, __LINE__);
#endif
                }
            }
#if TRAP_SEGFAULT
            signal(SIGSEGV, old_segv);
        }
        else result = false;
        can_jump = 0;
#endif
        return(result);
    }

// Assembly:
testq %rsi, %rsi
je 0x379bd
movb (%rsi), %al
decb %al
cmpb $0x32, %al
ja 0x379bd
movb $0x1, %al
testb $0x40, 0x7(%rsi)
jne 0x379bc
movq 0x2a68(%rdi), %rcx
testq %rcx, %rcx
je 0x3797f
movq (%rcx), %rdx
cmpq %rsi, %rdx
jg 0x37979
cmpq %rsi, 0x8(%rcx)
jg 0x37985
movq 0x18(%rcx), %rcx
jmp 0x37966
movq 0x30(%rsi), %rdx
jmp 0x379a0
movq %rsi, %rax
subq %rdx, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq $0x5, %rdx
addq 0x10(%rcx), %rdx
testq %rdx, %rdx
js 0x379bd
cmpq 0xa8(%rdi), %rdx
jge 0x379bd
movq 0x80(%rdi), %rax
cmpq %rsi, (%rax,%rdx,8)
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r14
cmpb $0x1c, (%r14)
jne 0x37a42
movq %rdi, %rbx
movq 0x10e61b(%rip), %r13    # 0x145ff8
leaq 0xdfddb(%rip), %r15     # 0x1177bf
cmpq 0x198(%rbx), %r14
jne 0x379f4
callq 0x8837
jmp 0x37a16
testb $0x20, 0x3(%r14)
jne 0x37a0b
cmpq 0x158(%rbx), %r14
jne 0x37a16
callq 0x881b
jmp 0x37a16
movq %r14, %rdi
movq %rbx, %rsi
callq 0x87e9
movq (%r13), %r12
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x37a4c
movq 0x10(%rax), %rdx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x8390
movq 0x10(%r14), %r14
cmpb $0x1c, (%r14)
je 0x379e4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_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 0x37c85
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3794a
testb %al, %al
jne 0x37c85
leaq 0xd250f(%rip), %rdx     # 0x10a17b
leaq 0xd251b(%rip), %rcx     # 0x10a18e
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %r14, %r8
xorl %eax, %eax
callq 0xeea2
movq %rbx, %rdi
callq 0x37d3b
movq %rax, %r15
movzbl (%r14), %eax
leaq 0x11a6a5(%rip), %rcx    # 0x152340
cmpb $0x1, (%rax,%rcx)
jne 0x37ccb
cmpl $0x15, %eax
jne 0x37cad
testb $0x1, 0x7(%r14)
jne 0x37ccb
cmpq %r14, 0x150(%rbx)
je 0x37ccb
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x95196
jmp 0x37ce7
leaq 0x11a6ae(%rip), %r9     # 0x152380
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *(%r9,%rax,8)
movq 0x20(%r15), %r12
testq %r12, %r12
je 0x37d29
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 0x37d2c
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x7e8(%rdi), %rbx
testq %rbx, %rbx
je 0x37d72
movq 0x28(%rbx), %rax
movq 0x18(%rax), %rax
movq %rax, 0x7e8(%r14)
movq $0x0, 0x20(%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax)
jmp 0x37eb5
movq %r14, %rdi
callq 0xec9f
movq %rax, %rbx
movq $0x22, (%rax)
movq %r14, %rdi
callq 0xf54a
movq %rax, 0x28(%rbx)
movq (%rax), %rax
movq %rax, 0x8(%rbx)
movl $0x1, 0x4(%rax)
movq 0x8(%rbx), %rax
movb $0x0, 0x2(%rax)
movq $0x80, 0x18(%rbx)
movq 0x28(%rbx), %rax
movq $0x0, 0x18(%rax)
movq 0x870(%r14), %r15
testq %r15, %r15
je 0x37dd9
movq 0x18(%r15), %rax
movq %rax, 0x870(%r14)
movq (%r15), %rcx
jmp 0x37e7c
movq 0x838(%r14), %r15
testq %r15, %r15
jne 0x37e24
movl $0x2800, %edi           # imm = 0x2800
callq 0x8480
movq %rax, %r15
movq %rax, 0x838(%r14)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x37e02
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x18(%r15), %rax
movq %rax, 0x838(%r14)
movq 0x8c8(%r14), %rcx
leaq 0x80(%rcx), %rdx
cmpq $0x10000, %rdx          # imm = 0x10000
jbe 0x37e60
movl $0x10000, %edi          # imm = 0x10000
callq 0x8480
movq %rax, 0x8d0(%r14)
movl $0x80, %edx
xorl %ecx, %ecx
jmp 0x37e67
movq 0x8d0(%r14), %rax
addq %rax, %rcx
movq %rdx, 0x8c8(%r14)
movq %rcx, (%r15)
movl $0x7, 0x8(%r15)
movq $0x80, 0x10(%r15)
movq %rcx, 0x10(%rbx)
movq 0x8(%rbx), %rax
movq %r15, 0x38(%rax)
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movq $0x0, 0x20(%rbx)
movq 0x8(%rbx), %rax
movb %cl, (%rax)
movq 0x8(%rbx), %rax
leaq 0x10e73f(%rip), %rcx    # 0x1465f0
movq %rcx, 0x48(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x37eee
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200013, (%rbx)       # imm = 0x200013
movq %r12, 0x20(%rbx)
movq (%r12), %rax
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movb $0x0, (%rax,%r15)
movq $0x0, 0x18(%rbx)
movq 0x738(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x37f50
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 0x38023
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x37fce
leaq 0xd2201(%rip), %rsi     # 0x10a1b8
leaq 0xe2fc7(%rip), %r8      # 0x11af85
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0xd4e5
movzbl (%rbx), %eax
leaq 0x11a368(%rip), %rcx    # 0x152340
cmpb $0x1, (%rax,%rcx)
jne 0x38007
cmpl $0x15, %eax
jne 0x37fe9
testb $0x1, 0x7(%rbx)
jne 0x38007
cmpq %rbx, 0x150(%r15)
je 0x38007
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x95196
jmp 0x38023
leaq 0x11a372(%rip), %r9     # 0x152380
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *(%r9,%rax,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq