LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_unique
static s7_pointer make_unique(s7_scheme *sc, const char* name, uint64_t typ)
                {
                    s7_pointer p;
                    p = alloc_pointer(sc);
                    set_type(p, typ | T_IMMUTABLE | T_UNHEAP);
                    unique_name_length(p) = safe_strlen(name);
                    unique_name(p) = copy_string_with_length(name, unique_name_length(p));
                    return(p);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x148a0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
orq $0x1000000, %rcx        # imm = 0x1000000
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
orq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
callq 0xa430
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
callq 0x135a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: permanent_cons
static s7_pointer permanent_cons(s7_scheme *sc, s7_pointer a, s7_pointer b, uint64_t type)
    {
        s7_pointer x;
        x = alloc_pointer(sc);
#if S7_DEBUGGING
        permanent_conses++;
#endif
        set_type(x, type | T_UNHEAP);
        set_car(x, a);
        set_cdr(x, b);
        return(x);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x148a0
movq %rax, (%rsp)
movabsq $0x4000000000000000, %rcx # imm = 0x4000000000000000
orq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: initialize_op_stack
static void initialize_op_stack(s7_scheme *sc)
    {
        int32_t i;
        sc->op_stack = (s7_pointer *)malloc(OP_STACK_INITIAL_SIZE * sizeof(s7_pointer));
        sc->op_stack_size = OP_STACK_INITIAL_SIZE;
        sc->op_stack_now = sc->op_stack;
        sc->op_stack_end = (s7_pointer *)(sc->op_stack + sc->op_stack_size);
        for (i = 0; i < OP_STACK_INITIAL_SIZE; i++)
            sc->op_stack[i] = sc->nil;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x40, %edi
callq 0x9480
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x10(%rsp), %rax
movl $0x8, 0x78(%rax)
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x68(%rax)
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rcx
movq 0x10(%rsp), %rax
movl 0x78(%rax), %eax
shlq $0x3, %rax
addq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x70(%rax)
movl $0x0, 0xc(%rsp)
cmpl $0x8, 0xc(%rsp)
jge 0x60be8
movq 0x10(%rsp), %rax
movq 0x110(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x60bb6
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: init_circle_info
static shared_info *init_circle_info(s7_scheme *sc)
    {
        shared_info *ci;
        ci = (shared_info *)calloc(1, sizeof(shared_info));
        ci->size = INITIAL_SHARED_INFO_SIZE;
        ci->size2 = ci->size - 2;
        ci->objs = (s7_pointer *)malloc(ci->size * sizeof(s7_pointer));
        ci->refs = (int32_t *)calloc(ci->size, sizeof(int32_t));   /* finder expects 0 = unseen previously */
        ci->defined = (bool *)calloc(ci->size, sizeof(bool));
        ci->cycle_port = sc->F;
        ci->init_port = sc->F;
        return(ci);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, %edi
movl $0x50, %esi
callq 0x9360
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x8, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
subl $0x2, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rdi
shlq $0x3, %rdi
callq 0x9480
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rdi
movl $0x4, %esi
callq 0x9360
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x9360
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x10(%rsp), %rax
movq 0x120(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movq 0x120(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_wrap_only
static vdims_t *make_wrap_only(s7_scheme *sc) /* this makes sc->wrap_only */
                {
                    vdims_t *v;
                    v = (vdims_t *)mallocate_block(sc);
                    vdims_original(v) = sc->F;
                    vector_elements_should_be_freed(v) = false;
                    vdims_rank(v) = 1;
                    vdims_dims(v) = NULL;
                    vdims_offsets(v) = NULL;
                    return(v);
                }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11020
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x120(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0xc(%rax)
movq 0x8(%rsp), %rax
movq $0x1, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: init_wrappers
static void init_wrappers(s7_scheme *sc)
                {
                    int32_t i;
                    sc->integer_wrapper1 = make_integer_wrapper();
                    sc->integer_wrapper2 = make_integer_wrapper();
                    sc->integer_wrapper3 = make_integer_wrapper();
                    sc->real_wrapper1 = make_real_wrapper();
                    sc->real_wrapper2 = make_real_wrapper();
                    sc->real_wrapper3 = make_real_wrapper();
                    sc->real_wrapper4 = make_real_wrapper();

                    sc->string_wrappers = (s7_pointer *)malloc(NUM_STRING_WRAPPERS * sizeof(s7_pointer));
                    sc->string_wrapper_pos = 0;
                    for (i = 0; i < NUM_STRING_WRAPPERS; i++)
                    {
                        s7_pointer p;
                        p = (s7_pointer)calloc(1, sizeof(s7_cell));
                        sc->string_wrappers[i] = p;
                        typeflag(p) = T_STRING | T_IMMUTABLE | T_SAFE_PROCEDURE | T_UNHEAP;
                        string_block(p) = NULL;
                        string_value(p) = NULL;
                        string_length(p) = 0;
                        string_hash(p) = 0;
                    }
                }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x1b99b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1f00(%rax)
callq 0x1b99b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1f08(%rax)
callq 0x1b99b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1f10(%rax)
callq 0x1b99e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1f18(%rax)
callq 0x1b99e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1f20(%rax)
callq 0x1b99e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1f28(%rax)
callq 0x1b99e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1f30(%rax)
movl $0x40, %edi
callq 0x9480
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x820(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x7dc(%rax)
movl $0x0, 0xc(%rsp)
cmpl $0x8, 0xc(%rsp)
jge 0x61419
movl $0x1, %edi
movl $0x30, %esi
callq 0x9360
movq %rax, (%rsp)
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x820(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
movabsq $0x4000000001200013, %rcx # imm = 0x4000000001200013
movq %rcx, (%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x61395
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: define_bool_function
static s7_pointer define_bool_function(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int optional_args, const char *doc, s7_pointer signature, int32_t sym_to_type,
                        void (*marker)(s7_pointer p, s7_int top),
                        bool simple, s7_function bool_setter)
                {
                    s7_pointer func, sym;
                    func = s7_make_typed_function(sc, name, fnc, 1, optional_args, false, doc, signature);
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    if (sym_to_type != T_FREE)
                        symbol_set_type(sym, sym_to_type);
                    c_function_symbol(func) = sym;
                    c_function_set_marker(func, marker);
                    if (simple) c_function_set_has_simple_elements(func);
                    c_function_set_bool_setter(func, s7_make_function(sc, name, bool_setter, 2, 0, false, NULL));
                    c_function_set_has_bool_setter(func);
                    return(sym);
                }

// Assembly:
subq $0x58, %rsp
movq 0x78(%rsp), %rax
movb 0x70(%rsp), %al
movq 0x68(%rsp), %r10
movl 0x60(%rsp), %r10d
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r10
movq 0x28(%rsp), %rax
movl $0x1, %ecx
xorl %r9d, %r9d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x39720
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xb400
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movq 0x50(%rsp), %rax
movq 0x110(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x10090
cmpl $0x0, 0x60(%rsp)
je 0x61e16
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
andq $-0x100, %rcx
movl 0x60(%rsp), %eax
andl $0xff, %eax
cltq
orq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x58(%rax)
movq 0x68(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x60(%rax)
testb $0x1, 0x27(%rsp)
je 0x61e54
movq 0x18(%rsp), %rax
movzwl 0x6(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movw %cx, 0x6(%rax)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x78(%rsp), %rdx
movl $0x2, %ecx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
movq $0x0, (%rsp)
callq 0x39300
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x50(%rax)
movq 0x18(%rsp), %rax
movzwl 0x6(%rax), %ecx
orl $0x2, %ecx
movw %cx, 0x6(%rax)
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_symbol_vector
static void mark_symbol_vector(s7_pointer p, s7_int len)
    {
        set_mark(p);
        if (mark_function[T_SYMBOL] != mark_noop) /* else no gensyms */
        {
            s7_int i;
            s7_pointer *e;
            e = vector_elements(p);
            for (i = 0; i < len; i++)
                if (is_gensym(e[i]))
                    set_mark(e[i]);
        }
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
leaq 0x5efba(%rip), %rax     # 0xc0f30
cmpq %rax, 0x1b4373(%rip)    # 0x2162f0
je 0x61ff1
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x10(%rsp), %rax
jge 0x61fef
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0x61fdd
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x61fdf
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x61f96
jmp 0x61ff1
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_vector_1
static void mark_vector_1(s7_pointer p, s7_int top)
    {
        s7_pointer *tp, *tend, *tend4;

        set_mark(p);

        tp = (s7_pointer *)(vector_elements(p));
        if (!tp) return;
        tend = (s7_pointer *)(tp + top);

        tend4 = (s7_pointer *)(tend - 8);
        while (tp <= tend4)
            LOOP_8(gc_mark(*tp++));
        while (tp < tend)
            gc_mark(*tp++);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x626ee
jmp 0x62818
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $-0x40, %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
cmpq (%rsp), %rax
ja 0x627ef
jmp 0x62722
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
jmp 0x62711
jmp 0x627f1
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x62818
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
jmp 0x627f1
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_is_openlet
static s7_pointer g_is_openlet(s7_scheme *sc, s7_pointer args)
    {
#define H_is_openlet "(openlet? obj) returns #t is 'obj' has methods."
#define Q_is_openlet sc->pl_bt
        s7_pointer e;

        e = car(args);  /* if e is not a let, should this raise an error? -- no, easier to use this way in cond */
        check_method(sc, e, sc->is_openlet_symbol, args);
        return(make_boolean(sc, has_methods(e)));
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x629c7
movq 0x38(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x629c7
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x9a10
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rax
movq 0x1130(%rax), %rdx
callq 0x98d0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x629c7
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x44270
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x40(%rsp)
jmp 0x62a06
movq 0x28(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x629ed
movq 0x38(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, (%rsp)
jmp 0x629fd
movq 0x38(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_is_c_pointer
static s7_pointer g_is_c_pointer(s7_scheme *sc, s7_pointer args)
    {
#define H_is_c_pointer "(c-pointer? obj type) returns #t if obj is a C pointer being held in s7.  If type is given, the c_pointer's type is also checked."
#define Q_is_c_pointer s7_make_signature(sc, 3, sc->is_boolean_symbol, sc->T, sc->T)

        s7_pointer p;
        p = car(args);
        if (!is_c_pointer(p))
        {
            if (!has_active_methods(sc, p)) return(sc->F);
            return(apply_boolean_method(sc, p, sc->is_c_pointer_symbol));
        }
        if (is_pair(cdr(args)))
            return(make_boolean(sc, c_pointer_type(p) == cadr(args)));
        return(sc->T);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x21, %eax
je 0x62f33
movq 0x8(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x62efb
movq 0x18(%rsp), %rax
testb $0x1, 0x24c(%rax)
jne 0x62f11
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x62f9a
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1000(%rax), %rdx
callq 0x147b20
movq %rax, 0x20(%rsp)
jmp 0x62f9a
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x62f89
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0x62f6e
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, (%rsp)
jmp 0x62f7e
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x62f9a
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_simple_vector
static void mark_simple_vector(s7_pointer p, s7_int len)
    {
        s7_int i;
        s7_pointer *e;
        set_mark(p);
        e = vector_elements(p);
        for (i = 0; i < len; i++)
            set_mark(e[i]);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x10(%rsp), %rax
jge 0x63320
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x632e6
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: b_is_proper_list_setter
static s7_pointer b_is_proper_list_setter(s7_scheme *sc, s7_pointer args)
                {
                    if (s7_is_proper_list(sc, car(args)))
                        return(cadr(args));
                    return(s7_error(sc, sc->wrong_type_arg_symbol,
                                set_elist_5(sc, wrap_string(sc, "set! ~S, ~S is ~A but should be ~A", 34),
                                    car(args), cadr(args), prepackaged_type_names[type(cadr(args))], wrap_string(sc, "a proper list", 13))));
                }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x31a40
testb $0x1, %al
jne 0x65817
jmp 0x6582e
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0x658fe
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq 0x1940(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x18dbaf(%rip), %rsi    # 0x1f340e
movl $0x22, %edx
callq 0xb880
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1b4ce9(%rip), %rax    # 0x21a590
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x18bf4a(%rip), %rsi    # 0x1f1806
movl $0xd, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq %rax, %r9
callq 0xd71e0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_is_c_object
static s7_pointer g_is_c_object(s7_scheme *sc, s7_pointer args)
                {
#define H_is_c_object "(c-object? obj) returns #t is obj is a c-object."
#define Q_is_c_object sc->pl_bt
                    s7_pointer obj;
                    obj = car(args);
                    if (is_c_object(obj)) return(sc->T);
                    if (!has_active_methods(sc, obj)) return(sc->F);
                    return(apply_boolean_method(sc, obj, sc->is_c_object_symbol));
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x14, %eax
jne 0x65fcc
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x66021
movq 0x8(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x65fee
movq 0x18(%rsp), %rax
testb $0x1, 0x24c(%rax)
jne 0x66001
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x66021
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xff0(%rax), %rdx
callq 0x147b20
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_to_string
static s7_pointer g_symbol_to_string(s7_scheme *sc, s7_pointer args)
    {
#define H_symbol_to_string "(symbol->string sym) returns the symbol sym converted to a string"
#define Q_symbol_to_string s7_make_signature(sc, 2, sc->is_string_symbol, sc->is_symbol_symbol)
        s7_pointer sym;

        sym = car(args);
        if (!is_symbol(sym))
            return(method_or_bust_one_arg(sc, sym, sc->symbol_to_string_symbol, args, T_SYMBOL));
        /* s7_make_string uses strlen which stops at an embedded null */
        return(make_string_with_length(sc, symbol_name(sym), symbol_name_length(sym)));    /* return a copy */
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x66af6
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x15c0(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0xa, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x66b1f
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
callq 0x144d0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x67257
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xfc80
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x67255
movq (%rsp), %rax
movq (%rax), %rcx
orq $0x1000000, %rcx        # imm = 0x1000000
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x67266
jmp 0x67257
movq 0x8(%rsp), %rdi
callq 0x9c90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x67389
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0x1300(%rax), %rdx
movq 0x20(%rsp), %rcx
movl $0x13, %r8d
callq 0xcfd30
movq %rax, 0x30(%rsp)
jmp 0x67422
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x673a6
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6740a
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x1948(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0x18c0de(%rip), %rsi    # 0x1f34b4
movl $0x2b, %edx
callq 0xb880
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0xb830
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x30(%rsp)
jmp 0x67422
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x104a0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x67537
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x1208(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x17c973(%rip), %rsi    # 0x1e3e7d
movl $0x9, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %rax, %r8
callq 0x1ba7e0
movq %rax, 0x40(%rsp)
jmp 0x6754d
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
je 0x675b2
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rcx
leaq 0x18c9e9(%rip), %rsi    # 0x1f3f83
movl $0x1, %edx
leaq 0x187849(%rip), %r8     # 0x1eedef
callq 0x12540
movq %rax, 0x20(%rsp)
jmp 0x675fd
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x150(%rcx), %rax
je 0x675dc
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x675ef
movq 0x18(%rsp), %rax
movq 0x150(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x675fd
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_curlet
static s7_pointer g_curlet(s7_scheme *sc, s7_pointer args)
    {
#define H_curlet "(curlet) returns the current definitions (symbol bindings)"
#define Q_curlet s7_make_signature(sc, 1, sc->is_let_symbol)

        sc->capture_let_counter++;
        if (is_let(sc->envir))
            return(sc->envir);
        return(sc->rootlet);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x240(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x240(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0x67672
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x67683
movq -0x10(%rsp), %rax
movq 0x150(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq 0x68(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x67845
movq 0x68(%rsp), %rax
movq 0x150(%rax), %rax
movq %rax, 0x58(%rsp)
jmp 0x67a07
movq 0x58(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x678f3
movq 0x68(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x678f3
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x9a10
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movq 0x68(%rsp), %rax
movq 0x1578(%rax), %rdx
callq 0x98d0
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x678f3
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x44270
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x70(%rsp)
jmp 0x67a30
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
je 0x67a05
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rax
movq 0x1578(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x1, 0x48(%rsp)
movq 0x48(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x67953
movq 0x48(%rsp), %rcx
leaq 0x1aeb37(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x679c9
jmp 0x67955
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x67979
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0xb, (%rax)
movq 0x48(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x68(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x1b2a8f(%rip), %r9     # 0x21a488
callq 0xc560
movq %rax, 0x70(%rsp)
jmp 0x67a30
jmp 0x67a07
movq 0x68(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x68(%rsp), %rax
movq 0x1578(%rax), %rcx
callq 0xc730
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x150(%rcx), %rax
je 0x69802
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x6985a
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0xea8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
leaq 0x189cfc(%rip), %rsi    # 0x1f352e
movl $0x15, %edx
callq 0xb880
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc3820
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x9a10
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
je 0x698b7
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x13b0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x28(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1b0be0(%rip), %r8     # 0x21a488
callq 0x14a60
movq %rax, 0x40(%rsp)
jmp 0x6993e
movq 0x28(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x69922
movq 0x38(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x69922
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0x13b0(%rax), %rdx
callq 0x98d0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x69922
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0xda50
movq %rax, 0x40(%rsp)
jmp 0x6993e
movq 0x28(%rsp), %rax
movq (%rax), %rcx
orq $0x40000000, %rcx       # imm = 0x40000000
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1d, %eax
je 0x69cb6
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x11c8(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1d, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x69cd0
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_iterator_sequence
static s7_pointer g_iterator_sequence(s7_scheme *sc, s7_pointer args)
    {
#define H_iterator_sequence "(iterator-sequence iterator) returns the sequence that iterator is traversing."
#define Q_iterator_sequence s7_make_signature(sc, 2, sc->is_sequence_symbol, sc->is_iterator_symbol)

        s7_pointer iter;

        iter = car(args);
        if (!is_iterator(iter))
            return(method_or_bust_one_arg(sc, iter, sc->iterator_sequence_symbol, args, T_ITERATOR));
        return(iterator_sequence(iter));
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1d, %eax
je 0x69d36
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x11d8(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1d, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x69d44
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movabsq $0x80000000, %rax       # imm = 0x80000000
andq (%rcx), %rax
cmpq $0x0, %rax
je 0x69d97
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x69de2
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1d, %eax
je 0x69dd1
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x11d0(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1d, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x69de2
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
je 0x6a10e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x6a10e
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0xea8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1894a0(%rip), %rsi    # 0x1f357d
movl $0x34, %edx
callq 0xb880
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0xb830
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x2b090
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x14, %eax
jne 0x6a6ed
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x6a662
movq 0x20(%rsp), %rcx
leaq 0x1abe28(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x6a6d8
jmp 0x6a664
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x6a688
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0xb, (%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x6a71b
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0xff8(%rax), %rdx
movq 0x30(%rsp), %rcx
movl $0x14, %r8d
xorl %r9d, %r9d
callq 0x13c50
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x21, %eax
je 0x6aa3c
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xc58(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x21, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x20(%rsp)
jmp 0x6aa82
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x120f0
movq (%rsp), %rdi
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %r8
movl $0x3, %esi
movb $0x0, %al
callq 0x320e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x6aaf1
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
je 0x6aaf1
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rcx
leaq 0x179fe2(%rip), %rsi    # 0x1e4ab9
xorl %eax, %eax
movl %eax, %edx
leaq 0x188ad0(%rip), %r8     # 0x1f35b2
callq 0x12540
movq %rax, 0x30(%rsp)
jmp 0x6ab9c
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x6ab28
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rcx
leaq 0x179fa8(%rip), %rsi    # 0x1e4ab9
xorl %eax, %eax
movl %eax, %edx
leaq 0x18831b(%rip), %r8     # 0x1f2e37
callq 0x12540
movq %rax, 0x30(%rsp)
jmp 0x6ab9c
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x6ab89
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x188a5a(%rip), %rsi    # 0x1f35b9
callq 0xa240
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rcx
callq 0x107d0
movq %rax, 0x30(%rsp)
jmp 0x6ab9c
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x108a0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)