LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xd98b8
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x1918(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x115486(%rip), %rsi    # 0x1eecfd
movl $0x21, %edx
callq 0xb880
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x28(%rax), %rcx
callq 0xf240
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x50(%rsp)
jmp 0xd9941
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x1918(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
leaq 0x115437(%rip), %rsi    # 0x1eed1f
movl $0x23, %edx
callq 0xb880
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x44fe0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x48(%rsp), %rax
movq 0x28(%rax), %r9
callq 0xd71e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x40000000, 0x28(%rax) # imm = 0x40000000
jne 0xd9a57
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xd9995
movq -0x10(%rsp), %rax
movl $0x0, 0x28(%rax)
jmp 0xd9a55
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xd99b6
movq -0x18(%rsp), %rax
movq (%rax), %rax
andq $0x2000000, %rax        # imm = 0x2000000
cmpq $0x0, %rax
je 0xd99c7
movq -0x10(%rsp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
jmp 0xd9a53
movl $0x0, -0x24(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xd9a24
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x1890(%rcx), %rax
jne 0xd9a09
jmp 0xd9a24
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xd99d9
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xd9a45
movl -0x24(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x28(%rax)
jmp 0xd9a51
movq -0x10(%rsp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
jmp 0xd9a53
jmp 0xd9a55
jmp 0xd9a57
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x7c0(%rcx), %rax
jge 0xd9adb
movq 0x20(%rsp), %rax
movq 0x7b0(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0xd9ac9
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xd9b81
jmp 0xd9acb
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xd9a7c
movq 0x20(%rsp), %rax
movq 0x7c0(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x7b8(%rcx), %rax
jne 0xd9b3b
movq 0x20(%rsp), %rax
movq 0x7b8(%rax), %rcx
shlq %rcx
movq %rcx, 0x7b8(%rax)
movq 0x20(%rsp), %rax
movq 0x7b0(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x7b8(%rax), %rsi
shlq $0x3, %rsi
callq 0x9510
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x7b0(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl $0x1000001, %ecx        # imm = 0x1000001
callq 0x60af0
movq %rax, %rdx
movq 0x20(%rsp), %rax
movq 0x7b0(%rax), %rax
movq 0x20(%rsp), %rsi
movq 0x7c0(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x7c0(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f870
testb $0x1, %al
jne 0xda224
jmp 0xda267
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x1940(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x114cc1(%rip), %rsi    # 0x1eef0c
movl $0x14, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdc840
movq (%rsp), %rdi
movq %rax, %rsi
shlq %rsi
callq 0x34cc0
movq 0x20(%rsp), %rax
cmpq $0x0, 0x6a0(%rax)
jle 0xda2bd
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdc8c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x4d8(%rax)
jmp 0xda2db
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdcc20
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x20(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movl $0x1, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0xda375
movq -0x18(%rsp), %rax
cmpq -0x28(%rsp), %rax
jne 0xda358
movl -0xc(%rsp), %eax
retq
jmp 0xda35a
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xda33d
jmp 0xda377
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xda32b
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %rcx
cmpq 0x150(%rcx), %rax
jne 0xda547
movq 0x58(%rsp), %rax
movq 0x160(%rax), %rax
movq %rax, 0x60(%rsp)
jmp 0xda702
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %rcx
cmpq 0x2150(%rcx), %rax
jne 0xda569
callq 0xdd0b0
movq %rax, 0x60(%rsp)
jmp 0xda702
movq 0x50(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0xda6b9
movq 0x58(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0xda6b9
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rax
movq 0x1218(%rax), %rdx
callq 0x98d0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x58(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0xda6b7
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xda61d
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
callq 0xda50
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0xda69b
jmp 0xda6ac
movq 0x40(%rsp), %rdi
callq 0x10790
movq %rax, 0x60(%rsp)
jmp 0xda702
movq $-0x1, 0x60(%rsp)
jmp 0xda702
jmp 0xda6b9
movq $0x0, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xda6f8
jmp 0xda6da
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0xda6d0
movq 0x48(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq (%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0xdaa86
jmp 0xdaaad
movq (%rsp), %rdi
callq 0x14450
movb %al, %dl
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xdab19
movq 0x18(%rsp), %rdi
leaq 0x114468(%rip), %rsi    # 0x1eef21
movl $0x19, %edx
callq 0xb880
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq 0x6e8(%rax), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x6e8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x1940(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x6e8(%rax), %rdx
callq 0x2f940
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xdab79
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rax
movq 0x8(%rax), %rdx
movq (%rsp), %rax
movq 0x10(%rax), %rcx
callq 0x2a7b0
movq %rax, 0x20(%rsp)
jmp 0xdabe5
movq 0x18(%rsp), %rdi
leaq 0x1143b6(%rip), %rsi    # 0x1eef3b
movl $0x1e, %edx
callq 0xb880
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq 0x6e8(%rax), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x6e8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x1940(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x6e8(%rax), %rdx
callq 0x2f940
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x580(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0xdac4e
movq 0x20(%rsp), %rcx
leaq 0x13b83c(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0xdacc4
jmp 0xdac50
movq 0x40(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x40(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xdac74
movq 0x40(%rsp), %rdi
callq 0xc670
movq 0x40(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0xb, (%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x588(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x590(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x8d8(%rax), %rax
movq 0x38(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rcx
movq 0x580(%rcx), %rsi
callq *%rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xdade0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xdadde
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xdd0c0
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0xdadb1
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0xc5e00
jmp 0xdadce
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
callq 0xbec0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0xdae4d
jmp 0xdade0
movq 0x28(%rsp), %rdi
leaq 0x11416e(%rip), %rsi    # 0x1eef5a
movl $0x21, %edx
callq 0xb880
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq 0x6e8(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq 0x6e8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x1940(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x6e8(%rax), %rdx
callq 0x2f940
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0xdb6ba
movq 0x48(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0xdb6ba
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x9a10
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rax
movq 0xe20(%rax), %rdx
callq 0x98d0
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0xdb6ba
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x44270
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x50(%rsp)
jmp 0xdb76c
movq 0x48(%rsp), %rax
movq 0x8d8(%rax), %rax
movq 0x38(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x68(%rax)
je 0xdb70a
movq 0x48(%rsp), %rax
movq 0x8d8(%rax), %rax
movq 0x38(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x68(%rax), %rax
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq *%rax
movq %rax, 0x50(%rsp)
jmp 0xdb76c
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq 0x1918(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
leaq 0x1137be(%rip), %rsi    # 0x1eeef8
movl $0x13, %edx
callq 0xb880
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
callq 0xb830
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x24, %eax
jne 0xdb82d
jmp 0xdb7af
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xdb7d3
movq 0x18(%rsp), %rdi
callq 0xc670
movq 0x18(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x24, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xdb83e
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: copy_closure
static s7_pointer copy_closure(s7_scheme *sc, s7_pointer fnc)
    {
        /* copy the source tree annotating (for eventual optimization), return a thing of the same type as fnc */
        s7_pointer x, body;

        body = copy_body(sc, closure_body(fnc));
        new_cell(sc, x, typeflag(fnc) & (~T_COLLECTED)); /* I'm paranoid about that is_collected bit */
        closure_set_args(x, closure_args(fnc));
        closure_set_body(x, body);
        closure_set_setter(x, closure_setter(fnc));
        closure_set_arity(x, closure_arity(fnc));
        closure_set_let(x, closure_let(fnc));
        return(x);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xda1f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xdc11a
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
andq $-0x20001, %rcx         # imm = 0xFFFDFFFF
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rax
movl 0x28(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11020
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xdc86a
movq $0x0, 0x10(%rsp)
jmp 0xdc8aa
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xdc88c
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
jne 0xdc897
movq $0x1, 0x10(%rsp)
jmp 0xdc8aa
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xdce60
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x88(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xdcd36
movq 0x88(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xdccb1
movq 0x90(%rsp), %rdi
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xdcc20
movq %rax, 0x50(%rsp)
jmp 0xdccc2
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x80(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xdcd00
movq 0x90(%rsp), %rdi
movq 0x80(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xdcc20
movq %rax, 0x40(%rsp)
jmp 0xdcd11
movq 0x80(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rsi
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rdx
callq 0xd9f0
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0xdcd47
movq 0x88(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x88(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xdce2e
movq 0x88(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xdcdb5
movq 0x90(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xdcc20
movq %rax, 0x20(%rsp)
jmp 0xdcdc3
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xdcdfb
movq 0x90(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xdcc20
movq %rax, 0x10(%rsp)
jmp 0xdce09
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0xd9f0
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xdce3f
movq 0x88(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movq 0x60(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0xd9f0
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: cons_unchecked_with_type
static s7_pointer cons_unchecked_with_type(s7_scheme *sc, s7_pointer p, s7_pointer a, s7_pointer b)
    {
        /* apparently slightly faster as a function? */
        s7_pointer x;
        new_cell_no_check(sc, x, typeflag(p) & (TYPE_MASK | T_IMMUTABLE | T_SAFE_PROCEDURE));
        set_car(x, a);
        set_cdr(x, b);
        return(x);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
andq $0x12000ff, %rcx        # imm = 0x12000FF
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: slot_in_let
static s7_pointer slot_in_let(s7_scheme *sc, s7_pointer e, s7_pointer sym)
    {
        s7_pointer y;
        for (y = let_slots(e); tis_slot(y); y = next_slot(y))
            if (slot_symbol(y) == sym)
                return(y);
        return(sc->undefined);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
je 0xdd113
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rsp), %rax
jne 0xdd101
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xdd124
jmp 0xdd103
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0xdd0dd
movq -0x10(%rsp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: clear_symbol_list
static inline void clear_symbol_list(s7_scheme *sc)
    {
        sc->syms_tag++;
        if (sc->syms_tag == 0)
        {
            sc->syms_tag = 1; /* we're assuming (in let_equal) that this tag is not 0 */
            sc->syms_tag2++;
        }
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0xa88(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa88(%rax)
movq -0x8(%rsp), %rax
cmpl $0x0, 0xa88(%rax)
jne 0xdd1fa
movq -0x8(%rsp), %rax
movl $0x1, 0xa88(%rax)
movq -0x8(%rsp), %rax
movl 0xa8c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa8c(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0xdd2e6
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x150(%rcx), %rax
je 0xdd2e6
movq (%rsp), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0xdd2cd
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xdd2f7
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xdd280
movq %rax, 0x10(%rsp)
jmp 0xdd2f7
movq 0x8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x48(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
subq $0x1, %rax
movq %rax, -0x18(%rsp)
cmpq $0x3, -0x18(%rsp)
jl 0xddf7b
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x1f0, %rax            # imm = 0x1F0
jne 0xddf69
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xddf84
jmp 0xddf6b
movq -0x18(%rsp), %rax
subq $0x4, %rax
movq %rax, -0x18(%rsp)
jmp 0xddf37
movq $-0x1, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: stacktrace_error_hook_function
static bool stacktrace_error_hook_function(s7_scheme *sc, s7_pointer sym)
                {
                    if (is_symbol(sym))
                    {
                        s7_pointer f;
                        f = s7_symbol_value(sc, sym);
                        return((is_procedure(f)) &&
                                (is_procedure(sc->error_hook)) &&
                                (hook_has_functions(sc->error_hook)) &&
                                (direct_memq(f, s7_hook_functions(sc, sc->error_hook))));
                    }
                    return(false);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xde0cb
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb3a0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x13de8c(%rip), %rax    # 0x21be60
testb $0x1, (%rax,%rcx)
jne 0xde010
movq 0x18(%rsp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x14, %ecx
movb %al, 0x17(%rsp)
jne 0xde0bf
movq 0x18(%rsp), %rax
movq (%rax), %rcx
andq $0x200000, %rcx         # imm = 0x200000
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, 0x17(%rsp)
je 0xde0bf
movq 0x28(%rsp), %rax
movq 0x208(%rax), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x13de38(%rip), %rax    # 0x21be60
testb $0x1, (%rax,%rcx)
jne 0xde06a
movq 0x28(%rsp), %rax
movq 0x208(%rax), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x14, %ecx
movb %al, 0x17(%rsp)
jne 0xde0bf
movq 0x28(%rsp), %rax
movq 0x208(%rax), %rax
movq (%rax), %rcx
andq $0x200000, %rcx         # imm = 0x200000
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, 0x17(%rsp)
je 0xde0bf
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x208(%rax), %rsi
callq 0xba20
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, 0x17(%rsp)
jne 0xde0bf
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x208(%rax), %rsi
callq 0xba20
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xde1a0
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xde0d0
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: direct_memq
static bool direct_memq(s7_pointer symbol, s7_pointer symbols)
    {
        s7_pointer x;
        for (x = symbols; is_pair(x); x = cdr(x))
            if (car(x) == symbol)
                return(true);
        return(false);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xde1ea
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rsp), %rax
jne 0xde1d8
movb $0x1, -0x1(%rsp)
jmp 0xde1ef
jmp 0xde1da
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xde1b4
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: set_wlist_4
static s7_pointer set_wlist_4(s7_pointer lst, s7_pointer x1, s7_pointer x2, s7_pointer x3, s7_pointer x4)
    {
        s7_pointer p;
        p = lst;
        set_car(p, x1); p = cdr(p);
        set_car(p, x2); p = cdr(p);
        set_car(p, x3); p = cdr(p);
        set_car(p, x4);
        return(lst);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x10(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jne 0xde9c9
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xdeac5
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jge 0xde9fd
jmp 0xde9ed
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xde9d7
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jne 0xdea28
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xdeac5
jmp 0xdea2a
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0xdea91
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
je 0xdea7f
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0xdea6d
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xdeac5
jmp 0xdea6f
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0xdea45
jmp 0xdea81
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xdea2a
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0xdeabc
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xdeac5
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: fill_star_defaults
static inline void fill_star_defaults(s7_scheme *sc, s7_pointer func, int32_t start_arg, int32_t n_args, s7_pointer par)
                {
                    int32_t i;
                    s7_pointer *df;
                    df = c_function_arg_defaults(func);

                    if (c_func_has_simple_defaults(func))
                    {
                        for (i = start_arg; i < n_args; i++, par = cdr(par))
                            set_car(par, df[i]);
                    }
                    else
                    {
                        for (i = start_arg; i < n_args; i++, par = cdr(par))
                        {
                            s7_pointer defval;
                            defval = df[i];
                            if (is_symbol(defval))
                                set_car(par, lookup_checked(sc, defval));
                            else
                            {
                                if (is_pair(defval))
                                    set_car(par, s7_eval(sc, defval, sc->nil));
                                else set_car(par, defval);
                            }
                        }
                    }
                }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0xdfc8a
movl 0x44(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x40(%rsp), %eax
jge 0xdfc85
movq 0x28(%rsp), %rax
movslq 0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0xdfc49
jmp 0xdfd7e
movl 0x44(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x40(%rsp), %eax
jge 0xdfd7c
movq 0x28(%rsp), %rax
movslq 0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xdfd16
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xde990
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xdfce8
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xdfcfc
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdead0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xdfd5c
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xdfd4c
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x50(%rsp), %rax
movq 0x110(%rax), %rdx
callq 0x2b5c0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xdfd5a
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xdfd5c
jmp 0xdfd5e
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0xdfc92
jmp 0xdfd7e
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: find_closure_let
static s7_pointer find_closure_let(s7_scheme *sc, s7_pointer cur_env)
                {
                    s7_pointer e;
                    for (e = cur_env; is_let(e); e = outlet(e))
                        if (is_funclet(e))
                            return(e);
                    return(sc->nil);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0xdfde3
movq -0x20(%rsp), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0xdfdd1
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xdfdf4
jmp 0xdfdd3
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xdfda4
movq -0x10(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: set_file_and_line_number
static void set_file_and_line_number(s7_scheme *sc, s7_pointer p)
                {
                    if (sc->input_port != sc->standard_input) /* (port_file_number(sc->input_port) > 1) -- maybe 0 is legit? */
                    {
                        pair_set_line_number(p, port_line_number(sc->input_port));
                        pair_set_file(p, port_file_number(sc->input_port));
                        set_has_line_number(p);	      /* sc->input_port above can't be nil(?) -- it falls back on stdin now */
                    }
                }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x170(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq 0x1c8(%rcx), %rax
je 0xdfe9c
movq -0x8(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movl 0x24(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
orq $0x40000, %rcx          # imm = 0x40000
movq %rcx, (%rax)
retq
nopl (%rax)