LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_assoc
s7_pointer s7_assoc(s7_scheme *sc, s7_pointer sym, s7_pointer lst)
                {
                    s7_pointer x, y;

                    if (!is_pair(lst))
                        return(sc->F);

                    x = lst;
                    y = lst;
                    while (true)
                    {
                        if ((is_pair(car(x))) && (s7_is_equal(sc, sym, caar(x)))) return(car(x));
                        x = cdr(x);
                        if (!is_pair(x)) return(sc->F);

                        if ((is_pair(car(x))) && (s7_is_equal(sc, sym, caar(x)))) return(car(x));
                        x = cdr(x);
                        if (!is_pair(x)) return(sc->F);

                        y = cdr(y);
                        if (x == y) return(sc->F);
                    }
                    return(sc->F);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x30f76
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x310a4
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x30fd0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
callq 0x2f770
testb $0x1, %al
jne 0x30fbd
jmp 0x30fd0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x310a4
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x31001
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x310a4
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x31044
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
callq 0x2f770
testb $0x1, %al
jne 0x31034
jmp 0x31044
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x310a4
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x31072
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x310a4
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x3109f
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x310a4
jmp 0x30f8a
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_append
s7_pointer s7_append(s7_scheme *sc, s7_pointer a, s7_pointer b)
                {
                    s7_pointer p, tp, np;
                    if (is_null(a)) return(b);

                    tp = cons(sc, car(a), sc->nil);
                    sc->y = tp;
                    for (p = cdr(a), np = tp; is_pair(p); p = cdr(p), np = cdr(np))
                        set_cdr(np, cons(sc, car(p), sc->nil));
                    set_cdr(np, b);
                    sc->y = sc->nil;

                    return(tp);
                }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq 0x68(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x31725
movq 0x58(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x318f6
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x31768
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x4e8(%rax)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x318c6
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x31844
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x317f0
movq 0x58(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x4e8(%rax)
movq 0x48(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_list_length
s7_int s7_list_length(s7_scheme *sc, s7_pointer a)
                {
                    /* returns -len if list is dotted, 0 if it's (directly) circular */
                    s7_int i;
                    s7_pointer slow, fast;

                    slow = fast = a;
                    for (i = 0; ; i += 2)
                    {
                        if (!is_pair(fast))
                        {
                            if (is_null(fast))
                                return(i);
                            return(-i);
                        }

                        fast = cdr(fast);
                        if (!is_pair(fast))
                        {
                            if (is_null(fast))
                                return(i + 1);
                            return(-i - 1);
                        }
                        /* if unrolled further, it's a lot slower? */

                        fast = cdr(fast);
                        slow = cdr(slow);
                        if (fast == slow)
                            return(0);
                    }
                    return(0);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq %rax, -0x28(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x31962
movq -0x30(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x31951
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x319fa
xorl %eax, %eax
subq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x319fa
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x319b2
movq -0x30(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x319a0
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x319fa
xorl %eax, %eax
subq -0x20(%rsp), %rax
subq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x319fa
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x28(%rsp), %rax
jne 0x319e5
movq $0x0, -0x8(%rsp)
jmp 0x319fa
jmp 0x319e7
movq -0x20(%rsp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rsp)
jmp 0x31922
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_is_proper_list
bool s7_is_proper_list(s7_scheme *sc, s7_pointer lst)
                {
                    /* #t if () or undotted/non-circular pair */
                    s7_pointer slow, fast;

                    fast = lst;
                    slow = lst;
                    while (true)
                    {
                        if (!is_pair(fast))
                            return(is_null(fast)); /* else it's an improper list */
                        LOOP_4(fast = cdr(fast); if (!is_pair(fast)) return(is_null(fast)));
                        fast = cdr(fast);
                        slow = cdr(slow);
                        if (fast == slow) return(false);
                    }
                    return(true);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x31a8a
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x110(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x31ba4
jmp 0x31a8c
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x31ac6
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x110(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x31ba4
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x31b00
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x110(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x31ba4
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x31b37
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x110(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x31ba4
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x31b6e
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x110(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x31ba4
jmp 0x31b70
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jne 0x31b9f
movb $0x0, -0x1(%rsp)
jmp 0x31ba4
jmp 0x31a5e
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_memq
s7_pointer s7_memq(s7_scheme *sc, s7_pointer obj, s7_pointer x)
                {
                    s7_pointer y;
                    y = x;
                    while (true)
                    {
                        LOOP_4(if (obj == car(x)) return(x); x = cdr(x); if (!is_pair(x)) return(sc->F));
                        y = cdr(y);
                        if (x == y) return(sc->F);
                    }
                    return(sc->F);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x28(%rsp)
jmp 0x31f6b
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x31f8a
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x320d6
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x31fbb
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x320d6
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x31fda
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x320d6
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x3200b
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x320d6
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x3202a
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x320d6
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x32058
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x320d6
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x32074
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x320d6
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x320a2
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x320d6
jmp 0x320a4
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jne 0x320d1
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x320d6
jmp 0x31f69
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_list
s7_pointer s7_list(s7_scheme *sc, s7_int num_values, ...)
                {
                    s7_int i;
                    va_list ap;
                    s7_pointer p;

                    if (num_values == 0)
                        return(sc->nil);

                    sc->w = make_list(sc, num_values, sc->nil);
                    va_start(ap, num_values);
                    for (i = 0, p = sc->w; i < num_values; i++, p = cdr(p))
                        set_car(p, va_arg(ap, s7_pointer));
                    va_end(ap);

                    if (sc->safety > NO_SAFETY)
                        check_list_validity(sc, "s7_list", sc->w);

                    p = sc->w;
                    sc->w = sc->nil;
                    return(p);
                }

// Assembly:
subq $0x118, %rsp            # imm = 0x118
testb %al, %al
je 0x32122
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
cmpq $0x0, 0x100(%rsp)
jne 0x3216d
movq 0x108(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x110(%rsp)
jmp 0x3231d
movq 0x108(%rsp), %rdi
movq 0x100(%rsp), %rax
movl %eax, %esi
movq 0x108(%rsp), %rax
movq 0x110(%rax), %rdx
callq 0x32330
movq %rax, %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0x4d8(%rax)
leaq 0xe0(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x120(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq $0x0, 0xf8(%rsp)
movq 0x108(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0xd8(%rsp)
movq 0xf8(%rsp), %rax
cmpq 0x100(%rsp), %rax
jge 0x3229b
leaq 0xe0(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0xe0(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x28, %eax
ja 0x32241
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, 0x8(%rsp)
jmp 0x3225a
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0xd8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0xf8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xf8(%rsp)
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xd8(%rsp)
jmp 0x321f2
leaq 0xe0(%rsp), %rax
movq 0x108(%rsp), %rax
cmpq $0x0, 0x6a0(%rax)
jle 0x322d8
movq 0x108(%rsp), %rdi
movq 0x108(%rsp), %rax
movq 0x4d8(%rax), %rdx
leaq 0x1afa29(%rip), %rsi    # 0x1e1cfc
callq 0x32de0
movq 0x108(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0xd8(%rsp)
movq 0x108(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0xd8(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rax
addq $0x118, %rsp            # imm = 0x118
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: check_list_validity
static void check_list_validity(s7_scheme *sc, const char *caller, s7_pointer lst)
                {
                    s7_pointer p;
                    int32_t i;
                    for (i = 1, p = lst; is_pair(p); p = cdr(p), i++)
                        if (!s7_is_valid(sc, car(p)))
                            s7_warn(sc, 256, "bad arg (#%d) to %s: %p\n", i, caller, car(p));
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x1, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x32e70
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x2ca70
testb $0x1, %al
jne 0x32e53
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %ecx
movq 0x18(%rsp), %r8
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r9
movl $0x100, %esi            # imm = 0x100
leaq 0x1bbd22(%rip), %rdx    # 0x1eeb6e
movb $0x0, %al
callq 0x14df0
jmp 0x32e55
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x32e05
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_make_int_vector
s7_pointer s7_make_int_vector(s7_scheme *sc, s7_int len, s7_int dims, s7_int *dim_info)
                {
                    s7_pointer p;
                    p = make_vector_1(sc, len, FILLED, T_INT_VECTOR);
                    if (dim_info)
                    {
                        vector_set_dimension_info(p, make_vdims(sc, false, dims, dim_info));
                        add_multivector(sc, p);
                    }
                    else add_vector(sc, p);
                    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
movq 0x18(%rsp), %rsi
movl $0x1, %edx
movl $0x16, %ecx
callq 0x333c0
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x33979
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
xorl %esi, %esi
callq 0x339a0
movq %rax, %rcx
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x790(%rax), %rdi
movq (%rsp), %rsi
callq 0x11230
jmp 0x3398e
movq 0x20(%rsp), %rax
movq 0x740(%rax), %rdi
movq (%rsp), %rsi
callq 0x11230
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_make_float_vector
s7_pointer s7_make_float_vector(s7_scheme *sc, s7_int len, s7_int dims, s7_int *dim_info)
                {
                    s7_pointer p;
                    p = make_vector_1(sc, len, FILLED, T_FLOAT_VECTOR);
                    if (dim_info)
                    {
                        vector_set_dimension_info(p, make_vdims(sc, false, dims, dim_info));
                        add_multivector(sc, p);
                    }
                    else add_vector(sc, p);
                    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
movq 0x18(%rsp), %rsi
movl $0x1, %edx
movl $0x17, %ecx
callq 0x333c0
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x33be9
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
xorl %esi, %esi
callq 0x339a0
movq %rax, %rcx
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x790(%rax), %rdi
movq (%rsp), %rsi
callq 0x11230
jmp 0x33bfe
movq 0x20(%rsp), %rax
movq 0x740(%rax), %rdi
movq (%rsp), %rsi
callq 0x11230
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_make_float_vector_wrapper
s7_pointer s7_make_float_vector_wrapper(s7_scheme *sc, s7_int len, s7_double *data, s7_int dims, s7_int *dim_info, bool free_data)
                {
                    /* this wraps up a C-allocated/freed double array as an s7 vector. */
                    s7_pointer x;
                    block_t *b;

                    new_cell(sc, x, T_FLOAT_VECTOR | T_SAFE_PROCEDURE);
                    b = mallocate_vector(sc, 0);
                    vector_block(x) = b;
                    /* block_data(b) = data; */
                    float_vector_floats(x) = data;
                    vector_getter(x) = float_vector_getter;
                    vector_setter(x) = float_vector_setter;
                    vector_length(x) = len;
                    if (!dim_info)
                    {
                        s7_int di[1];
                        di[0] = len;
                        vector_set_dimension_info(x, make_vdims(sc, free_data, 1, di));
                    }
                    else vector_set_dimension_info(x, make_vdims(sc, free_data, dims, dim_info));
                    add_multivector(sc, x);
                    return(x);
                }

// Assembly:
subq $0x48, %rsp
movb %r9b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x40(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x40(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x33c5a
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 $0x200017, (%rax)       # imm = 0x200017
movq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x33d80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
leaq 0x12c(%rip), %rcx       # 0x33df0
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
leaq 0x1cc(%rip), %rcx       # 0x33ea0
movq %rcx, 0x28(%rax)
movq 0x38(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x20(%rsp)
jne 0x33d24
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
movb 0x1f(%rsp), %al
movq %rsp, %rcx
movl $0x1, %edx
andb $0x1, %al
movzbl %al, %esi
callq 0x339a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x33d51
movq 0x40(%rsp), %rdi
movb 0x1f(%rsp), %al
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
andb $0x1, %al
movzbl %al, %esi
callq 0x339a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq 0x40(%rsp), %rax
movq 0x790(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11230
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mallocate_vector
static inline block_t *mallocate_vector(s7_scheme *sc, s7_int len)
                {
                    block_t *b;
                    if (len > 0)
                        return(mallocate(sc, len));
                    b = mallocate_block(sc);
                    block_data(b) = NULL;
                    block_info(b) = NULL;
                    return(b);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jle 0x33dac
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xaa80
movq %rax, 0x20(%rsp)
jmp 0x33dde
movq 0x18(%rsp), %rdi
callq 0x11020
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %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: vector_fill
static void vector_fill(s7_scheme *sc, s7_pointer vec, s7_pointer obj)
                {
                    switch (type(vec))
                    {
                        case T_FLOAT_VECTOR:
                            if (!s7_is_real(obj))
                                s7_wrong_type_arg_error(sc, "float-vector fill!", 2, obj, "a real");
                            else float_vector_fill(sc, vec, s7_real(obj));
                            break;

                        case T_INT_VECTOR:
                            if (!s7_is_integer(obj)) /* possibly a bignum */
                                s7_wrong_type_arg_error(sc, "int-vector fill!", 2, obj, "an integer");
                            else int_vector_fill(sc, vec, s7_integer(obj));
                            break;

                        case T_BYTE_VECTOR:
                            if (!is_byte(obj))
                                s7_wrong_type_arg_error(sc, "byte-vector fill!", 2, obj, "a byte");
                            else byte_vector_fill(sc, vec, (uint8_t)s7_integer(obj));
                            break;

                        default:
                            normal_vector_fill(sc, vec, obj);
                    }
                }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x3c(%rsp)
subl $0x16, %eax
je 0x3400b
jmp 0x33f8a
movl 0x3c(%rsp), %eax
subl $0x17, %eax
je 0x33fa7
jmp 0x33f95
movl 0x3c(%rsp), %eax
subl $0x18, %eax
je 0x3406f
jmp 0x340d3
movq 0x40(%rsp), %rdi
callq 0x11360
testb $0x1, %al
jne 0x33fd9
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rcx
leaq 0x1babc8(%rip), %rsi    # 0x1eeb8e
movl $0x2, %edx
leaq 0x1babcf(%rip), %r8     # 0x1eeba1
callq 0x12540
jmp 0x34006
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x128d0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xd8130
jmp 0x340e7
movq 0x40(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0x3403d
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rcx
leaq 0x1bab7e(%rip), %rsi    # 0x1eeba8
movl $0x2, %edx
leaq 0x1babfc(%rip), %r8     # 0x1eec32
callq 0x12540
jmp 0x3406d
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x10790
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0xd8330
jmp 0x340e7
movq 0x40(%rsp), %rdi
callq 0xd8510
testb $0x1, %al
jne 0x340a1
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rcx
leaq 0x1bab2b(%rip), %rsi    # 0x1eebb9
movl $0x2, %edx
leaq 0x1baaed(%rip), %r8     # 0x1eeb87
callq 0x12540
jmp 0x340d1
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x10790
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movzbl %al, %edx
callq 0xd8570
jmp 0x340e7
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xd85e0
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_set
s7_pointer s7_vector_set(s7_scheme *sc, s7_pointer vec, s7_int index, s7_pointer a)
                {
                    if (index >= vector_length(vec))
                        return(out_of_range(sc, sc->vector_set_symbol, small_int(2), wrap_integer1(sc, index), its_too_large_string));

                    if (is_typed_vector(vec))
                        return(typed_vector_setter(sc, vec, index, a));
                    vector_setter(vec)(sc, vec, index, T_Pos(a));
                    return(a);
                }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jl 0x34227
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x1668(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x1e22a2(%rip), %rax    # 0x216490
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x12430
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
movq 0x1e6355(%rip), %r8     # 0x21a570
callq 0x13880
movq %rax, 0x40(%rsp)
jmp 0x34281
movq 0x30(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x34258
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x34290
movq %rax, 0x40(%rsp)
jmp 0x34281
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq *%rax
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: typed_vector_setter
static inline s7_pointer typed_vector_setter(s7_scheme *sc, s7_pointer vec, s7_int loc, s7_pointer val)
                {
                    if ((sc->safety < NO_SAFETY) || /* or == NO_SAFETY?? */
                            (typed_vector_typer_call(sc, vec, set_plist_1(sc, val)) != sc->F))
                    {
                        vector_element(vec, loc) = val;
                        return(val);
                    }
                    return(s7_wrong_type_arg_error(sc, "vector-set!", 3, val, make_type_name(sc, typed_vector_typer_name(sc, vec), INDEFINITE_ARTICLE)));
                }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x58(%rsp), %rax
cmpq $0x0, 0x6a0(%rax)
jl 0x3435e
movq 0x50(%rsp), %rax
movq 0x28(%rax), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0x3430d
movq 0x50(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x35ea0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rax
callq *%rax
movq %rax, 0x38(%rsp)
jmp 0x3434b
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x35ea0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x58(%rsp), %rcx
cmpq 0x120(%rcx), %rax
je 0x34381
movq 0x40(%rsp), %rdx
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x40(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x343e1
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xd8a20
movq (%rsp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0xd8890
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq %rax, %r8
leaq 0x1b625b(%rip), %rsi    # 0x1ea62d
movl $0x3, %edx
callq 0x12540
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_dimensions
s7_int s7_vector_dimensions(s7_pointer vec, s7_int *dims, s7_int dims_size)
                {
                    if (dims_size <= 0) return(0);
                    if (vector_dimension_info(vec))
                    {
                        s7_int i, lim;
                        lim = vector_ndims(vec);
                        if (lim > dims_size) lim = dims_size;
                        for (i = 0; i < lim; i++)
                            dims[i] = vector_dimension(vec, i);
                        return(lim);
                    }
                    dims[0] = vector_length(vec);
                    return(1);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
jg 0x34445
movq $0x0, -0x8(%rsp)
jmp 0x344f7
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x344dd
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x20(%rsp), %rax
jle 0x34485
movq -0x20(%rsp), %rax
movq %rax, -0x30(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x30(%rsp), %rax
jge 0x344d1
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x3448e
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x344f7
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq $0x1, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_dimension
s7_int s7_vector_dimension(s7_pointer vec, s7_int dim)
                {
                    if (vector_dimension_info(vec))
                        return(vector_dimension(vec, dim));
                    if (dim == 0)
                        return(vector_length(vec));
                    return(-1);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x3453a
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rsp)
jmp 0x3455b
cmpq $0x0, -0x18(%rsp)
jne 0x34552
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x3455b
movq $-0x1, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_offsets
s7_int s7_vector_offsets(s7_pointer vec, s7_int *offs, s7_int offs_size)
                {
                    if (offs_size <= 0) return(0);
                    if (vector_dimension_info(vec))
                    {
                        s7_int i, lim;
                        lim = vector_ndims(vec);
                        if (lim > offs_size) lim = offs_size;
                        for (i = 0; i < lim; i++)
                            offs[i] = vector_offset(vec, i);
                        return(lim);
                    }
                    offs[0] = 1;
                    return(1);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
jg 0x34595
movq $0x0, -0x8(%rsp)
jmp 0x34643
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x3462e
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x20(%rsp), %rax
jle 0x345d5
movq -0x20(%rsp), %rax
movq %rax, -0x30(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x30(%rsp), %rax
jge 0x34622
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x345de
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x34643
movq -0x18(%rsp), %rax
movq $0x1, (%rax)
movq $0x1, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_set_n
s7_pointer s7_vector_set_n(s7_scheme *sc, s7_pointer vector, s7_pointer value, s7_int indices, ...)
                {
                    s7_int index;
                    va_list ap;
                    va_start(ap, indices);
                    index = flatten_multivector_indices(sc, vector, indices, ap);
                    if (is_typed_vector(vector))
                        return(typed_vector_setter(sc, vector, index, value));
                    return(vector_setter(vector)(sc, vector, index, value));
                }

// Assembly:
subq $0xf8, %rsp
testb %al, %al
je 0x34a9c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rdx, 0xd8(%rsp)
movq %rcx, 0xd0(%rsp)
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
movq 0xe8(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movq 0xd0(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
callq 0x34740
movq %rax, 0xc8(%rsp)
movq 0xe0(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x34b5e
movq 0xe8(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movq 0xd8(%rsp), %rcx
callq 0x34290
movq %rax, 0xf0(%rsp)
jmp 0x34b94
movq 0xe0(%rsp), %rax
movq 0x28(%rax), %rax
movq 0xe8(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movq 0xd8(%rsp), %rcx
callq *%rax
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_to_list
s7_pointer s7_vector_to_list(s7_scheme *sc, s7_pointer vect)
                {
                    s7_int i, len;
                    s7_pointer result;
                    len = vector_length(vect);
                    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, vector_getter(vect)(sc, vect, i), sc->v);
                    result = sc->v;
                    sc->v = sc->nil;
                    return(result);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x34bea
movq 0x28(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x34cb4
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x34cc0
movq 0x28(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x4d0(%rax)
movq 0x10(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jl 0x34c81
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rax
movq 0x4d0(%rax), %rdx
callq 0xd9f0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x4d0(%rax)
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x34c1f
movq 0x28(%rsp), %rax
movq 0x4d0(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x4d0(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: check_heap_size
static void check_heap_size(s7_scheme *sc, s7_int size)
#endif
        {
            s7_int free_cells;
            free_cells = sc->free_heap_top - sc->free_heap;
            if (free_cells < size)
            {
#if S7_DEBUGGING
                gc(sc, func, line);
#else
                gc(sc);
#endif
                while ((sc->free_heap_top - sc->free_heap) < size)
                    resize_heap(sc);
            }
        }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x88(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jge 0x34d3e
movq 0x10(%rsp), %rdi
callq 0xc1d50
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x88(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
cmpq 0x8(%rsp), %rax
jge 0x34d3c
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc0f40
jmp 0x34d06
jmp 0x34d3e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_simple_vector
static inline s7_pointer make_simple_vector(s7_scheme *sc, s7_int len) /* len >= 0 and < max */
                {
                    s7_pointer x;
                    block_t *b;
                    new_cell(sc, x, T_VECTOR | T_SAFE_PROCEDURE);
                    vector_length(x) = len;
                    b = mallocate_vector(sc, len * sizeof(s7_pointer));
                    vector_block(x) = b;
                    vector_elements(x) = (s7_pointer *)block_data(b);
                    vector_set_dimension_info(x, NULL);
                    vector_getter(x) = default_vector_getter;
                    vector_setter(x) = default_vector_setter;
                    add_vector(sc, x);
                    return(x);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x34dd2
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 0x10(%rsp), %rax
movq $0x200015, (%rax)       # imm = 0x200015
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
shlq $0x3, %rsi
callq 0x33d80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
leaq 0x2bd8d(%rip), %rcx     # 0x60bf0
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
leaq 0x2bdad(%rip), %rcx     # 0x60c20
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rax
movq 0x740(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11230
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_simple_float_vector
static inline s7_pointer make_simple_float_vector(s7_scheme *sc, s7_int len) /* len >= 0 and < max */
                {
                    s7_pointer x;
                    block_t *b;
                    new_cell(sc, x, T_FLOAT_VECTOR | T_SAFE_PROCEDURE);
                    vector_length(x) = len;
                    b = mallocate_vector(sc, len * sizeof(s7_double));
                    vector_block(x) = b;
                    float_vector_floats(x) = (s7_double *)block_data(b);
                    vector_set_dimension_info(x, NULL);
                    vector_getter(x) = float_vector_getter;
                    vector_setter(x) = float_vector_setter;
                    add_vector(sc, x);
                    return(x);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x36ff2
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 0x10(%rsp), %rax
movq $0x200017, (%rax)       # imm = 0x200017
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
shlq $0x3, %rsi
callq 0x33d80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
leaq -0x3293(%rip), %rcx     # 0x33df0
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
leaq -0x31f3(%rip), %rcx     # 0x33ea0
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rax
movq 0x740(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11230
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_simple_int_vector
static inline s7_pointer make_simple_int_vector(s7_scheme *sc, s7_int len) /* len >= 0 and < max */
                {
                    s7_pointer x;
                    block_t *b;
                    new_cell(sc, x, T_INT_VECTOR | T_SAFE_PROCEDURE);
                    vector_length(x) = len;
                    b = mallocate_vector(sc, len * sizeof(s7_int));
                    vector_block(x) = b;
                    int_vector_ints(x) = (s7_int *)block_data(b);
                    vector_set_dimension_info(x, NULL);
                    vector_getter(x) = int_vector_getter;
                    vector_setter(x) = int_vector_setter;
                    add_vector(sc, x);
                    return(x);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x370f2
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 0x10(%rsp), %rax
movq $0x200016, (%rax)       # imm = 0x200016
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
shlq $0x3, %rsi
callq 0x33d80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
leaq 0xa0c9d(%rip), %rcx     # 0xd7e20
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
leaq 0xa0d6d(%rip), %rcx     # 0xd7f00
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rax
movq 0x740(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11230
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_simple_byte_vector
static s7_pointer make_simple_byte_vector(s7_scheme *sc, s7_int len)
                {
                    s7_pointer x;
                    block_t *b;
                    new_cell(sc, x, T_BYTE_VECTOR | T_SAFE_PROCEDURE);
                    b = mallocate(sc, len);
                    vector_block(x) = b;
                    byte_vector_bytes(x) = (uint8_t *)block_data(b);
                    vector_length(x) = len;
                    vector_set_dimension_info(x, NULL);
                    vector_getter(x) = byte_vector_getter;
                    vector_setter(x) = byte_vector_setter;
                    add_vector(sc, x);
                    return(x);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x371f2
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 0x10(%rsp), %rax
movq $0x200018, (%rax)       # imm = 0x200018
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xaa80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
leaq 0xa0d01(%rip), %rcx     # 0xd7f80
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
leaq 0xa0dd1(%rip), %rcx     # 0xd8060
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rax
movq 0x740(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11230
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: callocate
static block_t *callocate(s7_scheme *sc, size_t bytes)
    {
        block_t *p;
        p = mallocate(sc, bytes);
        if ((block_data(p)) && (block_index(p) != BLOCK_LIST))
        {
            if (block_index(p) >= 6)
                memclr64((void *)block_data(p), bytes);
            else memclr((void *)(block_data(p)), bytes);
        }
        return(p);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xaa80
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x37385
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x37385
movq (%rsp), %rax
cmpl $0x6, 0x8(%rax)
jl 0x37372
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xd7ce0
jmp 0x37383
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xd2340
jmp 0x37385
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop