LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_to_dynamic_value
static s7_pointer g_symbol_to_dynamic_value(s7_scheme *sc, s7_pointer args)
    {
#define H_symbol_to_dynamic_value "(symbol->dynamic-value sym) returns the dynamic binding of the symbol sym"
#define Q_symbol_to_dynamic_value s7_make_signature(sc, 2, sc->T, sc->is_symbol_symbol)

        s7_pointer sym, val;
        int64_t i, top_id;

        sym = car(args);
        if (!is_symbol(sym))
            return(method_or_bust(sc, sym, sc->symbol_to_dynamic_value_symbol, args, T_SYMBOL, 1));

        if (is_global(sym))
            return(slot_value(global_slot(sym)));

        if (let_id(sc->envir) == symbol_id(sym))
            return(slot_value(local_slot(sym)));

        top_id = -1;
        val = find_dynamic_value(sc, sc->envir, sym, &top_id);
        if (top_id == symbol_id(sym))
            return(val);

        for (i = s7_stack_top(sc) - 1; i > 0; i -= 4)
            if (is_let_unchecked(stack_let(sc->stack, i))) /* OP_GC_PROTECT envir slot can be anything (even free) */
            {
                s7_pointer cur_val;
                cur_val = find_dynamic_value(sc, stack_let(sc->stack, i), sym, &top_id);
                if (cur_val != sc->unused)
                    val = cur_val;
                if (top_id == symbol_id(sym))
                    return(val);
            }

        if (val == sc->unused)
            return(s7_symbol_value(sc, sym));
        return(val);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rsi), %rbx
cmpb $0xa, (%rbx)
jne 0x5fb65
testb $0x1, 0x2(%rbx)
jne 0x5fb94
movq 0x8(%r14), %rsi
movq 0x20(%rbx), %r13
cmpq %r13, 0x18(%rsi)
jne 0x5fbae
movq 0x18(%rbx), %rax
jmp 0x5fb98
movq %rsi, %rcx
movq 0x15b0(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movl $0xa, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe42d
movq 0x10(%rbx), %rax
movq 0x10(%rax), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %r12
movq $-0x1, (%r12)
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq 0xfa1f6
movq %rax, %r15
cmpq %r13, (%r12)
je 0x5fb9c
movq 0x50(%r14), %rbp
subq 0x48(%r14), %rbp
sarq $0x3, %rbp
cmpq $0x2, %rbp
jl 0x5fc21
movq 0x38(%r14), %rax
movq 0x10(%rax), %r12
addq $0x3, %rbp
movq -0x30(%r12,%rbp,8), %rsi
cmpb $0x1c, (%rsi)
jne 0x5fc17
movq %r14, %rdi
movq %rbx, %rdx
movq %rsp, %rcx
callq 0xfa1f6
cmpq 0x140(%r14), %rax
cmovneq %rax, %r15
cmpq %r13, (%rsp)
je 0x5fb9c
addq $-0x4, %rbp
cmpq $0x4, %rbp
jg 0x5fbee
cmpq 0x140(%r14), %r15
jne 0x5fb9c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9a93
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_immutable
static s7_pointer g_immutable(s7_scheme *sc, s7_pointer args)
    {
#define H_immutable "(immutable! sequence) declares that the sequence's entries can't be changed. The sequence is returned."
#define Q_immutable s7_make_signature(sc, 2, sc->T, sc->T)
        s7_pointer p;
        p = car(args);
        if (is_symbol(p))
        {
            s7_pointer slot;
            slot = symbol_to_slot(sc, p);
            if (is_slot(slot))
            {
                set_immutable(slot);
                return(p);  /* symbol is not set immutable ? */
            }
        }
        return(s7_immutable(p));
    }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0xa, (%rax)
jne 0x5fc83
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rax), %rsi
movl $0x18, %ecx
cmpq %rsi, %rdi
je 0x5fc7a
jle 0x5fc75
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rsi
jl 0x5fc68
cmpq %rsi, %rdi
jne 0x5fc8b
movq (%rax,%rcx), %rsi
cmpb $0x20, (%rsi)
je 0x5fc86
movq %rax, %rsi
orb $0x1, 0x3(%rsi)
retq
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0x5fc7a
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0x5fcaa
cmpq %rax, 0x8(%rsi)
je 0x5fc7e
movq 0x18(%rsi), %rsi
jmp 0x5fc99
movq 0x10(%rdx), %rdx
jmp 0x5fc90
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_to_keyword
static s7_pointer g_string_to_keyword(s7_scheme *sc, s7_pointer args)
    {
#define H_string_to_keyword "(string->keyword str) prepends ':' to str and defines that as a keyword"
#define Q_string_to_keyword s7_make_signature(sc, 2, sc->is_keyword_symbol, sc->is_string_symbol)

        s7_pointer str;
        str = car(args);
        if (!is_string(str))
            return(method_or_bust_one_arg(sc, str, sc->string_to_keyword_symbol, args, T_STRING));
        if ((string_length(str) == 0) ||
                (string_value(str)[0] == '\0'))
            return(s7_error(sc, sc->out_of_range_symbol, set_elist_2(sc, wrap_string(sc, "string->keyword wants a non-null string: ~S", 43), str)));
        return(s7_make_keyword(sc, string_value(str)));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x5fd72
cmpq $0x0, 0x8(%rsi)
je 0x5fd84
movq 0x10(%rsi), %rax
cmpb $0x0, (%rax)
je 0x5fd84
movq %rax, %rsi
jmp 0xc250
movq 0x1300(%rdi), %rdx
movl $0x13, %r8d
jmp 0x95069
movq 0x1948(%rdi), %rax
movq 0x820(%rdi), %rcx
movslq 0x7dc(%rdi), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rdi)
leaq 0xbb7aa(%rip), %rdx     # 0x11b559
movq %rdx, 0x10(%rcx)
movq $0x2b, 0x8(%rcx)
movq 0x6e0(%rdi), %rdx
movq %rcx, 0x8(%rdx)
movq 0x6e0(%rdi), %rcx
movq 0x10(%rcx), %rcx
movq %rsi, 0x8(%rcx)
movq 0x6e0(%rdi), %rdx
movq %rax, %rsi
jmp 0x38dfa
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_to_keyword
static s7_pointer g_symbol_to_keyword(s7_scheme *sc, s7_pointer args)
    {
#define H_symbol_to_keyword "(symbol->keyword sym) returns a keyword with the same name as sym, but with a colon prepended"
#define Q_symbol_to_keyword s7_make_signature(sc, 2, sc->is_keyword_symbol, sc->is_symbol_symbol)

        if (!is_symbol(car(args)))
            return(method_or_bust_one_arg(sc, car(args), sc->symbol_to_keyword_symbol, args, T_SYMBOL));
        return(symbol_to_keyword(sc, car(args)));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0x5fdfd
movq 0x8(%rsi), %rax
movq 0x10(%rax), %rsi
jmp 0xc250
movq 0x15b8(%rdi), %rdx
movl $0xa, %r8d
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_keyword_to_symbol
static s7_pointer g_keyword_to_symbol(s7_scheme *sc, s7_pointer args)
    {
#define H_keyword_to_symbol "(keyword->symbol key) returns a symbol with the same name as key but no prepended colon"
#define Q_keyword_to_symbol s7_make_signature(sc, 2, sc->is_symbol_symbol, sc->is_keyword_symbol)

        s7_pointer sym;
        sym = car(args);
        if (!is_keyword(sym))
            return(method_or_bust_with_type_one_arg(sc, sym, sc->keyword_to_symbol_symbol, args, wrap_string(sc, "a keyword", 9)));
        return(keyword_symbol(sym));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
testb $-0x80, 0x6(%rsi)
jne 0x5fe5a
movq 0x1208(%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 0xac55f(%rip), %rax     # 0x10c3a8
movq %rax, 0x10(%r8)
movq $0x9, 0x8(%r8)
jmp 0xfa261
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_outlet
static s7_pointer g_outlet(s7_scheme *sc, s7_pointer args)
    {
#define H_outlet "(outlet env) is the environment that contains env."
#define Q_outlet s7_make_signature(sc, 2, sc->is_let_symbol, sc->is_let_symbol)

        s7_pointer env;

        env = car(args);
        if (!is_let(env))
            return(s7_wrong_type_arg_error(sc, "outlet", 1, env, "a let")); /* not a method call here! */

        if ((env == sc->rootlet) ||
                (is_null(outlet(env))))
            return(sc->rootlet);
        return(outlet(env));
    }

// Assembly:
movq 0x8(%rsi), %rcx
cmpb $0x1c, (%rcx)
jne 0x5fe8a
movq 0x150(%rdi), %rdx
cmpq %rdx, %rcx
je 0x5fea2
movq 0x10(%rcx), %rax
cmpq 0x110(%rdi), %rax
je 0x5fea2
retq
leaq 0xbc197(%rip), %rsi     # 0x11c028
leaq 0xb7497(%rip), %r8      # 0x11732f
movl $0x1, %edx
jmp 0xd4e5
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x5fef5
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x20001c, (%rax)       # imm = 0x20001C
movq 0x250(%rbx), %rcx
incq %rcx
movq %rcx, 0x250(%rbx)
movq %rcx, 0x18(%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x4d8(%rbx)
movq 0x168(%rbx), %rax
movq 0x10(%rax), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rax
cmpb $0x20, (%rax)
jne 0x5ff9a
movq 0x8(%rax), %r15
movq 0x10(%rax), %r14
movq 0x10(%r15), %rax
cmpq 0x10(%rax), %r14
je 0x5ff73
movq 0x4d8(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0xa332
jmp 0x5ff8e
testb $0x1, 0x2(%r15)
jne 0x5ff8e
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbe9a
cmpq %r14, %rax
jne 0x5ff5c
incq %r13
cmpq $0x200, %r13            # imm = 0x200
jne 0x5ff41
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_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
movq 0x110(%rdi), %r13
cmpq %r13, %r12
je 0x60143
movq (%r12), %rbp
btl $0x1e, %ebp
jae 0x60104
cmpb $0x1, 0x24c(%rbx)
jne 0x60104
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8a63
movq 0x1578(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x60104
cmpb $0x1, (%r15)
jne 0x6016e
movq %rax, (%rsp)
movq %r15, 0x4c8(%rbx)
movq 0x8(%r15), %rbp
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6005b
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %rbp, 0x8(%r12)
movq %r13, 0x10(%r12)
movq %r12, 0x4e8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x600e9
movq %r12, %r13
movq 0x8(%r15), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x600ba
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq %rax, %r13
je 0x60090
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq (%rsp), %rax
jmp 0x60171
cmpb $0x1c, %bpl
je 0x6014a
movq 0x1578(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xe683c(%rip), %rdx     # 0x146958
movq 0x140(%rbx), %r8
movq 0xea82e(%rip), %r9      # 0x14a958
movq %rbx, %rdi
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa4e4
movq 0x150(%rbx), %r12
movq 0x10(%r15), %rdx
movq 0x1578(%rbx), %rcx
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa597
movq %r13, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee6
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_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 0x61246
cmpb $0x1, 0x24c(%r14)
jne 0x61246
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8a63
movq 0xe38(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%r14), %rax
je 0x61246
movq %rax, %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x61212
movq %r14, %rdi
callq 0xa550
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 0xaee6
movq 0x110(%r14), %rax
movq %rax, 0x508(%r14)
cmpq 0x150(%r14), %rbx
je 0x61266
cmpq 0x2150(%r14), %rbx
jne 0x612c7
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 0xba32f(%rip), %rcx     # 0x11b5c1
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 0x38dfa
movzbl (%rbx), %eax
cmpq $0x1c, %rax
je 0x612dd
leaq 0xe5639(%rip), %rcx     # 0x146910
cmpb $0x0, (%rax,%rcx)
je 0x612f0
andb $-0x41, 0x3(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq $0x21, %rax
je 0x6130a
cmpl $0x14, %eax
jne 0x61313
movq 0x18(%rbx), %rax
cmpq 0x110(%r14), %rax
jne 0x612dd
jmp 0x61313
movq 0x18(%rbx), %rax
cmpb $0x1c, (%rax)
je 0x612dd
movq 0xe38(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xe962c(%rip), %r8      # 0x14a958
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x61366
cmpq 0x110(%r14), %rbx
jne 0x613b8
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 0xba241(%rip), %rcx     # 0x11b5d3
movq %rcx, 0x10(%rax)
movq $0x15, 0x8(%rax)
movq 0x6d8(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x6d8(%r14), %rdx
movq %r14, %rdi
callq 0x38dfa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8a63
cmpb $0x1c, (%rax)
jne 0x61410
movq (%rbx), %r12
btl $0x1e, %r12d
jae 0x6143f
cmpb $0x1, 0x24c(%r14)
jne 0x6143f
movq 0x13b0(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%r14), %rax
je 0x6143f
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaee6
movq 0x13b0(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xe952f(%rip), %r8      # 0x14a958
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xed2a
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_O3/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 0x6166d
cmpb $0x1d, %al
jne 0x61675
movq 0x118(%rdi), %rax
retq
movq 0x120(%rdi), %rax
retq
movq 0x11d0(%rdi), %rdx
movl $0x1d, %r8d
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/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 0x616ea
movq 0xee0(%rbx), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x616c6
movq %rcx, %rdx
cmpq %r14, 0x8(%rdx)
je 0x61795
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
je 0x616b3
testb $0x1, 0x2(%rax)
jne 0x6178c
leaq 0x8(%rbx), %rdi
movq 0x20(%rax), %rsi
movq (%rdi), %rdx
leaq 0x10(%rdx), %rdi
cmpq 0x18(%rdx), %rsi
jl 0x616d8
jmp 0x61787
movq 0x1168(%rbx), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x61717
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0xa, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x95069
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0x61783
cmpq %rax, 0x8(%rsi)
je 0x61769
movq 0x18(%rsi), %rsi
jmp 0x61758
movq 0x10(%rsi), %rdi
cmpq %rcx, %rdi
je 0x61763
cmpb $0x1, (%rdi)
jne 0x61763
cmpq %r14, 0x8(%rdi)
je 0x61795
movq 0x10(%rdi), %rdi
jmp 0x61772
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
je 0x61754
movq 0x120(%rbx), %rax
jmp 0x6179c
movq 0x118(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_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 0x61829
cmpq 0x110(%rbx), %rax
je 0x61829
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 0xb9e32(%rip), %rcx     # 0x11b622
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 0x38dfa
movq 0x8(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x36d43
// File: /workspace/github_c_makefile_star2_O3/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 0x61a28
movq 0x8(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x61a47
leaq 0xe4f2e(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x61a80
movq 0xff8(%rbx), %rdx
movq %rbx, %rdi
movl $0x14, %r8d
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe42d
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x61a66
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_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 0x61ae0
movq 0x120(%rbx), %r15
movq 0x8(%rsi), %rsi
movq 0x10(%rcx), %rax
cmpb $0x1, (%rax)
jne 0x61b06
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x61b09
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x61b0c
movq 0x8(%rax), %r12
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x61b0f
movq 0x8(%rax), %r15
jmp 0x61b0f
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 0xe42d
movq %r15, %rdx
movq %r15, %rcx
movq %r15, %r12
movq %rbx, %rdi
callq 0xc550
movq %rax, %r14
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movq 0x120(%rbx), %rax
cmpq %rax, %r12
jne 0x61b33
cmpq %rax, %r15
je 0x61b6e
movq 0x798(%rbx), %rbx
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
cmpq 0x8(%rbx), %rsi
jne 0x61b62
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%rbx)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%rbx)
movq 0x10(%rbx), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%rbx)
movq %r14, (%rax,%rsi,8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 0x61bdf
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xd27e
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 0x39ef9
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 0xe42d
// File: /workspace/github_c_makefile_star2_O3/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 0x61c34
movq 0x8(%rcx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x61c53
leaq 0xab3b9(%rip), %rsi     # 0x10cfe4
leaq 0xb92aa(%rip), %r8      # 0x11aedc
jmp 0x61c42
leaq 0xab3a9(%rip), %rsi     # 0x10cfe4
leaq 0xb9a15(%rip), %r8      # 0x11b657
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd4e5
cmpl $0x0, 0x4(%rax)
je 0x61c6a
movq 0x120(%rbx), %rcx
movq %rbx, %rdi
xorl %esi, %esi
movq %rcx, %rdx
jmp 0x61c8d
movq 0x8(%rax), %r14
leaq 0xb99e9(%rip), %rsi     # 0x11b65e
movq %rbx, %rdi
callq 0x8d7c
movq 0x120(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc550
// File: /workspace/github_c_makefile_star2_O3/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 0x61cd5
movq 0x8(%rax), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x61d00
leaq 0xba390(%rip), %rsi     # 0x11c04a
leaq 0xb99a3(%rip), %r8      # 0x11b664
movq %rbx, %rdi
xorl %edx, %edx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd4e5
movq 0x1400(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rbx), %rcx
movq 0xe8e8a(%rip), %r8      # 0x14ab78
movq %rbx, %rdi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xed2a
movl 0x4(%rcx), %edx
testl %edx, %edx
je 0x61d26
cmpl $0x1, %edx
jne 0x61d75
movq 0x20(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x61d3a
leaq 0xe4c30(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x61d7c
movq 0x8(%rcx), %rdi
callq 0x83a0
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
jbe 0x61d19
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x61d59
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0x61d7c
movq 0xe4bd4(%rip), %rax     # 0x146950
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6211c
testb $0x4, 0x2(%rsi)
jne 0x6214a
movq 0x120(%rbx), %rax
jmp 0x6219d
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 0x95069
movl 0x2c(%rsi), %r14d
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x62164
leaq 0xe47f2(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x6219d
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x62183
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_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
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpb $0x1, (%r12)
movq (%r12), %rax
jne 0x621d8
btl $0x12, %eax
jb 0x62336
movq 0x120(%rbx), %rax
jmp 0x62346
btl $0x1e, %eax
jae 0x62304
cmpb $0x1, 0x24c(%rbx)
jne 0x62304
movq %rsi, %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8a63
movq 0x13c8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x62304
cmpb $0x1, (%r15)
jne 0x62355
movq %rax, (%rsp)
movq %r15, 0x4c8(%rbx)
movq 0x8(%r15), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x6225b
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %r13, 0x8(%r12)
movq %rbp, 0x10(%r12)
movq %r12, 0x4e8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x622e9
movq %r12, %r13
movq 0x8(%r15), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x622ba
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq %rax, %r13
je 0x62290
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq (%rsp), %rax
jmp 0x6235c
movq 0x13c8(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xe874b(%rip), %r8      # 0x14aa68
movq %rbx, %rdi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xed2a
movq 0x498(%rbx), %rax
movl 0x28(%r12), %ecx
movq (%rax,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%rbx), %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee6
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_is_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 0x6239b
movq 0x8(%rsi), %rax
movzbl 0x2(%rax), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
cmpq 0x188(%rdi), %rsi
jne 0x623b0
movq 0x120(%rdi), %rax
cmpq %rax, %rsi
je 0x623ee
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 0xb927a(%rip), %rax     # 0x11b657
movq %rax, 0x10(%r8)
movq $0x6, 0x8(%r8)
jmp 0xfa261
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x190(%rdi), %rax
movq 0x8(%rsi), %r12
cmpb $0x22, (%r12)
jne 0x62439
movq 0x8(%r12), %rcx
cmpb $0x1, 0x2(%rcx)
jne 0x62571
cmpq 0x120(%rbx), %r12
je 0x62571
testb $0x40, 0x3(%r12)
je 0x62587
cmpb $0x1, 0x24c(%rbx)
jne 0x62587
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8a63
movq 0x14b8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x62587
cmpb $0x1, (%r15)
jne 0x625b0
movq %rax, (%rsp)
movq %r15, 0x4c8(%rbx)
movq 0x8(%r15), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x624c8
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %r13, 0x8(%r12)
movq %rbp, 0x10(%r12)
movq %r12, 0x4e8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x62556
movq %r12, %r13
movq 0x8(%r15), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x62527
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq %rax, %r13
je 0x624fd
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq (%rsp), %rax
jmp 0x625b7
movq %r12, 0x190(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaad91(%rip), %rsi     # 0x10d31f
leaq 0xb89f0(%rip), %r8      # 0x11af85
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd4e5
movq 0x110(%rbx), %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee6
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_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
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq (%r15), %r13
btl $0x1e, %r13d
jae 0x62719
cmpb $0x1, 0x24c(%rbx)
jne 0x62719
movq %rsi, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8a63
movq 0x1710(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x62719
cmpb $0x1, (%r12)
jne 0x62785
movq %rax, (%rsp)
movq %r12, 0x4c8(%rbx)
movq 0x8(%r12), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x6266e
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %r13, 0x8(%r15)
movq %rbp, 0x10(%r15)
movq %r15, 0x4e8(%rbx)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x626fe
movq %r15, %r13
movq 0x8(%r12), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x626cd
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
movq %rax, %r13
je 0x626a2
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq (%rsp), %rax
jmp 0x6278c
cmpb $0x21, %r13b
je 0x6272d
movzbl %r13b, %eax
cmpl $0x1c, %eax
je 0x6273a
cmpl $0x14, %eax
jne 0x62734
movq 0x18(%r15), %r15
movb (%r15), %r13b
cmpb $0x1c, %r13b
jne 0x62753
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa9d4
movq 0x1710(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xe81ec(%rip), %r8      # 0x14a958
movq %rbx, %rdi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xed2a
movq 0x110(%rbx), %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee6
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_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
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpb $0x23, (%r12)
jne 0x627d3
movq 0x8(%r12), %rax
cmpb $0x0, 0x2(%rax)
je 0x62927
testb $0x40, 0x3(%r12)
je 0x628fe
cmpb $0x1, 0x24c(%rbx)
jne 0x628fe
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8a63
movq 0x14c0(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x628fe
cmpb $0x1, (%r15)
jne 0x62944
movq %rax, (%rsp)
movq %r15, 0x4c8(%rbx)
movq 0x8(%r15), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x62855
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %r13, 0x8(%r12)
movq %rbp, 0x10(%r12)
movq %r12, 0x4e8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x628e3
movq %r12, %r13
movq 0x8(%r15), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x628b4
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq %rax, %r13
je 0x6288a
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq (%rsp), %rax
jmp 0x6294b
leaq 0xaaafd(%rip), %rsi     # 0x10d402
leaq 0xb8d58(%rip), %r8      # 0x11b664
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd4e5
movq 0x170(%rbx), %rax
movq %r12, 0x170(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%rbx), %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee6