LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_unlet
static s7_pointer g_unlet(s7_scheme *sc, s7_pointer args)
    {
        /* add sc->unlet bindings to the current environment */
#define H_unlet "(unlet) returns a let that establishes the original bindings of all the predefined functions"
#define Q_unlet s7_make_signature(sc, 1, sc->is_let_symbol)

        /* slightly confusing:
         *    ((unlet) 'abs) -> #<undefined>
         *    (defined? 'abs (unlet)) -> #t
         * this is because unlet sets up a local environment of unshadowed symbols, and s7_let_ref only looks at the local env chain
         *   (that is, if env is not the global env, then the global env is not searched).
         */
        int32_t i;
        s7_pointer *inits;
        s7_pointer x;

        sc->w = new_frame_in_env(sc, sc->envir);
        inits = vector_elements(sc->unlet);

        for (i = 0; (i < UNLET_ENTRIES) && (is_slot(inits[i])); i++)
        {
            s7_pointer sym;
            x = slot_value(inits[i]);
            sym = slot_symbol(inits[i]);
            if ((x != slot_value(global_slot(sym))) || /* it has been changed globally */
                    ((!is_global(sym)) &&                  /* it might be shadowed locally */
                     (s7_symbol_local_value(sc, sym, sc->envir) != slot_value(global_slot(sym)))))
                make_slot_1(sc, sc->w, sym, x);
        }
        /* if (set! + -) then + needs to be overridden, but the local bit isn't set, so we have to check the actual values in the non-local case.
         *   (define (f x) (with-let (unlet) (+ x 1)))
         */
        x = sc->w;
        sc->w = sc->nil;
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
callq 0x72a1d
movq %rax, 0x4d8(%rbx)
movq 0x168(%rbx), %rax
movq 0x10(%rax), %r12
xorl %r13d, %r13d
cmpq $0x200, %r13            # imm = 0x200
je 0x4cfda
movq (%r12,%r13,8), %rax
cmpb $0x20, (%rax)
jne 0x4cfda
movq 0x8(%rax), %r15
movq 0x10(%rax), %r14
movq 0x10(%r15), %rax
cmpq 0x10(%rax), %r14
je 0x4cfba
movq 0x4d8(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x9a09
jmp 0x4cfd5
testb $0x1, 0x2(%r15)
jne 0x4cfd5
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb072
cmpq %r14, %rax
jne 0x4cfa3
incq %r13
jmp 0x4cf7f
movq 0x4d8(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_sublet
static s7_pointer g_sublet(s7_scheme *sc, s7_pointer args)
    {
#define H_sublet "(sublet env ...) adds its arguments (each a let or a cons: '(symbol . value)) to env, and returns the new environment."
#define Q_sublet Q_varlet
        s7_pointer e;

        e = car(args);
        if (is_null(e))
            e = sc->rootlet;
        else
        {
            check_method(sc, e, sc->sublet_symbol, args);
            if (!is_let(e))
                return(wrong_type_argument_with_type(sc, sc->sublet_symbol, 1, e, a_let_string));
        }
        return(sublet_1(sc, e, cdr(args), sc->sublet_symbol));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpq 0x110(%rdi), %r14
je 0x4d0b1
movq (%r14), %r13
btl $0x1e, %r13d
jae 0x4d077
cmpb $0x1, 0x24c(%rbx)
jne 0x4d077
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0x1578(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x4d077
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35492
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xa34c
cmpb $0x1c, %r13b
je 0x4d0b8
movq 0x1578(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xc88c9(%rip), %rdx     # 0x115958
movq 0x140(%rbx), %r8
movq 0xcc8bb(%rip), %r9      # 0x119958
movq %rbx, %rdi
movq %r14, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9bbb
movq 0x150(%rbx), %r14
movq 0x10(%r15), %rdx
movq 0x1578(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9c6e
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_coverlet
static s7_pointer g_coverlet(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer e;
#define H_coverlet "(coverlet e) undoes an earlier openlet."
#define Q_coverlet sc->pcl_e

        e = car(args);
        sc->temp3 = e;
        check_method_uncopied(sc, e, sc->coverlet_symbol, list_1(sc, e));
        sc->temp3 = sc->nil;
        if ((e == sc->rootlet) || (e == sc->s7_let))
            s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't coverlet ~S", 17), e));

        if ((is_let(e)) ||
                (has_closure_let(e)) ||
                ((is_c_object(e)) && (c_object_let(e) != sc->nil)) ||
                ((is_c_pointer(e)) && (is_let(c_pointer_info(e)))))
        {
            clear_has_methods(e);
            return(e);
        }
        return(simple_wrong_type_argument_with_type(sc, sc->coverlet_symbol, e, a_let_string));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rsi), %rbx
movq %rbx, 0x508(%rdi)
testb $0x40, 0x3(%rbx)
je 0x4db9b
cmpb $0x1, 0x24c(%r14)
jne 0x4db9b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x88f3
movq 0xe38(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%r14), %rax
je 0x4db9b
movq %rax, %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x4db67
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %rbx, 0x8(%rdx)
movq %r12, 0x10(%rdx)
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa34c
movq 0x110(%r14), %rax
movq %rax, 0x508(%r14)
cmpq 0x150(%r14), %rbx
je 0x4dbbb
cmpq 0x2150(%r14), %rbx
jne 0x4dc1c
movq 0xea8(%r14), %rsi
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0x9997a(%rip), %rcx     # 0xe7561
movq %rcx, 0x10(%rax)
movq $0x11, 0x8(%rax)
movq 0x6e0(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%r14), %rax
movq 0x10(%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x6e0(%r14), %rdx
movq %r14, %rdi
callq 0x2cdc0
movzbl (%rbx), %eax
cmpq $0x1c, %rax
je 0x4dc32
leaq 0xc7ce4(%rip), %rcx     # 0x115910
cmpb $0x0, (%rax,%rcx)
je 0x4dc45
andb $-0x41, 0x3(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq $0x21, %rax
je 0x4dc5f
cmpl $0x14, %eax
jne 0x4dc68
movq 0x18(%rbx), %rax
cmpq 0x110(%r14), %rax
jne 0x4dc32
jmp 0x4dc68
movq 0x18(%rbx), %rax
cmpb $0x1c, (%rax)
je 0x4dc32
movq 0xe38(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xcbcd7(%rip), %r8      # 0x119958
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_openlet
static s7_pointer g_openlet(s7_scheme *sc, s7_pointer args)
    {
#define H_openlet "(openlet e) tells the built-in generic functions that the let 'e might have an over-riding method."
#define Q_openlet sc->pcl_e
        s7_pointer e, elet, func;

        e = car(args);
        if ((e == sc->rootlet) || (e == sc->nil))
            s7_error(sc, sc->error_symbol, set_elist_1(sc, wrap_string(sc, "can't openlet rootlet", 21)));
        elet = find_let(sc, e); /* returns nil if no let found, so has to follow error check above */
        if (!is_let(elet))
            return(simple_wrong_type_argument_with_type(sc, sc->openlet_symbol, e, a_let_string));

        if ((has_active_methods(sc, e)) &&
                ((func = find_method(sc, elet, sc->openlet_symbol)) != sc->undefined))
            return(s7_apply_function(sc, func, args));

        set_has_methods(e);
        return(e);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rbx
cmpq 0x150(%rdi), %rbx
je 0x4dcbb
cmpq 0x110(%r14), %rbx
jne 0x4dd0d
movq 0xea8(%r14), %rsi
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0x9988c(%rip), %rcx     # 0xe7573
movq %rcx, 0x10(%rax)
movq $0x15, 0x8(%rax)
movq 0x6d8(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x6d8(%r14), %rdx
movq %r14, %rdi
callq 0x2cdc0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x88f3
cmpb $0x1c, (%rax)
jne 0x4dd65
movq (%rbx), %r12
btl $0x1e, %r12d
jae 0x4dd94
cmpb $0x1, 0x24c(%r14)
jne 0x4dd94
movq 0x13b0(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%r14), %rax
je 0x4dd94
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa34c
movq 0x13b0(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xcbbda(%rip), %r8      # 0x119958
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd456
orq $0x40000000, %r12       # imm = 0x40000000
movq %r12, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_iterate
static s7_pointer g_iterate(s7_scheme *sc, s7_pointer args)
    {
#define H_iterate "(iterate obj) returns the next element from the iterator obj, or " ITERATOR_END_NAME "."
#define Q_iterate s7_make_signature(sc, 2, sc->T, sc->is_iterator_symbol)

        s7_pointer iter;
        iter = car(args);
        if (!is_iterator(iter))
            return(method_or_bust_one_arg(sc, iter, sc->iterate_symbol, args, T_ITERATOR));
        return((iterator_next(iter))(sc, iter));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x1d, (%rsi)
jne 0x4df55
movq 0x28(%rsi), %rax
jmpq *%rax
movq 0x11c8(%rdi), %rdx
pushq $0x1d
popq %r8
jmp 0x77745
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_iterator_is_at_end
static s7_pointer g_iterator_is_at_end(s7_scheme *sc, s7_pointer args)
    {
#define H_iterator_is_at_end "(iterator-at-end? iter) returns #t if the iterator has reached the end of its sequence."
#define Q_iterator_is_at_end s7_make_signature(sc, 2, sc->is_boolean_symbol, sc->is_iterator_symbol)
        s7_pointer iter;

        iter = car(args);
        if (iter_ok(iter))
            return(sc->F);
        if (!is_iterator(iter))
            return(method_or_bust_one_arg(sc, iter, sc->iterator_is_at_end_symbol, args, T_ITERATOR));
        return(sc->T);
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
movq (%rsi), %rax
testl %eax, %eax
js 0x4dfa0
cmpb $0x1d, %al
jne 0x4dfa8
movq 0x118(%rdi), %rax
retq
movq 0x120(%rdi), %rax
retq
movq 0x11d0(%rdi), %rdx
pushq $0x1d
popq %r8
jmp 0x77745
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0xa, (%r14)
jne 0x4dffb
movq 0xee0(%rbx), %r12
movq 0x10(%r12), %rax
movq 0x10(%rax), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2ab0b
testb %al, %al
je 0x4e066
movq 0x118(%rbx), %rax
jmp 0x4e0ca
movq 0x1168(%rbx), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x4e028
movq %rbx, %rdi
callq 0x9c27
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)
pushq $0xa
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x77745
testb $0x1, 0x2(%r12)
jne 0x4e0c3
leaq 0x8(%rbx), %rcx
movq 0x20(%r12), %rax
movq (%rcx), %r13
leaq 0x10(%r13), %rcx
cmpq 0x18(%r13), %rax
jl 0x4e077
jmp 0x4e0bc
leaq 0x8(%r13), %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x4e0b8
cmpq %r12, 0x8(%rbp)
jne 0x4e0b2
movq 0x10(%rbp), %rsi
cmpq %r15, %rsi
je 0x4e0b2
movq %r14, %rdi
callq 0x2ab0b
testb %al, %al
jne 0x4dfef
addq $0x18, %rbp
jmp 0x4e08a
movq 0x10(%r13), %r13
cmpb $0x1c, (%r13)
je 0x4e086
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4e15a
cmpq 0x110(%rbx), %rax
je 0x4e15a
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 0x994a1(%rip), %rcx     # 0xe75c2
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 0x2cdc0
movq 0x8(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2ab35
// File: /workspace/github_c_makefile_star2_O2/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 0x4e2ff
movq 0x8(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x4e31c
leaq 0xc7657(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x4e355
movq 0xff8(%rbx), %rdx
pushq $0x14
popq %r8
movq %rbx, %rdi
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcd70
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x4e33b
movq %rbx, %rdi
callq 0x9c27
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_O2/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 0x4e3b5
movq 0x120(%rbx), %r15
movq 0x8(%rsi), %rsi
movq 0x10(%rcx), %rax
cmpb $0x1, (%rax)
jne 0x4e3d7
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x4e3da
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x4e3dd
movq 0x8(%rax), %r12
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x4e3e0
movq 0x8(%rax), %r15
jmp 0x4e3e0
movq 0xc48(%rbx), %rdx
pushq $0xb
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xcd70
movq %r15, %rdx
movq %r15, %rcx
movq %r15, %r12
movq %rbx, %rdi
callq 0xb4a6
movq %rax, %r14
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movq 0x120(%rbx), %rax
cmpq %rax, %r12
jne 0x4e404
cmpq %rax, %r15
je 0x4e413
movq 0x798(%rbx), %rdi
movq %r14, %rsi
callq 0xb999
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4e482
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xc049
movq 0x10(%r14), %rcx
movq 0x18(%r14), %r8
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2dcbe
movq %rsi, %rcx
movq 0xc58(%rbx), %rdx
pushq $0x21
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/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 0x4e4d3
movq 0x8(%rcx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x4e4f2
leaq 0x8aaba(%rip), %rsi     # 0xd8f84
leaq 0x989ab(%rip), %r8      # 0xe6e7c
jmp 0x4e4e1
leaq 0x8aaaa(%rip), %rsi     # 0xd8f84
leaq 0x99116(%rip), %r8      # 0xe75f7
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc2b0
cmpl $0x0, 0x4(%rax)
je 0x4e509
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb516
movq 0x8(%rax), %r14
leaq 0x990ea(%rip), %rsi     # 0xe75fe
movq %rbx, %rdi
callq 0x8c03
movq 0x120(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb4a6
// File: /workspace/github_c_makefile_star2_O2/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 0x4e574
movq 0x8(%rax), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x4e59f
leaq 0x99a91(%rip), %rsi     # 0xe7fea
leaq 0x990a4(%rip), %r8      # 0xe7604
movq %rbx, %rdi
xorl %edx, %edx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc2b0
movq 0x1400(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rbx), %rcx
movq 0xcb5eb(%rip), %r8      # 0x119b78
movq %rbx, %rdi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd456
movl 0x4(%rcx), %edx
testl %edx, %edx
je 0x4e5c5
cmpl $0x1, %edx
jne 0x4e614
movq 0x20(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x4e5d9
leaq 0xc7391(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x4e61b
movq 0x8(%rcx), %rdi
callq 0x83a0
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
jbe 0x4e5b8
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x4e5f8
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0x4e61b
movq 0xc7335(%rip), %rax     # 0x115950
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4e808
testb $0x4, 0x2(%rsi)
jne 0x4e834
movq 0x120(%rbx), %rax
jmp 0x4e887
movq 0x13d0(%rbx), %rdx
movq 0x700(%rbx), %rax
movq %rsi, 0x8(%rax)
movq 0x700(%rbx), %rcx
pushq $0x1
popq %r8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x77745
movl 0x2c(%rsi), %r14d
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x4e84e
leaq 0xc7108(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x4e887
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x4e86d
movq %rbx, %rdi
callq 0x9c27
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_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x1, (%r14)
movq (%r14), %rax
jne 0x4e8bd
btl $0x12, %eax
jb 0x4e94b
movq 0x120(%rbx), %rax
jmp 0x4e95a
btl $0x1e, %eax
jae 0x4e91c
cmpb $0x1, 0x24c(%rbx)
jne 0x4e91c
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0x13c8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x4e91c
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35492
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa34c
movq 0x13c8(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xcb133(%rip), %r8      # 0x119a68
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd456
movq 0x498(%rbx), %rax
movl 0x28(%r14), %ecx
movq (%rax,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4e989
movq 0x8(%rsi), %rax
movzbl 0x2(%rax), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
cmpq 0x188(%rdi), %rsi
jne 0x4e99e
movq 0x120(%rdi), %rax
cmpq %rax, %rsi
je 0x4e9dc
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 0x98c2c(%rip), %rax     # 0xe75f7
movq %rax, 0x10(%r8)
movq $0x6, 0x8(%r8)
jmp 0xc736d
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x190(%rdi), %rax
movq 0x8(%rsi), %r14
cmpb $0x22, (%r14)
jne 0x4ea1e
movq 0x8(%r14), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x4ea84
cmpq 0x120(%rbx), %r14
je 0x4ea84
testb $0x40, 0x3(%r14)
je 0x4ea97
cmpb $0x1, 0x24c(%rbx)
jne 0x4ea97
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0x14b8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x4ea97
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35492
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa34c
movq %r14, 0x190(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8a821(%rip), %rsi     # 0xd92bf
leaq 0x98480(%rip), %r8      # 0xe6f25
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc2b0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq (%r14), %r13
btl $0x1e, %r13d
jae 0x4eb2e
cmpb $0x1, 0x24c(%rbx)
jne 0x4eb2e
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0x1710(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x4eb2e
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35492
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xa34c
cmpb $0x21, %r13b
je 0x4eb42
movzbl %r13b, %eax
cmpl $0x1c, %eax
je 0x4eb4f
cmpl $0x14, %eax
jne 0x4eb49
movq 0x18(%r14), %r14
movb (%r14), %r13b
cmpb $0x1c, %r13b
jne 0x4eb63
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9f90
movq 0x1710(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xcaddc(%rip), %r8      # 0x119958
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x23, (%r14)
jne 0x4ebb6
movq 0x8(%r14), %rax
cmpb $0x0, 0x2(%rax)
je 0x4ec39
testb $0x40, 0x3(%r14)
je 0x4ec13
cmpb $0x1, 0x24c(%rbx)
jne 0x4ec13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0x14c0(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x4ec13
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35492
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa34c
leaq 0x8a788(%rip), %rsi     # 0xd93a2
leaq 0x989e3(%rip), %r8      # 0xe7604
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc2b0
movq 0x170(%rbx), %rax
movq %r14, 0x170(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x188(%rdi), %rax
movq 0x8(%rsi), %r14
cmpb $0x22, (%r14)
jne 0x4ec7c
movq 0x8(%r14), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x4ece2
cmpq 0x120(%rbx), %r14
je 0x4ece2
testb $0x40, 0x3(%r14)
je 0x4ecf5
cmpb $0x1, 0x24c(%rbx)
jne 0x4ecf5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0x14c8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x4ecf5
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35492
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa34c
movq %r14, 0x188(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8a730(%rip), %rsi     # 0xd942c
leaq 0x98222(%rip), %r8      # 0xe6f25
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc2b0
// File: /workspace/github_c_makefile_star2_O2/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 0x4ed5b
movq %rsi, %rcx
movq 0x8(%rsi), %rax
cmpb $0x23, (%rax)
jne 0x4ed78
movq 0x8(%rax), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x4ed8e
movq 0x16e0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xd25d5(%rip), %r8      # 0x121328
movq %rax, %rdx
jmp 0xd456
movq 0x170(%rdi), %rax
cmpb $0x23, (%rax)
jne 0x4eda7
movq 0x8(%rax), %rcx
movl $0x118, %eax            # imm = 0x118
cmpl $0x1, 0x4(%rcx)
jne 0x4eda7
jmp 0x4edac
movq 0x16e0(%rdi), %rdx
movq 0xcae7a(%rip), %r8      # 0x119c00
movq %rax, %rsi
jmp 0xc736d
movl 0x4(%rcx), %edx
cmpl $0x1, %edx
je 0x4edb1
cmpl $0x2, %edx
jne 0x4eda7
movq 0x50(%rcx), %rcx
pushq $0x5
popq %rsi
movq %rax, %rdx
jmpq *%rcx
movl $0x120, %eax            # imm = 0x120
movq (%rdi,%rax), %rax
retq
movl $0x118, %eax            # imm = 0x118
jmp 0x4edac
// File: /workspace/github_c_makefile_star2_O2/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 0x4ede6
movzwl 0x2(%rsi), %eax
testw $0x104, %ax             # imm = 0x104
jne 0x4eddd
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 0xcadfa(%rip), %r8      # 0x119c00
movq %rbx, %rdi
popq %rbx
jmp 0xc736d
// File: /workspace/github_c_makefile_star2_O2/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)
jne 0x4ee26
movq %rbx, %rdi
callq 0xd6b6
jmp 0x4ee58
cmpq 0x120(%rbx), %rsi
je 0x4ee58
movq 0xe08(%rbx), %rdx
movq 0x700(%rbx), %rax
movq %rsi, 0x8(%rax)
movq 0x700(%rbx), %rcx
movq 0xd2479(%rip), %r8      # 0x1212c8
movq %rbx, %rdi
popq %rbx
jmp 0xc736d
movq 0x130(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4ee8a
movq %rbx, %rsi
callq 0xd543
jmp 0x4eead
cmpq 0x120(%rdi), %rbx
je 0x4eead
movq %rsi, %rcx
movq 0xf10(%rdi), %rdx
movq 0xd2424(%rip), %r8      # 0x1212c8
movq %rbx, %rsi
popq %rbx
jmp 0xc736d
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4eee7
movq 0x10(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0x4eefe
movq 0x8(%rdx), %rsi
cmpb $0x13, (%rsi)
jne 0x4ef15
movq 0x10(%rax), %rax
movq 0x10(%rsi), %rdx
leaq 0x87166(%rip), %rcx     # 0xd6045
movq %rax, %rsi
jmp 0xd6dd
movq 0x1390(%rdi), %rdx
pushq $0x13
popq %r8
pushq $0x1
popq %r9
movq %rax, %rsi
jmp 0xcd70
movq 0x10(%rax), %rsi
leaq 0x975de(%rip), %rdx     # 0xe64e7
leaq 0x87135(%rip), %rcx     # 0xd6045
jmp 0xd6dd
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 0x986d5(%rip), %rax     # 0xe7617
movq %rax, 0x10(%r8)
movq $0x1d, 0x8(%r8)
pushq $0x2
popq %r9
jmp 0xcf9a
// File: /workspace/github_c_makefile_star2_O2/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 0x4ef85
movq 0x10(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0x4ef9c
movq 0x8(%rdx), %rsi
cmpb $0x13, (%rsi)
jne 0x4efac
movq 0x10(%rax), %rax
movq 0x10(%rsi), %rdx
movq %rax, %rsi
jmp 0xd842
movq 0x13a0(%rdi), %rdx
pushq $0x13
popq %r8
pushq $0x1
popq %r9
movq %rax, %rsi
jmp 0xcd70
movq 0x10(%rax), %rsi
leaq 0x98e73(%rip), %rdx     # 0xe7e1a
jmp 0xd842
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 0x9865c(%rip), %rax     # 0xe7635
movq %rax, 0x10(%r8)
movq $0x1d, 0x8(%r8)
pushq $0x2
popq %r9
jmp 0xcf9a
// File: /workspace/github_c_makefile_star2_O2/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 0x4f2b7
movq %rdi, %rbx
cmpb $0x22, (%r14)
jne 0x4f2ca
movq 0x8(%r14), %rax
cmpb $0x1, 0x2(%rax)
jne 0x4f2ac
leaq 0x97943(%rip), %rsi     # 0xe6bda
leaq 0x97c87(%rip), %r8      # 0xe6f25
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0xc2b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c000
movq 0xca79a(%rip), %rax     # 0x119a58
movq 0x50(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rcx
movq 0x1360(%rbx), %rdx
movq 0xd1fed(%rip), %r8      # 0x1212c8
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc736d
// File: /workspace/github_c_makefile_star2_O2/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 0x4f3c9
movq 0x8(%r14), %rsi
jmp 0x4f3d9
movq %rbx, %rdi
callq 0xc7406
movq %rax, %rsi
testq %rax, %rax
je 0x4f41a
cmpb $0x23, (%rsi)
jne 0x4f3fa
movq 0xca673(%rip), %r14     # 0x119a58
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
callq *(%rax)
cltq
movq (%r14,%rax,8), %rax
jmp 0x4f421
movq 0x1448(%rbx), %rdx
movq 0xca7f8(%rip), %r8      # 0x119c00
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc736d
movq 0xc633f(%rip), %rax     # 0x115760
addq $0x8, %rsp
popq %rbx
popq %r14
retq