LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: float_vector_fill
static void float_vector_fill(s7_scheme *sc, s7_pointer vec, s7_double x)
                {
                    s7_int len;
                    len = vector_length(vec);
                    if (len == 0) return;
                    if (x == 0.0)
                    {
                        if (STEP_8(len))
                            memclr64((void *)float_vector_floats(vec), len * sizeof(s7_double));
                        else memclr((void *)float_vector_floats(vec), len * sizeof(s7_double));
                    }
                    else
                    {
                        s7_int i, left;
                        s7_double *orig;
                        left = len - 8;
                        i = 0;
                        orig = float_vector_floats(vec);
                        while (i <= left)
                            LOOP_8(orig[i++] = x);
                        for (; i < len; i++)
                            orig[i] = x;
                    }
                }

// Assembly:
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x7afdb
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7af9a
jp 0x7af9a
movl %esi, %eax
shlq $0x3, %rsi
movq 0x10(%rdi), %rdi
testb $0x7, %al
je 0x7ae55
jmp 0x78377
leaq -0x8(%rsi), %rdx
movq 0x10(%rdi), %rax
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
xorl %ecx, %ecx
cmpq %rdx, %rcx
jg 0x7afd6
movupd %xmm1, (%rax,%rcx,8)
movupd %xmm1, 0x10(%rax,%rcx,8)
movupd %xmm1, 0x20(%rax,%rcx,8)
movupd %xmm1, 0x30(%rax,%rcx,8)
addq $0x8, %rcx
jmp 0x7afac
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rsi, %rcx
jl 0x7afce
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: int_vector_fill
static void int_vector_fill(s7_scheme *sc, s7_pointer vec, s7_int k)
                {
                    s7_int len;
                    len = vector_length(vec);
                    if (len == 0) return;
                    if (k == 0)
                    {
                        if (STEP_8(len))
                            memclr64((void *)int_vector_ints(vec), len * sizeof(s7_int));
                        else memclr((void *)int_vector_ints(vec), len * sizeof(s7_int));
                    }
                    else
                    {
                        s7_int i, left;
                        s7_int* orig;
                        left = len - 8;
                        i = 0;
                        orig = int_vector_ints(vec);
                        while (i <= left)
                            LOOP_8(orig[i++] = k);
                        for (; i < len; i++)
                            orig[i] = k;
                    }
                }

// Assembly:
movq %rsi, %rax
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x7b035
testq %rax, %rax
je 0x7b036
leaq -0x8(%rsi), %r8
movq 0x10(%rdi), %rcx
xorl %edx, %edx
cmpq %r8, %rdx
jg 0x7b030
movq %rax, (%rcx,%rdx,8)
movq %rax, 0x8(%rcx,%rdx,8)
movq %rax, 0x10(%rcx,%rdx,8)
movq %rax, 0x18(%rcx,%rdx,8)
movq %rax, 0x20(%rcx,%rdx,8)
movq %rax, 0x28(%rcx,%rdx,8)
movq %rax, 0x30(%rcx,%rdx,8)
movq %rax, 0x38(%rcx,%rdx,8)
addq $0x8, %rdx
jmp 0x7aff7
movq %rax, (%rcx,%rdx,8)
incq %rdx
cmpq %rsi, %rdx
jl 0x7b029
retq
movl %esi, %eax
shlq $0x3, %rsi
movq 0x10(%rdi), %rdi
testb $0x7, %al
je 0x7ae55
jmp 0x78377
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: make_type_name
static const char *make_type_name(s7_scheme *sc, const char *name, article_t article)
                {
                    s7_int i, slen, len;

                    slen = safe_strlen(name);
                    len = slen + 8;
                    if (len > sc->typnam_len)
                    {
                        if (sc->typnam) free(sc->typnam);
                        sc->typnam = (char *)malloc(len);
                        sc->typnam_len = len;
                    }
                    if (article == INDEFINITE_ARTICLE)
                    {
                        i = 1;
                        sc->typnam[0] = 'a';
                        if ((name[0] == 'a') || (name[0] == 'e') || (name[0] == 'i') || (name[0] == 'o') || (name[0] == 'u'))
                            sc->typnam[i++] = 'n';
                        sc->typnam[i++] = ' ';
                    }
                    else i = 0;
                    memcpy((void *)(sc->typnam + i), (void *)name, slen);
                    sc->typnam[i + slen] = '\0';
                    return(sc->typnam);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8d06
movq %rax, %r14
leaq 0x8(%rax), %r12
movslq 0x480(%rbx), %rax
cmpq %rax, %r12
jle 0x7b09a
movq 0x478(%rbx), %rdi
callq 0x8050
movq %r12, %rdi
callq 0x8480
movq %rax, 0x478(%rbx)
movl %r12d, 0x480(%rbx)
cmpl $0x1, %ebp
jne 0x7b0e5
movq 0x478(%rbx), %rax
movb $0x61, (%rax)
movb (%r15), %al
addb $-0x61, %al
rorb %al
pushq $0x1
popq %r12
cmpb $0xa, %al
ja 0x7b0d4
movzbl %al, %eax
movl $0x495, %ecx            # imm = 0x495
btl %eax, %ecx
jae 0x7b0d4
movq 0x478(%rbx), %rax
movb $0x6e, 0x1(%rax)
pushq $0x2
popq %r12
movq 0x478(%rbx), %rax
movb $0x20, (%rax,%r12)
incq %r12
jmp 0x7b0e8
xorl %r12d, %r12d
movq 0x478(%rbx), %rdi
addq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x83e0
addq 0x478(%rbx), %r12
movb $0x0, (%r14,%r12)
movq 0x478(%rbx), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: typed_vector_typer_name
static const char *typed_vector_typer_name(s7_scheme *sc, s7_pointer p)
                {
                    s7_pointer typer;
                    typer = typed_vector_typer(p);
                    if (is_c_function(typer))
                        return(c_function_name(typer));
                    return(symbol_name(typed_vector_typer_symbol(sc, p)));
                }

// Assembly:
pushq %rax
movq 0x28(%rsi), %rax
cmpb $0x30, (%rax)
jb 0x7b129
movq 0x8(%rax), %rax
jmp 0x7b136
callq 0x7b13b
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: typed_vector_typer_symbol
static s7_pointer typed_vector_typer_symbol(s7_scheme *sc, s7_pointer p)
                {
                    s7_pointer typer;
                    typer = typed_vector_typer(p);
                    if (is_c_function(typer))
                        return(c_function_symbol(typer));
                    return(find_closure(sc, typer, closure_let(typer)));
                }

// Assembly:
movq 0x28(%rsi), %rsi
cmpb $0x30, (%rsi)
jb 0x7b14d
movq 0x8(%rsi), %rax
movq 0x58(%rax), %rax
retq
movq 0x18(%rsi), %rdx
jmp 0x7b153
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: find_closure
static s7_pointer find_closure(s7_scheme *sc, s7_pointer closure, s7_pointer cur_env)
    {
        s7_pointer e, y;
        for (e = cur_env; is_let(e); e = outlet(e))
        {
            if (is_funclet(e))
            {
                s7_pointer sym, f;
                sym = funclet_function(e);
                f = s7_symbol_local_value(sc, sym, e);
                if (f == closure)
                    return(sym);
            }

            for (y = let_slots(e); tis_slot(y); y = next_slot(y))
                if (slot_value(y) == closure)
                    return(slot_symbol(y));
        }
        return(sc->nil);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x1c, (%r14)
jne 0x7b1bc
testb $0x20, 0x3(%r14)
je 0x7b188
movq 0x20(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xb072
cmpq %r15, %rax
je 0x7b1ad
leaq 0x8(%r14), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x7b1a0
cmpq %r15, 0x10(%rax)
je 0x7b1a6
addq $0x18, %rax
jmp 0x7b18c
movq 0x10(%r14), %r14
jmp 0x7b164
addq $0x8, %rax
movq (%rax), %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %rax
jmp 0x7b1aa
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: make_multivector
static inline s7_pointer make_multivector(s7_scheme *sc, s7_pointer vec, s7_pointer x)
                {
                    vdims_t *v;
                    v = list_to_dims(sc, x);
                    vdims_original(v) = sc->F;
                    vector_set_dimension_info(vec, v);
                    add_multivector(sc, vec);
                    return(vec);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x7b414
movq 0x120(%r14), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq 0x790(%r14), %rdi
movq %rbx, %rsi
callq 0xb999
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: list_to_dims
static inline vdims_t *list_to_dims(s7_scheme *sc, s7_pointer x)
                {
                    s7_int i, offset, len;
                    s7_pointer y;
                    vdims_t *v;
                    s7_int *ds, *os;

                    len = safe_list_length(x);
                    v = (vdims_t *)mallocate(sc, len * 2 * sizeof(s7_int));
                    vdims_rank(v) = len;
                    vdims_offsets(v) = (s7_int *)(vdims_dims(v) + len);
                    vector_elements_should_be_freed(v) = false;
                    ds = vdims_dims(v);
                    os = vdims_offsets(v);

                    for (i = 0, y = x; is_not_null(y); i++, y = cdr(y))
                        ds[i] = s7_integer(car(y));

                    for (i = len - 1, offset = 1; i >= 0; i--)
                    {
                        os[i] = offset;
                        offset *= ds[i];
                    }
                    return(v);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x313be
movq %rax, %rbx
movq %rax, %r14
shlq $0x4, %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x9037
movq %rbx, 0x10(%rax)
movq (%rax), %rcx
leaq (%rcx,%rbx,8), %rdx
movq %rdx, 0x18(%rax)
movb $0x0, 0xc(%rax)
movq 0x110(%r12), %rdx
movq %rcx, %rsi
cmpq %rdx, %r15
je 0x7b480
movq 0x8(%r15), %rdi
cmpb $0xb, (%rdi)
jne 0x7b471
movq 0x8(%rdi), %rdi
jmp 0x7b473
xorl %edi, %edi
movq %rdi, (%rsi)
movq 0x10(%r15), %r15
addq $0x8, %rsi
jmp 0x7b45d
pushq $0x1
popq %rdx
testq %rbx, %rbx
jle 0x7b49c
movq %rdx, -0x8(%rcx,%r14)
imulq -0x8(%rcx,%rbx,8), %rdx
decq %rbx
addq $-0x8, %r14
jmp 0x7b483
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: hash_float_location
static s7_int hash_float_location(s7_double x)
                {
#if defined(__clang__)
                    if (is_NaN(x)) return(0);
#endif
                    x = fabs(x);
                    if (x < 100.0)
                        return(1000.0 * x);     /* this means hash_table_float_epsilon only works if it is less than about .001 */
                    return((s7_int)x);
                }

// Assembly:
ucomisd %xmm0, %xmm0
jp 0x7b4dc
andpd 0x5aa0a(%rip), %xmm0    # 0xd5ec0
movsd 0x56c42(%rip), %xmm1    # 0xd2100
ucomisd %xmm0, %xmm1
jbe 0x7b4d6
movsd 0x56c3c(%rip), %xmm1    # 0xd2108
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
retq
cvttsd2si %xmm0, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: hash_float_1
static hash_entry_t *hash_float_1(s7_scheme *sc, s7_pointer table, s7_int loc, s7_double keyval)
                {
                    hash_entry_t *x;
                    if (is_NaN(keyval))
                    {
                        for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                            if ((is_t_real(hash_entry_key(x))) &&       /* we're possibly called from hash_equal, so keys might not be T_REAL */
                                    (is_NaN(real(hash_entry_key(x)))))
                                return(x);
                    }
                    else
                    {
                        for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                            if (is_t_real(hash_entry_key(x)))
                            {
                                s7_double val;
                                val = real(hash_entry_key(x));
                                if ((val == keyval) ||                  /* inf case */
                                        (fabs(val - keyval) < sc->hash_table_float_epsilon))
                                    return(x);
                            }
                    }
                    return(sc->unentry);
                }

// Assembly:
movq %rdx, %rax
shlq $0x3, %rax
addq 0x10(%rsi), %rax
ucomisd %xmm0, %xmm0
jp 0x7b548
movapd 0x5a9c8(%rip), %xmm1    # 0xd5ec0
movq (%rax), %rax
testq %rax, %rax
je 0x7b550
movq (%rax), %rcx
cmpb $0xd, (%rcx)
jne 0x7b52b
movsd 0x8(%rcx), %xmm2
ucomisd %xmm0, %xmm2
jne 0x7b515
jnp 0x7b557
subsd %xmm0, %xmm2
andpd %xmm1, %xmm2
movsd 0x268(%rdi), %xmm3
ucomisd %xmm2, %xmm3
ja 0x7b557
addq $0x18, %rax
jmp 0x7b4f8
movq (%rax), %rcx
cmpb $0xd, (%rcx)
jne 0x7b544
movsd 0x8(%rcx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x7b557
addq $0x18, %rax
movq (%rax), %rax
testq %rax, %rax
jne 0x7b531
movq 0x490(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: hash_table_typer_symbol
static s7_pointer hash_table_typer_symbol(s7_scheme *sc, s7_pointer typer)
                {
                    if (typer == sc->T)
                        return(sc->T);
                    if (is_c_function(typer))
                        return(c_function_symbol(typer));
                    return(find_closure(sc, typer, closure_let(typer)));
                }

// Assembly:
movq 0x118(%rdi), %rax
cmpq %rsi, %rax
je 0x7b597
cmpb $0x30, (%rsi)
jb 0x7b598
movq 0x8(%rsi), %rax
movq 0x58(%rax), %rax
retq
movq 0x18(%rsi), %rdx
jmp 0x7b153
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: apply_error
static s7_pointer apply_error(s7_scheme *sc, s7_pointer obj, s7_pointer args)
                {
                    /* the operator type is needed here else the error message is confusing:
                     *    (apply '+ (list 1 2))) -> ;attempt to apply + to (1 2)?
                     */
                    if (is_null(obj))
                        return(s7_error(sc, sc->syntax_error_symbol,
                                    set_elist_3(sc, wrap_string(sc, "attempt to apply nil to ~S in ~S?", 33),
                                        args, current_code(sc))));
                    return(s7_error(sc, sc->syntax_error_symbol,
                                set_elist_5(sc, wrap_string(sc, "attempt to apply ~A ~S to ~S in ~S?", 35),
                                    type_name_string(sc, obj), obj, args, current_code(sc))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movslq 0x7dc(%rdi), %rax
leal 0x1(%rax), %ecx
andl $0x7, %ecx
movq 0x1918(%rdi), %r15
movq 0x820(%rdi), %rdx
movq (%rdx,%rax,8), %r13
cmpq %rsi, 0x110(%rdi)
movl %ecx, 0x7dc(%rdi)
je 0x7b623
movq %rsi, %r12
leaq 0x67c17(%rip), %rax     # 0xe31ff
movq %rax, 0x10(%r13)
movq $0x23, 0x8(%r13)
movq %rbx, %rdi
callq 0x35a1a
movq 0x28(%rbx), %rcx
leaq 0x6f8(%rbx), %rdx
movq 0x6f8(%rbx), %rsi
movq %r13, 0x8(%rsi)
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
addq $0x10, %rsi
movq %r12, %r13
jmp 0x7b644
leaq 0x67bb3(%rip), %rax     # 0xe31dd
movq %rax, 0x10(%r13)
movq $0x21, 0x8(%r13)
movq 0x28(%rbx), %rcx
leaq 0x6e8(%rbx), %rsi
movq %rsi, %rdx
movq (%rsi), %rax
movq %r13, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq (%rdx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2cdc0
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: closure_star_arity_1
static void closure_star_arity_1(s7_scheme *sc, s7_pointer x, s7_pointer args)
                {
                    if (closure_arity_unknown(x))
                    {
                        if (is_null(args))
                            closure_set_arity(x, 0);
                        else
                        {
                            if ((is_symbol(args)) || (allows_other_keys(args)))
                                closure_set_arity(x, -1);
                            else
                            {
                                s7_pointer p;
                                int32_t i;
                                for (i = 0, p = args; is_pair(p); p = cdr(p)) /* is_pair(p) so (f1 a . b) will end with b not null */
                                {
                                    s7_pointer arg;
                                    arg = car(p);
                                    if (arg == sc->key_rest_symbol)
                                        break;
                                    i++;
                                }
                                if (is_null(p))
                                    closure_set_arity(x, i);
                                else closure_set_arity(x, -1); /* see below */
                            }
                        }
                    }
                }

// Assembly:
cmpl $0x40000000, 0x28(%rsi) # imm = 0x40000000
jne 0x7b6ce
movq 0x110(%rdi), %rax
cmpq %rdx, %rax
je 0x7b6ba
pushq $-0x1
popq %r8
cmpb $0xa, (%rdx)
je 0x7b6ca
movq (%rdx), %r9
btl $0x19, %r9d
jb 0x7b6ca
xorl %ecx, %ecx
cmpb $0x1, %r9b
jne 0x7b6bf
movq 0x8(%rdx), %r8
cmpq 0x1890(%rdi), %r8
je 0x7b6bf
incl %ecx
movq 0x10(%rdx), %rdx
movb (%rdx), %r9b
jmp 0x7b69c
xorl %r8d, %r8d
jmp 0x7b6ca
cmpq %rax, %rdx
pushq $-0x1
popq %r8
cmovel %ecx, %r8d
movl %r8d, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: add_setter
static void add_setter(s7_scheme *sc, s7_pointer p, s7_pointer setter)
    {
        /* setters GC-protected. The c_function_setter field can't be used because the built-in functions
         *   are often removed from the heap and never thereafter marked.  Only closures and macros are protected here.
         */
        s7_int i;
#if S7_DEBUGGING
        if ((!is_any_closure(setter)) && (!is_any_macro(setter)))
            fprintf(stderr, "add_setter: %s %d?\n", DISPLAY(setter), type(setter));
#endif
        for (i = 0; i < sc->setters_loc; i++)
        {
            s7_pointer x;
            x = sc->setters[i];
            if (car(x) == p)
            {
                set_cdr(x, setter);
                return;
            }
        }
        if (sc->setters_loc == sc->setters_size)
        {
            sc->setters_size *= 2;
            sc->setters = (s7_pointer *)realloc(sc->setters, sc->setters_size * sizeof(s7_pointer));
        }
        sc->setters[sc->setters_loc++] = permanent_cons(sc, p, setter, T_PAIR | T_IMMUTABLE);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x7c0(%rdi), %rsi
xorl %eax, %eax
testq %rsi, %rsi
movl $0x0, %ecx
cmovgq %rsi, %rcx
cmpq %rax, %rcx
je 0x7b711
movq 0x7b0(%rbx), %rdx
movq (%rdx,%rax,8), %rdx
incq %rax
cmpq %r15, 0x8(%rdx)
jne 0x7b6f2
movq %r14, 0x10(%rdx)
jmp 0x7b776
cmpq 0x7b8(%rbx), %rsi
jne 0x7b73c
leaq (%rsi,%rsi), %rax
movq %rax, 0x7b8(%rbx)
movq 0x7b0(%rbx), %rdi
shlq $0x4, %rsi
callq 0x8510
movq %rax, 0x7b0(%rbx)
movq %rbx, %rdi
callq 0xd35f
movabsq $0x4000000001000001, %rcx # imm = 0x4000000001000001
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0x7b0(%rbx), %rcx
movq 0x7c0(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x7c0(%rbx)
movq %rax, (%rcx,%rdx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: copy_body
static s7_pointer copy_body(s7_scheme *sc, s7_pointer p)
    {
        sc->w = p;
        if (tree_is_cyclic(sc, p))
            s7_error(sc, sc->wrong_type_arg_symbol, wrap_string(sc, "copy: tree is cyclic", 20));
        check_heap_size(sc, tree_len(sc, p) * 2);
        if (sc->safety > NO_SAFETY)
            sc->w = copy_tree_with_type(sc, p);
        else sc->w = copy_tree(sc, p);
        p = sc->w;
        sc->w = sc->nil;
        return(p);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x4d8(%rdi)
callq 0x2cd63
testb %al, %al
je 0x7b7d6
movq 0x1940(%rbx), %rsi
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rdx
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0x67c2a(%rip), %rax     # 0xe33ec
movq %rax, 0x10(%rdx)
movq $0x14, 0x8(%rdx)
movq %rbx, %rdi
callq 0x2cdc0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c5fc
leaq (%rax,%rax), %rsi
movq %rbx, %rdi
callq 0x2f187
cmpq $0x0, 0x6a0(%rbx)
jle 0x7b804
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c622
jmp 0x7b80f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c76d
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: circular_list_entries
static int32_t circular_list_entries(s7_pointer lst)
    {
        int32_t i;
        s7_pointer x;
        for (i = 1, x = cdr(lst); ; i++, x = cdr(x))
        {
            int32_t j;
            s7_pointer y;
            for (y = lst, j = 0; j < i; y = cdr(y), j++)
                if (x == y)
                    return(i);
        }
    }

// Assembly:
pushq $0x1
popq %rax
movq %rdi, %rcx
movq 0x10(%rcx), %rcx
movl %eax, %edx
movq %rdi, %rsi
subl $0x1, %edx
jb 0x7b844
cmpq %rsi, %rcx
je 0x7b848
movq 0x10(%rsi), %rsi
jmp 0x7b834
incl %eax
jmp 0x7b82b
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: let_length
static s7_int let_length(s7_scheme *sc, s7_pointer e)
    {
        /* used by length, applicable_length, copy, and some length optimizations */
        s7_int i;
        s7_pointer p;

        if (e == sc->rootlet)
            return(sc->rootlet_entries);
        if (e == sc->s7_let)
            return(s7_let_length());

        if (has_active_methods(sc, e))
        {
            s7_pointer length_func;
            length_func = find_method(sc, e, sc->length_symbol);
            if (length_func != sc->undefined)
            {
                p = s7_apply_function(sc, length_func, list_1(sc, e));
                if (s7_is_integer(p))
                    return(s7_integer(p));
                return(-1); /* ?? */
            }
        }
        for (i = 0, p = let_slots(e); tis_slot(p); i++, p = next_slot(p));
        return(i);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq %rsi, 0x150(%rdi)
je 0x7b9be
movq %rsi, %rbx
cmpq %rsi, 0x2150(%r14)
je 0x7b9e1
testb $0x40, 0x3(%rbx)
je 0x7b9ca
cmpb $0x1, 0x24c(%r14)
jne 0x7b9ca
movq 0x1218(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x888f
cmpq 0x128(%r14), %rax
je 0x7b9ca
movq %rax, %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x7b987
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %rbx, 0x8(%rdx)
movq %r12, 0x10(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa34c
cmpb $0xb, (%rax)
jne 0x7b9f0
movq %rax, %r14
addq $0x8, %r14
jmp 0x7b9c5
addq $0x160, %r14            # imm = 0x160
movq (%r14), %rax
jmp 0x7b9e4
addq $0x8, %rbx
xorl %eax, %eax
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x7b9e4
incq %rax
addq $0x18, %rbx
jmp 0x7b9d0
pushq $0x2b
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $-0x1
jmp 0x7b9e3
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: start_and_end
static s7_pointer start_and_end(s7_scheme *sc, s7_pointer caller, s7_pointer args, int32_t position, s7_int *start, s7_int *end)
    {
        /* we assume that *start=0 and *end=length, that end is "exclusive", return true if the start/end points are not changed */
        s7_pointer pstart, index_args;
        s7_int i, index;

        for (i = 0, index_args = args; (i < (position - 1)) && (is_pair(index_args)); i++, index_args = cdr(index_args)) {}

        pstart = car(index_args);
        if (!s7_is_integer(pstart))
            return(method_or_bust(sc, pstart, caller, args, T_INTEGER, position));
        index = s7_integer(pstart);
        if ((index < 0) ||
                (index > *end)) /* *end == length here */
            return(out_of_range(sc, caller, small_int(position), pstart, (index < 0) ? its_negative_string : its_too_large_string));
        *start = index;

        if (is_pair(cdr(index_args)))
        {
            s7_pointer pend;
            pend = cadr(index_args);
            if (!s7_is_integer(pend))
                return(method_or_bust(sc, pend, caller, args, T_INTEGER, position + 1));
            index = s7_integer(pend);
            if ((index < *start) ||
                    (index > *end))
                return(out_of_range(sc, caller, small_int(position + 1), pend, (index < *start) ? its_too_small_string : its_too_large_string));
            *end = index;
        }
        return(sc->unused);
    }

// Assembly:
movl %ecx, %eax
movq %rdx, %rcx
movq %rsi, %rdx
leal -0x1(%rax), %r10d
movq %rcx, %rsi
subq $0x1, %r10
jb 0x7ba14
cmpb $0x1, (%rsi)
jne 0x7ba14
movq 0x10(%rsi), %rsi
jmp 0x7ba03
movq 0x8(%rsi), %r10
cmpb $0xb, (%r10)
jne 0x7bab0
movq 0x8(%r10), %r11
testq %r11, %r11
js 0x7ba30
cmpq (%r9), %r11
jle 0x7ba61
testq %r11, %r11
movq 0x8(%rdx), %rsi
movl %eax, %eax
leaq 0x99f10(%rip), %rcx     # 0x115950
movq (%rcx,%rax,8), %rdx
leaq 0x9dffd(%rip), %rax     # 0x119a48
leaq 0x9dfee(%rip), %rcx     # 0x119a40
cmovsq %rax, %rcx
movq (%rcx), %r8
movq %r10, %rcx
jmp 0xcb8f
movq %r11, (%r8)
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
jne 0x7bac2
movq 0x8(%rsi), %r10
cmpb $0xb, (%r10)
jne 0x7baae
movq 0x8(%r10), %rcx
cmpq %r11, %rcx
jl 0x7ba85
cmpq (%r9), %rcx
jle 0x7babf
cmpq %r11, %rcx
movq 0x8(%rdx), %rsi
movl %eax, %eax
leaq 0x99ebb(%rip), %rcx     # 0x115950
movq 0x8(%rcx,%rax,8), %rdx
leaq 0xa65c7(%rip), %rax     # 0x122068
leaq 0x9df98(%rip), %rcx     # 0x119a40
cmovlq %rax, %rcx
jmp 0x7ba56
incl %eax
pushq $0xb
popq %r8
movq %r10, %rsi
movl %eax, %r9d
jmp 0xcd70
movq %rcx, (%r9)
movq 0x140(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: string_setter
static s7_pointer string_setter(s7_scheme *sc, s7_pointer str, s7_int loc, s7_pointer val)
                {
                    if (s7_is_character(val))
                    {
                        string_value(str)[loc] = s7_character(val);
                        return(val);
                    }
                    set_car(sc->elist_3, wrap_string(sc, "~S: ~S is not a character", 25));
                    set_caddr(sc->elist_3, val);
                    return(s7_error(sc, sc->wrong_type_arg_symbol, sc->elist_3));
                }

// Assembly:
pushq %rbx
movq %rcx, %rbx
cmpb $0x8, (%rcx)
jne 0x7badf
movb 0x8(%rbx), %al
movq 0x10(%rsi), %rcx
movb %al, (%rcx,%rdx)
jmp 0x7bb43
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rdi)
leaq 0x678fe(%rip), %rcx     # 0xe3401
movq %rcx, 0x10(%rax)
movq $0x19, 0x8(%rax)
movq 0x6e8(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e8(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x1940(%rdi), %rbx
movq 0x6e8(%rdi), %rdx
movq %rbx, %rsi
callq 0x2cdc0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: hash_table_setter
static s7_pointer hash_table_setter(s7_scheme *sc, s7_pointer e, s7_int loc, s7_pointer val)
                {
                    /* loc is irrelevant here, e is the hash-table, val has to be of the form (cons key value)
                     * if key is already in e, its value is changed, otherwise a new slot is added to e
                     */
                    if (is_pair(val))
                        return(s7_hash_table_set(sc, e, car(val), cdr(val)));

                    set_car(sc->elist_3, wrap_string(sc, "~S: ~S is not (cons key value)", 30));
                    set_caddr(sc->elist_3, val);
                    return(s7_error(sc, sc->wrong_type_arg_symbol, sc->elist_3));
                }

// Assembly:
cmpb $0x1, (%rcx)
jne 0x7bb5a
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rcx
jmp 0x2a7e4
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rdx
movq (%rax,%rdx,8), %rax
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rdi)
leaq 0x6789d(%rip), %rdx     # 0xe341b
movq %rdx, 0x10(%rax)
movq $0x1e, 0x8(%rax)
movq 0x6e8(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e8(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x1940(%rdi), %rsi
movq 0x6e8(%rdi), %rdx
jmp 0x2cdc0
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: c_object_setter
static s7_pointer c_object_setter(s7_scheme *sc, s7_pointer obj, s7_int loc, s7_pointer val)
                {
                    set_car(sc->t3_1, obj);
                    set_car(sc->t3_2, make_integer(sc, loc));
                    set_car(sc->t3_3, val);
                    return((*(c_object_set(sc, obj)))(sc, sc->t3_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x580(%rdi), %rax
movq %rsi, 0x8(%rax)
cmpq $0x7ff, %rdx            # imm = 0x7FF
ja 0x7bbf0
leaq 0x99d66(%rip), %rax     # 0x115950
movq (%rax,%r12,8), %rax
jmp 0x7bc29
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7bc0f
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r12, 0x8(%rax)
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x590(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x8d8(%rbx), %rax
movq 0x8(%r14), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
movq 0x580(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: let_setter
static s7_pointer let_setter(s7_scheme *sc, s7_pointer e, s7_int loc, s7_pointer val)
                {
                    /* loc is irrelevant here
                     * val has to be of the form (cons symbol value)
                     * if symbol is already in e, its value is changed, otherwise a new slot is added to e
                     */
                    if (is_pair(val))
                    {
                        s7_pointer sym;
                        sym = car(val);
                        if (is_symbol(sym))
                        {
                            s7_pointer slot;
                            slot = slot_in_let(sc, e, sym);
                            if (is_slot(slot))
                                checked_slot_set_value(sc, slot, cdr(val));
                            else make_slot_1(sc, e, sym, cdr(val));
                            return(cdr(val));
                        }
                    }
                    set_car(sc->elist_3, wrap_string(sc, "~S: ~S is not (cons symbol value)", 33));
                    set_caddr(sc->elist_3, val);
                    return(s7_error(sc, sc->wrong_type_arg_symbol, sc->elist_3));
                }

// Assembly:
pushq %rbx
movq %rcx, %rbx
cmpb $0x1, (%rcx)
jne 0x7bc93
movq 0x8(%rbx), %rdx
cmpb $0xa, (%rdx)
jne 0x7bc93
leaq 0x8(%rsi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x7bcf9
cmpq %rdx, 0x8(%rax)
je 0x7bd00
addq $0x18, %rax
jmp 0x7bc7f
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rdi)
leaq 0x67783(%rip), %rcx     # 0xe343a
movq %rcx, 0x10(%rax)
movq $0x21, 0x8(%rax)
movq 0x6e8(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e8(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x1940(%rdi), %rbx
movq 0x6e8(%rdi), %rdx
movq %rbx, %rsi
callq 0x2cdc0
jmp 0x7bd1f
movq 0x128(%rdi), %rax
cmpb $0x20, (%rax)
movq 0x10(%rbx), %rcx
jne 0x7bd16
movq %rax, %rsi
movq %rcx, %rdx
callq 0x72e20
jmp 0x7bd1b
callq 0x9a09
movq 0x10(%rbx), %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: tree_len
static inline s7_int tree_len(s7_scheme *sc, s7_pointer p)
    {
        if (is_null(p))
            return(0);
        if ((!is_pair(p)) ||
                (car(p) == sc->quote_symbol))
            return(1);
        return(tree_len_1(sc, p));
    }

// Assembly:
cmpq %rsi, 0x110(%rdi)
je 0x7c61f
pushq $0x1
popq %rax
cmpb $0x1, (%rsi)
jne 0x7c61e
movq 0x8(%rsi), %rcx
cmpq 0x17b0(%rdi), %rcx
jne 0x7c868
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: copy_tree_with_type
static s7_pointer copy_tree_with_type(s7_scheme *sc, s7_pointer tree)
    {
        /* if sc->safety > NO_SAFETY, '(1 2) is set immutable by the reader, but eval (in that safety case) calls
         *   copy_body on the incoming tree, so we have to preserve T_IMMUTABLE in that case.
         * if tree is something like (+ 1 (car '#1=(2 . #1#))), we have to see the quoted list and not copy it.
         */
#if WITH_GCC
#define COPY_TREE_WITH_TYPE(P) ({s7_pointer _p; _p = P; \
        cons_unchecked_with_type(sc, _p, (is_unquoted_pair(car(_p))) ? copy_tree_with_type(sc, car(_p)) : car(_p), \
                (is_unquoted_pair(cdr(_p))) ? copy_tree_with_type(sc, cdr(_p)) : cdr(_p));})
#else
#define COPY_TREE_WITH_TYPE(P) copy_tree_with_type(sc, P)
#endif

        return(cons_unchecked_with_type(sc, tree,
                    (is_unquoted_pair(car(tree))) ? COPY_TREE_WITH_TYPE(car(tree)) : car(tree),
                    (is_unquoted_pair(cdr(tree))) ? COPY_TREE_WITH_TYPE(cdr(tree)) : cdr(tree)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r12
cmpb $0x1, (%r12)
jne 0x7c6b7
movq 0x8(%r12), %r15
movq 0x17b0(%r14), %rax
cmpq %rax, %r15
je 0x7c6b7
cmpb $0x1, (%r15)
jne 0x7c667
cmpq %rax, 0x8(%r15)
je 0x7c667
movq %r14, %rdi
movq %r15, %rsi
callq 0x7c622
movq %rax, %r15
movq 0x10(%r12), %rax
cmpb $0x1, (%rax)
jne 0x7c689
movq 0x8(%rax), %rcx
cmpq 0x17b0(%r14), %rcx
je 0x7c689
movq %r14, %rdi
movq %rax, %rsi
callq 0x7c622
movq 0x90(%r14), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%r14)
movq (%r12), %rdx
movq -0x8(%rcx), %r12
andl $0x12000ff, %edx        # imm = 0x12000FF
movq %rdx, (%r12)
movq %r15, 0x8(%r12)
movq %rax, 0x10(%r12)
movq 0x10(%rbx), %r13
cmpb $0x1, (%r13)
jne 0x7c739
movq 0x8(%r13), %r15
movq 0x17b0(%r14), %rax
cmpq %rax, %r15
je 0x7c739
cmpb $0x1, (%r15)
jne 0x7c6ec
cmpq %rax, 0x8(%r15)
je 0x7c6ec
movq %r14, %rdi
movq %r15, %rsi
callq 0x7c622
movq %rax, %r15
movq 0x10(%r13), %rax
cmpb $0x1, (%rax)
jne 0x7c70d
movq 0x8(%rax), %rcx
cmpq 0x17b0(%r14), %rcx
je 0x7c70d
movq %r14, %rdi
movq %rax, %rsi
callq 0x7c622
movq 0x90(%r14), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%r14)
movq (%r13), %rdx
movq -0x8(%rcx), %r13
andl $0x12000ff, %edx        # imm = 0x12000FF
movq %rdx, (%r13)
movq %r15, 0x8(%r13)
movq %rax, 0x10(%r13)
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq (%rbx), %rcx
andl $0x12000ff, %ecx        # imm = 0x12000FF
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movq %r13, 0x10(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: copy_tree
static s7_pointer copy_tree(s7_scheme *sc, s7_pointer tree)
    {
#if WITH_GCC
#define COPY_TREE(P) ({s7_pointer _p; _p = P; \
        cons_unchecked(sc, (is_pair(car(_p))) ? copy_tree(sc, car(_p)) : car(_p), \
                (is_pair(cdr(_p))) ? copy_tree(sc, cdr(_p)) : cdr(_p));})
#else
#define COPY_TREE(P) copy_tree(sc, P)
#endif

        return(cons_unchecked(sc,
                    (is_pair(car(tree))) ? COPY_TREE(car(tree)) : car(tree),
                    (is_pair(cdr(tree))) ? COPY_TREE(cdr(tree)) : cdr(tree)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpb $0x1, (%r12)
jne 0x7c7dc
movq 0x8(%r12), %r15
cmpb $0x1, (%r15)
jne 0x7c79f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7c76d
movq %rax, %r15
movq 0x10(%r12), %rax
cmpb $0x1, (%rax)
jne 0x7c7b4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c76d
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rcx), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %r15, 0x8(%r12)
movq %rax, 0x10(%r12)
movq 0x10(%r14), %r15
cmpb $0x1, (%r15)
jne 0x7c837
movq 0x8(%r15), %r14
cmpb $0x1, (%r14)
jne 0x7c7fe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c76d
movq %rax, %r14
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0x7c812
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c76d
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rcx), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %r14, 0x8(%r15)
movq %rax, 0x10(%r15)
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: tree_len_1
static inline s7_int tree_len_1(s7_scheme *sc, s7_pointer p)
    {
        s7_int sum;
        for (sum = 0; is_pair(p); p = cdr(p))
        {
            s7_pointer cp;
            cp = car(p);
            if ((!is_pair(cp)) ||
                    (car(cp) == sc->quote_symbol))
                sum++;
            else
            {
                do {
                    s7_pointer ccp;
                    ccp = car(cp);
                    if ((!is_pair(ccp)) ||
                            (car(ccp) == sc->quote_symbol))
                        sum++;
                    else
                    {
                        do {
                            s7_pointer cccp;
                            cccp = car(ccp);
                            if ((!is_pair(cccp)) ||
                                    (car(cccp) == sc->quote_symbol))
                                sum++;
                            else sum += tree_len_1(sc, cccp);
                            ccp = cdr(ccp);
                        } while (is_pair(ccp));
                        if (!is_null(ccp)) sum++;
                    }
                    cp = cdr(cp);
                } while (is_pair(cp));
                if (!is_null(cp)) sum++;
            }
        }
        if (!is_null(p)) return(sum + 1);
        return(sum);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
cmpb $0x1, (%r14)
jne 0x7c915
movq 0x8(%r14), %r12
cmpb $0x1, (%r12)
jne 0x7c909
movq 0x17b0(%r15), %r13
cmpq %r13, 0x8(%r12)
je 0x7c909
movq 0x8(%r12), %rbp
cmpb $0x1, (%rbp)
jne 0x7c8e9
cmpq %r13, 0x8(%rbp)
je 0x7c8e9
movq 0x8(%rbp), %rsi
cmpb $0x1, (%rsi)
jne 0x7c8cb
cmpq %r13, 0x8(%rsi)
je 0x7c8cb
movq %r15, %rdi
callq 0x7c868
addq %rax, %rbx
jmp 0x7c8ce
incq %rbx
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
je 0x7c8af
xorl %eax, %eax
cmpq 0x110(%r15), %rbp
setne %al
addq %rax, %rbx
jmp 0x7c8ec
incq %rbx
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
je 0x7c89e
xorl %eax, %eax
cmpq 0x110(%r15), %r12
setne %al
addq %rax, %rbx
jmp 0x7c90c
incq %rbx
movq 0x10(%r14), %r14
jmp 0x7c87b
xorl %eax, %eax
cmpq 0x110(%r15), %r14
setne %al
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: stacktrace_find_caller
static s7_pointer stacktrace_find_caller(s7_scheme *sc, s7_pointer e)
                {
                    if ((is_let(e)) && (e != sc->rootlet))
                    {
                        if (is_funclet(e))
                            return(funclet_function(e));
                        return(stacktrace_find_caller(sc, outlet(e)));
                    }
                    return(sc->F);
                }

// Assembly:
cmpb $0x1c, (%rsi)
jne 0x7c9b4
cmpq %rsi, 0x150(%rdi)
je 0x7c9b4
testb $0x20, 0x3(%rsi)
jne 0x7c9bd
movq 0x10(%rsi), %rsi
jmp 0x7c99a
addq $0x120, %rdi            # imm = 0x120
jmp 0x7c9c4
addq $0x20, %rsi
movq %rsi, %rdi
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: stacktrace_find_error_hook_quit
static int64_t stacktrace_find_error_hook_quit(s7_scheme *sc)
                {
                    int64_t i;
                    for (i = s7_stack_top(sc) - 1; i >= 3; i -= 4)
                        if (stack_op(sc->stack, i) == OP_ERROR_HOOK_QUIT)
                            return(i);
                    return(-1);
                }

// Assembly:
movq 0x50(%rdi), %rcx
subq 0x48(%rdi), %rcx
sarq $0x3, %rcx
decq %rcx
pushq $-0x1
popq %rax
cmpq $0x3, %rcx
jl 0x7cf27
movq 0x38(%rdi), %rdx
movq 0x10(%rdx), %rdx
cmpq $0x1f0, (%rdx,%rcx,8)   # imm = 0x1F0
je 0x7cf24
addq $-0x4, %rcx
jmp 0x7cf06
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: prepackaged_type_name
static s7_pointer prepackaged_type_name(s7_scheme *sc, s7_pointer x)
                {
                    s7_pointer p;
                    uint8_t typ;

                    if (has_active_methods(sc, x))
                    {
                        p = find_method(sc, find_let(sc, x), sc->class_name_symbol);
                        if (is_symbol(p))
                            return(symbol_name_cell(p));
                    }
                    typ = type(x);
                    switch (typ)
                    {
                        case T_C_OBJECT:    return(c_object_scheme_name(sc, x));
                        case T_INPUT_PORT:  return((is_file_port(x)) ? an_input_file_port_string : ((is_string_port(x)) ? an_input_string_port_string : an_input_port_string));
                        case T_OUTPUT_PORT: return((is_file_port(x)) ? an_output_file_port_string : ((is_string_port(x)) ? an_output_string_port_string : an_output_port_string));
                        default:
                                            p = prepackaged_type_names[type(x)];
                                            if (is_string(p)) return(p);
                    }
                    return(wrap_string(sc, "unknown type!", 13));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
btl $0x1e, %r15d
jae 0x7cf89
cmpb $0x1, 0x24c(%rbx)
jne 0x7cf89
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0x18e8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpb $0xa, (%rax)
jne 0x7cf89
movq 0x8(%rax), %rax
jmp 0x7d04e
cmpb $0x23, %r15b
je 0x7cfd3
movzbl %r15b, %eax
cmpl $0x22, %eax
je 0x7cfb5
cmpl $0x14, %eax
jne 0x7cff8
movq 0x8d8(%rbx), %rax
movq 0x8(%r14), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
jmp 0x7d04e
movq 0x8(%r14), %rax
movl 0x4(%rax), %eax
testl %eax, %eax
je 0x7d03e
cmpl $0x1, %eax
leaq 0xa50be(%rip), %rax     # 0x122088
leaq 0xa42f7(%rip), %rcx     # 0x1212c8
jmp 0x7cfef
movq 0x8(%r14), %rax
movl 0x4(%rax), %eax
testl %eax, %eax
je 0x7d047
cmpl $0x1, %eax
leaq 0xa5090(%rip), %rax     # 0x122078
leaq 0x9cc11(%rip), %rcx     # 0x119c00
cmoveq %rax, %rcx
movq (%rcx), %rax
jmp 0x7d04e
movzbl %r15b, %eax
leaq 0x9ca5d(%rip), %rcx     # 0x119a60
movq (%rcx,%rax,8), %rax
cmpb $0x13, (%rax)
je 0x7d04e
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x66518(%rip), %rcx     # 0xe3548
movq %rcx, 0x10(%rax)
movq $0xd, 0x8(%rax)
jmp 0x7d04e
movq 0xa503b(%rip), %rax     # 0x122080
jmp 0x7d04e
movq 0xa5022(%rip), %rax     # 0x122070
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: type_name
static const char *type_name(s7_scheme *sc, s7_pointer arg, article_t article)
                {
                    switch (unchecked_type(arg))
                    {
                        case T_C_OBJECT:
                            return(make_type_name(sc, string_value(c_object_scheme_name(sc, arg)), article));

                        case T_INPUT_PORT:
                            return(make_type_name(sc, (is_file_port(arg)) ? "input file port" : ((is_string_port(arg)) ? "input string port" : "input port"), article));

                        case T_OUTPUT_PORT:
                            return(make_type_name(sc, (is_file_port(arg)) ? "output file port" : ((is_string_port(arg)) ? "output string port" : "output port"), article));

                        case T_LET:
                            if (has_active_methods(sc, arg))
                            {
                                s7_pointer class_name;
                                class_name = find_method(sc, arg, sc->class_name_symbol);
                                if (is_symbol(class_name))
                                    return(make_type_name(sc, symbol_name(class_name), article));
                            }

                        default:
                            {
                                const char *str;
                                str = type_name_from_type(unchecked_type(arg), article);
                                if (str) return(str);
                            }
                    }
                    return("messed up object");
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movzbl (%rsi), %r15d
cmpl $0x23, %r15d
je 0x7d10e
cmpl $0x1c, %r15d
je 0x7d09a
cmpl $0x22, %r15d
je 0x7d0e7
cmpl $0x14, %r15d
jne 0x7d0c8
movq 0x8d8(%r14), %rax
movq 0x8(%rsi), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
jmp 0x7d137
movq (%rsi), %r15
btl $0x1e, %r15d
jae 0x7d0c8
cmpb $0x1, 0x24c(%r14)
jne 0x7d0c8
movq 0x18e8(%r14), %rdx
movq %r14, %rdi
callq 0x888f
cmpb $0xa, (%rax)
jne 0x7d0c8
movq 0x8(%rax), %rax
jmp 0x7d091
movzbl %r15b, %edi
movl %ebx, %esi
callq 0x49959
testq %rax, %rax
leaq 0x66479(%rip), %rcx     # 0xe3556
cmoveq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsi), %rax
movl 0x4(%rax), %eax
cmpl $0x1, %eax
leaq 0x5c629(%rip), %rcx     # 0xd9721
leaq 0x5c3af(%rip), %rdx     # 0xd94ae
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x69da8(%rip), %rsi     # 0xe6eb4
jmp 0x7d133
movq 0x8(%rsi), %rax
movl 0x4(%rax), %eax
cmpl $0x1, %eax
leaq 0x69d6d(%rip), %rcx     # 0xe6e8c
leaq 0x5c2fb(%rip), %rdx     # 0xd9421
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x69d6e(%rip), %rsi     # 0xe6ea1
cmovneq %rdx, %rsi
movq %r14, %rdi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x7b04d