LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_set_current_output_port
static s7_pointer g_set_current_output_port(s7_scheme *sc, s7_pointer args)
    {
#define H_set_current_output_port "(set-current-output-port port) sets the current-output port to port and returns the previous value of the output port"
#define Q_set_current_output_port s7_make_signature(sc, 2, s7_make_signature(sc, 2, sc->is_output_port_symbol, sc->not_symbol), s7_make_signature(sc, 2, sc->is_output_port_symbol, sc->not_symbol))

        s7_pointer old_port, port;
        old_port = sc->output_port;
        port = car(args);
        if (((is_output_port(port)) &&
                    (!port_is_closed(port))) ||
                (port == sc->F))
            sc->output_port = port;
        else
        {
            check_method(sc, port, sc->set_current_output_port_symbol, args);
            return(s7_wrong_type_arg_error(sc, "set-current-output-port", 0, port, "an open output port"));
        }
        return(old_port);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x188(%rdi), %rax
movq 0x8(%rsi), %r12
cmpb $0x22, (%r12)
jne 0x62999
movq 0x8(%r12), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x62ad1
cmpq 0x120(%rbx), %r12
je 0x62ad1
testb $0x40, 0x3(%r12)
je 0x62ae7
cmpb $0x1, 0x24c(%rbx)
jne 0x62ae7
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8a63
movq 0x14c8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x62ae7
cmpb $0x1, (%r15)
jne 0x62b10
movq %rax, (%rsp)
movq %r15, 0x4c8(%rbx)
movq 0x8(%r15), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x62a28
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %r13, 0x8(%r12)
movq %rbp, 0x10(%r12)
movq %r12, 0x4e8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x62ab6
movq %r12, %r13
movq 0x8(%r15), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x62a87
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 %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq %rax, %r13
je 0x62a5d
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq (%rsp), %rax
jmp 0x62b17
movq %r12, 0x188(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaa99e(%rip), %rsi     # 0x10d48c
leaq 0xb8490(%rip), %r8      # 0x11af85
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd4e5
movq 0x110(%rbx), %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee6
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_is_char_ready
static s7_pointer g_is_char_ready(s7_scheme *sc, s7_pointer args)
    {
#define H_is_char_ready "(char-ready? (port (current-input-port))) returns #t if a character is ready for input on the given port"
#define Q_is_char_ready s7_make_signature(sc, 2, sc->is_boolean_symbol, sc->is_input_port_symbol)
        if (is_not_null(args))
        {
            s7_pointer pt = car(args);
            if (!is_input_port(pt))
                return(method_or_bust_with_type_one_arg(sc, pt, sc->is_char_ready_symbol, args, an_input_port_string));
            if (port_is_closed(pt))
                return(simple_wrong_type_argument_with_type(sc, sc->is_char_ready_symbol, pt, an_open_port_string));

            if (is_function_port(pt))
                return((*(port_input_function(pt)))(sc, S7_IS_CHAR_READY, pt));
            return(make_boolean(sc, is_string_port(pt)));
        }
        return(make_boolean(sc, (is_input_port(sc->input_port)) && (is_string_port(sc->input_port))));
    }

// Assembly:
cmpq %rsi, 0x110(%rdi)
je 0x62b73
movq %rsi, %rcx
movq 0x8(%rsi), %rax
cmpb $0x23, (%rax)
jne 0x62b90
movq 0x8(%rax), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x62ba6
movq 0x16e0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xef7bd(%rip), %r8      # 0x152328
movq %rax, %rdx
jmp 0xed2a
movq 0x170(%rdi), %rax
cmpb $0x23, (%rax)
jne 0x62bc1
movq 0x8(%rax), %rcx
movl $0x118, %eax            # imm = 0x118
cmpl $0x1, 0x4(%rcx)
jne 0x62bc1
jmp 0x62bc6
movq 0x16e0(%rdi), %rdx
movq 0xe8062(%rip), %r8      # 0x14ac00
movq %rax, %rsi
jmp 0xfa261
movl 0x4(%rcx), %edx
cmpl $0x1, %edx
je 0x62bcb
cmpl $0x2, %edx
jne 0x62bc1
movq 0x50(%rcx), %rcx
movl $0x5, %esi
movq %rax, %rdx
jmpq *%rcx
movl $0x120, %eax            # imm = 0x120
movq (%rdi,%rax), %rax
retq
movl $0x118, %eax            # imm = 0x118
jmp 0x62bc6
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_close_input_port
static s7_pointer g_close_input_port(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer pt;
#define H_close_input_port "(close-input-port port) closes the port"
#define Q_close_input_port s7_make_signature(sc, 2, sc->is_unspecified_symbol, sc->is_input_port_symbol)

        pt = car(args);
        if (!is_input_port(pt))
            return(method_or_bust_with_type_one_arg(sc, pt, sc->close_input_port_symbol, set_plist_1(sc, pt), an_input_port_string));
        if ((!is_immutable_port(pt)) &&  /* (close-input-port *stdin*) */
                (!is_loader_port(pt)))       /* top-level unmatched (close-input-port (current-input-port)) should not clobber the loader's input port */
            s7_close_input_port(sc, pt);
        return(sc->unspecified);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x23, (%rsi)
jne 0x62c01
movzwl 0x2(%rsi), %eax
testl $0x104, %eax            # imm = 0x104
jne 0x62bf8
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq 0x130(%rbx), %rax
popq %rbx
retq
movq 0xe00(%rbx), %rdx
movq 0x700(%rbx), %rax
movq %rsi, 0x8(%rax)
movq 0x700(%rbx), %rcx
movq 0xe7fdf(%rip), %r8      # 0x14ac00
movq %rbx, %rdi
popq %rbx
jmp 0xfa261
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_close_output_port
static s7_pointer g_close_output_port(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer pt;
#define H_close_output_port "(close-output-port port) closes the port"
#define Q_close_output_port s7_make_signature(sc, 2, sc->is_unspecified_symbol, s7_make_signature(sc, 2, sc->is_output_port_symbol, sc->not_symbol))

        pt = car(args);
        if (!is_output_port(pt))
        {
            if (pt == sc->F) return(sc->unspecified);
            return(method_or_bust_with_type_one_arg(sc, pt, sc->close_output_port_symbol, set_plist_1(sc, pt), an_output_port_string));
        }
        s7_close_output_port(sc, pt);
        return(sc->unspecified);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x22, (%rsi)
movq 0x120(%rdi), %rax
jne 0x62c59
cmpq %rsi, %rax
je 0x62c87
testb $0x1, 0x3(%rsi)
jne 0x62c87
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
callq *0x48(%rax)
jmp 0x62c87
cmpq %rax, %rsi
je 0x62c87
movq 0xe08(%rbx), %rdx
movq 0x700(%rbx), %rax
movq %rsi, 0x8(%rax)
movq 0x700(%rbx), %rcx
movq 0xef64a(%rip), %r8      # 0x1522c8
movq %rbx, %rdi
popq %rbx
jmp 0xfa261
movq 0x130(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_flush_output_port
static s7_pointer g_flush_output_port(s7_scheme *sc, s7_pointer args)
    {
#define H_flush_output_port "(flush-output-port port) flushes the file port (that is, it writes any accumulated output to the output file)"
#define Q_flush_output_port s7_make_signature(sc, 2, sc->T, s7_make_signature(sc, 2, sc->is_output_port_symbol, sc->not_symbol))
        s7_pointer pt;

        if (is_null(args))
            pt = sc->output_port;
        else pt = car(args);

        if (!is_output_port(pt))
        {
            if (pt == sc->F) return(pt);
            return(method_or_bust_with_type_one_arg(sc, pt, sc->flush_output_port_symbol, args, an_output_port_string));
        }
        s7_flush_output_port(sc, pt);
        return(pt);
    }

// Assembly:
pushq %rbx
leaq 0x188(%rdi), %rax
leaq 0x8(%rsi), %rdx
cmpq %rsi, 0x110(%rdi)
cmoveq %rax, %rdx
movq (%rdx), %rbx
cmpb $0x22, (%rbx)
jne 0x62cb9
movq %rbx, %rsi
callq 0xee17
jmp 0x62cdc
cmpq 0x120(%rdi), %rbx
je 0x62cdc
movq %rsi, %rcx
movq 0xf10(%rdi), %rdx
movq 0xef5f5(%rip), %r8      # 0x1522c8
movq %rbx, %rsi
popq %rbx
jmp 0xfa261
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_open_input_file
static s7_pointer g_open_input_file(s7_scheme *sc, s7_pointer args)
    {
#define H_open_input_file "(open-input-file filename (mode \"r\")) opens filename for reading"
#define Q_open_input_file s7_make_signature(sc, 3, sc->is_input_port_symbol, sc->is_string_symbol, sc->is_string_symbol)
        s7_pointer name = car(args);
        /* open-input-file can create a new output file if the file to be opened does not exist, and the "a" mode is given */

        if (!is_string(name))
            return(method_or_bust(sc, name, sc->open_input_file_symbol, args, T_STRING, 1));

        if (is_pair(cdr(args)))
        {
            s7_pointer mode;
            mode = cadr(args);
            if (!is_string(mode))
                return(method_or_bust_with_type(sc, mode, sc->open_input_file_symbol, args,
                            wrap_string(sc, "a string (a mode such as \"r\")", 29), 2));
            /* since scheme allows embedded nulls, dumb stuff is accepted here: (open-input-file file "a\x00b") -- should this be an error? */
            return(open_input_file_1(sc, string_value(name), string_value(mode), "open-input-file"));
        }
        return(open_input_file_1(sc, string_value(name), "r", "open-input-file"));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rax
cmpb $0x13, (%rax)
jne 0x62d16
movq 0x10(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0x62d31
movq 0x8(%rdx), %rsi
cmpb $0x13, (%rsi)
jne 0x62d48
movq 0x10(%rax), %rax
movq 0x10(%rsi), %rdx
leaq 0xa7397(%rip), %rcx     # 0x10a0a5
movq %rax, %rsi
jmp 0xefb8
movq 0x1390(%rdi), %rdx
movq %rax, %rsi
movl $0x13, %r8d
movl $0x1, %r9d
jmp 0xe42d
movq 0x10(%rax), %rsi
leaq 0xb780b(%rip), %rdx     # 0x11a547
leaq 0xa7362(%rip), %rcx     # 0x10a0a5
jmp 0xefb8
movq 0x1390(%rdi), %rdx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r9
movq (%rax,%r9,8), %r8
leal 0x1(%r9), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0xb8902(%rip), %rax     # 0x11b677
movq %rax, 0x10(%r8)
movq $0x1d, 0x8(%r8)
movl $0x2, %r9d
jmp 0xe659
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_open_output_file
static s7_pointer g_open_output_file(s7_scheme *sc, s7_pointer args)
    {
#define H_open_output_file "(open-output-file filename (mode \"w\")) opens filename for writing"
#define Q_open_output_file s7_make_signature(sc, 3, sc->is_output_port_symbol, sc->is_string_symbol, sc->is_string_symbol)
        s7_pointer name = car(args);

        if (!is_string(name))
            return(method_or_bust(sc, name, sc->open_output_file_symbol, args, T_STRING, 1));

        if (is_pair(cdr(args)))
        {
            if (!is_string(cadr(args)))
                return(method_or_bust_with_type(sc, cadr(args), sc->open_output_file_symbol, args,
                            wrap_string(sc, "a string (a mode such as \"w\")", 29), 2));
            return(s7_open_output_file(sc, string_value(name), string_value(cadr(args))));
        }
        return(s7_open_output_file(sc, string_value(name), "w"));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rax
cmpb $0x13, (%rax)
jne 0x62dba
movq 0x10(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0x62dd5
movq 0x8(%rdx), %rsi
cmpb $0x13, (%rsi)
jne 0x62de5
movq 0x10(%rax), %rax
movq 0x10(%rsi), %rdx
movq %rax, %rsi
jmp 0xf166
movq 0x13a0(%rdi), %rdx
movq %rax, %rsi
movl $0x13, %r8d
movl $0x1, %r9d
jmp 0xe42d
movq 0x10(%rax), %rsi
leaq 0xb909a(%rip), %rdx     # 0x11be7a
jmp 0xf166
movq 0x13a0(%rdi), %rdx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r9
movq (%rax,%r9,8), %r8
leal 0x1(%r9), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0xb8883(%rip), %rax     # 0x11b695
movq %rax, 0x10(%r8)
movq $0x1d, 0x8(%r8)
movl $0x2, %r9d
jmp 0xe659
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_newline
static s7_pointer g_newline(s7_scheme *sc, s7_pointer args)
    {
#define H_newline "(newline (port (current-output-port))) writes a carriage return to the port"
#define Q_newline s7_make_signature(sc, 2, sc->is_char_symbol, s7_make_signature(sc, 2, sc->is_output_port_symbol, sc->not_symbol))
        s7_pointer port;

        if (is_not_null(args))
            port = car(args);
        else port = sc->output_port;
        if (port == sc->F) return(newline_char);
        if (!is_output_port(port))
            return(method_or_bust_with_type_one_arg(sc, port, sc->newline_symbol, args, an_output_port_string));
        if (port_is_closed(port))
            s7_wrong_type_arg_error(sc, "newline", 1, port, "an open output port");
        s7_newline(sc, port);
        return(newline_char);  /* return(sc->unspecified) until 28-Sep-17, but for example (display c) returns c */
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
leaq 0x8(%rsi), %rdx
leaq 0x188(%rdi), %rsi
movq 0x120(%rdi), %rax
cmpq %rcx, 0x110(%rdi)
cmoveq %rsi, %rdx
movq (%rdx), %r14
cmpq %rax, %r14
je 0x631b2
movq %rdi, %rbx
cmpb $0x22, (%r14)
jne 0x631c5
movq 0x8(%r14), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x63197
leaq 0xb7ac1(%rip), %rsi     # 0x11ac3a
leaq 0xb7e05(%rip), %r8      # 0x11af85
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0xd4e5
movq 0x120(%rbx), %rax
cmpq %r14, %rax
je 0x631b2
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
movl $0xa, %esi
movq %r14, %rdx
callq *0x8(%rax)
movq 0xe789f(%rip), %rax     # 0x14aa58
movq 0x50(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1360(%rbx), %rdx
movq 0xef0f5(%rip), %r8      # 0x1522c8
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfa261
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_write
static s7_pointer g_write(s7_scheme *sc, s7_pointer args)
    {
#define H_write "(write obj (port (current-output-port))) writes (object->string obj) to the output port"
#define Q_write s7_make_signature(sc, 3, sc->T, sc->T, s7_make_signature(sc, 2, sc->is_output_port_symbol, sc->not_symbol))

        check_method(sc, car(args), sc->write_symbol, args);
        return(write_p_pp(sc, car(args), (is_pair(cdr(args))) ? cadr(args) : sc->output_port));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
testb $0x40, 0x3(%r12)
je 0x63325
cmpb $0x1, 0x24c(%rbx)
jne 0x63325
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8a63
movq 0x16b8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x63325
cmpb $0x1, (%r15)
jne 0x63357
movq %rax, (%rsp)
movq %r15, 0x4c8(%rbx)
movq 0x8(%r15), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x6327c
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %r13, 0x8(%r12)
movq %rbp, 0x10(%r12)
movq %r12, 0x4e8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x6330a
movq %r12, %r13
movq 0x8(%r15), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x632db
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 %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq %rax, %r13
je 0x632b1
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq (%rsp), %rax
jmp 0x6335e
movq 0x10(%r15), %rax
leaq 0x8(%rax), %rcx
leaq 0x188(%rbx), %rdx
cmpb $0x1, (%rax)
cmoveq %rcx, %rdx
movq (%rdx), %rdx
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x840cb
movq 0x110(%rbx), %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee6
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_read_char
static s7_pointer g_read_char(s7_scheme *sc, s7_pointer args)
    {
#define H_read_char "(read-char (port (current-input-port))) returns the next character in the input port"
#define Q_read_char s7_make_signature(sc, 2, s7_make_signature(sc, 2, sc->is_char_symbol, sc->is_eof_object_symbol), sc->is_input_port_symbol)
        s7_pointer port;

        if (is_not_null(args))
            port = car(args);
        else
        {
            port = input_port_if_not_loading(sc);
            if (!port) return(eof_object);
        }
        if (!is_input_port(port))
            return(method_or_bust_with_type_one_arg(sc, port, sc->read_char_symbol, args, an_input_port_string));
        return(chars[port_read_character(port)(sc, port)]);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rsi, 0x110(%rdi)
je 0x633b8
movq 0x8(%r14), %rsi
jmp 0x633c8
movq %rbx, %rdi
callq 0xfa3f2
movq %rax, %rsi
testq %rax, %rax
je 0x63409
cmpb $0x23, (%rsi)
jne 0x633e9
movq 0xe7684(%rip), %r14     # 0x14aa58
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
callq *(%rax)
cltq
movq (%r14,%rax,8), %rax
jmp 0x63410
movq 0x1448(%rbx), %rdx
movq 0xe7809(%rip), %r8      # 0x14ac00
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfa261
movq 0xe3350(%rip), %rax     # 0x146760
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_peek_char
static s7_pointer g_peek_char(s7_scheme *sc, s7_pointer args)
    {
#define H_peek_char "(peek-char (port (current-input-port))) returns the next character in the input port, but does not remove it from the input stream"
#define Q_peek_char s7_make_signature(sc, 2, s7_make_signature(sc, 2, sc->is_char_symbol, sc->is_eof_object_symbol), sc->is_input_port_symbol)
        s7_pointer port;

        if (is_not_null(args))
            port = car(args);
        else port = sc->input_port;

        if (!is_input_port(port))
            return(method_or_bust_with_type_one_arg(sc, port, sc->peek_char_symbol, args, an_input_port_string));
        if (port_is_closed(port))
            return(simple_wrong_type_argument_with_type(sc, sc->peek_char_symbol, port, an_open_port_string));

        if (is_function_port(port))
            return((*(port_input_function(port)))(sc, S7_PEEK_CHAR, port));
        return(s7_peek_char(sc, port));
    }

// Assembly:
leaq 0x8(%rsi), %rax
leaq 0x170(%rdi), %rdx
cmpq %rsi, 0x110(%rdi)
cmoveq %rdx, %rax
movq (%rax), %rax
cmpb $0x23, (%rax)
jne 0x63461
movq 0x8(%rax), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x6347a
movq 0x13d8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xeeecf(%rip), %r8      # 0x152328
movq %rax, %rdx
jmp 0xed2a
movq %rsi, %rcx
movq 0x13d8(%rdi), %rdx
movq 0xe778e(%rip), %r8      # 0x14ac00
movq %rax, %rsi
jmp 0xfa261
cmpl $0x2, 0x4(%rcx)
jne 0x6348e
movq 0x50(%rcx), %rcx
movl $0x4, %esi
movq %rax, %rdx
jmpq *%rcx
movq %rax, %rsi
jmp 0xfa95
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_read_byte
static s7_pointer g_read_byte(s7_scheme *sc, s7_pointer args)
    {
#define H_read_byte "(read-byte (port (current-input-port))): reads a byte from the input port"
#define Q_read_byte s7_make_signature(sc, 2, s7_make_signature(sc, 2, sc->is_byte_symbol, sc->is_eof_object_symbol), sc->is_input_port_symbol)
        s7_pointer port;
        int32_t c;

        if (is_not_null(args))
            port = car(args);
        else
        {
            port = input_port_if_not_loading(sc);
            if (!port) return(eof_object);
        }
        if (!is_input_port(port))
            return(method_or_bust_with_type_one_arg(sc, port, sc->read_byte_symbol, args, an_input_port_string));

        c = port_read_character(port)(sc, port);
        if (c == EOF)
            return(eof_object);
        return(small_int(c));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rsi, 0x110(%rdi)
je 0x636c6
movq 0x8(%r14), %rsi
jmp 0x636d6
movq %rbx, %rdi
callq 0xfa3f2
movq %rax, %rsi
testq %rax, %rax
je 0x6371c
cmpb $0x23, (%rsi)
jne 0x636fc
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl $-0x1, %eax
je 0x6371c
cltq
leaq 0xe325a(%rip), %rcx     # 0x146950
movq (%rcx,%rax,8), %rax
jmp 0x63723
movq 0x1440(%rbx), %rdx
movq 0xe74f6(%rip), %r8      # 0x14ac00
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfa261
movq 0xe303d(%rip), %rax     # 0x146760
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_write_byte
static s7_pointer g_write_byte(s7_scheme *sc, s7_pointer args)
    {
#define H_write_byte "(write-byte byte (port (current-output-port))): writes byte to the output port"
#define Q_write_byte s7_make_signature(sc, 3, sc->is_byte_symbol, sc->is_byte_symbol, s7_make_signature(sc, 2, sc->is_output_port_symbol, sc->not_symbol))
        s7_pointer port, b;
        s7_int val;

        b = car(args);
        if (!s7_is_integer(b))
            return(method_or_bust(sc, car(args), sc->write_byte_symbol, args, T_INTEGER, 1));

        val = s7_integer(b);
        if ((val < 0) || (val > 255)) /* need to check this before port==#f, else (write-byte most-positive-fixnum #f) is not an error */
            return(wrong_type_argument_with_type(sc, sc->write_byte_symbol, 1, b, an_unsigned_byte_string));

        if (is_pair(cdr(args)))
            port = cadr(args);
        else port = sc->output_port;

        if (!is_output_port(port))
        {
            if (port == sc->F) return(car(args));
            return(method_or_bust_with_type_one_arg(sc, port, sc->write_byte_symbol, args, an_output_port_string));
        }

        port_write_character(port)(sc, (uint8_t)val, port);
        return(b);
    }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq 0x8(%rsi), %rbx
cmpb $0xb, (%rbx)
jne 0x6376d
movq 0x8(%rbx), %rax
cmpq $0x100, %rax            # imm = 0x100
jb 0x63789
movq 0x16a0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xe3202(%rip), %rdx     # 0x146958
movq 0x140(%rdi), %r8
movq 0xef8fc(%rip), %r9      # 0x153060
movq %rbx, %rcx
popq %rbx
jmp 0xa4e4
movq 0x16a0(%rdi), %rdx
movq %rbx, %rsi
movl $0xb, %r8d
movl $0x1, %r9d
popq %rbx
jmp 0xe42d
movq 0x10(%rcx), %rdx
leaq 0x8(%rdx), %rsi
leaq 0x188(%rdi), %r8
cmpb $0x1, (%rdx)
cmoveq %rsi, %r8
movq (%r8), %rdx
cmpb $0x22, (%rdx)
jne 0x637b7
movq 0x8(%rdx), %rcx
movq 0x48(%rcx), %rcx
movzbl %al, %esi
callq *0x8(%rcx)
jmp 0x637da
cmpq 0x120(%rdi), %rdx
je 0x637da
movq 0x16a0(%rdi), %rax
movq 0xeeafa(%rip), %r8      # 0x1522c8
movq %rdx, %rsi
movq %rax, %rdx
popq %rbx
jmp 0xfa261
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_read_line
static s7_pointer g_read_line(s7_scheme *sc, s7_pointer args)
    {
#define H_read_line "(read-line port (with-eol #f)) returns the next line from port, or #<eof>. \
        If 'with-eol' is not #f, read-line includes the trailing end-of-line character."
#define Q_read_line s7_make_signature(sc, 3, s7_make_signature(sc, 2, sc->is_string_symbol, sc->is_eof_object_symbol), sc->is_input_port_symbol, sc->is_boolean_symbol)

        s7_pointer port;
        bool with_eol = false;

        if (is_not_null(args))
        {
            port = car(args);
            if (!is_input_port(port))
                return(method_or_bust_with_type(sc, port, sc->read_line_symbol, args, an_input_port_string, 1));

            if (is_not_null(cdr(args)))
                with_eol = (cadr(args) != sc->F); /* perhaps this should insist on #t: (read-line port (c-pointer 0)) */
        }
        else
        {
            port = input_port_if_not_loading(sc);
            if (!port) return(eof_object);
        }
        return(port_read_line(port)(sc, port, with_eol, true));
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x110(%rdi), %rax
cmpq %rsi, %rax
je 0x63814
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x23, (%rsi)
jne 0x63841
movq 0x10(%rcx), %rcx
cmpq %rax, %rcx
je 0x63824
movq 0x8(%rcx), %rax
cmpq 0x120(%rbx), %rax
setne %al
jmp 0x63826
movq %rbx, %rdi
callq 0xfa3f2
testq %rax, %rax
je 0x6385e
movq %rax, %rsi
xorl %eax, %eax
movq 0x8(%rsi), %rcx
movq 0x48(%rcx), %rcx
movq 0x38(%rcx), %r8
movzbl %al, %edx
movq %rbx, %rdi
movl $0x1, %ecx
popq %rbx
jmpq *%r8
movq 0x1450(%rbx), %rdx
movq 0xe73b1(%rip), %r8      # 0x14ac00
movq %rbx, %rdi
movl $0x1, %r9d
popq %rbx
jmp 0xe659
movq 0xe2efb(%rip), %rax     # 0x146760
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_read
static s7_pointer g_read(s7_scheme *sc, s7_pointer args)
    {
#define H_read "(read (port (current-input-port))) returns the next object in the input port, or #<eof> at the end"
#define Q_read s7_make_signature(sc, 2, sc->T, sc->is_input_port_symbol)
        s7_pointer port;

        if (is_not_null(args))
            port = car(args);
        else
        {
            port = input_port_if_not_loading(sc);
            if (!port) return(eof_object);
        }

        if (!is_input_port(port))
            return(method_or_bust_with_type_one_arg(sc, port, sc->read_symbol, args, an_input_port_string));

        if (is_function_port(port))
            return((*(port_input_function(port)))(sc, S7_READ, port));

        if ((is_string_port(port)) &&
                (port_data_size(port) <= port_position(port)))
            return(eof_object);

        push_input_port(sc, port);
        push_stack_op_let(sc, OP_READ_DONE); /* this stops the internal read process so we only get one form */
        push_stack_op_let(sc, OP_READ_INTERNAL);

        return(port);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq %rsi, 0x110(%rdi)
je 0x63bf2
movq 0x8(%r15), %rbx
jmp 0x63c02
movq %r14, %rdi
callq 0xfa3f2
movq %rax, %rbx
testq %rax, %rax
je 0x63c71
cmpb $0x23, (%rbx)
jne 0x63c2b
movq 0x8(%rbx), %rax
movl 0x4(%rax), %ecx
cmpl $0x1, %ecx
je 0x63c4c
cmpl $0x2, %ecx
jne 0x63c56
movq 0x50(%rax), %rax
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq 0x1460(%r14), %rdx
movq 0xe6fc7(%rip), %r8      # 0x14ac00
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xfa261
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
jle 0x63c71
movl 0x180(%r14), %esi
movl 0x184(%r14), %ecx
cmpl %esi, %ecx
jae 0x63c7d
movq 0x178(%r14), %rax
jmp 0x63ca4
movq 0xe2ae8(%rip), %rbx     # 0x146760
jmp 0x63cff
addl %esi, %esi
movl %esi, 0x180(%r14)
movq 0x178(%r14), %rdi
shlq $0x3, %rsi
callq 0x8510
movq %rax, 0x178(%r14)
movl 0x184(%r14), %ecx
movq 0x170(%r14), %rdx
leal 0x1(%rcx), %esi
movl %esi, 0x184(%r14)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq %rbx, 0x170(%r14)
movq 0x8(%r14), %rax
movq 0x50(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%r14), %rax
movq $0x1dc, 0x18(%rax)      # imm = 0x1DC
movq 0x8(%r14), %rax
movq 0x50(%r14), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%r14)
movq %rax, 0x28(%rcx)
movq 0x50(%r14), %rax
movq $0x190, 0x18(%rax)      # imm = 0x190
addq $0x20, 0x50(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_call_with_input_file
static s7_pointer g_call_with_input_file(s7_scheme *sc, s7_pointer args)
    {
#define H_call_with_input_file "(call-with-input-file filename proc) opens filename and calls proc with the input port as its argument"
#define Q_call_with_input_file sc->pl_sf
        s7_pointer str, proc;

        str = car(args);
        if (!is_string(str))
            return(method_or_bust(sc, str, sc->call_with_input_file_symbol, args, T_STRING, 1));

        proc = cadr(args);
        if (!s7_is_aritable(sc, proc, 1))
            return(wrong_type_argument_with_type(sc, sc->call_with_input_file_symbol, 2, proc,
                        wrap_string(sc, "a procedure of one argument (the port)", 38)));
        if ((is_continuation(proc)) || (is_goto(proc)))
            return(wrong_type_argument_with_type(sc, sc->call_with_input_file_symbol, 2, proc, a_normal_procedure_string));

        return(call_with_input(sc, open_input_file_1(sc, string_value(str), "r", "call-with-input-file"), args));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpb $0x13, (%r12)
jne 0x63ff6
movq 0x10(%r15), %rax
movq 0x8(%rax), %r14
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f86f
testb %al, %al
je 0x64022
movb (%r14), %al
addb $-0x25, %al
cmpb $0x1, %al
ja 0x64082
movq 0xd00(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xe297a(%rip), %rdx     # 0x146960
movq 0x140(%rbx), %r8
movq 0xf1614(%rip), %r9      # 0x155608
jmp 0x6406c
movq 0xd00(%rbx), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe42d
movq 0xd00(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xe292c(%rip), %rdx     # 0x146960
movq 0x140(%rbx), %r8
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %r9
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0xb7670(%rip), %rax     # 0x11b6d0
movq %rax, 0x10(%r9)
movq $0x26, 0x8(%r9)
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa4e4
movq 0x10(%r12), %rsi
leaq 0xb64b9(%rip), %rdx     # 0x11a547
leaq 0xa9c9a(%rip), %rcx     # 0x10dd2f
movq %rbx, %rdi
callq 0xefb8
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfa439
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_with_input_from_file
static s7_pointer g_with_input_from_file(s7_scheme *sc, s7_pointer args)
    {
#define H_with_input_from_file "(with-input-from-file filename thunk) opens filename as the temporary current-input-port and calls thunk"
#define Q_with_input_from_file sc->pl_sf

        if (!is_string(car(args)))
            return(method_or_bust(sc, car(args), sc->with_input_from_file_symbol, args, T_STRING, 1));

        if (!is_thunk(sc, cadr(args)))
            return(method_or_bust_with_type(sc, cadr(args), sc->with_input_from_file_symbol, args, a_thunk_string, 2));

        return(with_input(sc, open_input_file_1(sc, string_value(car(args)), "r", "with-input-from-file"), args));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x642ef
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rsi
cmpb $0x26, (%rsi)
jb 0x6431c
movq %r14, %rdi
xorl %edx, %edx
callq 0x3f86f
testb %al, %al
je 0x64314
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
leaq 0xb627c(%rip), %rdx     # 0x11a547
leaq 0xa9b51(%rip), %rcx     # 0x10de23
movq %r14, %rdi
callq 0xefb8
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfa500
movq 0x1680(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rcx
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe42d
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x1680(%r14), %rdx
movq 0xee006(%rip), %r8      # 0x152330
movq %r14, %rdi
movq %rbx, %rcx
movl $0x2, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe659
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_call_with_output_file
static s7_pointer g_call_with_output_file(s7_scheme *sc, s7_pointer args)
    {
#define H_call_with_output_file "(call-with-output-file filename proc) opens filename and calls proc with the output port as its argument"
#define Q_call_with_output_file sc->pl_sf
        s7_pointer port, file, proc;

        file = car(args);
        if (!is_string(file))
            return(method_or_bust(sc, file, sc->call_with_output_file_symbol, args, T_STRING, 1));

        proc = cadr(args);
        if ((!is_any_procedure(proc)) ||
                (!s7_is_aritable(sc, proc, 1)))
            return(method_or_bust_with_type(sc, proc, sc->call_with_output_file_symbol, args, wrap_string(sc, "a procedure of one argument (the port)", 38), 2));

        port = s7_open_output_file(sc, string_value(file), "w");
        push_stack(sc, OP_UNWIND_OUTPUT, sc->unused, port); /* #<unused> here is a marker (needed) */
        push_stack(sc, OP_APPLY, list_1(sc, port), proc);
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpb $0x13, (%r12)
jne 0x64747
movq 0x10(%r15), %rax
movq 0x8(%rax), %r14
cmpb $0x28, (%r14)
jb 0x64773
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f86f
testb %al, %al
je 0x64773
movq 0x10(%r12), %rsi
leaq 0xb77f8(%rip), %rdx     # 0x11be7a
movq %rbx, %rdi
callq 0xf166
movq %rax, %r15
movq 0x50(%rbx), %rax
movq %r15, (%rax)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq 0x140(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x1ef, 0x18(%rax)      # imm = 0x1EF
movq 0x50(%rbx), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movq %r14, 0x20(%rax)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x646fd
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 %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x198, 0x18(%rax)      # imm = 0x198
addq $0x20, 0x50(%rbx)
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xd10(%rbx), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe42d
movq 0xd10(%rbx), %rdx
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %r8
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0xb6f31(%rip), %rax     # 0x11b6d0
movq %rax, 0x10(%r8)
movq $0x26, 0x8(%r8)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
movl $0x2, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe659
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_with_output_to_string
static s7_pointer g_with_output_to_string(s7_scheme *sc, s7_pointer args)
    {
#define H_with_output_to_string "(with-output-to-string thunk) opens a string as a temporary current-output-port, calls thunk, then returns the collected output"
#define Q_with_output_to_string s7_make_signature(sc, 2, sc->is_string_symbol, s7_make_signature(sc, 2, sc->is_procedure_symbol, sc->is_macro_symbol))
        s7_pointer old_output_port, p;

        p = car(args);
        if (!is_thunk(sc, p))
            return(method_or_bust_with_type(sc, p, sc->with_output_to_string_symbol, args, a_thunk_string, 1));

        if ((is_continuation(p)) || (is_goto(p)))
            return(wrong_type_argument_with_type(sc, sc->with_output_to_string_symbol, 1, p, a_normal_procedure_string));

        old_output_port = sc->output_port;
        sc->output_port = s7_open_output_string(sc);
        push_stack(sc, OP_UNWIND_OUTPUT, old_output_port, sc->output_port);
        push_stack(sc, OP_GET_OUTPUT_STRING, old_output_port, sc->output_port);
        push_stack(sc, OP_APPLY, sc->nil, p);
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x26, (%r14)
jb 0x64829
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3f86f
testb %al, %al
je 0x64829
movb (%r14), %al
addb $-0x25, %al
cmpb $0x1, %al
ja 0x64850
movq 0x1698(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xe214d(%rip), %rdx     # 0x146958
movq 0x140(%rbx), %r8
movq 0xf0def(%rip), %r9      # 0x155608
movq %rbx, %rdi
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xa4e4
movq 0x1698(%rbx), %rdx
movq 0xedaf9(%rip), %r8      # 0x152330
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
movl $0x1, %r9d
popq %rbx
popq %r14
popq %r15
jmp 0xe659
movq 0x188(%rbx), %r15
movq %rbx, %rdi
callq 0xf75a
movq %rax, 0x188(%rbx)
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq %r15, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x1ef, 0x18(%rax)      # imm = 0x1EF
movq 0x50(%rbx), %rax
movq 0x188(%rbx), %rcx
leaq 0x20(%rax), %rdx
movq %rdx, 0x50(%rbx)
movq %rcx, 0x20(%rax)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq %r15, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x207, 0x18(%rax)      # imm = 0x207
movq 0x50(%rbx), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movq %r14, 0x20(%rax)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x198, 0x18(%rax)      # imm = 0x198
addq $0x20, 0x50(%rbx)
movq 0x120(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_with_output_to_file
static s7_pointer g_with_output_to_file(s7_scheme *sc, s7_pointer args)
    {
#define H_with_output_to_file "(with-output-to-file filename thunk) opens filename as the temporary current-output-port and calls thunk"
#define Q_with_output_to_file sc->pl_sf
        s7_pointer old_output_port, file, proc;

        file = car(args);
        if (!is_string(file))
            return(method_or_bust(sc, file, sc->with_output_to_file_symbol, args, T_STRING, 1));

        proc = cadr(args);
        if (!is_thunk(sc, proc))
            return(method_or_bust_with_type(sc, proc, sc->with_output_to_file_symbol, args, a_thunk_string, 2));

        if ((is_continuation(proc)) || (is_goto(proc)))
            return(wrong_type_argument_with_type(sc, sc->with_output_to_file_symbol, 1, proc, a_normal_procedure_string));

        old_output_port = sc->output_port;
        sc->output_port = s7_open_output_file(sc, string_value(file), "w");
        push_stack(sc, OP_UNWIND_OUTPUT, old_output_port, sc->output_port);
        push_stack(sc, OP_APPLY, sc->nil, proc);
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpb $0x13, (%r12)
jne 0x6498c
movq 0x10(%r15), %rax
movq 0x8(%rax), %r14
cmpb $0x26, (%r14)
jb 0x649b8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3f86f
testb %al, %al
je 0x649b8
movb (%r14), %al
addb $-0x25, %al
cmpb $0x1, %al
ja 0x649e5
movq 0x1690(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xe1ff0(%rip), %rdx     # 0x146958
movq 0x140(%rbx), %r8
movq 0xf0c92(%rip), %r9      # 0x155608
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa4e4
movq 0x1690(%rbx), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe42d
movq 0x1690(%rbx), %rdx
movq 0xed96a(%rip), %r8      # 0x152330
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
movl $0x2, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe659
movq 0x188(%rbx), %r15
movq 0x10(%r12), %rsi
leaq 0xb7482(%rip), %rdx     # 0x11be7a
movq %rbx, %rdi
callq 0xf166
movq %rax, 0x188(%rbx)
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq %r15, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x1ef, 0x18(%rax)      # imm = 0x1EF
movq 0x50(%rbx), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movq %r14, 0x20(%rax)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x198, 0x18(%rax)      # imm = 0x198
addq $0x20, 0x50(%rbx)
movq 0x120(%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: g_is_directory
static s7_pointer g_is_directory(s7_scheme *sc, s7_pointer args)
    {
#define H_is_directory "(directory? str) returns #t if str is the name of a directory"
#define Q_is_directory s7_make_signature(sc, 2, sc->is_boolean_symbol, sc->is_string_symbol)
        s7_pointer name;
        name = car(args);

        if (!is_string(name))
            return(method_or_bust_one_arg(sc, name, sc->is_directory_symbol, args, T_STRING));
        return(s7_make_boolean(sc, is_directory(string_value(name))));
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x64ad7
movq 0x10(%rsi), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x83d0
testl %eax, %eax
sets %al
movl 0x18(%r14), %ecx
andl $0xf000, %ecx           # imm = 0xF000
cmpl $0x4000, %ecx           # imm = 0x4000
setne %cl
orb %al, %cl
movzbl %cl, %eax
movq 0x118(%rbx,%rax,8), %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq 0x1e70(%rbx), %rdx
movq %rbx, %rdi
movl $0x13, %r8d
addq $0x98, %rsp
popq %rbx
popq %r14
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_file_exists
static s7_pointer g_file_exists(s7_scheme *sc, s7_pointer args)
    {
#define H_file_exists "(file-exists? filename) returns #t if the file exists"
#define Q_file_exists s7_make_signature(sc, 2, sc->is_boolean_symbol, sc->is_string_symbol)

        s7_pointer name;
        name = car(args);

        if (!is_string(name))
            return(method_or_bust_one_arg(sc, name, sc->file_exists_symbol, args, T_STRING));
        return(s7_make_boolean(sc, file_probe(string_value(name))));
    }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x64b22
movq 0x10(%rsi), %rdi
xorl %esi, %esi
callq 0x8590
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movq 0x118(%rbx,%rcx,8), %rax
popq %rbx
retq
movq 0x1e78(%rbx), %rdx
movq %rbx, %rdi
movl $0x13, %r8d
popq %rbx
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_delete_file
static s7_pointer g_delete_file(s7_scheme *sc, s7_pointer args)
    {
#define H_delete_file "(delete-file filename) deletes the file filename."
#define Q_delete_file s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_string_symbol)

        s7_pointer name;
        name = car(args);

        if (!is_string(name))
            return(method_or_bust_one_arg(sc, name, sc->delete_file_symbol, args, T_STRING));
        return(make_integer(sc, unlink(string_value(name))));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x64b6d
movq 0x10(%rsi), %rdi
callq 0x80a0
movslq %eax, %r14
cmpl $0x7ff, %r14d           # imm = 0x7FF
ja 0x64b89
leaq 0xe1de9(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x64bc2
movq 0x1e80(%rbx), %rdx
movq %rbx, %rdi
movl $0x13, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x95069
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x64ba8
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_getenv
static s7_pointer g_getenv(s7_scheme *sc, s7_pointer args)
    {
#define H_getenv "(getenv var) returns the value of an environment variable."
#define Q_getenv sc->pcl_s

        s7_pointer name;
        name = car(args);

        if (!is_string(name))
            return(method_or_bust_one_arg(sc, name, sc->getenv_symbol, args, T_STRING));
        return(s7_make_string(sc, getenv(string_value(name))));
    }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x64bef
movq 0x10(%rsi), %rdi
callq 0x8030
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0xe9af
movq 0x1e88(%rbx), %rdx
movq %rbx, %rdi
movl $0x13, %r8d
popq %rbx
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_directory_to_list
static s7_pointer g_directory_to_list(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer name;
        DIR *dpos;
        s7_pointer result;

#define H_directory_to_list "(directory->list directory) returns the contents of the directory as a list of strings (filenames)."
#define Q_directory_to_list s7_make_signature(sc, 2, sc->is_list_symbol, sc->is_string_symbol)   /* can return nil */

        name = car(args);
        if (!is_string(name))
            return(method_or_bust_one_arg(sc, name, sc->directory_to_list_symbol, list_1(sc, name), T_STRING));

        sc->w = sc->nil;
        if ((dpos = opendir(string_value(name))))
        {
            struct dirent *dirp;
            while ((dirp = readdir(dpos)))
                sc->w = cons(sc, s7_make_string(sc, dirp->d_name), sc->w);
            closedir(dpos);
        }

        result = sc->w;
        sc->w = sc->nil;
        return(result);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x13, (%r14)
jne 0x64ee5
movq 0x110(%rbx), %rax
movq %rax, 0x4d8(%rbx)
movq 0x10(%r14), %rdi
callq 0x8190
testq %rax, %rax
je 0x64f57
movq %rax, %r14
movq %r14, %rdi
callq 0x8440
testq %rax, %rax
je 0x64f4f
addq $0x13, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe9af
movq %rax, %r15
movq 0x4d8(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x64ebe
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 %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x4d8(%rbx)
jmp 0x64e75
movq 0x1e98(%rbx), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x64f12
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x13, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x95069
movq %r14, %rdi
callq 0x82e0
movq 0x4d8(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
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: g_file_mtime
static s7_pointer g_file_mtime(s7_scheme *sc, s7_pointer args)
    {
#define H_file_mtime "(file-mtime file): return the write date of file"
#define Q_file_mtime s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_string_symbol)

        struct stat statbuf;
        int32_t err;
        s7_pointer name;

        name = car(args);
        if (!is_string(name))
            return(method_or_bust_one_arg(sc, name, sc->file_mtime_symbol, args, T_STRING));

        err = stat(string_value(name), &statbuf);
        if (err < 0)
            return(file_error(sc, "file-mtime", strerror(errno), string_value(name)));

        return(s7_make_integer(sc, (s7_int)(statbuf.st_mtime)));
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x13, (%r14)
jne 0x64fb8
movq 0x10(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x83d0
testl %eax, %eax
js 0x64fdd
movq 0x60(%rsp), %rsi
movq %rbx, %rdi
addq $0x98, %rsp
popq %rbx
popq %r14
jmp 0xd27e
movq %rsi, %rcx
movq 0x1ea0(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x13, %r8d
addq $0x98, %rsp
popq %rbx
popq %r14
jmp 0x95069
callq 0x8090
movl (%rax), %edi
callq 0x86b0
movq 0x10(%r14), %rcx
leaq 0xa92d5(%rip), %rsi     # 0x10e2c9
movq %rbx, %rdi
movq %rax, %rdx
addq $0x98, %rsp
popq %rbx
popq %r14
jmp 0xf406