LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_provided
static s7_pointer g_is_provided(s7_scheme *sc, s7_pointer args)
    {
#define H_is_provided "(provided? symbol) returns #t if symbol is a member of the *features* list"
#define Q_is_provided s7_make_signature(sc, 2, sc->is_boolean_symbol, sc->is_symbol_symbol)
        s7_pointer sym, topf, x;

        sym = car(args);
        if (!is_symbol(sym))
            return(method_or_bust_one_arg(sc, sym, sc->is_provided_symbol, list_1(sc, sym), T_SYMBOL));

        /* here the *features* list is spread out (or can be anyway) along the curlet chain,
         *   so we need to travel back all the way to the top level checking each *features* list in turn.
         *   Since *features* grows via cons (newest first), we can stop the scan if we hit the shared
         *   top-level at least.
         */
        topf = slot_value(global_slot(sc->features_symbol));
        if (is_memq(sym, topf))
            return(sc->T);

        if (is_global(sc->features_symbol))
            return(sc->F);
        for (x = sc->envir; symbol_id(sc->features_symbol) < let_id(x); x = outlet(x));
        for (; is_let(x); x = outlet(x))
        {
            s7_pointer y;
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == sc->features_symbol)
                {
                    if ((slot_value(y) != topf) &&
                            (is_memq(sym, slot_value(y))))
                        return(sc->T);
                }
        }
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0xa, (%r14)
jne 0x6665c
movq 0xee0(%rbx), %rcx
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rdx
cmpb $0x1, (%rdx)
sete %al
jne 0x6664c
cmpq %r14, 0x8(%rdx)
je 0x6664c
movq %rdx, %rsi
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
sete %al
jne 0x6664c
cmpq %r14, 0x8(%rsi)
jne 0x6663a
testb %al, %al
je 0x666c6
movq 0x118(%rbx), %rax
jmp 0x66740
movq 0x1168(%rbx), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x66682
movq %rbx, %rdi
callq 0xb389
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 $0xa, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9b739
testb $0x1, 0x2(%rcx)
jne 0x66739
leaq 0x8(%rbx), %rdi
movq 0x20(%rcx), %rax
movq (%rdi), %rsi
leaq 0x10(%rsi), %rdi
cmpq 0x18(%rsi), %rax
jl 0x666d4
cmpb $0x1c, (%rsi)
jne 0x66739
movq 0x8(%rsi), %r8
testq %r8, %r8
sete %dil
je 0x6672a
cmpq %rcx, 0x8(%r8)
jne 0x6671d
movq 0x10(%r8), %r9
cmpq %rdx, %r9
je 0x6671d
cmpb $0x1, (%r9)
sete %r10b
jne 0x66718
cmpq %r14, 0x8(%r9)
je 0x66718
movq 0x10(%r9), %r9
jmp 0x66702
testb %r10b, %r10b
jne 0x66723
movq 0x18(%r8), %r8
jmp 0x666ea
movq 0x118(%rbx), %rax
testb $0x1, %dil
je 0x66740
movq 0x10(%rsi), %rsi
cmpb $0x1c, (%rsi)
je 0x666e6
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_provide
static s7_pointer g_provide(s7_scheme *sc, s7_pointer args)
    {
#define H_provide "(provide symbol) adds symbol to the *features* list"
#define Q_provide s7_make_signature(sc, 2, sc->is_symbol_symbol, sc->is_symbol_symbol)

        if ((is_immutable(sc->envir)) &&
                (sc->envir != sc->nil))
            s7_error(sc, sc->error_symbol,
                    set_elist_2(sc, wrap_string(sc, "can't provide '~S (current environment is immutable)", 52), car(args)));
        return(c_provide(sc, car(args)));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testb $0x1, 0x3(%rax)
je 0x667cd
cmpq 0x110(%rbx), %rax
je 0x667cd
movq 0xea8(%rbx), %rsi
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0xbdd7e(%rip), %rcx     # 0x124512
movq %rcx, 0x10(%rax)
movq $0x34, 0x8(%rax)
movq 0x8(%r14), %rcx
movq 0x6e0(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
callq 0x3b366
movq 0x8(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x391cc
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_c_object_type
static s7_pointer g_c_object_type(s7_scheme *sc, s7_pointer args)
                {
#define H_c_object_type "(c-object-type obj) returns the c_object's type tag."
#define Q_c_object_type s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_c_object_symbol)

                    s7_pointer p;
                    p = car(args);
                    if (is_c_object(p))
                        return(make_integer(sc, c_object_type(p))); /* this is the c_object_types table index = tag */
                    return(method_or_bust(sc, p, sc->c_object_type_symbol, args, T_C_OBJECT, 0));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x14, (%rsi)
jne 0x669d5
movq 0x8(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x669f4
leaq 0xe7f81(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x66a2d
movq 0xff8(%rbx), %rdx
movq %rbx, %rdi
movl $0x14, %r8d
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf1ae
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x66a0c
movq %rbx, %rdi
callq 0xb389
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_O1/BernardTatin[P]s7sh/s7.c
// Function: g_c_pointer
static s7_pointer g_c_pointer(s7_scheme *sc, s7_pointer args)
    {
#define H_c_pointer "(c-pointer int type info unmarked) returns a c-pointer object. The type and info args are optional, defaulting to #f."
#define Q_c_pointer s7_make_circular_signature(sc, 2, 3, sc->is_c_pointer_symbol, sc->is_integer_symbol, sc->T)

        s7_pointer arg, type, info, weak1, weak2, cp;
        intptr_t p;

        type = sc->F;
        info = sc->F;
        weak1 = sc->F;
        weak2 = sc->F;
        arg = car(args);
        if (!s7_is_integer(arg))
            return(method_or_bust(sc, arg, sc->c_pointer_symbol, args, T_INTEGER, 1));
        p = (intptr_t)s7_integer(arg);             /* (c-pointer (bignum "1234")) */
        args = cdr(args);
        if (is_pair(args))
        {
            type = car(args);
            args = cdr(args);
            if (is_pair(args))
            {
                info = car(args);
                args = cdr(args);
                if (is_pair(args))
                {
                    weak1 = car(args);
                    args = cdr(args);
                    if (is_pair(args))
                        weak2 = car(args);
                }
            }
        }
        cp = s7_make_c_pointer_with_type(sc, (void *)p, type, info);
        c_pointer_set_weak1(cp, weak1);
        c_pointer_set_weak2(cp, weak2);
        if ((weak1 != sc->F) || (weak2 != sc->F))
            add_weak_ref(sc, cp);
        return(cp);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0xb, (%rsi)
jne 0x66a8d
movq 0x120(%rbx), %r15
movq 0x8(%rsi), %rsi
movq 0x10(%rcx), %rax
cmpb $0x1, (%rax)
jne 0x66ab3
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x66ab6
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x66ab9
movq 0x8(%rax), %r12
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x66abc
movq 0x8(%rax), %r15
jmp 0x66abc
movq 0xc48(%rbx), %rdx
movq %rbx, %rdi
movl $0xb, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf1ae
movq %r15, %rdx
movq %r15, %rcx
movq %r15, %r12
movq %rbx, %rdi
callq 0xd2f5
movq %rax, %r14
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movq 0x120(%rbx), %rax
cmpq %rax, %r12
jne 0x66ae0
cmpq %rax, %r15
je 0x66b1b
movq 0x798(%rbx), %rbx
movq 0x8(%rbx), %rsi
cmpq %rsi, 0x10(%rbx)
jne 0x66b08
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movq %r14, (%rax,%rcx,8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_c_pointer_to_list
static s7_pointer g_c_pointer_to_list(s7_scheme *sc, s7_pointer args)
    {
#define H_c_pointer_to_list "(c-pointer->list obj) returns the c-pointer data as (list pointer-as-int type info)"
#define Q_c_pointer_to_list s7_make_signature(sc, 2, sc->is_pair_symbol, sc->is_c_pointer_symbol)

        s7_pointer p;
        p = car(args);
        if (!is_c_pointer(p))
            return(method_or_bust(sc, p, sc->c_pointer_to_list_symbol, args, T_C_POINTER, 1));
        return(s7_list(sc, 3, s7_make_integer(sc, (s7_int)((intptr_t)c_pointer(p))), c_pointer_type(p), c_pointer_info(p)));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x21, (%r14)
jne 0x66b8c
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xdff8
movq 0x10(%r14), %rcx
movq 0x18(%r14), %r8
movl $0x3, %esi
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c485
movq %rsi, %rcx
movq 0xc58(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x21, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_port_file
static s7_pointer g_port_file(s7_scheme *sc, s7_pointer args)
    {
#define H_port_file "(port-file port) returns the FILE* pointer associated with the port, wrapped in a c-pointer object"
#define Q_port_file s7_make_signature(sc, 2, sc->is_c_pointer_symbol, s7_make_signature(sc, 2, sc->is_input_port_symbol, sc->is_output_port_symbol))
        s7_pointer port;

        port = car(args);
        if ((!is_input_port(port)) &&
                (!is_output_port(port)))
            return(s7_wrong_type_arg_error(sc, "port-file", 0, port, "a port"));
        if (port_is_closed(port))
            return(s7_wrong_type_arg_error(sc, "port-file", 0, port, "an open port"));
#if (!MS_WINDOWS)
        if (is_file_port(port))
            return(s7_make_c_pointer_with_type(sc, (void *)(port_file(port)), s7_make_symbol(sc, "FILE*"), sc->F));
#endif
        return(s7_make_c_pointer(sc, NULL));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
movb (%rcx), %al
andb $-0x2, %al
cmpb $0x22, %al
jne 0x66be1
movq 0x8(%rcx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x66c00
leaq 0xaf2fc(%rip), %rsi     # 0x115ed4
leaq 0xbd1ed(%rip), %r8      # 0x123dcc
jmp 0x66bef
leaq 0xaf2ec(%rip), %rsi     # 0x115ed4
leaq 0xbd958(%rip), %r8      # 0x124547
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe25f
cmpl $0x0, 0x4(%rax)
je 0x66c17
movq 0x120(%rbx), %rcx
movq %rbx, %rdi
xorl %esi, %esi
movq %rcx, %rdx
jmp 0x66c3f
movq 0x8(%rax), %r14
leaq 0xbd92c(%rip), %rsi     # 0x12454e
movl $0x5, %edx
movq %rbx, %rdi
callq 0x9d9f
movq 0x120(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd2f5
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_port_position
static s7_pointer g_port_position(s7_scheme *sc, s7_pointer args)
    {
#define H_port_position "(port-position input-port) returns the current location (in bytes) in the port's data where the next read will take place."
#define Q_port_position s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_input_port_symbol)
        s7_pointer port;

        port = car(args);
        if (!(is_input_port(port)))
            return(simple_wrong_type_argument(sc, sc->port_position_symbol, port, T_INPUT_PORT));
        if (port_is_closed(port))
            return(s7_wrong_type_arg_error(sc, "port-position", 0, port, "an open input port"));
        if (is_string_port(port))
            return(make_integer(sc, port_position(port)));
#if (!MS_WINDOWS)
        if (is_file_port(port))
            return(make_integer(sc, ftell(port_file(port))));
#endif
        return(small_int(0));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpb $0x23, (%rax)
jne 0x66c87
movq 0x8(%rax), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x66cb2
leaq 0xbe2ce(%rip), %rsi     # 0x124f3a
leaq 0xbd8e1(%rip), %r8      # 0x124554
movq %rbx, %rdi
xorl %edx, %edx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe25f
movq 0x1400(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rbx), %rcx
movq 0xebed8(%rip), %r8      # 0x152b78
movq %rbx, %rdi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfac8
movl 0x4(%rcx), %edx
testl %edx, %edx
je 0x66cd8
cmpl $0x1, %edx
jne 0x66d27
movq 0x20(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x66cec
leaq 0xe7c7e(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x66d2e
movq 0x8(%rcx), %rdi
callq 0x93a0
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
jbe 0x66ccb
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x66d04
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0x66d2e
movq 0xe7c22(%rip), %rax     # 0x14e950
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x1, (%rsi)
jne 0x670e2
testb $0x4, 0x2(%rsi)
jne 0x67110
movq 0x120(%rbx), %rax
jmp 0x67163
movq 0x13d0(%rbx), %rdx
movq 0x700(%rbx), %rax
movq %rsi, 0x8(%rax)
movq 0x700(%rbx), %rcx
movq %rbx, %rdi
movl $0x1, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b739
movl 0x2c(%rsi), %r14d
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x6712a
leaq 0xe782c(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x67163
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x67142
movq %rbx, %rdi
callq 0xb389
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_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x8(%rsi), %rbx
cmpb $0x1, (%rbx)
movq (%rbx), %rax
jne 0x6719e
btl $0x12, %eax
jb 0x67317
movq 0x120(%r14), %rax
jmp 0x67325
movb $0x1, %bpl
btl $0x1e, %eax
jae 0x672e0
cmpb $0x1, 0x24c(%r14)
jne 0x672e0
movq %rsi, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a55
movq 0x13c8(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%r14), %rax
je 0x672e0
cmpb $0x1, (%r12)
jne 0x67334
movq %rax, 0x10(%rsp)
movq %r12, 0x4c8(%r14)
movq 0x8(%r12), %rbp
movq 0x90(%r14), %rax
movq 0x110(%r14), %r15
cmpq 0x98(%r14), %rax
ja 0x67221
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rax, 0x4e8(%r14)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x672bf
movq 0x8(%rsp), %rbp
movq 0x8(%r12), %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x67287
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rax, 0x10(%rbp)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
movq %rax, %rbp
je 0x67263
movq 0x110(%r14), %rax
movq %rax, 0x4e8(%r14)
movq %rax, 0x4c8(%r14)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
jmp 0x6733b
testb %bpl, %bpl
je 0x67325
movq 0x13c8(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xeb76a(%rip), %r8      # 0x152a68
movq %r14, %rdi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfac8
movq 0x498(%r14), %rax
movl 0x28(%rbx), %ecx
movq (%rax,%rcx,8), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xbd41
xorl %ebp, %ebp
jmp 0x672e0
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
movb (%rsi), %al
andb $-0x2, %al
cmpb $0x22, %al
jne 0x6736d
movq 0x8(%rsi), %rax
movzbl 0x2(%rax), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
cmpq 0x188(%rdi), %rsi
jne 0x67382
movq 0x120(%rdi), %rax
cmpq %rax, %rsi
je 0x673c0
movq 0x1148(%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 0xbd198(%rip), %rax     # 0x124547
movq %rax, 0x10(%r8)
movq $0x6, 0x8(%r8)
jmp 0x103001
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
movq 0x190(%rdi), %rax
movq 0x8(%rsi), %rbx
cmpb $0x22, (%rbx)
jne 0x6740b
movq 0x8(%rbx), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x67557
cmpq 0x120(%r14), %rbx
je 0x67557
movb $0x1, %bpl
testb $0x40, 0x3(%rbx)
je 0x67560
cmpb $0x1, 0x24c(%r14)
jne 0x67560
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a55
movq 0x14b8(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%r14), %rax
je 0x67560
cmpb $0x1, (%r12)
jne 0x6759d
movq %rax, 0x10(%rsp)
movq %r12, 0x4c8(%r14)
movq 0x8(%r12), %rbp
movq 0x90(%r14), %rax
movq 0x110(%r14), %r15
cmpq 0x98(%r14), %rax
ja 0x67498
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rax, 0x4e8(%r14)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x67536
movq 0x8(%rsp), %rbp
movq 0x8(%r12), %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x674fe
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rax, 0x10(%rbp)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
movq %rax, %rbp
je 0x674da
movq 0x110(%r14), %rax
movq %rax, 0x4e8(%r14)
movq %rax, 0x4c8(%r14)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
jmp 0x675a4
movq %rbx, 0x190(%r14)
jmp 0x6758e
testb %bpl, %bpl
je 0x6758e
leaq 0xaeca3(%rip), %rsi     # 0x11620f
leaq 0xbc902(%rip), %r8      # 0x123e75
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe25f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xbd41
xorl %ebp, %ebp
jmp 0x67560
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x8(%rsi), %rbx
movb $0x1, %bpl
testb $0x40, 0x3(%rbx)
je 0x67709
cmpb $0x1, 0x24c(%r14)
jne 0x67709
movq %rsi, %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a55
movq 0x1710(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%r14), %rax
je 0x67709
cmpb $0x1, (%r13)
jne 0x67783
movq %rax, 0x10(%rsp)
movq %r13, 0x4c8(%r14)
movq 0x8(%r13), %rbp
movq 0x90(%r14), %rax
movq 0x110(%r14), %r15
cmpq 0x98(%r14), %rax
ja 0x6764a
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rax, 0x4e8(%r14)
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
jne 0x676e5
movq 0x8(%rsp), %rbp
movq 0x8(%r13), %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x676ae
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x10(%rbp)
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
movq %rax, %rbp
je 0x6768b
movq 0x110(%r14), %rax
movq %rax, 0x4e8(%r14)
movq %rax, 0x4c8(%r14)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
jmp 0x6778a
testb %bpl, %bpl
je 0x67742
movzbl (%rbx), %eax
cmpl $0x21, %eax
je 0x67720
cmpl $0x1c, %eax
je 0x67729
cmpl $0x14, %eax
jne 0x67724
movq 0x18(%rbx), %rbx
cmpb $0x1c, (%rbx)
jne 0x67751
movq %r14, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb83a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1710(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xeb1ee(%rip), %r8      # 0x152958
movq %r14, %rdi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfac8
movq 0x110(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xbd41
xorl %ebp, %ebp
jmp 0x67709
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rsi), %rbx
cmpb $0x23, (%rbx)
jne 0x677c7
movq 0x8(%rbx), %rax
cmpb $0x0, 0x2(%rax)
je 0x67934
movb $0x1, %bpl
testb $0x40, 0x3(%rbx)
je 0x67906
cmpb $0x1, 0x24c(%r14)
jne 0x67906
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a55
movq 0x14c0(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%r14), %rax
je 0x67906
cmpb $0x1, (%r12)
jne 0x67951
movq %rax, 0x10(%rsp)
movq %r12, 0x4c8(%r14)
movq 0x8(%r12), %rbp
movq 0x90(%r14), %rax
movq 0x110(%r14), %r15
cmpq 0x98(%r14), %rax
ja 0x67847
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rax, 0x4e8(%r14)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x678e5
movq 0x8(%rsp), %rbp
movq 0x8(%r12), %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x678ad
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rax, 0x10(%rbp)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
movq %rax, %rbp
je 0x67889
movq 0x110(%r14), %rax
movq %rax, 0x4e8(%r14)
movq %rax, 0x4c8(%r14)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
jmp 0x67958
testb %bpl, %bpl
je 0x67942
leaq 0xae9e0(%rip), %rsi     # 0x1162f2
leaq 0xbcc3b(%rip), %r8      # 0x124554
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe25f
movq 0x170(%r14), %rax
movq %rbx, 0x170(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xbd41
xorl %ebp, %ebp
jmp 0x67906
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
movq 0x188(%rdi), %rax
movq 0x8(%rsi), %rbx
cmpb $0x22, (%rbx)
jne 0x67999
movq 0x8(%rbx), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x67ae5
cmpq 0x120(%r14), %rbx
je 0x67ae5
movb $0x1, %bpl
testb $0x40, 0x3(%rbx)
je 0x67aee
cmpb $0x1, 0x24c(%r14)
jne 0x67aee
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a55
movq 0x14c8(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%r14), %rax
je 0x67aee
cmpb $0x1, (%r12)
jne 0x67b2b
movq %rax, 0x10(%rsp)
movq %r12, 0x4c8(%r14)
movq 0x8(%r12), %rbp
movq 0x90(%r14), %rax
movq 0x110(%r14), %r15
cmpq 0x98(%r14), %rax
ja 0x67a26
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rax, 0x4e8(%r14)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x67ac4
movq 0x8(%rsp), %rbp
movq 0x8(%r12), %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x67a8c
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rax, 0x10(%rbp)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
movq %rax, %rbp
je 0x67a68
movq 0x110(%r14), %rax
movq %rax, 0x4e8(%r14)
movq %rax, 0x4c8(%r14)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
jmp 0x67b32
movq %rbx, 0x188(%r14)
jmp 0x67b1c
testb %bpl, %bpl
je 0x67b1c
leaq 0xae882(%rip), %rsi     # 0x11637c
leaq 0xbc374(%rip), %r8      # 0x123e75
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe25f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xbd41
xorl %ebp, %ebp
jmp 0x67aee
// File: /workspace/github_c_makefile_star2_O1/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 0x67b81
movq %rsi, %rcx
movq 0x8(%rsi), %rax
cmpb $0x23, (%rax)
jne 0x67b9e
movq 0x8(%rax), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x67bb4
movq 0x16e0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xf27af(%rip), %r8      # 0x15a328
movq %rax, %rdx
jmp 0xfac8
movq 0x170(%rdi), %rax
cmpb $0x23, (%rax)
jne 0x67bcf
movq 0x8(%rax), %rcx
movl $0x118, %eax            # imm = 0x118
cmpl $0x1, 0x4(%rcx)
jne 0x67bcf
jmp 0x67bd4
movq 0x16e0(%rdi), %rdx
movq 0xeb054(%rip), %r8      # 0x152c00
movq %rax, %rsi
jmp 0x103001
movl 0x4(%rcx), %edx
cmpl $0x1, %edx
je 0x67bd9
cmpl $0x2, %edx
jne 0x67bcf
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 0x67bd4
// File: /workspace/github_c_makefile_star2_O1/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 0x67c0f
movzwl 0x2(%rsi), %eax
testl $0x104, %eax            # imm = 0x104
jne 0x67c06
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 0xeafd1(%rip), %r8      # 0x152c00
movq %rbx, %rdi
popq %rbx
jmp 0x103001
// File: /workspace/github_c_makefile_star2_O1/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 0x67c67
cmpq %rsi, %rax
je 0x67c95
testb $0x1, 0x3(%rsi)
jne 0x67c95
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
callq *0x48(%rax)
jmp 0x67c95
cmpq %rax, %rsi
je 0x67c95
movq 0xe08(%rbx), %rdx
movq 0x700(%rbx), %rax
movq %rsi, 0x8(%rax)
movq 0x700(%rbx), %rcx
movq 0xf263c(%rip), %r8      # 0x15a2c8
movq %rbx, %rdi
popq %rbx
jmp 0x103001
movq 0x130(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x67cc7
movq %rbx, %rsi
callq 0xfbb5
jmp 0x67cea
cmpq 0x120(%rdi), %rbx
je 0x67cea
movq %rsi, %rcx
movq 0xf10(%rdi), %rdx
movq 0xf25e7(%rip), %r8      # 0x15a2c8
movq %rbx, %rsi
popq %rbx
jmp 0x103001
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x67d24
movq 0x10(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0x67d3f
movq 0x8(%rdx), %rsi
cmpb $0x13, (%rsi)
jne 0x67d56
movq 0x10(%rax), %rax
movq 0x10(%rsi), %rdx
leaq 0xab279(%rip), %rcx     # 0x112f95
movq %rax, %rsi
jmp 0xfd5a
movq 0x1390(%rdi), %rdx
movq %rax, %rsi
movl $0x13, %r8d
movl $0x1, %r9d
jmp 0xf1ae
movq 0x10(%rax), %rsi
leaq 0xbb6ed(%rip), %rdx     # 0x123437
leaq 0xab244(%rip), %rcx     # 0x112f95
jmp 0xfd5a
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 0xbc7e4(%rip), %rax     # 0x124567
movq %rax, 0x10(%r8)
movq $0x1d, 0x8(%r8)
movl $0x2, %r9d
jmp 0xf3da
// File: /workspace/github_c_makefile_star2_O1/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 0x67dc8
movq 0x10(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0x67de3
movq 0x8(%rdx), %rsi
cmpb $0x13, (%rsi)
jne 0x67df3
movq 0x10(%rax), %rax
movq 0x10(%rsi), %rdx
movq %rax, %rsi
jmp 0xff27
movq 0x13a0(%rdi), %rdx
movq %rax, %rsi
movl $0x13, %r8d
movl $0x1, %r9d
jmp 0xf1ae
movq 0x10(%rax), %rsi
leaq 0xbcf7c(%rip), %rdx     # 0x124d6a
jmp 0xff27
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 0xbc765(%rip), %rax     # 0x124585
movq %rax, 0x10(%r8)
movq $0x1d, 0x8(%r8)
movl $0x2, %r9d
jmp 0xf3da
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x8(%rsi), %rax
leaq 0x188(%rdi), %rdx
cmpq %rsi, 0x110(%rdi)
cmoveq %rdx, %rax
movq (%rax), %r14
cmpq 0x120(%rdi), %r14
je 0x681b7
movq %rdi, %rbx
cmpb $0x22, (%r14)
jne 0x681ca
movq 0x8(%r14), %rax
cmpb $0x1, 0x2(%rax)
jne 0x68198
leaq 0xbb9a9(%rip), %rsi     # 0x123b2a
leaq 0xbbced(%rip), %r8      # 0x123e75
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0xe25f
cmpq %r14, 0x120(%rbx)
je 0x681b7
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
movl $0xa, %esi
movq %r14, %rdx
callq *0x8(%rax)
movq 0xea89a(%rip), %rax     # 0x152a58
movq 0x50(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rcx
movq 0x1360(%rbx), %rdx
movq 0xf20ed(%rip), %r8      # 0x15a2c8
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x103001
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movb $0x1, %bpl
testb $0x40, 0x3(%rsi)
je 0x6833b
cmpb $0x1, 0x24c(%rbx)
jne 0x6833b
movq %rbx, %rdi
callq 0x9a55
movq 0x16b8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%rbx), %rax
je 0x6833b
cmpb $0x1, (%r14)
jne 0x68382
movq %rax, 0x10(%rsp)
movq %r14, 0x4c8(%rbx)
movq 0x8(%r14), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r15
cmpq 0x98(%rbx), %rax
ja 0x6827f
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r13, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rax, 0x4e8(%rbx)
movq 0x10(%r14), %r13
cmpb $0x1, (%r13)
jne 0x6831a
movq 0x8(%rsp), %rbp
movq 0x8(%r13), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x682e3
movq %rbx, %rdi
callq 0xb389
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, 0x10(%rbp)
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
movq %rax, %rbp
je 0x682c0
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
jmp 0x68389
testb %bpl, %bpl
je 0x68373
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
leaq 0x8(%rax), %rcx
leaq 0x188(%rbx), %rdx
cmpb $0x1, (%rax)
cmoveq %rcx, %rdx
movq (%rdx), %rdx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8a666
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbd41
xorl %ebp, %ebp
jmp 0x6833b
// File: /workspace/github_c_makefile_star2_O1/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 0x683d6
movq 0x8(%r14), %rsi
jmp 0x683e6
movq %rbx, %rdi
callq 0x103191
movq %rax, %rsi
testq %rax, %rax
je 0x68427
cmpb $0x23, (%rsi)
jne 0x68407
movq 0xea666(%rip), %r14     # 0x152a58
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
callq *(%rax)
cltq
movq (%r14,%rax,8), %rax
jmp 0x6842e
movq 0x1448(%rbx), %rdx
movq 0xea7eb(%rip), %r8      # 0x152c00
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x103001
movq 0xe6332(%rip), %rax     # 0x14e760
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6847f
movq 0x8(%rax), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x68498
movq 0x13d8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xf1eb1(%rip), %r8      # 0x15a328
movq %rax, %rdx
jmp 0xfac8
movq %rsi, %rcx
movq 0x13d8(%rdi), %rdx
movq 0xea770(%rip), %r8      # 0x152c00
movq %rax, %rsi
jmp 0x103001
cmpl $0x2, 0x4(%rcx)
jne 0x684ac
movq 0x50(%rcx), %rcx
movl $0x4, %esi
movq %rax, %rdx
jmpq *%rcx
movq %rax, %rsi
jmp 0x10898