LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, %rbx
cmpb $0x1c, (%rdx)
jne 0x99cfd
movq %rdx, %r14
movq %rsi, %r15
testb $0x20, 0x3(%r14)
je 0x99cde
movq 0x20(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xbe9a
cmpq %r15, %rax
je 0x99d10
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x99cf3
cmpq %r15, 0x10(%rax)
je 0x99d06
movq 0x18(%rax), %rax
jmp 0x99ce2
movq 0x10(%r14), %r14
cmpb $0x1c, (%r14)
je 0x99cc0
addq $0x110, %rbx            # imm = 0x110
jmp 0x99d0d
addq $0x8, %rax
movq %rax, %rbx
movq (%rbx), %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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, %r14
movq %rdi, %r15
cmpb $0x1, (%rsi)
jne 0x99fdf
xorl %r12d, %r12d
movq %r14, %rax
incq %r12
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x99fd1
jmp 0x99fe2
xorl %r12d, %r12d
movq %r12, %rbx
shlq $0x4, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9357
movq %r12, 0x10(%rax)
movq (%rax), %rcx
leaq (%rcx,%r12,8), %rdx
movq %rdx, 0x18(%rax)
movb $0x0, 0xc(%rax)
movq 0x110(%r15), %rdx
cmpq %r14, %rdx
je 0x9a037
movq %rcx, %rsi
movq 0x8(%r14), %rdi
cmpb $0xb, (%rdi)
jne 0x9a025
movq 0x8(%rdi), %rdi
jmp 0x9a027
xorl %edi, %edi
movq %rdi, (%rsi)
movq 0x10(%r14), %r14
addq $0x8, %rsi
cmpq %rdx, %r14
jne 0x9a016
testq %r12, %r12
jle 0x9a05f
incq %r12
addq $-0x8, %rbx
movl $0x1, %edx
movq %rdx, (%rcx,%rbx)
imulq -0x10(%rcx,%r12,8), %rdx
decq %r12
addq $-0x8, %rbx
cmpq $0x1, %r12
ja 0x9a048
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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:
ucomisd %xmm0, %xmm0
movq 0x10(%rsi), %rax
movq (%rax,%rdx,8), %rax
jp 0x9a0d9
testq %rax, %rax
je 0x9a0ba
movapd 0x6fe3a(%rip), %xmm1    # 0x109ec0
movq (%rax), %rcx
cmpb $0xd, (%rcx)
jne 0x9a0b1
movsd 0x8(%rcx), %xmm2
ucomisd %xmm0, %xmm2
jne 0x9a09b
jnp 0x9a0c1
subsd %xmm0, %xmm2
andpd %xmm1, %xmm2
movsd 0x268(%rdi), %xmm3
ucomisd %xmm2, %xmm3
ja 0x9a0c1
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x9a086
movq 0x490(%rdi), %rax
retq
movq (%rax), %rcx
cmpb $0xd, (%rcx)
jne 0x9a0d5
movsd 0x8(%rcx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x9a0c1
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x9a0c2
jmp 0x9a0ba
// File: /workspace/github_c_makefile_star2_O3/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 0x9a0fd
cmpb $0x30, (%rsi)
jb 0x9a0fe
movq 0x8(%rsi), %rax
movq 0x58(%rax), %rax
retq
movq 0x18(%rsi), %rdx
jmp 0x99caa
// File: /workspace/github_c_makefile_star2_O3/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 0x9a189
movq %rsi, %r12
leaq 0x7d111(%rip), %rax     # 0x11725f
movq %rax, 0x10(%r13)
movq $0x23, 0x8(%r13)
movq %rbx, %rdi
callq 0x43731
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 0x9a1aa
leaq 0x7d0ad(%rip), %rax     # 0x11723d
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 0x38dfa
// File: /workspace/github_c_makefile_star2_O3/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 0x9a23a
movq 0x110(%rdi), %rax
cmpq %rdx, %rax
je 0x9a233
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmpb $0xa, (%rdx)
je 0x9a236
movq (%rdx), %r9
btl $0x19, %r9d
jb 0x9a236
xorl %ecx, %ecx
cmpb $0x1, %r9b
jne 0x9a224
movq 0x1890(%rdi), %rdi
xorl %ecx, %ecx
cmpq %rdi, 0x8(%rdx)
je 0x9a224
incl %ecx
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
je 0x9a213
cmpq %rax, %rdx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmovel %ecx, %r8d
jmp 0x9a236
xorl %r8d, %r8d
movl %r8d, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
jle 0x9a270
movq 0x7b0(%rbx), %rax
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
cmpq %r15, 0x8(%rdx)
je 0x9a2d7
incq %rcx
cmpq %rcx, %rsi
jne 0x9a25e
cmpq 0x7b8(%rbx), %rsi
jne 0x9a29b
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 0xec9f
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)
jmp 0x9a2db
movq %r14, 0x10(%rdx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x38d93
testb %al, %al
je 0x9a33b
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 0x7d125(%rip), %rax     # 0x11744c
movq %rax, 0x10(%rdx)
movq $0x14, 0x8(%rdx)
movq %rbx, %rdi
callq 0x38dfa
cmpq %r14, 0x110(%rbx)
je 0x9a36f
movl $0x2, %esi
cmpb $0x1, (%r14)
jne 0x9a371
movq 0x8(%r14), %rax
cmpq 0x17b0(%rbx), %rax
je 0x9a371
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9bbee
movq %rax, %rsi
addq %rax, %rsi
jmp 0x9a371
xorl %esi, %esi
movq %rbx, %rdi
callq 0x3bbd4
cmpq $0x0, 0x6a0(%rbx)
jle 0x9a390
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9b9a8
jmp 0x9a39b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9baf3
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
cmpq %rsi, 0x150(%rdi)
je 0x9a52d
movq %rsi, %r14
cmpq %rsi, 0x2150(%rbx)
je 0x9a54d
testb $0x40, 0x3(%r14)
je 0x9a539
cmpb $0x1, 0x24c(%rbx)
jne 0x9a539
movq 0x1218(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x9a539
movq %rax, %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x9a4ef
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r14, 0x8(%rdx)
movq %r12, 0x10(%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaee6
movq %rax, %rbx
movq $-0x1, %rax
cmpb $0xb, (%rbx)
jne 0x9a552
addq $0x8, %rbx
jmp 0x9a534
addq $0x160, %rbx            # imm = 0x160
movq (%rbx), %rax
jmp 0x9a552
movq 0x8(%r14), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x9a552
incq %rax
movq 0x18(%rcx), %rcx
jmp 0x9a53f
movl $0x2b, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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:
pushq %rbx
movl %ecx, %eax
movq %rdx, %rcx
movq %rsi, %rdx
movl %eax, %esi
movq %rcx, %r10
decl %esi
je 0x9a582
movq %rcx, %r10
cmpb $0x1, (%r10)
jne 0x9a582
movq 0x10(%r10), %r10
decq %rsi
jne 0x9a573
movq 0x8(%r10), %rsi
cmpb $0xb, (%rsi)
jne 0x9a659
movq 0x8(%rsi), %r11
testq %r11, %r11
js 0x9a59d
cmpq (%r9), %r11
jle 0x9a608
testq %r11, %r11
movq 0x8(%rdx), %rcx
movl %eax, %eax
leaq 0xac3a3(%rip), %rdx     # 0x146950
movq (%rdx,%rax,8), %rax
leaq 0xb0490(%rip), %rdx     # 0x14aa48
leaq 0xb0481(%rip), %r8      # 0x14aa40
cmovsq %rdx, %r8
movq (%r8), %rdx
movq 0x1ee8(%rdi), %r8
movq 0x10(%r8), %r8
movq %rcx, 0x8(%r8)
movq 0x10(%r8), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ee8(%rdi), %rdx
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq
movq %r11, (%r8)
movq 0x10(%r10), %rsi
cmpb $0x1, (%rsi)
jne 0x9a66b
movq 0x8(%rsi), %rsi
cmpb $0xb, (%rsi)
jne 0x9a657
movq 0x8(%rsi), %rcx
cmpq %r11, %rcx
jl 0x9a62b
cmpq (%r9), %rcx
jle 0x9a668
cmpq %r11, %rcx
movq 0x8(%rdx), %rcx
movl %eax, %eax
leaq 0xac315(%rip), %rdx     # 0x146950
movq 0x8(%rdx,%rax,8), %rax
leaq 0xb8a21(%rip), %rdx     # 0x153068
leaq 0xb03f2(%rip), %r8      # 0x14aa40
cmovlq %rdx, %r8
jmp 0x9a5c3
incl %eax
movl $0xb, %r8d
movl %eax, %r9d
popq %rbx
jmp 0xe42d
movq %rcx, (%r9)
movq 0x140(%rdi), %rbx
jmp 0x9a603
// File: /workspace/github_c_makefile_star2_O3/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 0x9a689
movb 0x8(%rbx), %al
movq 0x10(%rsi), %rcx
movb %al, (%rcx,%rdx)
jmp 0x9a6ed
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rdi)
leaq 0x7cdb4(%rip), %rcx     # 0x117461
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 0x38dfa
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9a704
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rcx
jmp 0x36924
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rdx
movq (%rax,%rdx,8), %rax
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rdi)
leaq 0x7cd53(%rip), %rdx     # 0x11747b
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 0x38dfa
// File: /workspace/github_c_makefile_star2_O3/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 0x9a79a
leaq 0xac1bc(%rip), %rax     # 0x146950
movq (%rax,%r12,8), %rax
jmp 0x9a7d3
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x9a7b9
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %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_O3/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 %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
cmpb $0x1, (%rcx)
jne 0x9a83d
movq 0x8(%rbx), %rdx
cmpb $0xa, (%rdx)
jne 0x9a83d
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x9a8a6
cmpq %rdx, 0x8(%r14)
je 0x9a8ad
movq 0x18(%r14), %r14
jmp 0x9a82c
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rdi)
leaq 0x7cc39(%rip), %rcx     # 0x11749a
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 0x38dfa
jmp 0x9a928
movq 0x128(%rdi), %r14
cmpb $0x20, (%r14)
movq 0x10(%rbx), %rcx
jne 0x9a8cc
movq (%r14), %rax
btl $0x12, %eax
jb 0x9a8d3
btl $0x18, %eax
jb 0x9a8e4
movq %rcx, 0x10(%r14)
jmp 0x9a924
callq 0xa332
jmp 0x9a924
movq %r14, %rsi
movq %rcx, %rdx
callq 0x8f082
movq %rax, 0x10(%r14)
jmp 0x9a924
movq 0xb007d(%rip), %rax     # 0x14a968
movq 0x1240(%rdi), %rcx
movq 0x8(%r14), %rdx
movq 0x6e8(%rdi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x6e8(%rdi), %rdx
movq 0xea8(%rdi), %rsi
callq 0x38dfa
movq 0x10(%rbx), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: copy_c_object
static s7_pointer copy_c_object(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer obj;
                    obj = car(args);
                    check_method(sc, obj, sc->copy_symbol, args);
                    if (c_object_copy(sc, obj))
                        return((*(c_object_copy(sc, obj)))(sc, args));
                    eval_error(sc, "attempt to copy ~S?", 19, obj);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
testb $0x40, 0x3(%r12)
je 0x9b130
cmpb $0x1, 0x24c(%rbx)
jne 0x9b130
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8a63
movq 0xe20(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x9b130
cmpb $0x1, (%r15)
jne 0x9b1cd
movq %rax, (%rsp)
movq %r15, 0x4c8(%rbx)
movq 0x8(%r15), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x9b084
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %r13, 0x8(%r12)
movq %rbp, 0x10(%r12)
movq %r12, 0x4e8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x9b112
movq %r12, %r13
movq 0x8(%r15), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x9b0e3
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq %rax, %r13
je 0x9b0b9
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq (%rsp), %rax
jmp 0x9b1d4
movq 0x8d8(%rbx), %rax
movq 0x8(%r12), %rcx
movq (%rax,%rcx,8), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0x9b15f
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x1918(%rbx), %rsi
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x7c2ae(%rip), %rcx     # 0x117438
movq %rcx, 0x10(%rax)
movq $0x13, 0x8(%rax)
movq 0x6e0(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %r12, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x38dfa
movq 0x110(%rbx), %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee6
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: rng_copy
static s7_pointer rng_copy(s7_scheme *sc, s7_pointer args)
    {
#if WITH_GMP
        return(sc->F); /* I can't find a way to copy a gmp random generator */
#else
        s7_pointer obj;
        obj = car(args);
        if (is_random_state(obj))
        {
            s7_pointer new_r;
            new_cell(sc, new_r, T_RANDOM_STATE);
            random_seed(new_r) = random_seed(obj);
            random_carry(new_r) = random_carry(obj);
            return(new_r);
        }
        return(sc->F);
#endif
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x24, (%r14)
jne 0x9b248
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x9b220
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x24, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
jmp 0x9b24f
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: make_hash_entry
static hash_entry_t *make_hash_entry(s7_scheme *sc, s7_pointer key, s7_pointer value, s7_int raw_hash)
                {
                    hash_entry_t *p;
                    p = (hash_entry_t *)mallocate_block(sc);
                    hash_entry_key(p) = key;
                    hash_entry_set_value(p, value);
                    hash_entry_set_raw_hash(p, raw_hash);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x838(%rdi), %rax
testq %rax, %rax
jne 0x9b97e
movl $0x2800, %edi           # imm = 0x2800
callq 0x8480
movq %rax, 0x838(%r12)
movq %rax, %rcx
addq $0x28, %rcx
movl $0xff, %edx
movq %rcx, -0x10(%rcx)
movl $0x0, -0x20(%rcx)
addq $0x28, %rcx
decl %edx
jne 0x9b95c
movq $0x0, -0x10(%rcx)
movl $0x0, -0x20(%rcx)
movq 0x18(%rax), %rcx
movq %rcx, 0x838(%r12)
movl $0x0, 0x8(%rax)
movq %r15, (%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 0x9ba3d
movq 0x8(%r12), %r15
movq 0x17b0(%r14), %rax
cmpq %rax, %r15
je 0x9ba3d
cmpb $0x1, (%r15)
jne 0x9b9ed
cmpq %rax, 0x8(%r15)
je 0x9b9ed
movq %r14, %rdi
movq %r15, %rsi
callq 0x9b9a8
movq %rax, %r15
movq 0x10(%r12), %rax
cmpb $0x1, (%rax)
jne 0x9ba0f
movq 0x8(%rax), %rcx
cmpq 0x17b0(%r14), %rcx
je 0x9ba0f
movq %r14, %rdi
movq %rax, %rsi
callq 0x9b9a8
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 0x9babf
movq 0x8(%r13), %r15
movq 0x17b0(%r14), %rax
cmpq %rax, %r15
je 0x9babf
cmpb $0x1, (%r15)
jne 0x9ba72
cmpq %rax, 0x8(%r15)
je 0x9ba72
movq %r14, %rdi
movq %r15, %rsi
callq 0x9b9a8
movq %rax, %r15
movq 0x10(%r13), %rax
cmpb $0x1, (%rax)
jne 0x9ba93
movq 0x8(%rax), %rcx
cmpq 0x17b0(%r14), %rcx
je 0x9ba93
movq %r14, %rdi
movq %rax, %rsi
callq 0x9b9a8
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_O3/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 0x9bb62
movq 0x8(%r12), %r15
cmpb $0x1, (%r15)
jne 0x9bb25
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9baf3
movq %rax, %r15
movq 0x10(%r12), %rax
cmpb $0x1, (%rax)
jne 0x9bb3a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9baf3
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 0x9bbbd
movq 0x8(%r15), %r14
cmpb $0x1, (%r14)
jne 0x9bb84
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9baf3
movq %rax, %r14
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0x9bb98
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9baf3
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_O3/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, %rbx
movq %rdi, %r14
cmpb $0x1, (%rsi)
jne 0x9bca1
xorl %r15d, %r15d
movq 0x8(%rbx), %r12
cmpb $0x1, (%r12)
jne 0x9bc8f
movq 0x17b0(%r14), %r13
cmpq %r13, 0x8(%r12)
je 0x9bc8f
movq 0x8(%r12), %rbp
cmpb $0x1, (%rbp)
jne 0x9bc6f
cmpq %r13, 0x8(%rbp)
je 0x9bc6f
movq 0x8(%rbp), %rsi
cmpb $0x1, (%rsi)
jne 0x9bc51
cmpq %r13, 0x8(%rsi)
je 0x9bc51
movq %r14, %rdi
callq 0x9bbee
addq %rax, %r15
jmp 0x9bc54
incq %r15
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
je 0x9bc35
xorl %eax, %eax
cmpq 0x110(%r14), %rbp
setne %al
addq %rax, %r15
jmp 0x9bc72
incq %r15
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
je 0x9bc24
xorl %eax, %eax
cmpq 0x110(%r14), %r12
setne %al
addq %rax, %r15
jmp 0x9bc92
incq %r15
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0x9bc0b
jmp 0x9bca4
xorl %r15d, %r15d
xorl %eax, %eax
cmpq 0x110(%r14), %rbx
setne %al
addq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9c27e
cmpb $0x1, 0x24c(%rbx)
jne 0x9c27e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a63
movq 0x18e8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpb $0xa, (%rax)
jne 0x9c27e
movq 0x8(%rax), %rax
jmp 0x9c343
cmpb $0x23, %r15b
je 0x9c2c8
movzbl %r15b, %eax
cmpl $0x22, %eax
je 0x9c2aa
cmpl $0x14, %eax
jne 0x9c2ed
movq 0x8d8(%rbx), %rax
movq 0x8(%r14), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
jmp 0x9c343
movq 0x8(%r14), %rax
movl 0x4(%rax), %eax
testl %eax, %eax
je 0x9c333
cmpl $0x1, %eax
leaq 0xb6dc9(%rip), %rax     # 0x153088
leaq 0xb6002(%rip), %rcx     # 0x1522c8
jmp 0x9c2e4
movq 0x8(%r14), %rax
movl 0x4(%rax), %eax
testl %eax, %eax
je 0x9c33c
cmpl $0x1, %eax
leaq 0xb6d9b(%rip), %rax     # 0x153078
leaq 0xae91c(%rip), %rcx     # 0x14ac00
cmoveq %rax, %rcx
movq (%rcx), %rax
jmp 0x9c343
movzbl %r15b, %eax
leaq 0xae768(%rip), %rcx     # 0x14aa60
movq (%rcx,%rax,8), %rax
cmpb $0x13, (%rax)
je 0x9c343
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x7b283(%rip), %rcx     # 0x1175a8
movq %rcx, 0x10(%rax)
movq $0xd, 0x8(%rax)
jmp 0x9c343
movq 0xb6d46(%rip), %rax     # 0x153080
jmp 0x9c343
movq 0xb6d2d(%rip), %rax     # 0x153070
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movb (%rsi), %r15b
movzbl %r15b, %eax
cmpl $0x21, %eax
jg 0x9c39b
cmpl $0x14, %eax
je 0x9c3eb
cmpl $0x1c, %eax
jne 0x9c3cc
movq (%rsi), %r15
btl $0x1e, %r15d
jae 0x9c3cc
cmpb $0x1, 0x24c(%r14)
jne 0x9c3cc
movq 0x18e8(%r14), %rdx
movq %r14, %rdi
callq 0x89ff
cmpb $0xa, (%rax)
jne 0x9c3cc
movq 0x8(%rax), %rax
jmp 0x9c3fe
cmpl $0x22, %eax
je 0x9c404
cmpl $0x23, %eax
jne 0x9c3cc
movq 0x8(%rsi), %rax
movl 0x4(%rax), %eax
cmpl $0x1, %eax
leaq 0x7eb36(%rip), %rcx     # 0x11aeec
leaq 0x710c4(%rip), %rdx     # 0x10d481
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x7eb37(%rip), %rsi     # 0x11af01
jmp 0x9c429
movzbl %r15b, %edi
movl %ebx, %esi
callq 0x5c25e
testq %rax, %rax
leaq 0x7b1d5(%rip), %rcx     # 0x1175b6
cmoveq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8d8(%r14), %rax
movq 0x8(%rsi), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
jmp 0x9c42d
movq 0x8(%rsi), %rax
movl 0x4(%rax), %eax
cmpl $0x1, %eax
leaq 0x7136c(%rip), %rcx     # 0x10d781
leaq 0x710f2(%rip), %rdx     # 0x10d50e
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x7eaeb(%rip), %rsi     # 0x11af14
cmovneq %rdx, %rsi
movq %r14, %rdi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x99bbf
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: lookup
static inline s7_pointer lookup(s7_scheme *sc, s7_pointer symbol) /* lookup_checked includes the unbound_variable call */
#endif
        {
            s7_pointer x;
            if (let_id(sc->envir) == symbol_id(symbol))
                return(slot_value(local_slot(symbol)));
            for (x = sc->envir; symbol_id(symbol) < let_id(x); x = outlet(x));
            if (let_id(x) == symbol_id(symbol))
                return(slot_value(local_slot(symbol)));
            for (; is_let(x); x = outlet(x))
            {
                s7_pointer y;
                for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                    if (slot_symbol(y) == symbol)
                        return(slot_value(y));
            }
            /* if (is_global(symbol)) fprintf(stderr, "%s in %s\n", DISPLAY(symbol), DISPLAY_80(sc->code)); */
            x = global_slot(symbol);
            if (is_slot(x)) return(slot_value(x));
#if WITH_GCC
            return(NULL); /* much faster than various alternatives */
#else
            return(unbound_variable(sc, symbol));
#endif
        }

// Assembly:
movq 0x18(%rdi), %rcx
movq 0x20(%rsi), %rax
cmpq %rax, %rcx
je 0x9c45d
jle 0x9c458
movq 0x10(%rdi), %rdi
movq 0x18(%rdi), %rcx
cmpq %rcx, %rax
jl 0x9c44b
cmpq %rax, %rcx
jne 0x9c466
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rax
retq
cmpb $0x1c, (%rdi)
jne 0x9c486
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x9c480
cmpq %rsi, 0x8(%rax)
je 0x9c461
movq 0x18(%rax), %rax
jmp 0x9c46f
movq 0x10(%rdi), %rdi
jmp 0x9c466
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
je 0x9c461
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: find_autoload_name
static const char *find_autoload_name(s7_scheme *sc, s7_pointer symbol, bool *already_loaded, bool loading)
    {
        s7_int l = 0, lib, libs;
        const char *name;

        name = symbol_name(symbol);
        libs = sc->autoload_names_loc;

        for (lib = 0; lib < libs; lib++)
        {
            const char **names;
            s7_int u;
            u = sc->autoload_names_sizes[lib] - 1;
            names = sc->autoload_names[lib];

            while (true)
            {
                s7_int comp, pos;
                const char *this_name;
                if (u < l) break;
                pos = (l + u) / 2;
                this_name = names[pos * 2];
                comp = strcmp(this_name, name);
                if (comp == 0)
                {
                    *already_loaded = sc->autoloaded_already[lib][pos];
                    if (loading) sc->autoloaded_already[lib][pos] = true;
                    return(names[pos * 2 + 1]);             /* file name given func name */
                }
                if (comp < 0)
                    l = pos + 1;
                else u = pos - 1;
            }
        }
        return(NULL);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x2178(%rdi), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
jle 0x9cdb3
movq %rsi, %r13
movq %rdx, 0x18(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x2160(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x2168(%rdi), %rax
movq %rax, 0x30(%rsp)
xorl %r15d, %r15d
xorl %ecx, %ecx
movq 0x30(%rsp), %rax
movq (%rax,%rcx,8), %r12
cmpq %r15, %r12
movq %rcx, 0x8(%rsp)
jle 0x9cda4
movq 0x20(%rsp), %rax
movq (%rax,%rcx,8), %r14
decq %r12
leaq (%r15,%r12), %rbx
movq %rbx, %rbp
shrq %rbp
movq %rbx, %rax
movabsq $0x1ffffffffffffffe, %rcx # imm = 0x1FFFFFFFFFFFFFFE
andq %rcx, %rax
movq (%r14,%rax,8), %rdi
movq %r13, %rsi
callq 0x8370
testl %eax, %eax
je 0x9cdb7
js 0x9cd99
decq %rbp
movq %rbp, %r12
jmp 0x9cd9f
incq %rbp
movq %rbp, %r15
cmpq %r15, %r12
jge 0x9cd65
movq 0x8(%rsp), %rcx
incq %rcx
cmpq 0x28(%rsp), %rcx
jne 0x9cd46
xorl %eax, %eax
jmp 0x9cded
movq 0x10(%rsp), %rax
movq 0x2170(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movb (%rax,%rbp), %cl
movq 0x18(%rsp), %rdx
movb %cl, (%rdx)
cmpb $0x0, 0x4(%rsp)
je 0x9cde1
movb $0x1, (%rax,%rbp)
shlq $0x3, %rbx
orq $0x8, %rbx
movq (%r14,%rbx), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: loaded_library
static s7_pointer loaded_library(s7_scheme *sc, const char *file)
                {
                    s7_pointer p;
                    for (p = slot_value(global_slot(sc->libraries_symbol)); is_pair(p); p = cdr(p))
                        if (local_strcmp(file, string_value(caar(p))))
                            return(cdar(p));
                    return(sc->nil);
                }

// Assembly:
movq 0x1250(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x9ce3f
movq 0x8(%rax), %rcx
movq 0x8(%rcx), %rdx
movq 0x10(%rdx), %rdx
xorl %r8d, %r8d
movb (%rsi,%r8), %r9b
movb (%rdx,%r8), %r10b
testb %r9b, %r9b
je 0x9ce34
incq %r8
cmpb %r10b, %r9b
je 0x9ce1f
cmpb %r10b, %r9b
jne 0x9ce07
addq $0x10, %rcx
jmp 0x9ce49
addq $0x110, %rdi            # imm = 0x110
movq %rdi, %rcx
movq (%rcx), %rax
retq