LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x2c0c2
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x2c0b2
leaq 0xaa0c1(%rip), %rsi     # 0xd615e
leaq 0xbae81(%rip), %r8      # 0xe6f25
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0xc2b0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x2ba5b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x2c252
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)
callq 0x2c2e2
movq %rax, %r14
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
xorl %r15d, %r15d
movq %r14, %r12
cmpb $0x1, (%r12)
jne 0x2c2d0
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x2c2a0
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x2c2ae
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 0x2c33b
movq 0x10(%r12), %r12
incq %r15
jmp 0x2c280
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: permanent_list
static s7_pointer permanent_list(s7_scheme *sc, s7_int len)
    {
        s7_int j;
        s7_pointer p;
        p = sc->nil;
        for (j = 0; j < len; j++)
            p = permanent_cons(sc, sc->nil, p, T_PAIR | T_IMMUTABLE);
        return(p);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x110(%rdi), %r14
xorl %r15d, %r15d
testq %rsi, %rsi
cmovgq %rsi, %r15
movabsq $0x4000000001000001, %r12 # imm = 0x4000000001000001
subq $0x1, %r15
jb 0x2c32e
movq 0x110(%rbx), %r13
movq %rbx, %rdi
callq 0xd35f
movq %r12, (%rax)
movq %r13, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, %r14
jmp 0x2c309
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2c39c
cmpl $0x7, %edx
je 0x2c39c
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xa, %edx
jne 0x2c364
testb $-0x80, 0x6(%rax)
je 0x2c39c
leaq 0xb6cd9(%rip), %rdx     # 0xe3044
leaq 0xbc0fc(%rip), %rax     # 0xe846e
testb %cl, %cl
cmovneq %rdx, %rax
leaq 0xb6c89(%rip), %rdx     # 0xe3008
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xd5c7
movq 0x110(%r14), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %r15
movq %rsi, %r12
leaq 0x40(%rsp), %rbx
movq %rcx, 0x18(%rbx)
movq %r8, 0x20(%rbx)
movq %r9, 0x28(%rbx)
testb %al, %al
je 0x2c40d
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 %rdi, 0x8(%rsp)
movq %rdx, %rsi
callq 0x2c2e2
movq %rax, %r14
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, 0x10(%rsp)
leaq 0x130(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r15, 0x30(%rsp)
decq %r15
xorl %r13d, %r13d
movq %r14, 0x38(%rsp)
xorl %ebp, %ebp
xorl %ebx, %ebx
cmpb $0x1, (%r14)
jne 0x2c4b2
movl 0x10(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x2c473
movq %rcx, %rax
addq 0x20(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x10(%rsp)
jmp 0x2c481
movq 0x18(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%r14)
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
pushq $0x1
popq %rcx
callq 0x2c33b
cmpq %r13, %r12
cmoveq %r14, %rbp
cmpq %r13, %r15
cmoveq %r14, %rbx
movq 0x10(%r14), %r14
incq %r13
jmp 0x2c452
testq %rbx, %rbx
je 0x2c4bb
movq %rbp, 0x10(%rbx)
cmpq 0x30(%rsp), %r13
movq 0x38(%rsp), %r14
jge 0x2c4f0
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b8e4
leaq 0xa9c88(%rip), %rdx     # 0xd6166
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0xd5c7
movq %r14, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2c872
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x2c87e
movq 0x8(%rcx), %rsi
jmp 0x2c885
movq 0x128(%rdi), %rdi
movq %rdi, %rsi
jmpq *%rdx
movq 0x128(%rdi), %rsi
movq %rax, %rdi
jmpq *%rdx
// File: /workspace/github_c_makefile_star2_O2/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 0x2c8b2
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
cmpb $0x1, (%rdx)
jne 0x2c8c1
movq 0x8(%rdx), %rsi
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
jne 0x2c8d0
movq 0x8(%rdx), %rdx
jmp 0x2c8d7
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_O2/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 0x2c911
movq 0x8(%rsi), %r8
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x2c91d
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x2c92f
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x2c93b
movq 0x8(%rcx), %rcx
jmp 0x2c942
movq 0x128(%rdi), %rcx
movq %rcx, %rdi
jmp 0x2c927
movq 0x128(%rdi), %rcx
movq %r8, %rdi
movq %rcx, %rsi
movq %rcx, %rdx
jmpq *%rax
movq 0x128(%rdi), %rcx
movq %r8, %rdi
jmp 0x2c92a
movq 0x128(%rdi), %rcx
movq %r8, %rdi
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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 0x2c98e
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x2c99a
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x2c9ac
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %r9
cmpb $0x1, (%r9)
jne 0x2c9b5
movq 0x8(%r9), %rcx
movq 0x10(%r9), %r9
cmpb $0x1, (%r9)
jne 0x2c9be
movq 0x8(%r9), %r8
jmpq *%rax
movq 0x128(%r8), %rcx
movq %rcx, %rdi
jmp 0x2c9a1
movq 0x128(%r8), %rcx
movq %rcx, %rsi
movq %rcx, %rdx
movq %rcx, %r8
jmpq *%rax
movq 0x128(%r8), %rcx
jmp 0x2c9a4
movq 0x128(%r8), %rcx
jmp 0x2c9a7
movq 0x128(%r8), %r8
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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 0x2ca20
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0x2ca23
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x2ca26
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %r8
cmpb $0x1, (%r8)
jne 0x2ca29
movq 0x8(%r8), %rcx
movq 0x10(%r8), %r10
cmpb $0x1, (%r10)
jne 0x2ca2c
movq 0x8(%r10), %r8
movq 0x10(%r10), %r10
cmpb $0x1, (%r10)
jne 0x2ca2f
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_O2/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 %ecx, %ecx
testq %rdx, %rdx
movl $0x0, %eax
cmovgq %rdx, %rax
cmpq %rcx, %rax
je 0x2cc1b
cmpb $0x1, (%rsi)
jne 0x2cc18
incq %rcx
movq 0x10(%rsi), %rsi
jmp 0x2cc05
movq %rcx, %rax
cmpq %rdx, %rax
jne 0x2cc2e
cmpb $0x1, (%rsi)
jne 0x2cc2e
addq $0x8, %rsi
movq %rsi, %rdi
jmp 0x2cc35
addq $0x110, %rdi            # imm = 0x110
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %edi, %edi
testq %rdx, %rdx
movl $0x0, %ecx
cmovgq %rdx, %rcx
cmpq %rdi, %rcx
je 0x2cc60
cmpb $0x1, (%rsi)
jne 0x2cc5d
incq %rdi
movq 0x10(%rsi), %rsi
jmp 0x2cc4a
movq %rdi, %rcx
cmpq %rdx, %rcx
jne 0x2cc6e
cmpb $0x1, (%rsi)
jne 0x2cc6e
movq %rax, 0x8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xf5099(%rip), %r12     # 0x121d20
cmpb $0x1, (%rbx)
jne 0x2ccaa
movq 0x8(%rbx), %rdx
movzbl (%r15), %eax
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq *(%r12,%rax,8)
testb %al, %al
jne 0x2ccb1
movq 0x10(%rbx), %rbx
jmp 0x2cc87
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_O2/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 0x2cd57
movq %rdx, %rbx
cmpb $0x1, (%rdx)
jne 0x2cd5b
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x6a0(%rdi)
jle 0x2cd44
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2cd63
testb %al, %al
je 0x2cd44
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 0xa946a(%rip), %rax     # 0xd619a
movq %rax, 0x10(%rdx)
movq $0x19, 0x8(%rdx)
movq %r15, %rdi
callq 0x2cdc0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2d63c
movb $0x1, %al
jmp 0x2cd5d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7abe9
testl %eax, %eax
je 0x2cd7f
cmpl $0x1, %eax
jne 0x2cd83
movb $0x1, %al
jmp 0x2cdb8
xorl %eax, %eax
jmp 0x2cdb8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ac6a
xorl %ecx, %ecx
movslq 0x7d4(%rbx), %rdx
cmpq %rdx, %rcx
jge 0x2cdb1
movq 0x7c8(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
andw $-0x9, 0x6(%rdx)
incq %rcx
jmp 0x2cd90
andl $0x0, 0x7d4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2d6d4
movq %rdi, %r12
movq 0x8(%r15), %rbp
movb $0x1, %bl
cmpq %r14, %rbp
je 0x2d6f8
cmpb $0x1, (%rbp)
jne 0x2d6c3
cmpq %r13, 0x8(%rbp)
je 0x2d6a6
movq 0x8(%rbp), %rdx
cmpq %r14, %rdx
je 0x2d6f8
cmpb $0x1, (%rdx)
jne 0x2d695
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d63c
testb %al, %al
jne 0x2d6f8
movq 0x10(%rbp), %rbp
cmpq %r14, %rbp
je 0x2d6f8
cmpb $0x1, (%rbp)
je 0x2d678
jmp 0x2d6c3
movzbl (%r14), %eax
cmpl $0x1, %eax
je 0x2d6c3
cmpl $0xa, %eax
je 0x2d6c3
movq 0x10(%rbp), %rax
cmpb $0x1, (%rax)
jne 0x2d6c3
cmpq %r14, 0x8(%rax)
je 0x2d6f8
movq 0x10(%r15), %r15
cmpq %r14, %r15
je 0x2d6f8
cmpb $0x1, (%r15)
je 0x2d65d
jmp 0x2d6f6
movzbl (%r14), %eax
xorl %ebx, %ebx
cmpl $0x1, %eax
je 0x2d6f8
cmpl $0xa, %eax
je 0x2d6f8
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0x2d6f6
cmpq %r14, 0x8(%rax)
sete %bl
jmp 0x2d6f8
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_O2/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 0x2d787
movq %rdx, %rbx
movq %rsi, %r15
leaq 0xf45f9(%rip), %r12     # 0x121d20
movq %rdx, %r13
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x2d74b
movq 0x8(%rax), %rdx
movzbl (%r15), %eax
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq *(%r12,%rax,8)
testb %al, %al
jne 0x2d79e
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
jne 0x2d787
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x2d775
movq 0x8(%rax), %rdx
movzbl (%r15), %eax
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq *(%r12,%rax,8)
testb %al, %al
jne 0x2d79e
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
jne 0x2d787
movq 0x10(%r13), %r13
cmpq %r13, %rbx
jne 0x2d72a
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 0x2d791
// File: /workspace/github_c_makefile_star2_O2/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 0x2dac5
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, (%rsp)
movq 0x8(%rsi), %rbp
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x2da27
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %rbp, 0x8(%r12)
movq %r13, 0x10(%r12)
movq %r12, 0x4e8(%r14)
movq %r12, %r13
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x2daad
movq 0x8(%r15), %rbp
movq 0x90(%r14), %rax
movq 0x110(%r14), %rbx
cmpq 0x98(%r14), %rax
ja 0x2da86
movq %r14, %rdi
callq 0x9c27
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 %rax, %r13
jmp 0x2da52
movq (%rsp), %rax
movq %rax, 0x10(%r13)
movq 0x110(%r14), %rax
movq %rax, 0x4e8(%r14)
jmp 0x2dac8
movq %rdx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2db70
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x2db70
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x2db70
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x2db70
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x2db70
movq 0x10(%rax), %rax
movq 0x10(%rsi), %rsi
cmpq %rsi, %rax
jne 0x2db37
xorl %eax, %eax
retq
cmpq 0x110(%rdi), %rax
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2dd1a
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 0x2dde3
movq %rsi, %r14
movq 0x110(%rbx), %rdx
movq %rbx, %rdi
callq 0x2ddf5
leaq 0x4d8(%rbx), %rcx
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)
pushq $0x10
popq %rax
xorl %edx, %edx
testq %r14, %r14
cmovgq %r14, %rdx
subq $0x1, %rdx
jb 0x2ddac
cmpl $0x28, %eax
ja 0x2dd8e
movl %eax, %esi
addq 0x10(%rsp), %rsi
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x2dd9c
movq 0x8(%rsp), %rsi
leaq 0x8(%rsi), %rdi
movq %rdi, 0x8(%rsp)
movq (%rcx), %rcx
movq (%rsi), %rsi
movq %rsi, 0x8(%rcx)
addq $0x10, %rcx
jmp 0x2dd74
cmpq $0x0, 0x6a0(%rbx)
jle 0x2ddcc
movq 0x4d8(%rbx), %rdx
leaq 0xa83f0(%rip), %rsi     # 0xd61b4
movq %rbx, %rdi
callq 0x2e1c9
movq 0x4d8(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
jmp 0x2ddea
movq 0x110(%rbx), %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rbp
leaq 0xb4e67(%rip), %r12     # 0xe304e
cmpb $0x1, (%rbx)
jne 0x2e221
movq 0x8(%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x2b68b
testb %al, %al
jne 0x2e219
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movq %r12, %rdx
movl %ebp, %ecx
movq %r14, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0xd5c7
movq 0x10(%rbx), %rbx
incl %ebp
jmp 0x2e1e7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
pushq $0x1
popq %rdx
pushq $0x16
popq %rcx
callq 0x2e4a2
movq %rax, %r14
testq %r15, %r15
je 0x2e751
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2e771
movq 0x18(%r14), %rcx
movq %rax, 0x20(%rcx)
movl $0x790, %eax            # imm = 0x790
jmp 0x2e756
movl $0x740, %eax            # imm = 0x740
movq (%rbx,%rax), %rdi
movq %r14, %rsi
callq 0xb999
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r15
cmpq $0x1, %rdx
setne %al
orb %bpl, %al
je 0x2e7dd
movq %rdx, %rbx
cmpq $0x2, %rdx
jl 0x2e7e6
movq %rcx, %r14
movq %rbx, %rsi
shlq $0x4, %rsi
movq %r15, %rdi
callq 0x9037
movq 0x120(%r15), %rcx
movq %rcx, 0x20(%rax)
movb %bpl, 0xc(%rax)
movq %rbx, 0x10(%rax)
leaq (,%rbx,8), %rcx
addq (%rax), %rcx
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x2e819
movq (%r14,%rcx,8), %rdx
movq (%rax), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
jmp 0x2e7c8
movq 0x470(%r15), %rax
jmp 0x2e80e
movq %r15, %rdi
callq 0xb93f
movq 0x120(%r15), %rcx
movq %rcx, 0x20(%rax)
movb %bpl, 0xc(%rax)
movq $0x1, 0x10(%rax)
andq $0x0, (%rax)
andq $0x0, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rcx
testq %rbx, %rbx
jle 0x2e80e
movq 0x18(%rax), %rdx
movq %rcx, -0x8(%rdx,%rbx,8)
movq (%rax), %rdx
imulq -0x8(%rdx,%rbx,8), %rcx
decq %rbx
jmp 0x2e81c
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
pushq $0x1
popq %rdx
pushq $0x17
popq %rcx
callq 0x2e4a2
movq %rax, %r14
testq %r15, %r15
je 0x2e87b
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2e771
movq 0x18(%r14), %rcx
movq %rax, 0x20(%rcx)
movl $0x790, %eax            # imm = 0x790
jmp 0x2e880
movl $0x740, %eax            # imm = 0x740
movq (%rbx,%rax), %rdi
movq %r14, %rsi
callq 0xb999
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x2e8dc
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x200017, (%r14)       # imm = 0x200017
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2e974
movq %rax, 0x18(%r14)
movq %r12, 0x10(%r14)
leaq 0x83(%rip), %rax        # 0x2e98e
movq %rax, 0x20(%r14)
leaq 0xd5(%rip), %rax        # 0x2e9eb
movq %rax, 0x28(%r14)
movq %r13, 0x8(%r14)
testq %r15, %r15
je 0x2e934
movzbl %bpl, %esi
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq %r15, %rcx
jmp 0x2e946
leaq 0x10(%rsp), %rcx
movq %r13, (%rcx)
movzbl %bpl, %esi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x2e771
movq 0x18(%r14), %rcx
movq %rax, 0x20(%rcx)
movq 0x790(%rbx), %rdi
movq %r14, %rsi
callq 0xb999
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
cmpq %rdx, 0x8(%rsi)
jle 0x2ec80
movq %rcx, %rbx
testb $0x2, 0x6(%rsi)
jne 0x2ecb4
movq %rbx, %rcx
callq *0x28(%rsi)
movq %rbx, %rax
popq %rbx
retq
movq 0x1668(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xe6cce(%rip), %rax     # 0x115960
movq 0x1f00(%rdi), %rcx
movq %rdx, 0x8(%rcx)
movq 0x1f00(%rdi), %rcx
movq 0xead95(%rip), %r8      # 0x119a40
movq %rax, %rdx
popq %rbx
jmp 0xcb8f
movq %rbx, %rcx
popq %rbx
jmp 0x2ecba
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movq %rsi, %r15
cmpq $0x0, 0x6a0(%rdi)
js 0x2ed21
movq %rdi, %r14
movq 0x28(%r15), %rsi
cmpb $0x30, (%rsi)
jb 0x2ecfe
movq 0x10(%rsi), %rax
movq 0x700(%r14), %rcx
movq %rbx, 0x8(%rcx)
movq 0x700(%r14), %rsi
movq %r14, %rdi
callq *%rax
jmp 0x2ed18
movq 0x700(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x700(%r14), %rdx
movq %r14, %rdi
callq 0xa34c
cmpq 0x120(%r14), %rax
je 0x2ed38
movq 0x10(%r15), %rax
movq %rbx, (%rax,%r12,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r15, %rsi
callq 0x7b119
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x7b04d
leaq 0xafda0(%rip), %rsi     # 0xdeaf8
pushq $0x3
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc2b0
// File: /workspace/github_c_makefile_star2_O2/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 0x2edce
movq 0x18(%rdi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x2edd1
movq %rdx, %rax
movq 0x10(%rcx), %rcx
cmpq %rdx, %rcx
cmovlq %rcx, %rax
xorl %ecx, %ecx
testq %rax, %rax
movl $0x0, %edx
cmovgq %rax, %rdx
cmpq %rcx, %rdx
je 0x2eddb
movq 0x18(%rdi), %r8
movq 0x20(%r8), %r8
movq (%r8), %r8
movq (%r8,%rcx,8), %r8
movq %r8, (%rsi,%rcx,8)
incq %rcx
jmp 0x2edb1
xorl %eax, %eax
retq
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2ee52
movq 0x18(%rdi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x2ee55
movq %rdx, %rax
movq 0x10(%rcx), %rcx
cmpq %rdx, %rcx
cmovlq %rcx, %rax
xorl %ecx, %ecx
testq %rax, %rax
movl $0x0, %edx
cmovgq %rax, %rdx
cmpq %rcx, %rdx
je 0x2ee5f
movq 0x18(%rdi), %r8
movq 0x20(%r8), %r8
movq 0x18(%r8), %r8
movq (%r8,%rcx,8), %r8
movq %r8, (%rsi,%rcx,8)
incq %rcx
jmp 0x2ee34
xorl %eax, %eax
retq
movq $0x1, (%rsi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0xd0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %rdx
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x2f095
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 0xf0(%rsp), %rdx
movq %rdx, 0x8(%rax)
movabsq $0x3000000020, %rdx     # imm = 0x3000000020
movq %rdx, (%rax)
movq %rcx, %rdx
movq %rax, %rcx
callq 0x2eefb
testb $0x2, 0x6(%r14)
jne 0x2f0d9
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq *0x28(%r14)
jmp 0x2f0ea
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2ecba
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x2f17a
movq %rsi, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2f187
movq 0x110(%rbx), %rax
movq %rax, 0x4d0(%rbx)
testq %r15, %r15
jle 0x2f16a
decq %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x20(%r14)
movq %rax, %rcx
movq 0x4d0(%rbx), %rdx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
jmp 0x2f11d
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d0(%rbx)
jmp 0x2f181
movq 0x110(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x90(%rdi), %rax
subq 0x88(%rdi), %rax
sarq $0x3, %rax
cmpq %rsi, %rax
jge 0x2f1d7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x714ee
movq 0x90(%r14), %rax
subq 0x88(%r14), %rax
sarq $0x3, %rax
cmpq %rbx, %rax
jge 0x2f1d0
movq %r14, %rdi
xorl %esi, %esi
callq 0x70da3
jmp 0x2f1ad
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x2f22c
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200015, (%r15)       # imm = 0x200015
movq %r14, 0x8(%r15)
shlq $0x3, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e974
movq %rax, 0x18(%r15)
movq (%rax), %rcx
movq %rcx, 0x10(%r15)
andq $0x0, 0x20(%rax)
leaq 0x1a6d8(%rip), %rax     # 0x49944
movq %rax, 0x20(%r15)
leaq 0x1a6d6(%rip), %rax     # 0x4994d
movq %rax, 0x28(%r15)
movq 0x740(%rbx), %rdi
movq %r15, %rsi
callq 0xb999
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x2fd8d
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200017, (%r15)       # imm = 0x200017
movq %r14, 0x8(%r15)
shlq $0x3, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e974
movq %rax, 0x18(%r15)
movq (%rax), %rcx
movq %rcx, 0x10(%r15)
andq $0x0, 0x20(%rax)
leaq -0x143f(%rip), %rax     # 0x2e98e
movq %rax, 0x20(%r15)
leaq -0x13ed(%rip), %rax     # 0x2e9eb
movq %rax, 0x28(%r15)
movq 0x740(%rbx), %rdi
movq %r15, %rsi
callq 0xb999
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq