LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_display
s7_pointer s7_display(s7_scheme *sc, s7_pointer obj, s7_pointer port)
    {
        if (port != sc->F)
        {
            if (port_is_closed(port))
                s7_wrong_type_arg_error(sc, "display", 2, port, "an open output port");
            object_out(sc, obj, port, P_DISPLAY);
        }
        return(obj);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq %rdx, 0x120(%rdi)
je 0x380ba
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x3806b
leaq 0xd216a(%rip), %rsi     # 0x10a1be
leaq 0xe2f2a(%rip), %r8      # 0x11af85
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0xd4e5
movzbl (%rbx), %eax
leaq 0x11a2cb(%rip), %rcx    # 0x152340
cmpb $0x1, (%rax,%rcx)
jne 0x380a1
cmpl $0x15, %eax
jne 0x38086
testb $0x1, 0x7(%rbx)
jne 0x380a1
cmpq %rbx, 0x150(%r15)
je 0x380a1
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x95196
jmp 0x380ba
leaq 0x11a2d8(%rip), %r9     # 0x152380
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *(%r9,%rax,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_cons
s7_pointer s7_cons(s7_scheme *sc, s7_pointer a, s7_pointer b)
    {
        s7_pointer x;
        new_cell(sc, x, T_PAIR | T_SAFE_PROCEDURE);
        set_car(x, a);
        set_cdr(x, b);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x381ce
movq %r15, %rdi
callq 0xa550
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_make_signature
s7_pointer s7_make_signature(s7_scheme *sc, s7_int len, ...)
    {
        va_list ap;
        s7_int i;
        s7_pointer p, res;

        res = permanent_list(sc, len);
        va_start(ap, len);
        for (p = res, i = 0; is_pair(p); p = cdr(p), i++)
        {
            set_car(p, va_arg(ap, s7_pointer));
            check_sig_entry(sc, p, i, false);
        }
        va_end(ap);

        return((s7_pointer)res);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x38255
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 0x110(%rdi), %r12
testq %rsi, %rsi
jle 0x38295
movq %rsi, %r15
movabsq $0x4000000001000001, %r13 # imm = 0x4000000001000001
movq 0x110(%rbx), %rbp
movq %rbx, %rdi
callq 0xec9f
movq %rax, %r14
movq %r13, (%rax)
movq %rbp, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, %r12
decq %r15
jne 0x3826e
jmp 0x38298
movq %r12, %r14
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
cmpb $0x1, (%r14)
jne 0x38317
xorl %r15d, %r15d
movq %r14, %r12
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x382e2
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x382f0
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%r12)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x3832c
movq 0x10(%r12), %r12
incq %r15
cmpb $0x1, (%r12)
je 0x382c9
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: check_sig_entry
static void check_sig_entry(s7_scheme *sc, s7_pointer p, s7_int pos, bool circle)
    {
        if ((!is_normal_symbol(car(p))) &&
                (!s7_is_boolean(car(p))) &&
                (!is_pair(car(p))))
        {
            s7_warn(sc, 512, "s7_make_%ssignature got an invalid entry at position %" print_s7_int ": (", (circle) ? "circular_" : "", pos);
            set_car(p, sc->nil);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r8
movq 0x8(%rsi), %rax
movzbl (%rax), %edx
cmpl $0x1, %edx
je 0x3838d
cmpl $0x7, %edx
je 0x3838d
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xa, %edx
jne 0x38355
testb $-0x80, 0x6(%rax)
je 0x3838d
leaq 0xded48(%rip), %rdx     # 0x1170a4
leaq 0xe416b(%rip), %rax     # 0x11c4ce
testb %cl, %cl
cmovneq %rdx, %rax
leaq 0xdecf8(%rip), %rdx     # 0x117068
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xeea2
movq 0x110(%r14), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_make_circular_signature
s7_pointer s7_make_circular_signature(s7_scheme *sc, s7_int cycle_point, s7_int len, ...)
    {
        va_list ap;
        s7_int i;
        s7_pointer p, res, back = NULL, end = NULL;

        res = permanent_list(sc, len);
        va_start(ap, len);
        for (p = res, i = 0; is_pair(p); p = cdr(p), i++)
        {
            set_car(p, va_arg(ap, s7_pointer));
            check_sig_entry(sc, p, i, true);
            if (i == cycle_point) back = p;
            if (i == (len - 1)) end = p;
        }
        va_end(ap);
        if (end) set_cdr(end, back);
        if (i < len)
            s7_warn(sc, 256, "s7_make_circular_signature got too few entries: %s\n", s7_object_to_c_string(sc, res));
        return((s7_pointer)res);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, 0x38(%rsp)
movq %rdi, %rbx
movq %rcx, 0x58(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x68(%rsp)
testb %al, %al
je 0x383fe
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq 0x110(%rdi), %r14
testq %rdx, %rdx
movq %rdx, 0x8(%rsp)
jle 0x38443
movabsq $0x4000000001000001, %r12 # imm = 0x4000000001000001
movq %rdx, %r13
movq 0x110(%rbx), %rbp
movq %rbx, %rdi
callq 0xec9f
movq %rax, %r15
movq %r12, (%rax)
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, %r14
decq %r13
jne 0x3841c
jmp 0x38446
movq %r14, %r15
leaq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x130(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, 0x10(%rsp)
cmpb $0x1, (%r15)
jne 0x384fc
movq 0x8(%rsp), %rax
decq %rax
movq %rax, 0x30(%rsp)
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %r15, %rbp
movl 0x10(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x384aa
movq %rcx, %rax
addq 0x20(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x10(%rsp)
jmp 0x384b8
movq 0x18(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rbp)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x3832c
cmpq %r13, 0x38(%rsp)
cmoveq %rbp, %r12
cmpq %r13, 0x30(%rsp)
cmoveq %rbp, %r14
movq 0x10(%rbp), %rbp
incq %r13
cmpb $0x1, (%rbp)
je 0x3848f
testq %r14, %r14
je 0x384ff
movq %r12, 0x10(%r14)
jmp 0x384ff
xorl %r13d, %r13d
movq 0x8(%rsp), %rax
cmpq %rax, %r13
jge 0x3852d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37c3e
leaq 0xd1cab(%rip), %rdx     # 0x10a1c6
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xeea2
movq %r15, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_n_2
s7_pointer s7_apply_n_2(s7_scheme *sc, s7_pointer args, s7_pointer (*f2)(s7_pointer a1, s7_pointer a2))
    {
        if (is_pair(args))
        {
            if (is_pair(cdr(args)))
                return(f2(car(args), cadr(args)));
            return(f2(car(args), sc->undefined));
        }
        return(f2(sc->undefined, sc->undefined));
    }

// Assembly:
cmpb $0x1, (%rsi)
jne 0x388b1
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x388bd
movq 0x8(%rcx), %rsi
jmp 0x388c4
movq 0x128(%rdi), %rdi
movq %rdi, %rsi
jmpq *%rdx
movq 0x128(%rdi), %rsi
movq %rax, %rdi
jmpq *%rdx
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_n_3
s7_pointer s7_apply_n_3(s7_scheme *sc, s7_pointer args, s7_pointer (*f3)(s7_pointer a1, s7_pointer a2, s7_pointer a3))
    {
        if (is_pair(args))
        {
            s7_pointer a1;
            a1 = car(args); args = cdr(args);
            if (is_pair(args))
            {
                s7_pointer a2;
                a2 = car(args);
                if (is_pair(cdr(args)))
                    return(f3(a1, a2, cadr(args)));
                return(f3(a1, a2, sc->undefined));
            }
            return(f3(a1, sc->undefined, sc->undefined));
        }
        return(f3(sc->undefined, sc->undefined, sc->undefined));
    }

// Assembly:
movq %rdx, %rax
cmpb $0x1, (%rsi)
jne 0x388f1
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
cmpb $0x1, (%rdx)
jne 0x38900
movq 0x8(%rdx), %rsi
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
jne 0x3890f
movq 0x8(%rdx), %rdx
jmp 0x38916
movq 0x128(%rdi), %rdi
movq %rdi, %rsi
movq %rdi, %rdx
jmpq *%rax
movq 0x128(%rdi), %rdx
movq %rcx, %rdi
movq %rdx, %rsi
jmpq *%rax
movq 0x128(%rdi), %rdx
movq %rcx, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_n_4
s7_pointer s7_apply_n_4(s7_scheme *sc, s7_pointer args, s7_pointer (*f4)(s7_pointer a1, s7_pointer a2, s7_pointer a3, s7_pointer a4))
    {
        if (is_pair(args))
        {
            s7_pointer a1;
            a1 = car(args); args = cdr(args);
            if (is_pair(args))
            {
                s7_pointer a2;
                a2 = car(args); args = cdr(args);
                if (is_pair(args))
                {
                    s7_pointer a3;
                    a3 = car(args);
                    if (is_pair(cdr(args)))
                        return(f4(a1, a2, a3, cadr(args)));
                    return(f4(a1, a2, a3, sc->undefined));
                }
                return(f4(a1, a2, sc->undefined, sc->undefined));
            }
            return(f4(a1, sc->undefined, sc->undefined, sc->undefined));
        }
        return(f4(sc->undefined, sc->undefined, sc->undefined, sc->undefined));
    }

// Assembly:
movq %rdx, %rax
cmpb $0x1, (%rsi)
jne 0x38950
movq 0x8(%rsi), %r8
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x3895c
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x3896e
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x3897a
movq 0x8(%rcx), %rcx
jmp 0x38981
movq 0x128(%rdi), %rcx
movq %rcx, %rdi
jmp 0x38966
movq 0x128(%rdi), %rcx
movq %r8, %rdi
movq %rcx, %rsi
movq %rcx, %rdx
jmpq *%rax
movq 0x128(%rdi), %rcx
movq %r8, %rdi
jmp 0x38969
movq 0x128(%rdi), %rcx
movq %r8, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_n_5
s7_pointer s7_apply_n_5(s7_scheme *sc, s7_pointer args,
            s7_pointer (*f5)(s7_pointer a1, s7_pointer a2, s7_pointer a3, s7_pointer a4, s7_pointer a5))
    {
        if (is_pair(args))
        {
            s7_pointer a1;
            a1 = car(args); args = cdr(args);
            if (is_pair(args))
            {
                s7_pointer a2;
                a2 = car(args); args = cdr(args);
                if (is_pair(args))
                {
                    s7_pointer a3;
                    a3 = car(args); args = cdr(args);
                    if (is_pair(args))
                    {
                        s7_pointer a4;
                        a4 = car(args);
                        if (is_pair(cdr(args)))
                            return(f5(a1, a2, a3, a4, cadr(args)));
                        return(f5(a1, a2, a3, a4, sc->undefined));
                    }
                    return(f5(a1, a2, a3, sc->undefined, sc->undefined));
                }
                return(f5(a1, a2, sc->undefined, sc->undefined, sc->undefined));
            }
            return(f5(a1, sc->undefined, sc->undefined, sc->undefined, sc->undefined));
        }
        return(f5(sc->undefined, sc->undefined, sc->undefined, sc->undefined, sc->undefined));
    }

// Assembly:
movq %rdx, %rax
movq %rdi, %r8
cmpb $0x1, (%rsi)
jne 0x389cd
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x389d9
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x389eb
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %r9
cmpb $0x1, (%r9)
jne 0x389f4
movq 0x8(%r9), %rcx
movq 0x10(%r9), %r9
cmpb $0x1, (%r9)
jne 0x389fd
movq 0x8(%r9), %r8
jmpq *%rax
movq 0x128(%r8), %rcx
movq %rcx, %rdi
jmp 0x389e0
movq 0x128(%r8), %rcx
movq %rcx, %rsi
movq %rcx, %rdx
movq %rcx, %r8
jmpq *%rax
movq 0x128(%r8), %rcx
jmp 0x389e3
movq 0x128(%r8), %rcx
jmp 0x389e6
movq 0x128(%r8), %r8
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_n_6
s7_pointer s7_apply_n_6(s7_scheme *sc, s7_pointer args,
            s7_pointer (*f6)(s7_pointer a1, s7_pointer a2, s7_pointer a3, s7_pointer a4, s7_pointer a5, s7_pointer a6))
    {
        s7_pointer a1, a2, a3, a4, a5, a6, a7, a8, a9;
        a7 = sc->undefined; a8 = a7; a9 = a8;
        a1 = a9; a2 = a9; a3 = a9; a4 = a9; a5 = a9; a6 = a9;
        apply_set_args(args)
            return(f6(a1, a2, a3, a4, a5, a6));
    }

// Assembly:
movq %rdx, %rax
movq 0x128(%rdi), %r9
cmpb $0x1, (%rsi)
jne 0x38a5f
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x38a62
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x38a65
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %r8
cmpb $0x1, (%r8)
jne 0x38a68
movq 0x8(%r8), %rcx
movq 0x10(%r8), %r10
cmpb $0x1, (%r10)
jne 0x38a6b
movq 0x8(%r10), %r8
movq 0x10(%r10), %r10
cmpb $0x1, (%r10)
jne 0x38a6e
movq 0x8(%r10), %r9
jmpq *%rax
movq %r9, %rdi
movq %r9, %rsi
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_list_ref
s7_pointer s7_list_ref(s7_scheme *sc, s7_pointer lst, s7_int num)
    {
        s7_int i;
        s7_pointer x;
        for (x = lst, i = 0; (i < num) && (is_pair(x)); i++, x = cdr(x)) {}
        if ((i == num) && (is_pair(x)))
            return(car(x));
        return(sc->nil);
    }

// Assembly:
xorl %eax, %eax
testq %rdx, %rdx
jle 0x38c52
cmpb $0x1, (%rsi)
jne 0x38c52
incq %rax
movq 0x10(%rsi), %rsi
cmpq %rax, %rdx
jne 0x38c3f
jmp 0x38c57
cmpq %rdx, %rax
jne 0x38c65
cmpb $0x1, (%rsi)
jne 0x38c65
addq $0x8, %rsi
movq %rsi, %rdi
jmp 0x38c6c
addq $0x110, %rdi            # imm = 0x110
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_list_set
s7_pointer s7_list_set(s7_scheme *sc, s7_pointer lst, s7_int num, s7_pointer val)
    {
        s7_int i;
        s7_pointer x;
        for (x = lst, i = 0; (i < num) && (is_pair(x)); i++, x = cdr(x)) {}
        if ((i == num) &&
                (is_pair(x)))
            set_car(x, T_Pos(val));
        return(val);
    }

// Assembly:
movq %rcx, %rax
xorl %ecx, %ecx
testq %rdx, %rdx
jle 0x38c8d
cmpb $0x1, (%rsi)
jne 0x38c8d
incq %rcx
movq 0x10(%rsi), %rsi
cmpq %rcx, %rdx
jne 0x38c7a
jmp 0x38c92
cmpq %rdx, %rcx
jne 0x38c9b
cmpb $0x1, (%rsi)
jne 0x38c9b
movq %rax, 0x8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_member
s7_pointer s7_member(s7_scheme *sc, s7_pointer sym, s7_pointer lst)
    {
        s7_pointer x;
        for (x = lst; is_pair(x); x = cdr(x))
            if (s7_is_equal(sc, sym, car(x)))
                return(x);
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpb $0x1, (%rdx)
jne 0x38cda
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x11a067(%rip), %r12    # 0x152d20
movq 0x8(%rbx), %rdx
movzbl (%r15), %eax
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq *(%r12,%rax,8)
testb %al, %al
jne 0x38ce1
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0x38cb9
movq 0x120(%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_tree_memq
bool s7_tree_memq(s7_scheme *sc, s7_pointer sym, s7_pointer tree)
    {
        if (sym == tree) return(true);
        if (!is_pair(tree)) return(false);
        if ((sc->safety > NO_SAFETY) &&
                (tree_is_cyclic(sc, tree)))
            s7_error(sc, sc->wrong_type_arg_symbol, wrap_string(sc, "tree-memq: tree is cyclic", 25));
        return(tree_memq_1(sc, sym, tree));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rdx, %rsi
je 0x38d87
movq %rdx, %rbx
cmpb $0x1, (%rdx)
jne 0x38d8b
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x6a0(%rdi)
jle 0x38d74
movq %r15, %rdi
movq %rbx, %rsi
callq 0x38d93
testb %al, %al
je 0x38d74
movq 0x1940(%r15), %rsi
movq 0x820(%r15), %rax
movslq 0x7dc(%r15), %rcx
movq (%rax,%rcx,8), %rdx
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%r15)
leaq 0xd149a(%rip), %rax     # 0x10a1fa
movq %rax, 0x10(%rdx)
movq $0x19, 0x8(%rdx)
movq %r15, %rdi
callq 0x38dfa
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x39866
movb $0x1, %al
jmp 0x38d8d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: tree_is_cyclic
static bool tree_is_cyclic(s7_scheme *sc, s7_pointer tree)
    {
        int32_t i, result;

        result = tree_is_cyclic_or_has_pairs(sc, tree);
        if (result == TREE_NOT_CYCLIC) return(false);
        if (result == TREE_CYCLIC) return(true);

#if S7_DEBUGGING
        if (sc->tree_pointers_top != 0)
            fprintf(stderr, "top: %d\n", sc->tree_pointers_top);
#endif

        result = tree_is_cyclic_1(sc, tree);
        for (i = 0; i < sc->tree_pointers_top; i++)
            tree_clear_collected(sc->tree_pointers[i]);
        sc->tree_pointers_top = 0;

        return(result);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x995bc
testl %eax, %eax
je 0x38daf
cmpl $0x1, %eax
jne 0x38db3
movb $0x1, %al
jmp 0x38df2
xorl %eax, %eax
jmp 0x38df2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x99641
cmpl $0x0, 0x7d4(%rbx)
jle 0x38de8
xorl %ecx, %ecx
movq 0x7c8(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
andw $-0x9, 0x6(%rdx)
incq %rcx
movslq 0x7d4(%rbx), %rdx
cmpq %rdx, %rcx
jl 0x38dc9
movl $0x0, 0x7d4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: tree_memq_1
static inline bool tree_memq_1(s7_scheme *sc, s7_pointer sym, s7_pointer tree)    /* sym need not be a symbol */
    {
        if (car(tree) == sc->quote_symbol)
        {
            if ((is_symbol(sym)) || (is_pair(sym)) || (!is_pair(cdr(tree))))
                return(false);
            return(sym == cadr(tree));
        }
        do {
            if (sym == car(tree))
                return(true);

            if (is_pair(car(tree)))
            {
                s7_pointer cp;
                cp = car(tree);
                if (car(cp) == sc->quote_symbol)
                {
                    if ((!is_symbol(sym)) && (!is_pair(sym)) && (is_pair(cdr(cp))) && (sym == cadr(cp)))
                        return(true);
                }
                else
                {
                    do {
                        if (sym == car(cp))
                            return(true);
                        if ((is_pair(car(cp))) &&
                                (tree_memq_1(sc, sym, car(cp))))
                            return(true);
                        cp = cdr(cp);
                        if (sym == cp)
                            return(true);
                    } while (is_pair(cp));
                }
            }

            tree = cdr(tree);
            if (sym == tree)
                return(true);
        } while (is_pair(tree));
        return(false);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq 0x17b0(%rdi), %r13
cmpq %r13, 0x8(%rdx)
je 0x398fe
movq %rdi, %r12
movq 0x8(%r15), %rbp
movb $0x1, %bl
cmpq %r14, %rbp
je 0x39922
cmpb $0x1, (%rbp)
jne 0x398ed
cmpq %r13, 0x8(%rbp)
je 0x398d0
movq 0x8(%rbp), %rdx
cmpq %r14, %rdx
je 0x39922
cmpb $0x1, (%rdx)
jne 0x398bf
movq %r12, %rdi
movq %r14, %rsi
callq 0x39866
testb %al, %al
jne 0x39922
movq 0x10(%rbp), %rbp
cmpq %r14, %rbp
je 0x39922
cmpb $0x1, (%rbp)
je 0x398a2
jmp 0x398ed
movzbl (%r14), %eax
cmpl $0x1, %eax
je 0x398ed
cmpl $0xa, %eax
je 0x398ed
movq 0x10(%rbp), %rax
cmpb $0x1, (%rax)
jne 0x398ed
cmpq %r14, 0x8(%rax)
je 0x39922
movq 0x10(%r15), %r15
cmpq %r14, %r15
je 0x39922
cmpb $0x1, (%r15)
je 0x39887
jmp 0x39920
movzbl (%r14), %eax
xorl %ebx, %ebx
cmpl $0x1, %eax
je 0x39922
cmpl $0xa, %eax
je 0x39922
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0x39920
cmpq %r14, 0x8(%rax)
sete %bl
jmp 0x39922
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
cmpb $0x1, (%rdx)
jne 0x399b1
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x1193cf(%rip), %r12    # 0x152d20
movq %rdx, %r13
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x39975
movq 0x8(%rax), %rdx
movzbl (%r15), %eax
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq *(%r12,%rax,8)
testb %al, %al
jne 0x399c8
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
jne 0x399b1
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x3999f
movq 0x8(%rax), %rdx
movzbl (%r15), %eax
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq *(%r12,%rax,8)
testb %al, %al
jne 0x399c8
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
jne 0x399b1
movq 0x10(%r13), %r13
cmpq %r13, %rbx
jne 0x39954
addq $0x120, %r14            # imm = 0x120
movq %r14, %rbx
movq (%rbx), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq $0x8, %rbx
jmp 0x399bb
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x110(%rdi), %r13
cmpq %rsi, %r13
je 0x39cf8
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, (%rsp)
movq 0x8(%rsi), %rbp
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x39c4d
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %rbp, 0x8(%r15)
movq %r13, 0x10(%r15)
movq %r15, 0x4e8(%r14)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
movq %r15, %rax
jne 0x39ce0
movq %r15, %r13
movq 0x8(%r12), %rbp
movq 0x90(%r14), %rax
movq 0x110(%r14), %rbx
cmpq 0x98(%r14), %rax
ja 0x39caf
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
movq %rax, %r13
je 0x39c84
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x110(%r14), %rax
movq %rax, 0x4e8(%r14)
jmp 0x39cfb
movq %rdx, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 %rsi, %rax
cmpb $0x1, (%rax)
jne 0x39dab
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x39dab
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x39dab
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x39dab
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x39dab
movq 0x10(%rax), %rax
movq 0x10(%rsi), %rsi
cmpq %rsi, %rax
jne 0x39d72
xorl %eax, %eax
retq
cmpq 0x110(%rdi), %rax
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x39f55
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)
testq %rsi, %rsi
je 0x3a017
movq %rsi, %r14
movq 0x110(%rbx), %rdx
movq %rbx, %rdi
callq 0x3a029
movq %rax, 0x4d8(%rbx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
testq %r14, %r14
jle 0x39fe0
leaq 0x4d8(%rbx), %rax
movl (%rsp), %ecx
cmpl $0x28, %ecx
ja 0x39fbf
movl %ecx, %edx
addq 0x10(%rsp), %rdx
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x39fcd
movq 0x8(%rsp), %rdx
leaq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rsp)
movq (%rax), %rax
movq (%rdx), %rdx
movq %rdx, 0x8(%rax)
addq $0x10, %rax
decq %r14
jne 0x39fab
cmpq $0x0, 0x6a0(%rbx)
jle 0x3a000
movq 0x4d8(%rbx), %rdx
leaq 0xd021c(%rip), %rsi     # 0x10a214
movq %rbx, %rdi
callq 0x3a3fd
movq 0x4d8(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
jmp 0x3a01e
movq 0x110(%rbx), %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x1, (%rdx)
jne 0x3a468
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %ebp
leaq 0xdcc8c(%rip), %r12     # 0x1170ae
movq 0x8(%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x3794a
testb %al, %al
jne 0x3a44f
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movq %r12, %rdx
movl %ebp, %ecx
movq %r14, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0xeea2
movq 0x10(%rbx), %rbx
incl %ebp
cmpb $0x1, (%rbx)
je 0x3a422
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_make_vector
s7_pointer s7_make_vector(s7_scheme *sc, s7_int len)
                {
                    s7_pointer v;
                    v = make_vector_1(sc, len, FILLED, T_VECTOR);
                    add_vector(sc, v);
                    return(v);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edx
movl $0x15, %ecx
callq 0x3a74f
movq %rax, %rbx
movq 0x740(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x3a738
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
movl $0x1, %edx
movl $0x16, %ecx
callq 0x3a74f
movq %rax, %rbx
testq %r15, %r15
je 0x3ace1
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x3ad2e
movq 0x18(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq 0x790(%r14), %r14
jmp 0x3ace8
movq 0x740(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x3ad10
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
leaq (%rax,%rsi,8), %rax
movq %rbx, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: make_vdims
static vdims_t *make_vdims(s7_scheme *sc, bool elements_should_be_freed, s7_int dims, s7_int *dim_info)
                {
                    vdims_t *v;

                    if ((dims == 1) && (!elements_should_be_freed))
                        return(sc->wrap_only);

                    if (dims > 1)
                    {
                        s7_int i, offset = 1;
                        v = (vdims_t *)mallocate(sc, dims * 2 * sizeof(s7_int));
                        vdims_original(v) = sc->F;
                        vector_elements_should_be_freed(v) = elements_should_be_freed;
                        vdims_rank(v) = dims;
                        vdims_offsets(v) = (s7_int *)(vdims_dims(v) + dims);

                        for (i = 0; i < dims; i++)
                            vdims_dims(v)[i] = dim_info[i];
                        for (i = dims - 1; i >= 0; i--)
                        {
                            vdims_offsets(v)[i] = offset;
                            offset *= vdims_dims(v)[i];
                        }
                    }
                    else
                    {
                        v = (vdims_t *)mallocate_block(sc);
                        vdims_original(v) = sc->F;
                        vector_elements_should_be_freed(v) = elements_should_be_freed;
                        vdims_rank(v) = 1;
                        vdims_dims(v) = NULL;
                        vdims_offsets(v) = NULL;
                    }
                    return(v);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
cmpq $0x1, %rdx
setne %al
orb %bl, %al
je 0x3adbf
movq %rdx, %r14
cmpq $0x2, %rdx
jl 0x3adc8
movq %rcx, %r12
movq %r14, %rsi
shlq $0x4, %rsi
movq %r15, %rdi
callq 0x9357
movq 0x120(%r15), %rcx
movq %rcx, 0x20(%rax)
movb %bl, 0xc(%rax)
movq %r14, 0x10(%rax)
leaq (,%r14,8), %rcx
addq (%rax), %rcx
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq (%r12,%rcx,8), %rdx
movq (%rax), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x3ad84
incq %r14
movl $0x1, %ecx
movq 0x18(%rax), %rdx
movq %rcx, -0x10(%rdx,%r14,8)
movq (%rax), %rdx
imulq -0x10(%rdx,%r14,8), %rcx
decq %r14
cmpq $0x1, %r14
jg 0x3ad9f
jmp 0x3ae44
movq 0x470(%r15), %rax
jmp 0x3ae44
movq 0x838(%r15), %rax
testq %rax, %rax
jne 0x3ae13
movl $0x2800, %edi           # imm = 0x2800
callq 0x8480
movq %rax, 0x838(%r15)
movq %rax, %rcx
addq $0x28, %rcx
movl $0xff, %edx
movq %rcx, -0x10(%rcx)
movl $0x0, -0x20(%rcx)
addq $0x28, %rcx
decl %edx
jne 0x3adf1
movq $0x0, -0x10(%rcx)
movl $0x0, -0x20(%rcx)
movq 0x18(%rax), %rcx
movq %rcx, 0x838(%r15)
movl $0x0, 0x8(%rax)
movq 0x120(%r15), %rcx
movq %rcx, 0x20(%rax)
movb %bl, 0xc(%rax)
movq $0x1, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rcx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
movl $0x1, %edx
movl $0x17, %ecx
callq 0x3a74f
movq %rax, %rbx
testq %r15, %r15
je 0x3ae99
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x3ad2e
movq 0x18(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq 0x790(%r14), %r14
jmp 0x3aea0
movq 0x740(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x3aec8
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
leaq (%rax,%rsi,8), %rax
movq %rbx, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x3af27
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200017, (%rbx)       # imm = 0x200017
movq 0x838(%r14), %rax
testq %rax, %rax
jne 0x3af88
movl $0x2800, %edi           # imm = 0x2800
callq 0x8480
movq %rax, 0x838(%r14)
movq %rax, %rcx
addq $0x28, %rcx
movl $0xff, %edx
movq %rcx, -0x10(%rcx)
movl $0x0, -0x20(%rcx)
addq $0x28, %rcx
decl %edx
jne 0x3af66
movq $0x0, -0x10(%rcx)
movl $0x0, -0x20(%rcx)
movq 0x18(%rax), %rcx
movq %rcx, 0x838(%r14)
movl $0x0, 0x8(%rax)
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rcx, 0x20(%rax)
movq %rax, 0x18(%rbx)
movq %r12, 0x10(%rbx)
leaq 0x97(%rip), %rax        # 0x3b049
movq %rax, 0x20(%rbx)
leaq 0xe9(%rip), %rax        # 0x3b0a6
movq %rax, 0x28(%rbx)
movq %r13, 0x8(%rbx)
testq %r15, %r15
je 0x3afdb
movzbl %bpl, %esi
movq %r14, %rdi
movq 0x8(%rsp), %rdx
movq %r15, %rcx
jmp 0x3afef
leaq 0x10(%rsp), %rcx
movq %r13, (%rcx)
movzbl %bpl, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3ad2e
movq 0x18(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq 0x790(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x3b02b
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
cmpq %rdx, 0x8(%rsi)
jle 0x3b4c4
movq %rcx, %rbx
movq %rsi, %r12
testb $0x2, 0x6(%rsi)
jne 0x3b531
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq *0x28(%r12)
jmp 0x3b58e
movq 0x1668(%r14), %rax
movq 0x8(%rax), %rax
movq 0x10b48a(%rip), %rcx    # 0x146960
movq 0x1f00(%r14), %rdx
movq %r15, 0x8(%rdx)
movq 0x1ee8(%r14), %rdx
movq 0x1f00(%r14), %rsi
movq 0x10f54a(%rip), %rdi    # 0x14aa40
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%r14), %rbx
movq 0x1ee8(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x38dfa
jmp 0x3b58e
cmpq $0x0, 0x6a0(%r14)
js 0x3b585
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0x3b562
movq 0x10(%rsi), %rax
movq 0x700(%r14), %rcx
movq %rbx, 0x8(%rcx)
movq 0x700(%r14), %rsi
movq %r14, %rdi
callq *%rax
jmp 0x3b57c
movq 0x700(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x700(%r14), %rdx
movq %r14, %rdi
callq 0xaee6
cmpq 0x120(%r14), %rax
je 0x3b59d
movq 0x10(%r12), %rax
movq %rbx, (%rax,%r15,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0x3b5ad
movq 0x8(%rsi), %rax
jmp 0x3b5c1
movq 0x18(%rsi), %rdx
movq %r14, %rdi
callq 0x99caa
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x99bbf
leaq 0xd7580(%rip), %rsi     # 0x112b58
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd4e5
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
cmpq $0x0, 0x6a0(%rdi)
js 0x3b65e
movq %rdi, %r14
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0x3b63b
movq 0x10(%rsi), %rax
movq 0x700(%r14), %rcx
movq %rbx, 0x8(%rcx)
movq 0x700(%r14), %rsi
movq %r14, %rdi
callq *%rax
jmp 0x3b655
movq 0x700(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x700(%r14), %rdx
movq %r14, %rdi
callq 0xaee6
cmpq 0x120(%r14), %rax
je 0x3b676
movq 0x10(%r12), %rax
movq %rbx, (%rax,%r15,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0x3b686
movq 0x8(%rsi), %rax
jmp 0x3b69a
movq 0x18(%rsi), %rdx
movq %r14, %rdi
callq 0x99caa
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x99bbf
leaq 0xd74a7(%rip), %rsi     # 0x112b58
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd4e5
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
jle 0x3b721
movq 0x18(%rdi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x3b724
movq %rdx, %rax
movq 0x10(%rcx), %rcx
cmpq %rdx, %rcx
cmovlq %rcx, %rax
testq %rcx, %rcx
jle 0x3b720
xorl %ecx, %ecx
movq 0x18(%rdi), %rdx
movq 0x20(%rdx), %rdx
movq (%rdx), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x3b705
retq
xorl %eax, %eax
retq
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
jle 0x3b7a3
movq 0x18(%rdi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x3b7a6
movq %rdx, %rax
movq 0x10(%rcx), %rcx
cmpq %rdx, %rcx
cmovlq %rcx, %rax
testq %rcx, %rcx
jle 0x3b7a2
xorl %ecx, %ecx
movq 0x18(%rdi), %rdx
movq 0x20(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x3b786
retq
xorl %eax, %eax
retq
movq $0x1, (%rsi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rsp), %rdx
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x3ba25
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 %rsp, %rax
movq %rdx, 0x10(%rax)
leaq 0x100(%rsp), %rdx
movq %rdx, 0x8(%rax)
movabsq $0x3000000020, %rdx     # imm = 0x3000000020
movq %rdx, (%rax)
movq %rcx, %rdx
movq %rax, %rcx
callq 0x3b84e
movq %rax, %r12
testb $0x2, 0x6(%r15)
jne 0x3ba6f
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq *0x28(%r15)
movq %rax, %rbx
jmp 0x3baca
cmpq $0x0, 0x6a0(%r14)
js 0x3bac2
movq 0x28(%r15), %rsi
cmpb $0x30, (%rsi)
jb 0x3ba9f
movq 0x10(%rsi), %rax
movq 0x700(%r14), %rcx
movq %rbx, 0x8(%rcx)
movq 0x700(%r14), %rsi
movq %r14, %rdi
callq *%rax
jmp 0x3bab9
movq 0x700(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x700(%r14), %rdx
movq %r14, %rdi
callq 0xaee6
cmpq 0x120(%r14), %rax
je 0x3badc
movq 0x10(%r15), %rax
movq %rbx, (%rax,%r12,8)
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x28(%r15), %rsi
cmpb $0x30, (%rsi)
jb 0x3baeb
movq 0x8(%rsi), %rax
jmp 0x3baff
movq 0x18(%rsi), %rdx
movq %r14, %rdi
callq 0x99caa
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x99bbf
leaq 0xd7042(%rip), %rsi     # 0x112b58
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
callq 0xd4e5
jmp 0x3ba6a