LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: hash_equivalent
static hash_entry_t *hash_equivalent(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    hash_entry_t *x;
                    s7_int hash, loc;

                    hash = hash_loc(sc, table, key);
                    loc = hash & hash_table_mask(table);
                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if (hash_entry_key(x) == key)
                            return(x);

                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if ((hash_entry_raw_hash(x) == hash) &&
                                (s7_is_equivalent(sc, hash_entry_key(x), key)))
                            return(x);
                    return(sc->unentry);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rax
movzbl (%rdx), %ecx
callq *(%rax,%rcx,8)
movq %rax, %r12
movq 0x8(%r15), %rax
andq %r12, %rax
movq 0x10(%r15), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x9d0eb
cmpq %rbx, (%r15)
je 0x9d128
movq 0x18(%r15), %r15
jmp 0x9d0db
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x9d121
leaq 0xbddc5(%rip), %r13     # 0x15aec0
cmpq %r12, 0x10(%r15)
jne 0x9d118
movq (%r15), %rsi
movzbl (%rsi), %eax
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq *(%r13,%rax,8)
testb %al, %al
jne 0x9d128
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x9d0fb
movq 0x490(%r14), %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: format_error_1
static s7_pointer format_error_1(s7_scheme *sc, s7_pointer msg, const char *str, s7_pointer args, format_data *fdat)
    {
        s7_pointer x = NULL, ctrl_str;

        if (fdat->orig_str)
            ctrl_str = fdat->orig_str;
        else ctrl_str = s7_make_string_wrapper(sc, str);

        if (fdat->loc == 0)
        {
            if (is_pair(args))
                x = set_elist_4(sc, format_string_1, ctrl_str, args, msg);
            else x = set_elist_3(sc, format_string_2, ctrl_str, msg);
        }
        else
        {
            if (is_pair(args))
                x = set_elist_5(sc, format_string_3, ctrl_str, args, wrap_integer1(sc, fdat->loc + 20), msg);
            else x = set_elist_4(sc, format_string_4, ctrl_str, wrap_integer1(sc, fdat->loc + 20), msg);
        }
        if (fdat->port)
        {
            close_format_port(sc, fdat->port);
            fdat->port = NULL;
        }
        return(s7_error(sc, sc->format_error_symbol, x));
    }

// Assembly:
movq 0x28(%r8), %rax
testq %rax, %rax
jne 0x9ee2b
testq %rdx, %rdx
je 0x9ee00
cmpb $0x0, (%rdx)
je 0x9ee00
movq $-0x1, %rax
leaq 0x1(%rax), %r9
cmpb $0x0, 0x1(%rdx,%rax)
movq %r9, %rax
jne 0x9edf0
jmp 0x9ee03
xorl %r9d, %r9d
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r10
movq (%rax,%r10,8), %rax
incl %r10d
andl $0x7, %r10d
movl %r10d, 0x7dc(%rdi)
movq %rdx, 0x10(%rax)
movq %r9, 0x8(%rax)
movq (%r8), %rdx
movb (%rcx), %r9b
testq %rdx, %rdx
je 0x9ee7c
addq $0x14, %rdx
movq 0x1f00(%rdi), %r10
cmpb $0x1, %r9b
jne 0x9ee9d
movq 0xbbd7a(%rip), %r9      # 0x15abc8
movq %rdx, 0x8(%r10)
movq %rcx, %r10
movq 0x1f00(%rdi), %rcx
leaq 0x6f8(%rdi), %rdx
movq 0x6f8(%rdi), %r11
movq %r9, 0x8(%r11)
movq 0x10(%r11), %r9
movq %rax, 0x8(%r9)
addq $0x10, %r9
jmp 0x9eede
cmpb $0x1, %r9b
jne 0x9eeca
movq 0xbbd2f(%rip), %r10     # 0x15abb8
leaq 0x6f0(%rdi), %rdx
movq 0x6f0(%rdi), %r9
movq %r10, 0x8(%r9)
jmp 0x9eec1
movq 0xbbd2c(%rip), %r11     # 0x15abd0
movq %rdx, 0x8(%r10)
movq 0x1f00(%rdi), %rcx
leaq 0x6f0(%rdi), %rdx
movq 0x6f0(%rdi), %r9
movq %r11, 0x8(%r9)
addq $0x10, %r9
movq %rax, %r10
jmp 0x9eede
movq 0xbbcef(%rip), %r10     # 0x15abc0
leaq 0x6e8(%rdi), %r9
movq %rax, %rcx
movq %r9, %rdx
movq (%r9), %rax
movq %r10, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq (%rdx), %rdx
movq 0x38(%r8), %rax
testq %rax, %rax
je 0x9ef1f
movq 0x7e8(%rdi), %rcx
movq 0x28(%rax), %rsi
movq %rcx, 0x18(%rsi)
movq %rax, 0x7e8(%rdi)
movq $0x0, 0x38(%r8)
movq 0x18f8(%rdi), %rsi
jmp 0x3b366
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: format_method
static bool format_method(s7_scheme *sc, const char *str, format_data *fdat, s7_pointer port)
    {
        s7_pointer func, obj;
        char ctrl_str[3];

        obj = car(fdat->args);
        if ((!has_active_methods(sc, obj)) ||
                ((func = find_method(sc, find_let(sc, obj), sc->format_symbol)) == sc->undefined))
            return(false);

        ctrl_str[0] = '~';
        ctrl_str[1] = str[0];
        ctrl_str[2] = '\0';
        s7_apply_function(sc, func, list_3(sc, port, s7_make_string_wrapper(sc, ctrl_str), obj));

        fdat->args = cdr(fdat->args);
        fdat->ctr++;
        return(true);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x20(%rdx), %rax
movq 0x8(%rax), %r12
testb $0x40, 0x3(%r12)
je 0x9f745
movq %rdi, %r14
cmpb $0x1, 0x24c(%rdi)
jne 0x9f745
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %rbp
movq %r14, %rdi
movq %r12, %rsi
callq 0x9a55
movq 0xf20(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%r14), %rax
je 0x9f745
movq %rax, %r8
movb $0x7e, 0xd(%rsp)
movb (%rbp), %al
movb %al, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
movq $-0x1, %rax
cmpb $0x0, 0xe(%rsp,%rax)
leaq 0x1(%rax), %rax
jne 0x9f65e
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdx
movq (%rcx,%rdx,8), %rbp
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0xd(%rsp), %rcx
movq %rcx, 0x10(%rbp)
movq %rax, 0x8(%rbp)
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x9f6be
movq %r14, %rdi
movq %r8, 0x10(%rsp)
callq 0xb389
movq 0x10(%rsp), %r8
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%r14), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%r14)
movq -0x8(%rdx), %rsi
movq %rcx, (%rsi)
movq %rbp, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rdx
movq %rdx, 0x90(%r14)
movq -0x8(%rax), %rdx
movq %rcx, (%rdx)
movq %r15, 0x8(%rdx)
movq %rsi, 0x10(%rdx)
movq %r14, %rdi
movq %r8, %rsi
callq 0xbd41
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rbx)
incq 0x10(%rbx)
movb $0x1, %al
jmp 0x9f747
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: format_numeric_arg
static s7_int format_numeric_arg(s7_scheme *sc, const char *str, s7_int str_len, format_data *fdat, s7_int *i)
    {
        s7_int width, old_i;
        old_i = *i;
        width = format_read_integer(i, str_len, str);
        if (width < 0)
        {
            if (str[old_i - 1] != ',') /* need branches here, not if-expr because just_format_error creates the permanent string */
                just_format_error(sc, "width is negative?", 18, str, fdat->args, fdat);
            else just_format_error(sc, "precision is negative?", 22, str, fdat->args, fdat);
        }
        else
        {
            if (width > sc->max_format_length)
            {
                if (str[old_i - 1] != ',')
                    just_format_error(sc, "width is too big", 16, str, fdat->args, fdat);
                else just_format_error(sc, "precision is too big", 20, str, fdat->args, fdat);
            }
        }
        return(width);
    }

// Assembly:
pushq %rbx
movq %rcx, %rax
movq %rsi, %r9
movq (%r8), %rcx
decq %rdx
xorl %ebx, %ebx
cmpq %rdx, %rcx
jge 0x9f7a7
leaq 0xbdeef(%rip), %r10     # 0x15d660
movq %rcx, %rsi
movzbl (%r9,%rsi), %r11d
movslq (%r10,%r11,4), %r11
cmpq $0x9, %r11
jg 0x9f789
imulq $0xa, %rbx, %rbx
jno 0x9f78e
xorl %r11d, %r11d
jmp 0x9f795
addq %r11, %rbx
setno %r11b
testb %r11b, %r11b
je 0x9f7aa
incq %rsi
cmpq %rsi, %rdx
jne 0x9f774
movq %rdx, %rsi
jmp 0x9f7aa
movq %rcx, %rsi
movq %rsi, (%r8)
testq %rbx, %rbx
js 0x9f7fd
cmpq 0x2c0(%rdi), %rbx
jle 0x9f872
movslq 0x7dc(%rdi), %rdx
leal 0x1(%rdx), %r8d
andl $0x7, %r8d
cmpb $0x2c, -0x1(%r9,%rcx)
movq 0x820(%rdi), %rcx
movq (%rcx,%rdx,8), %rsi
movl %r8d, 0x7dc(%rdi)
jne 0x9f850
leaq 0x806f3(%rip), %rcx     # 0x11fee2
movq %rcx, 0x10(%rsi)
movq $0x14, 0x8(%rsi)
jmp 0x9f863
movslq 0x7dc(%rdi), %rdx
leal 0x1(%rdx), %r8d
andl $0x7, %r8d
cmpb $0x2c, -0x1(%r9,%rcx)
movq 0x820(%rdi), %rcx
movq (%rcx,%rdx,8), %rsi
movl %r8d, 0x7dc(%rdi)
jne 0x9f83b
leaq 0x8068d(%rip), %rcx     # 0x11feba
movq %rcx, 0x10(%rsi)
movq $0x16, 0x8(%rsi)
jmp 0x9f863
leaq 0x80665(%rip), %rcx     # 0x11fea7
movq %rcx, 0x10(%rsi)
movq $0x12, 0x8(%rsi)
jmp 0x9f863
leaq 0x8067a(%rip), %rcx     # 0x11fed1
movq %rcx, 0x10(%rsi)
movq $0x10, 0x8(%rsi)
movq 0x20(%rax), %rcx
movq %r9, %rdx
movq %rax, %r8
callq 0x9edd6
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: format_n_arg
static s7_int format_n_arg(s7_scheme *sc, const char *str, format_data *fdat, s7_pointer args)
    {
        s7_int n;

        if (is_null(fdat->args))          /* (format #f "~nT") */
            just_format_error(sc, "~~N: missing argument", 21, str, args, fdat);
        if (!s7_is_integer(car(fdat->args)))
            just_format_error(sc, "~~N: integer argument required", 30, str, args, fdat);
        n = s7_integer(car(fdat->args));

        if (n < 0)
            just_format_error(sc, "~~N value is negative?", 22, str, args, fdat);
        else
        {
            if (n > sc->max_format_length)
                just_format_error(sc, "~~N value is too big", 20, str, args, fdat);
        }
        fdat->args = cdr(fdat->args);    /* I don't think fdat->ctr should be incremented here -- it's for *vector-print-length* etc */
        return(n);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rdx), %rax
cmpq 0x110(%rdi), %rax
jne 0x9f8df
movq 0x820(%r12), %rax
movslq 0x7dc(%r12), %rcx
movq (%rax,%rcx,8), %rsi
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%r12)
leaq 0x80635(%rip), %rax     # 0x11fef7
movq %rax, 0x10(%rsi)
movq $0x15, 0x8(%rsi)
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x9edd6
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
je 0x9f932
movq 0x820(%r12), %rax
movslq 0x7dc(%r12), %rcx
movq (%rax,%rcx,8), %rsi
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%r12)
leaq 0x805f8(%rip), %rax     # 0x11ff0d
movq %rax, 0x10(%rsi)
movq $0x1e, 0x8(%rsi)
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x9edd6
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x9f945
movq 0x8(%rax), %r13
jmp 0x9f948
xorl %r13d, %r13d
testq %r13, %r13
js 0x9f965
cmpq 0x2c0(%r12), %r13
jle 0x9f9ac
movl $0x14, %eax
leaq 0x805e0(%rip), %rcx     # 0x11ff43
jmp 0x9f971
movl $0x16, %eax
leaq 0x805bb(%rip), %rcx     # 0x11ff2c
movq 0x820(%r12), %rdx
movslq 0x7dc(%r12), %rdi
movq (%rdx,%rdi,8), %rsi
leal 0x1(%rdi), %edx
andl $0x7, %edx
movl %edx, 0x7dc(%r12)
movq %rcx, 0x10(%rsi)
movq %rax, 0x8(%rsi)
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x9edd6
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rbx)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_string_to_list
static s7_pointer s7_string_to_list(s7_scheme *sc, const char *str, s7_int len)
    {
        s7_int i;
        s7_pointer result;
        if (len == 0)
            return(sc->nil);
        check_heap_size(sc, len);
        sc->v = sc->nil;
        for (i = len - 1; i >= 0; i--)
            sc->v = cons_unchecked(sc, s7_make_character(sc, ((uint8_t)str[i])), sc->v);
        result = sc->v;
        sc->v = sc->nil;
        return(result);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
je 0x9fdca
movq %rdx, %r14
movq %rsi, %r15
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3e1dd
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d0(%rbx)
testq %r14, %r14
jle 0x9fdd3
movq 0xb2cd5(%rip), %rdx     # 0x152a58
incq %r14
movzbl -0x2(%r15,%r14), %eax
movq (%rdx,%rax,8), %rsi
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rdi
movq %rdi, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rsi, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, 0x4d0(%rbx)
decq %r14
movq %rax, %rcx
cmpq $0x1, %r14
jg 0x9fd86
jmp 0x9fdd6
movq 0x110(%rbx), %rax
jmp 0x9fde4
movq %rcx, %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: tree_is_cyclic_or_has_pairs
static int tree_is_cyclic_or_has_pairs(s7_scheme *sc, s7_pointer tree)
    {
        s7_pointer fast, slow;
        bool has_pairs = false;

        if (!is_pair(tree)) return(TREE_NOT_CYCLIC);
        slow = tree;
        fast = tree;
        while (true)
        {
            if (tree_is_collected(fast)) return(TREE_CYCLIC);
            if ((!has_pairs) &&
                    (is_unquoted_pair(car(fast))))
                has_pairs = true;
            fast = cdr(fast);
            if (!is_pair(fast))
            {
                if (!has_pairs) return(TREE_NOT_CYCLIC);
                break;
            }
            if (tree_is_collected(fast)) return(TREE_CYCLIC);
            if ((!has_pairs) &&
                    (is_unquoted_pair(car(fast))))
                has_pairs = true;
            fast = cdr(fast);
            if (!is_pair(fast))
            {
                if (!has_pairs) return(TREE_NOT_CYCLIC);
                break;
            }
            slow = cdr(slow);
            if (fast == slow) return(TREE_CYCLIC);
        }
#if S7_DEBUGGING
        if (!has_pairs) fprintf(stderr, "at end but no pairs: %s\n", DISPLAY(tree));
#endif
        return(TREE_HAS_PAIRS);
    }

// Assembly:
cmpb $0x1, (%rsi)
jne 0x9fef8
xorl %ecx, %ecx
movl $0x1, %eax
movq %rsi, %rdx
testb $0x8, 0x6(%rsi)
jne 0x9feec
testb $0x1, %cl
jne 0x9feab
movq 0x8(%rsi), %r8
cmpb $0x1, (%r8)
jne 0x9feab
movq 0x8(%r8), %r8
cmpq 0x17b0(%rdi), %r8
movzbl %cl, %ecx
cmovnel %eax, %ecx
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
jne 0x9feed
testb $0x8, 0x6(%rsi)
jne 0x9feec
testb $0x1, %cl
jne 0x9feda
movq 0x8(%rsi), %r8
cmpb $0x1, (%r8)
jne 0x9feda
movq 0x8(%r8), %r8
cmpq 0x17b0(%rdi), %r8
movzbl %cl, %ecx
cmovnel %eax, %ecx
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
jne 0x9feed
movq 0x10(%rdx), %rdx
cmpq %rdx, %rsi
jne 0x9fe85
retq
testb $0x1, %cl
je 0x9fef8
movl $0x2, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: tree_is_cyclic_1
static bool tree_is_cyclic_1(s7_scheme *sc, s7_pointer tree)
    {
        s7_pointer p;
        for (p = tree; is_pair(p); p = cdr(p))
        {
            tree_set_collected(p);
            if (sc->tree_pointers_top == sc->tree_pointers_size)
            {
                if (sc->tree_pointers_size == 0)
                {
                    sc->tree_pointers_size = 8;
                    sc->tree_pointers = (s7_pointer *)malloc(sc->tree_pointers_size * sizeof(s7_pointer));
                }
                else
                {
                    sc->tree_pointers_size *= 2;
                    sc->tree_pointers = (s7_pointer *)realloc(sc->tree_pointers, sc->tree_pointers_size * sizeof(s7_pointer));
                }
            }
            sc->tree_pointers[sc->tree_pointers_top++] = p;
            if (is_unquoted_pair(car(p)))
            {
                int32_t i, old_top, result;
                old_top = sc->tree_pointers_top;
                result = tree_is_cyclic_or_has_pairs(sc, car(p));
                if ((result == TREE_CYCLIC) ||
                        (tree_is_cyclic_1(sc, car(p))))
                    return(true);
                for (i = old_top; i < sc->tree_pointers_top; i++)
                    tree_clear_collected(sc->tree_pointers[i]);
                sc->tree_pointers_top = old_top;
            }
        }
        return(false);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x1, (%rsi)
sete %bpl
jne 0x9fffc
movq %rsi, %rbx
movq %rdi, %r14
orb $0x8, 0x6(%rbx)
movslq 0x7d0(%r14), %rsi
cmpl %esi, 0x7d4(%r14)
jne 0x9ff66
testl %esi, %esi
je 0x9ff4a
leal (%rsi,%rsi), %eax
movl %eax, 0x7d0(%r14)
movq 0x7c8(%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
jmp 0x9ff5f
movl $0x8, 0x7d0(%r14)
movl $0x40, %edi
callq 0x9480
movq %rax, 0x7c8(%r14)
movq 0x7c8(%r14), %rax
movslq 0x7d4(%r14), %rcx
leal 0x1(%rcx), %r12d
movl %r12d, 0x7d4(%r14)
movq %rbx, (%rax,%rcx,8)
movq 0x8(%rbx), %r15
cmpb $0x1, (%r15)
jne 0x9ffeb
movq 0x8(%r15), %rax
cmpq 0x17b0(%r14), %rax
je 0x9ffeb
movq %r14, %rdi
movq %r15, %rsi
callq 0x9fe76
cmpl $0x1, %eax
je 0x9fffc
movq %r14, %rdi
movq %r15, %rsi
callq 0x9fefb
testb %al, %al
jne 0x9fffc
cmpl 0x7d4(%r14), %r12d
jge 0x9ffe4
movslq %r12d, %rax
movq 0x7c8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
andw $-0x9, 0x6(%rcx)
incq %rax
movslq 0x7d4(%r14), %rcx
cmpq %rcx, %rax
jl 0x9ffc5
movl %r12d, 0x7d4(%r14)
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
sete %bpl
je 0x9ff16
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_big_list
static s7_pointer make_big_list(s7_scheme *sc, int32_t len, s7_pointer init)
                {
                    s7_pointer result;
                    int32_t i;

                    check_heap_size(sc, len);
                    sc->v = sc->nil;
                    for (i = 0; i < len; i++)
                        sc->v = cons_unchecked(sc, init, sc->v);
                    result = sc->v;
                    sc->v = sc->nil;
                    return(result);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r15
movq %r15, %rsi
callq 0x3e1dd
movq 0x110(%rbx), %rax
movq %rax, 0x4d0(%rbx)
testl %r15d, %r15d
jle 0xa00e1
movq 0x4d0(%rbx), %rax
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq %rcx, 0x4d0(%rbx)
decl %ebp
jne 0xa00aa
movq 0x4d0(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: int_vector_setter
static s7_pointer int_vector_setter(s7_scheme *sc, s7_pointer vec, s7_int loc, s7_pointer val)
                {
                    if (s7_is_integer(val))
                        int_vector(vec, loc) = s7_integer(val);
                    else s7_wrong_type_arg_error(sc, "int-vector-set!", 3, val, "an integer");
                    return(val);
                }

// Assembly:
pushq %rbx
movq %rcx, %rbx
cmpb $0xb, (%rcx)
jne 0xa017e
movq 0x8(%rbx), %rax
movq 0x10(%rsi), %rcx
movq %rax, (%rcx,%rdx,8)
jmp 0xa0199
leaq 0x7b6f0(%rip), %rsi     # 0x11b875
leaq 0x7fed6(%rip), %r8      # 0x120062
movl $0x3, %edx
movq %rbx, %rcx
callq 0xe25f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: byte_vector_setter
static s7_pointer byte_vector_setter(s7_scheme *sc, s7_pointer str, s7_int loc, s7_pointer val)
                {
                    if (s7_is_integer(val))
                    {
                        s7_int byte;
                        byte = s7_integer(val);
                        if ((byte >= 0) && (byte < 256))
                        {
                            byte_vector(str, loc) = (uint8_t)byte;
                            return(val);
                        }
                        return(s7_wrong_type_arg_error(sc, "byte-vector-set!", 3, val, "a byte"));
                    }
                    return(s7_wrong_type_arg_error(sc, "byte-vector-set!", 3, val, "an integer"));
                }

// Assembly:
cmpb $0xb, (%rcx)
jne 0xa01ce
movq 0x8(%rcx), %rax
cmpq $0xff, %rax
ja 0xa01de
movq 0x10(%rsi), %rsi
movb %al, (%rsi,%rdx)
movq %rcx, %rax
retq
leaq 0x7b86e(%rip), %rsi     # 0x11ba43
leaq 0x7fe86(%rip), %r8      # 0x120062
jmp 0xa01ec
leaq 0x7b85e(%rip), %rsi     # 0x11ba43
leaq 0x7fdcb(%rip), %r8      # 0x11ffb7
movl $0x3, %edx
jmp 0xe25f
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: float_vector_fill
static void float_vector_fill(s7_scheme *sc, s7_pointer vec, s7_double x)
                {
                    s7_int len;
                    len = vector_length(vec);
                    if (len == 0) return;
                    if (x == 0.0)
                    {
                        if (STEP_8(len))
                            memclr64((void *)float_vector_floats(vec), len * sizeof(s7_double));
                        else memclr((void *)float_vector_floats(vec), len * sizeof(s7_double));
                    }
                    else
                    {
                        s7_int i, left;
                        s7_double *orig;
                        left = len - 8;
                        i = 0;
                        orig = float_vector_floats(vec);
                        while (i <= left)
                            LOOP_8(orig[i++] = x);
                        for (; i < len; i++)
                            orig[i] = x;
                    }
                }

// Assembly:
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0xa0343
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa0227
jp 0xa0227
testb $0x7, %dl
je 0xa0235
shlq $0x3, %rdx
testq %rdx, %rdx
je 0xa0343
movq 0x10(%rdi), %rdi
jmp 0xa026c
movq 0x10(%rdi), %rcx
cmpq $0x8, %rdx
jge 0xa0273
xorl %esi, %esi
jmp 0xa02a4
movabsq $0x1ffffffffffffff8, %rax # imm = 0x1FFFFFFFFFFFFFF8
testq %rax, %rdx
je 0xa0343
movq 0x10(%rdi), %rdi
andq %rax, %rdx
cmpq $0x9, %rdx
movl $0x8, %eax
cmovaeq %rdx, %rax
leaq -0x8(,%rax,8), %rdx
andq $-0x40, %rdx
addq $0x40, %rdx
xorl %esi, %esi
jmp 0x9270
leaq -0x8(%rdx), %rax
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
xorl %edi, %edi
movupd %xmm1, (%rcx,%rdi,8)
movupd %xmm1, 0x10(%rcx,%rdi,8)
leaq 0x8(%rdi), %rsi
movupd %xmm1, 0x20(%rcx,%rdi,8)
movupd %xmm1, 0x30(%rcx,%rdi,8)
movq %rsi, %rdi
cmpq %rax, %rsi
jle 0xa0281
subq %rsi, %rdx
jle 0xa0343
leaq 0x1(%rdx), %rax
andq $-0x2, %rax
decq %rdx
movq %rdx, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
leaq (%rcx,%rsi,8), %rcx
addq $0x8, %rcx
xorl %edx, %edx
movdqa 0x72b0c(%rip), %xmm2    # 0x112de0
movdqa 0x72b14(%rip), %xmm3    # 0x112df0
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
por %xmm2, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm1, %xmm6
pcmpeqd %xmm1, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0xa0326
movsd %xmm0, -0x8(%rcx,%rdx,8)
pxor %xmm4, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0xa033a
movsd %xmm0, (%rcx,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rax
jne 0xa02e4
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: int_vector_fill
static void int_vector_fill(s7_scheme *sc, s7_pointer vec, s7_int k)
                {
                    s7_int len;
                    len = vector_length(vec);
                    if (len == 0) return;
                    if (k == 0)
                    {
                        if (STEP_8(len))
                            memclr64((void *)int_vector_ints(vec), len * sizeof(s7_int));
                        else memclr((void *)int_vector_ints(vec), len * sizeof(s7_int));
                    }
                    else
                    {
                        s7_int i, left;
                        s7_int* orig;
                        left = len - 8;
                        i = 0;
                        orig = int_vector_ints(vec);
                        while (i <= left)
                            LOOP_8(orig[i++] = k);
                        for (; i < len; i++)
                            orig[i] = k;
                    }
                }

// Assembly:
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0xa0456
testq %rsi, %rsi
je 0xa0364
movq 0x10(%rdi), %rcx
cmpq $0x8, %rdx
jge 0xa0383
xorl %edi, %edi
jmp 0xa03b9
testb $0x7, %dl
je 0xa0457
shlq $0x3, %rdx
testq %rdx, %rdx
je 0xa0456
movq 0x10(%rdi), %rdi
jmp 0xa048a
leaq -0x8(%rdx), %rax
xorl %edi, %edi
movq %rsi, (%rcx,%rdi,8)
movq %rsi, 0x8(%rcx,%rdi,8)
movq %rsi, 0x10(%rcx,%rdi,8)
movq %rsi, 0x18(%rcx,%rdi,8)
movq %rsi, 0x20(%rcx,%rdi,8)
movq %rsi, 0x28(%rcx,%rdi,8)
movq %rsi, 0x30(%rcx,%rdi,8)
movq %rsi, 0x38(%rcx,%rdi,8)
addq $0x8, %rdi
cmpq %rax, %rdi
jle 0xa0389
subq %rdi, %rdx
jle 0xa0456
leaq 0x1(%rdx), %rax
andq $-0x2, %rax
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rcx,%rdi,8), %rcx
addq $0x8, %rcx
xorl %edx, %edx
movdqa 0x729f7(%rip), %xmm1    # 0x112de0
movdqa 0x729ff(%rip), %xmm2    # 0x112df0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0xa043a
movq %rsi, -0x8(%rcx,%rdx,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0xa044d
movq %rsi, (%rcx,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rax
jne 0xa03f9
retq
movabsq $0x1ffffffffffffff8, %rax # imm = 0x1FFFFFFFFFFFFFF8
testq %rax, %rdx
je 0xa0456
movq 0x10(%rdi), %rdi
andq %rax, %rdx
cmpq $0x9, %rdx
movl $0x8, %eax
cmovaeq %rdx, %rax
leaq -0x8(,%rax,8), %rdx
andq $-0x40, %rdx
addq $0x40, %rdx
xorl %esi, %esi
jmp 0x9270
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_type_name
static const char *make_type_name(s7_scheme *sc, const char *name, article_t article)
                {
                    s7_int i, slen, len;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0xa04c4
cmpb $0x0, (%r14)
je 0xa04c4
movq $-0x1, %rax
leaq 0x1(%rax), %r15
cmpb $0x0, 0x1(%r14,%rax)
movq %r15, %rax
jne 0xa04b3
jmp 0xa04c7
xorl %r15d, %r15d
leaq 0x8(%r15), %r12
movslq 0x480(%rbx), %rax
cmpq %rax, %r12
jle 0xa04fe
movq 0x478(%rbx), %rdi
testq %rdi, %rdi
je 0xa04e8
callq 0x9050
movq %r12, %rdi
callq 0x9480
movq %rax, 0x478(%rbx)
movl %r12d, 0x480(%rbx)
cmpl $0x1, %ebp
jne 0xa054d
movq 0x478(%rbx), %rax
movb $0x61, (%rax)
movb (%r14), %al
addb $-0x61, %al
rorb %al
movl $0x1, %r12d
cmpb $0xa, %al
ja 0xa053c
movzbl %al, %eax
movl $0x495, %ecx            # imm = 0x495
btl %eax, %ecx
jae 0xa053c
movq 0x478(%rbx), %rax
movb $0x6e, 0x1(%rax)
movl $0x2, %r12d
movq 0x478(%rbx), %rax
movb $0x20, (%rax,%r12)
incq %r12
jmp 0xa0550
xorl %r12d, %r12d
movq 0x478(%rbx), %rdi
addq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x93e0
addq 0x478(%rbx), %r12
movb $0x0, (%r15,%r12)
movq 0x478(%rbx), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: typed_vector_typer_name
static const char *typed_vector_typer_name(s7_scheme *sc, s7_pointer p)
                {
                    s7_pointer typer;
                    typer = typed_vector_typer(p);
                    if (is_c_function(typer))
                        return(c_function_name(typer));
                    return(symbol_name(typed_vector_typer_symbol(sc, p)));
                }

// Assembly:
pushq %rax
movq 0x28(%rsi), %rsi
cmpb $0x30, (%rsi)
jb 0xa0591
movq 0x8(%rsi), %rax
jmp 0xa05a2
movq 0x18(%rsi), %rdx
callq 0xa05a7
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpb $0x1c, (%rdx)
jne 0xa05ff
movq %rdx, %r14
movq %rsi, %r15
testb $0x20, 0x3(%r14)
je 0xa05e0
movq 0x20(%r14), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0xcd2c
cmpq %r15, %rax
cmoveq %r13, %r12
je 0xa0612
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa05f5
cmpq %r15, 0x10(%rax)
je 0xa0608
movq 0x18(%rax), %rax
jmp 0xa05e4
movq 0x10(%r14), %r14
cmpb $0x1c, (%r14)
je 0xa05be
addq $0x110, %rbx            # imm = 0x110
jmp 0xa060f
addq $0x8, %rax
movq %rax, %rbx
movq (%rbx), %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa08d9
xorl %r12d, %r12d
movq %r14, %rax
incq %r12
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xa08cb
jmp 0xa08dc
xorl %r12d, %r12d
movq %r12, %rbx
shlq $0x4, %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa305
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 0xa0931
movq %rcx, %rsi
movq 0x8(%r14), %rdi
cmpb $0xb, (%rdi)
jne 0xa091f
movq 0x8(%rdi), %rdi
jmp 0xa0921
xorl %edi, %edi
movq %rdi, (%rsi)
movq 0x10(%r14), %r14
addq $0x8, %rsi
cmpq %rdx, %r14
jne 0xa0910
testq %r12, %r12
jle 0xa0959
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
jg 0xa0942
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rcx
jp 0xa09da
testq %rcx, %rcx
je 0xa09df
movapd 0x72450(%rip), %xmm1    # 0x112dd0
movq (%rcx), %rdx
cmpb $0xd, (%rdx)
jne 0xa09b4
movsd 0x8(%rdx), %xmm2
ucomisd %xmm0, %xmm2
jne 0xa0995
jnp 0xa09ab
subsd %xmm0, %xmm2
andpd %xmm1, %xmm2
movsd 0x268(%rdi), %xmm3
ucomisd %xmm2, %xmm3
jbe 0xa09bf
xorl %edx, %edx
movq %rcx, %rax
testb %dl, %dl
je 0xa09e6
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xa0980
jmp 0xa09df
movb $0x1, %dl
jmp 0xa09b0
movq (%rcx), %rax
cmpb $0xd, (%rax)
jne 0xa09d6
movsd 0x8(%rax), %xmm0
ucomisd %xmm0, %xmm0
jp 0xa09e7
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xa09c3
movq 0x490(%rdi), %rax
retq
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa0a08
cmpb $0x30, (%rsi)
jb 0xa0a09
movq 0x8(%rsi), %rax
movq 0x58(%rax), %rax
retq
movq 0x18(%rsi), %rdx
jmp 0xa05a7
// File: /workspace/github_c_makefile_star2_O1/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 0xa0a94
movq %rsi, %r12
leaq 0x7f6f6(%rip), %rax     # 0x12014f
movq %rax, 0x10(%r13)
movq $0x23, 0x8(%r13)
movq %rbx, %rdi
callq 0x461ec
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 0xa0ab5
leaq 0x7f692(%rip), %rax     # 0x12012d
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 0x3b366
// File: /workspace/github_c_makefile_star2_O1/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 0xa0b4f
movq 0x110(%rdi), %rax
cmpq %rdx, %rax
je 0xa0b48
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmpb $0xa, (%rdx)
je 0xa0b4b
testb $0x2, 0x3(%rdx)
jne 0xa0b4b
xorl %ecx, %ecx
cmpb $0x1, (%rdx)
jne 0xa0b39
movq 0x1890(%rdi), %rdi
xorl %ecx, %ecx
movl %ecx, %r8d
movq 0x8(%rdx), %r9
xorl %ecx, %ecx
cmpq %rdi, %r9
setne %cl
addl %r8d, %ecx
cmpq %rdi, %r9
je 0xa0b39
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
je 0xa0b19
cmpq %rax, %rdx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmovel %ecx, %r8d
jmp 0xa0b4b
xorl %r8d, %r8d
movl %r8d, 0x28(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
testq %rax, %rax
jle 0xa0b85
movq 0x7b0(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
cmpq %r15, 0x8(%rsi)
je 0xa0bef
incq %rdx
cmpq %rdx, %rax
jne 0xa0b73
movq 0x7b8(%rbx), %rsi
cmpq %rsi, %rax
jne 0xa0bb3
leaq (%rsi,%rsi), %rax
movq %rax, 0x7b8(%rbx)
movq 0x7b0(%rbx), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, 0x7b0(%rbx)
movq %rbx, %rdi
callq 0xfa3b
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 0xa0bf3
movq %r14, 0x10(%rsi)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3b2ff
testb %al, %al
je 0xa0c53
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 0x7f6fd(%rip), %rax     # 0x12033c
movq %rax, 0x10(%rdx)
movq $0x14, 0x8(%rdx)
movq %rbx, %rdi
callq 0x3b366
cmpq %r14, 0x110(%rbx)
je 0xa0c87
movl $0x2, %esi
cmpb $0x1, (%r14)
jne 0xa0c89
movq 0x8(%r14), %rax
cmpq 0x17b0(%rbx), %rax
je 0xa0c89
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa25cc
movq %rax, %rsi
addq %rax, %rsi
jmp 0xa0c89
xorl %esi, %esi
movq %rbx, %rdi
callq 0x3e1dd
cmpq $0x0, 0x6a0(%rbx)
jle 0xa0ca8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa2386
jmp 0xa0cb3
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa24d1
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
cmpq %rsi, 0x150(%rdi)
je 0xa0e49
movq %rsi, %rbx
cmpq %rsi, 0x2150(%r14)
je 0xa0e52
testb $0x40, 0x3(%rbx)
je 0xa0e68
cmpb $0x1, 0x24c(%r14)
jne 0xa0e68
movq 0x1218(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x99ef
movq %rax, %r15
movq 0x128(%r14), %r12
cmpq %r12, %rax
je 0xa0e59
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0xa0e04
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %rbx, 0x8(%rdx)
movq %r13, 0x10(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0xbd41
movq %rax, %rcx
movq $-0x1, %rax
cmpb $0xb, (%rcx)
jne 0xa0e59
movq 0x8(%rcx), %rax
jmp 0xa0e59
movq 0x160(%r14), %rax
jmp 0xa0e5e
movl $0x2b, %eax
jmp 0xa0e5e
cmpq %r12, %r15
je 0xa0e68
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0xa0e5e
incq %rax
movq 0x18(%rcx), %rcx
jmp 0xa0e6e
// File: /workspace/github_c_makefile_star2_O1/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 0xa102b
movb 0x8(%rbx), %al
movq 0x10(%rsi), %rcx
movb %al, (%rcx,%rdx)
jmp 0xa108f
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rdi)
leaq 0x7f302(%rip), %rcx     # 0x120351
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 0x3b366
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa10a6
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rcx
jmp 0x38db7
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rdx
movq (%rax,%rdx,8), %rax
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rdi)
leaq 0x7f2a1(%rip), %rdx     # 0x12036b
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 0x3b366
// File: /workspace/github_c_makefile_star2_O1/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 0xa113c
leaq 0xad81a(%rip), %rax     # 0x14e950
movq (%rax,%r12,8), %rax
jmp 0xa1175
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xa1154
movq %rbx, %rdi
callq 0xb389
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