LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_pair_line_number
static s7_pointer g_pair_line_number(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer p;
#define H_pair_line_number "(pair-line-number pair) returns the line number at which it read 'pair', or #f if no such number is available"
#define Q_pair_line_number s7_make_signature(sc, 2, s7_make_signature(sc, 2, sc->is_integer_symbol, sc->not_symbol), sc->is_pair_symbol)

        p = car(args);
        if (!is_pair(p))
            return(method_or_bust_one_arg(sc, p, sc->pair_line_number_symbol, set_plist_1(sc, p), T_PAIR));

        if (has_line_number(p))
            return(make_integer(sc, pair_line_number(p)));
        return(sc->F); /* was 0 21-Mar-17 */
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x6af64
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq 0x13d0(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x35ea0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rax, %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x60(%rsp)
jmp 0x6b04f
movq 0x48(%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0x6b03e
movq 0x48(%rsp), %rax
movl 0x2c(%rax), %eax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x6afb1
movq 0x40(%rsp), %rcx
leaq 0x1ab4da(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x6b028
jmp 0x6afb3
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x6afd7
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0xb, (%rax)
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x6b04f
movq 0x58(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_pair_filename
static s7_pointer g_pair_filename(s7_scheme *sc, s7_pointer args)
    {
#define H_pair_filename "(pair-filename pair) returns the name of the file containing 'pair'"
#define Q_pair_filename s7_make_signature(sc, 2, s7_make_signature(sc, 2, sc->is_string_symbol, sc->not_symbol), sc->is_pair_symbol)
        s7_pointer p;
        p = car(args);

        if (!is_pair(p))
        {
            check_method(sc, p, sc->pair_filename_symbol, args);
            return(simple_wrong_type_argument(sc, sc->pair_filename_symbol, p, T_PAIR));
        }
        if (has_line_number(p))
            return(sc->file_names[pair_file(p)]);
        return(sc->F);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x6b171
movq 0x28(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x6b138
movq 0x38(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x6b138
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x9a10
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rax
movq 0x13c8(%rax), %rdx
callq 0x98d0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x6b138
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x44270
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x40(%rsp)
jmp 0x6b1b5
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x13c8(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x28(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1af433(%rip), %r8     # 0x21a598
callq 0x14a60
movq %rax, 0x40(%rsp)
jmp 0x6b1b5
movq 0x28(%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0x6b1a4
movq 0x38(%rsp), %rax
movq 0x498(%rax), %rax
movq 0x28(%rsp), %rcx
movl 0x28(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x40(%rsp)
jmp 0x6b1b5
movq 0x38(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_is_port_closed
static s7_pointer g_is_port_closed(s7_scheme *sc, s7_pointer args)
    {
#define H_is_port_closed "(port-closed? p) returns #t if the port p is closed."
#define Q_is_port_closed s7_make_signature(sc, 2, sc->is_boolean_symbol, s7_make_signature(sc, 3, sc->is_input_port_symbol, sc->is_output_port_symbol, sc->not_symbol))
        s7_pointer x;

        x = car(args);
        if ((is_input_port(x)) || (is_output_port(x)))
            return(make_boolean(sc, port_is_closed(x)));
        if ((x == sc->output_port) && (x == sc->F))
            return(sc->F);
        return(method_or_bust_with_type_one_arg(sc, x, sc->is_port_closed_symbol, args, wrap_string(sc, "a port", 6)));
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x6b1f6
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x6b238
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x6b218
movq 0x38(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x6b229
movq 0x38(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x6b2d5
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x188(%rcx), %rax
jne 0x6b271
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x6b271
movq 0x38(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x6b2d5
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x1148(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x188307(%rip), %rsi    # 0x1f35b2
movl $0x6, %edx
callq 0xb880
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rax, %r8
callq 0x1ba7e0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_set_current_error_port
static s7_pointer g_set_current_error_port(s7_scheme *sc, s7_pointer args)
    {
#define H_set_current_error_port "(set-current-error-port port) sets the current-error port to port and returns the previous value of the error port"
#define Q_set_current_error_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->error_port;
        port = car(args);
        if (((is_output_port(port)) &&
                    (!port_is_closed(port))) ||
                (port == sc->F))
            sc->error_port = port;
        else
        {
            check_method(sc, port, sc->set_current_error_port_symbol, args);
            return(s7_wrong_type_arg_error(sc, "set-current-error-port", 0, port, "an open output port"));
        }
        return(old_port);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x190(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x6b389
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x6b39c
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x6b3b2
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x190(%rax)
jmp 0x6b47f
movq 0x20(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x6b457
movq 0x38(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x6b457
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x9a10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rax
movq 0x14b8(%rax), %rdx
callq 0x98d0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x6b457
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x44270
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x40(%rsp)
jmp 0x6b489
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rcx
leaq 0x17998c(%rip), %rsi    # 0x1e4df4
xorl %eax, %eax
movl %eax, %edx
leaq 0x187a6d(%rip), %r8     # 0x1f2ee0
callq 0x12540
movq %rax, 0x40(%rsp)
jmp 0x6b489
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_let_to_list
static s7_pointer g_let_to_list(s7_scheme *sc, s7_pointer args)
    {
#define H_let_to_list "(let->list env) returns env's bindings as a list of cons's: '(symbol . value)."
#define Q_let_to_list s7_make_signature(sc, 2, sc->is_pair_symbol, sc->is_let_symbol)

        s7_pointer env;
        env = car(args);
        check_method(sc, env, sc->let_to_list_symbol, args);
        if (!is_let(env))
        {
            if (is_c_object(env))
                env = c_object_let(env);
            else
            {
                if (is_c_pointer(env))
                    env = c_pointer_info(env);
            }
            if (!is_let(env))
                return(simple_wrong_type_argument_with_type(sc, sc->let_to_list_symbol, env, a_let_string));
        }
        return(s7_let_to_list(sc, env));
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x6b56a
movq 0x38(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x6b56a
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x9a10
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rax
movq 0x1710(%rax), %rdx
callq 0x98d0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x6b56a
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x44270
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x40(%rsp)
jmp 0x6b611
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
je 0x6b5fd
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x14, %eax
jne 0x6b598
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x6b5b5
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x21, %eax
jne 0x6b5b3
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x6b5b5
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
je 0x6b5fb
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x1710(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x28(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1aee99(%rip), %r8     # 0x21a488
callq 0x14a60
movq %rax, 0x40(%rsp)
jmp 0x6b611
jmp 0x6b5fd
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xd130
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_set_current_input_port
static s7_pointer g_set_current_input_port(s7_scheme *sc, s7_pointer args)
    {
#define H_set_current_input_port "(set-current-input-port port) sets the current-input port to port and returns the previous value of the input port"
#define Q_set_current_input_port s7_make_signature(sc, 2, sc->is_input_port_symbol, sc->is_input_port_symbol)

        s7_pointer old_port, port;
        old_port = sc->input_port;
        port = car(args);
        if ((is_input_port(port)) &&
                (!port_is_closed(port)))
            sc->input_port = port;
        else
        {
            check_method(sc, port, sc->set_current_input_port_symbol, args);
            return(s7_wrong_type_arg_error(sc, "set-current-input-port", 0, port, "an open input port"));
        }
        return(old_port);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x170(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0x6b67f
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
jne 0x6b67f
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x170(%rax)
jmp 0x6b74c
movq 0x20(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x6b724
movq 0x38(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x6b724
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x9a10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rax
movq 0x14c0(%rax), %rdx
callq 0x98d0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x6b724
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x44270
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x40(%rsp)
jmp 0x6b756
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rcx
leaq 0x1797a2(%rip), %rsi    # 0x1e4ed7
xorl %eax, %eax
movl %eax, %edx
leaq 0x187e7f(%rip), %r8     # 0x1f35bf
callq 0x12540
movq %rax, 0x40(%rsp)
jmp 0x6b756
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x188(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x6b7a9
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x6b7bc
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x6b7d2
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x188(%rax)
jmp 0x6b89f
movq 0x20(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x6b877
movq 0x38(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x6b877
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x9a10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rax
movq 0x14c8(%rax), %rdx
callq 0x98d0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x6b877
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x44270
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x40(%rsp)
jmp 0x6b8a9
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rcx
leaq 0x1796d9(%rip), %rsi    # 0x1e4f61
xorl %eax, %eax
movl %eax, %edx
leaq 0x18764d(%rip), %r8     # 0x1f2ee0
callq 0x12540
movq %rax, 0x40(%rsp)
jmp 0x6b8a9
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x6b9f2
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x6b931
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0x16e0(%rax), %rdx
movq 0x20(%rsp), %rcx
movq 0x1aee0e(%rip), %r8     # 0x21a730
callq 0x1ba7e0
movq %rax, 0x30(%rsp)
jmp 0x6ba4a
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x6b97c
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x16e0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1b6513(%rip), %r8     # 0x221e80
callq 0x14a60
movq %rax, 0x30(%rsp)
jmp 0x6ba4a
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x2, 0x4(%rax)
jne 0x6b9b3
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl $0x5, %esi
callq *%rax
movq %rax, 0x30(%rsp)
jmp 0x6ba4a
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0x6b9d5
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x6b9e6
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x6ba4a
movq 0x28(%rsp), %rax
movq 0x170(%rax), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0x6ba2f
movq 0x28(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0x6ba2f
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x6ba40
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x6bae0
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0xe00(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x35ea0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
movq 0x1aec5c(%rip), %r8     # 0x21a730
callq 0x1ba7e0
movq %rax, 0x30(%rsp)
jmp 0x6bb28
movq 0x18(%rsp), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
jne 0x6bb17
movq 0x18(%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
jne 0x6bb17
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x14ce0
movq 0x28(%rsp), %rax
movq 0x130(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
je 0x6bbe6
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x6bb8f
movq 0x28(%rsp), %rax
movq 0x130(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x6bc06
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0xe08(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x35ea0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
movq 0x1b622e(%rip), %r8     # 0x221e08
callq 0x1ba7e0
movq %rax, 0x30(%rsp)
jmp 0x6bc06
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x14f80
movq 0x28(%rsp), %rax
movq 0x130(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x6bc44
movq 0x18(%rsp), %rax
movq 0x188(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x6bc52
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
je 0x6bcac
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x6bc7e
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x6bcc5
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xf10(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x1b6168(%rip), %r8     # 0x221e08
callq 0x1ba7e0
movq %rax, 0x20(%rsp)
jmp 0x6bcc5
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14d10
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x6bd2f
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0x1390(%rax), %rdx
movq 0x30(%rsp), %rcx
movl $0x13, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x40(%rsp)
jmp 0x6be1f
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x6bdf9
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x6bdcf
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x1390(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x187835(%rip), %rsi    # 0x1f35d2
movl $0x1d, %edx
callq 0xb880
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rax, %r8
movl $0x2, %r9d
callq 0x14130
movq %rax, 0x40(%rsp)
jmp 0x6be1f
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x175da0(%rip), %rcx    # 0x1e1b8d
callq 0x15040
movq %rax, 0x40(%rsp)
jmp 0x6be1f
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x18665f(%rip), %rdx    # 0x1f246d
leaq 0x175d78(%rip), %rcx    # 0x1e1b8d
callq 0x15040
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x6be8f
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0x13a0(%rax), %rdx
movq 0x30(%rsp), %rcx
movl $0x13, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x40(%rsp)
jmp 0x6bf79
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x6bf5a
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x6bf2f
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x13a0(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x1876f4(%rip), %rsi    # 0x1f35f0
movl $0x1d, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %rax, %r8
movl $0x2, %r9d
callq 0x14130
movq %rax, 0x40(%rsp)
jmp 0x6bf79
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
callq 0x15250
movq %rax, 0x40(%rsp)
jmp 0x6bf79
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x187e66(%rip), %rdx    # 0x1f3dd5
callq 0x15250
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_open_input_string
static s7_pointer g_open_input_string(s7_scheme *sc, s7_pointer args)
    {
#define H_open_input_string "(open-input-string str) opens an input port reading str"
#define Q_open_input_string s7_make_signature(sc, 2, sc->is_input_port_symbol, sc->is_string_symbol)
        s7_pointer input_string, port;

        input_string = car(args);
        if (!is_string(input_string))
            return(method_or_bust_one_arg(sc, input_string, sc->open_input_string_symbol, args, T_STRING));
        port = open_and_protect_input_string(sc, input_string);
        return(port);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x6bfe6
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1398(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x13, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x6c002
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1babf0
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x6c5b1
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x6c5c2
movq 0x18(%rsp), %rax
movq 0x188(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x6c5ea
movq 0x1adfac(%rip), %rax    # 0x21a588
movq 0x50(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x6c675
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
je 0x6c625
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1360(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x1b57ef(%rip), %r8     # 0x221e08
callq 0x1ba7e0
movq %rax, 0x20(%rsp)
jmp 0x6c675
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x6c656
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rcx
leaq 0x186535(%rip), %rsi    # 0x1f2b7a
movl $0x1, %edx
leaq 0x18688f(%rip), %r8     # 0x1f2ee0
callq 0x12540
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2d390
movq 0x1adf1c(%rip), %rax    # 0x21a588
movq 0x50(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x6c871
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x6c898
movq 0x18(%rsp), %rdi
callq 0x1bac60
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6c896
movq 0x1a9a01(%rip), %rax    # 0x216290
movq %rax, 0x20(%rsp)
jmp 0x6c90c
jmp 0x6c898
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x6c8d3
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1448(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x1ade69(%rip), %r8     # 0x21a730
callq 0x1ba7e0
movq %rax, 0x20(%rsp)
jmp 0x6c90c
movq 0x1adcae(%rip), %rax    # 0x21a588
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x6c951
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x6c962
movq 0x18(%rsp), %rax
movq 0x170(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x6c9a0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x13d8(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x1add9f(%rip), %r8     # 0x21a730
callq 0x1ba7e0
movq %rax, 0x20(%rsp)
jmp 0x6ca30
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x6c9e8
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x13d8(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1b54a4(%rip), %r8     # 0x221e80
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x6ca30
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x2, 0x4(%rax)
jne 0x6ca1c
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x4, %esi
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0x6ca30
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x15de0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x6cd41
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x6cd6b
movq 0x18(%rsp), %rdi
callq 0x1bac60
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6cd69
movq 0x1a9531(%rip), %rax    # 0x216290
movq %rax, 0x20(%rsp)
jmp 0x6cdf0
jmp 0x6cd6b
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x6cda6
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1440(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x1ad996(%rip), %r8     # 0x21a730
callq 0x1ba7e0
movq %rax, 0x20(%rsp)
jmp 0x6cdf0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jne 0x6cddb
movq 0x1a94bc(%rip), %rax    # 0x216290
movq %rax, 0x20(%rsp)
jmp 0x6cdf0
movslq 0x4(%rsp), %rcx
leaq 0x1a9699(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movb $0x0, 0x7(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x6d117
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x6d0dc
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1450(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x1ad669(%rip), %r8     # 0x21a730
movl $0x1, %r9d
callq 0x14130
movq %rax, 0x20(%rsp)
jmp 0x6d16f
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x6d115
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0x7(%rsp)
jmp 0x6d13e
movq 0x18(%rsp), %rdi
callq 0x1bac60
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6d13c
movq 0x1a915b(%rip), %rax    # 0x216290
movq %rax, 0x20(%rsp)
jmp 0x6d16f
jmp 0x6d13e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x38(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movb 0x7(%rsp), %dl
movl $0x1, %ecx
andb $0x1, %dl
movzbl %dl, %edx
callq *%rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x6da21
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x6da4b
movq 0x18(%rsp), %rdi
callq 0x1bac60
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6da49
movq 0x1a8851(%rip), %rax    # 0x216290
movq %rax, 0x20(%rsp)
jmp 0x6db7e
jmp 0x6da4b
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x6da89
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1460(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x1accb6(%rip), %r8     # 0x21a730
callq 0x1ba7e0
movq %rax, 0x20(%rsp)
jmp 0x6db7e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x2, 0x4(%rax)
jne 0x6dabd
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
xorl %esi, %esi
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0x6db7e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0x6daf1
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jg 0x6daf1
movq 0x1a87a9(%rip), %rax    # 0x216290
movq %rax, 0x20(%rsp)
jmp 0x6db7e
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x16310
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1dc, %ecx            # imm = 0x1DC
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
jmp 0x6db3b
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x190, %ecx            # imm = 0x190
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x6e719
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x1680(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x13, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x20(%rsp)
jmp 0x6e7cf
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x26, %eax
jl 0x6e74d
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3cbf0
testb $0x1, %al
jne 0x6e789
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x1680(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x1b3711(%rip), %r8     # 0x221e88
movl $0x2, %r9d
callq 0x14130
movq %rax, 0x20(%rsp)
jmp 0x6e7cf
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x183cc1(%rip), %rdx    # 0x1f246d
leaq 0x177145(%rip), %rcx    # 0x1e58f8
callq 0x15040
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rdx
callq 0x1baeb0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x6f466
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1e70(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x13, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x6f491
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x27dd0
movq (%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x9c10
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)