LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: let_equivalent
static bool let_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    if (x == y) return(true);
                    check_equivalent_method(sc, x, y);
                    check_equivalent_method(sc, y, x);
                    return(let_equal_1(sc, x, y, ci, true));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rdx, %rsi
je 0xf74ba
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testb $0x40, 0x3(%rsi)
je 0xf73d8
cmpb $0x1, 0x24c(%rbx)
jne 0xf73d8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8a63
movq 0x1100(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0xf73d8
movq %rax, %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xf7397
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %r12, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r15, 0x8(%rdx)
jmp 0xf747f
testb $0x40, 0x3(%r14)
je 0xf749a
cmpb $0x1, 0x24c(%rbx)
jne 0xf749a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a63
movq 0x1100(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0xf749a
movq %rax, %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xf7443
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r14, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xaee6
cmpq %rax, 0x120(%rbx)
setne %al
jmp 0xf74bc
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
movl $0x1, %r8d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf8845
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: integer_equivalent
static bool integer_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    if (is_big_number(y))
                        return(big_num_eq(sc, set_plist_2(sc, x, y)) != sc->F);
#endif
                    if (is_t_integer(y))
                        return(integer(x) == integer(y));
                    if (is_real(y))
                        return(floats_are_equivalent(sc, (double)integer(x), s7_real(y)));
                    if (is_t_complex(y))
                        return((fabs(imag_part(y)) <= sc->equivalent_float_epsilon) &&
                                (floats_are_equivalent(sc, (double)integer(x), real_part(y))));
                    return(false);
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movzbl (%rdx), %eax
cmpq $0xb, %rax
jne 0xf7dfb
movq 0x8(%rsi), %rax
cmpq 0x8(%rdx), %rax
sete %al
jmp 0xf7e63
movq %rdi, %rbx
leaq 0x52bab(%rip), %rcx     # 0x14a9b0
cmpb $0x1, (%rax,%rcx)
jne 0xf7e41
cvtsi2sdq 0x8(%rsi), %xmm0
cmpl $0xd, %eax
je 0xf7e72
movq 0x52c13(%rip), %rdi     # 0x14aa30
leaq 0x12254(%rip), %rax     # 0x10a078
movq %rdx, %rsi
movq %rax, %rdx
movsd %xmm0, 0x8(%rsp)
callq 0xd498
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
jmp 0xf7e77
cmpl $0xe, %eax
jne 0xf7e61
movsd 0x10(%rdx), %xmm0
andpd 0x1206d(%rip), %xmm0    # 0x109ec0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jae 0xf7e69
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%rsi), %xmm0
movsd 0x8(%rdx), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xf8d05
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fraction_equivalent
static bool fraction_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    if (is_big_number(y))
                        return(big_num_eq(sc, set_plist_2(sc, x, y)) != sc->F);
#endif
                    if (is_real(y))
                        return(floats_are_equivalent(sc, (s7_double)fraction(x), s7_real(y)));
                    if (is_t_complex(y))
                        return((floats_are_equivalent(sc, (s7_double)fraction(x), real_part(y))) &&
                                (fabs(imag_part(y)) <= sc->equivalent_float_epsilon));
                    return(false);
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movzbl (%rdx), %eax
leaq 0x52b15(%rip), %rcx     # 0x14a9b0
cmpb $0x1, (%rax,%rcx)
jne 0xf7ed6
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
movq %rcx, 0x18(%rsp)
fildll 0x18(%rsp)
movq %rdx, 0x10(%rsp)
fildll 0x10(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
cmpb $0xd, %al
jne 0xf7f3b
movsd 0x8(%r14), %xmm1
jmp 0xf7f5e
cmpb $0xe, %al
jne 0xf7f31
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rax, 0x30(%rsp)
fildll 0x30(%rsp)
movq %rcx, 0x28(%rsp)
fildll 0x28(%rsp)
fdivrp %st, %st(1)
fstpl 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x8(%r14), %xmm1
movq %rbx, %rdi
callq 0xf8d05
testb %al, %al
je 0xf7f31
movsd 0x10(%r14), %xmm0
andpd 0x11fa0(%rip), %xmm0    # 0x109ec0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
setae %al
jmp 0xf7f33
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x52aee(%rip), %rdi     # 0x14aa30
leaq 0x1212f(%rip), %rdx     # 0x10a078
movq %r14, %rsi
movsd %xmm0, (%rsp)
callq 0xd498
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
jmp 0xf8d05
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: real_equivalent
static bool real_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    if (is_big_number(y))
                        return(big_num_eq(sc, set_plist_2(sc, x, y)) != sc->F);
#endif
                    if (is_real(y))
                        return(floats_are_equivalent(sc, real(x), s7_real(y)));
                    if (is_t_complex(y))
                        return((fabs(imag_part(y)) <= sc->equivalent_float_epsilon) &&
                                (floats_are_equivalent(sc, real(x), real_part(y))));
                    return(false);
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzbl (%rdx), %eax
leaq 0x52a31(%rip), %rcx     # 0x14a9b0
cmpb $0x1, (%rax,%rcx)
jne 0xf7fb8
movsd 0x8(%rsi), %xmm0
cmpb $0xd, %al
je 0xf7fe4
movq 0x52a9b(%rip), %rdi     # 0x14aa30
leaq 0x120dc(%rip), %rax     # 0x10a078
movq %rdx, %rsi
movq %rax, %rdx
movsd %xmm0, 0x8(%rsp)
callq 0xd498
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
jmp 0xf7fe9
cmpb $0xe, %al
jne 0xf7fd7
movsd 0x10(%rdx), %xmm0
andpd 0x11ef7(%rip), %xmm0    # 0x109ec0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jae 0xf7fdf
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
movsd 0x8(%rsi), %xmm0
movsd 0x8(%rdx), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xf8d05
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: complex_equivalent
static bool complex_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    if (is_big_number(y))
                        return(big_num_eq(sc, set_plist_2(sc, x, y)) != sc->F);
#endif
                    if (is_t_complex(y))
                        return((floats_are_equivalent(sc, real_part(x), real_part(y))) &&
                                (floats_are_equivalent(sc, imag_part(x), imag_part(y))));

                    if (is_real(y))
                        return((fabs(imag_part(x)) <= sc->equivalent_float_epsilon) &&
                                (floats_are_equivalent(sc, real_part(x), s7_real(y))));

                    return(false);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movzbl (%rdx), %eax
cmpq $0xe, %rax
jne 0xf8046
movsd 0x8(%r15), %xmm0
movsd 0x8(%r14), %xmm1
movq %rbx, %rdi
callq 0xf8d05
testb %al, %al
je 0xf806f
movsd 0x10(%r15), %xmm0
movsd 0x10(%r14), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf8d05
leaq 0x52963(%rip), %rcx     # 0x14a9b0
cmpb $0x1, (%rax,%rcx)
jne 0xf806f
movsd 0x10(%r15), %xmm0
andpd 0x11e5f(%rip), %xmm0    # 0x109ec0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jae 0xf807b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd 0x8(%r15), %xmm0
cmpl $0xd, %eax
jne 0xf808e
movsd 0x8(%r14), %xmm1
jmp 0xf8035
movq 0x5299b(%rip), %rdi     # 0x14aa30
leaq 0x11fdc(%rip), %rdx     # 0x10a078
movq %r14, %rsi
movsd %xmm0, 0x8(%rsp)
callq 0xd498
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
jmp 0xf8035
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: add_shared_ref
static void add_shared_ref(shared_info *ci, s7_pointer x, int32_t ref_x)
    {
        /* called only in equality check, not printer */
        if (ci->top == ci->size)
            enlarge_shared_info(ci);
        set_collected(x);
        ci->objs[ci->top] = x;
        ci->refs[ci->top++] = ref_x;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0xc(%rdi), %eax
cmpl 0x8(%rdi), %eax
jne 0xf80d2
movq %r14, %rdi
callq 0x967fa
orb $0x2, 0x2(%r15)
movq (%r14), %rax
movslq 0xc(%r14), %rcx
movq %r15, (%rax,%rcx,8)
movq 0x20(%r14), %rax
leal 0x1(%rcx), %edx
movl %edx, 0xc(%r14)
movl %ebx, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: vector_rank_match
static bool vector_rank_match(s7_scheme *sc, s7_pointer x, s7_pointer y)
                {
                    s7_int x_dims;
                    s7_int j;

                    if (vector_has_dimensional_info(x))
                        x_dims = vector_ndims(x);
                    else return((!vector_has_dimensional_info(y)) || (vector_ndims(y) == 1));
                    if (x_dims == 1)
                        return((!vector_has_dimensional_info(y)) || (vector_ndims(y) == 1));

                    if ((!vector_has_dimensional_info(y)) ||
                            (x_dims != vector_ndims(y)))
                        return(false);

                    for (j = 0; j < x_dims; j++)
                        if (vector_dimension(x, j) != vector_dimension(y, j))
                            return(false);

                    return(true);
                }

// Assembly:
testq %rdi, %rdi
je 0xf8c02
movq 0x10(%rdi), %rcx
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
cmpq $0x1, %rcx
je 0xf8c0a
testq %rax, %rax
je 0xf8c1b
cmpq 0x10(%rax), %rcx
jne 0xf8c1b
testq %rcx, %rcx
jle 0xf8c18
movq (%rdi), %rdx
movq (%rax), %rsi
decq %rcx
xorl %edi, %edi
movq (%rdx,%rdi,8), %rax
cmpq (%rsi,%rdi,8), %rax
sete %al
jne 0xf8c01
leaq 0x1(%rdi), %r8
cmpq %rdi, %rcx
movq %r8, %rdi
jne 0xf8be8
retq
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xf8c18
cmpq $0x1, 0x10(%rax)
sete %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: iv_meq
static bool iv_meq(s7_int *ex, s7_int *ey, s7_int len)
                {
                    s7_int i, left;
                    left = len - 8;
                    i = 0;
                    while (i <= left)
                        LOOP_8(if (ex[i] != ey[i]) return(false); i++);
                    for (; i < len; i++)
                        if (ex[i] != ey[i])
                            return(false);
                    return(true);
                }

// Assembly:
cmpq $0x8, %rdx
jge 0xf8c4c
xorl %ecx, %ecx
movb $0x1, %al
cmpq %rdx, %rcx
jge 0xf8c4b
decq %rdx
movq (%rdi,%rcx,8), %r8
movq (%rsi,%rcx,8), %r9
cmpq %r9, %r8
sete %al
cmpq %rcx, %rdx
je 0xf8c4b
incq %rcx
cmpq %r9, %r8
je 0xf8c30
retq
leaq -0x8(%rdx), %rax
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %r8
cmpq (%rsi,%rcx,8), %r8
jne 0xf8cbe
movq 0x8(%rdi,%rcx,8), %r8
cmpq 0x8(%rsi,%rcx,8), %r8
jne 0xf8cbe
movq 0x10(%rdi,%rcx,8), %r8
cmpq 0x10(%rsi,%rcx,8), %r8
jne 0xf8cbe
movq 0x18(%rdi,%rcx,8), %r8
cmpq 0x18(%rsi,%rcx,8), %r8
jne 0xf8cbe
movq 0x20(%rdi,%rcx,8), %r8
cmpq 0x20(%rsi,%rcx,8), %r8
jne 0xf8cbe
movq 0x28(%rdi,%rcx,8), %r8
cmpq 0x28(%rsi,%rcx,8), %r8
jne 0xf8cbe
movq 0x30(%rdi,%rcx,8), %r8
cmpq 0x30(%rsi,%rcx,8), %r8
jne 0xf8cbe
movq 0x38(%rdi,%rcx,8), %r8
cmpq 0x38(%rsi,%rcx,8), %r8
jne 0xf8cbe
addq $0x8, %rcx
cmpq %rax, %rcx
jle 0xf8c52
jmp 0xf8c26
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: byte_vector_equal
static bool byte_vector_equal(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    s7_int i, len;
                    uint8_t *xp, *yp;

                    if (x == y) return(true);
                    if (type(x) != type(y)) return(false);
                    len = vector_length(x);
                    if (len != vector_length(y)) return(false);

                    xp = byte_vector_bytes(x);
                    yp = byte_vector_bytes(y);
                    for (i = 0; i < len; i++)
                        if (xp[i] != yp[i])
                            return(false);
                    return(true);
                }

// Assembly:
movb $0x1, %al
cmpq %rsi, %rdi
je 0xf8d01
movb (%rdi), %cl
cmpb (%rsi), %cl
jne 0xf8d02
movq 0x8(%rdi), %rcx
cmpq 0x8(%rsi), %rcx
jne 0xf8d02
testq %rcx, %rcx
jle 0xf8d01
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %rsi
decq %rcx
xorl %edi, %edi
movb (%rdx,%rdi), %al
cmpb (%rsi,%rdi), %al
sete %al
jne 0xf8d01
leaq 0x1(%rdi), %r8
cmpq %rdi, %rcx
movq %r8, %rdi
jne 0xf8cea
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: floats_are_equivalent
static bool floats_are_equivalent(s7_scheme *sc, s7_double x, s7_double y)
                {
                    s7_double diff, eps;
                    if (x == y) return(true);
                    eps = sc->equivalent_float_epsilon;
                    diff = fabs(x - y);
                    if (diff <= eps) return(true);

                    if ((is_NaN(x)) || (is_NaN(y)))
                        return((is_NaN(x)) && (is_NaN(y)));

                    if (x < 0.0) x = -x;
                    return((x > 1.0) &&
                            (diff < (x * eps)));
                }

// Assembly:
movb $0x1, %al
ucomisd %xmm1, %xmm0
jne 0xf8d0f
jnp 0xf8d61
movsd 0x260(%rdi), %xmm3
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
andpd 0x11199(%rip), %xmm2    # 0x109ec0
ucomisd %xmm2, %xmm3
jae 0xf8d61
ucomisd %xmm1, %xmm0
jp 0xf8d64
movapd 0x11175(%rip), %xmm1    # 0x109eb0
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
mulsd %xmm1, %xmm3
movsd 0xd2e1(%rip), %xmm0     # 0x106030
cmpltpd %xmm1, %xmm0
cmpltpd %xmm3, %xmm2
andpd %xmm0, %xmm2
movd %xmm2, %eax
andb $0x1, %al
retq
xorpd %xmm2, %xmm2
cmpunordpd %xmm2, %xmm1
cmpunordpd %xmm2, %xmm0
andpd %xmm1, %xmm0
movd %xmm0, %eax
jmp 0xf8d61
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: make_permanent_string
static s7_pointer make_permanent_string(const char *str)
    {
        s7_pointer x;
        s7_int len;

        x = (s7_pointer)calloc(1, sizeof(s7_cell));
        set_type(x, T_STRING | T_IMMUTABLE | T_UNHEAP);
        len = safe_strlen(str);
        string_length(x) = len;
        string_block(x) = NULL;
        string_value(x) = (char *)str;
        string_hash(x) = 0;
        return(x);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x30, %esi
callq 0x8360
movabsq $0x4000000001000013, %rcx # imm = 0x4000000001000013
movq %rcx, (%rax)
testq %rbx, %rbx
je 0xf8db8
cmpb $0x0, (%rbx)
je 0xf8db8
xorl %edx, %edx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%rbx,%rdx)
movq %rcx, %rdx
jne 0xf8da8
jmp 0xf8dba
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_recur_if_a_a_opa_laq
static s7_pointer fx_recur_if_a_a_opa_laq(s7_scheme *sc, s7_pointer arg)
                {
#if S7_DEBUGGING
                    tc_rec_calls[OP_RECUR_IF_A_A_opA_LAq]++;
#endif
                    sc->rec_stack = recur_make_stack(sc);
                    opinit_if_a_a_opa_laq(sc, true, arg);
                    sc->value = oprec_if_a_a_opa_laq(sc);
                    sc->rec_loc = 0;
                    return(sc->value);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd16b2
movq %rax, 0x2e8(%r14)
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0xd1847
movq %r14, %rdi
callq 0xd1900
movq %rax, 0x20(%r14)
movq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_recur_if_a_opa_laq_a
static s7_pointer fx_recur_if_a_opa_laq_a(s7_scheme *sc, s7_pointer arg)
                {
#if S7_DEBUGGING
                    tc_rec_calls[OP_RECUR_IF_A_opA_LAq_A]++;
#endif
                    sc->rec_stack = recur_make_stack(sc);
                    opinit_if_a_a_opa_laq(sc, false, arg);
                    sc->value = oprec_if_a_opa_laq_a(sc);
                    sc->rec_loc = 0;
                    return(sc->value);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd16b2
movq %rax, 0x2e8(%r14)
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xd1847
movq %r14, %rdi
callq 0xd1a2a
movq %rax, 0x20(%r14)
movq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_recur_if_a_a_and_a_laa_laa
static s7_pointer fx_recur_if_a_a_and_a_laa_laa(s7_scheme *sc, s7_pointer arg)
                {
#if S7_DEBUGGING
                    tc_rec_calls[OP_RECUR_IF_A_A_AND_A_LAA_LAA]++;
#endif
                    /* sc->envir is set already and will be restored by the caller */
                    sc->rec_stack = recur_make_stack(sc);
                    opinit_if_a_a_and_a_laa_laa(sc, arg);
                    sc->value = oprec_if_a_a_and_a_laa_laa(sc);
                    sc->rec_loc = 0;
                    return(sc->value);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd16b2
movq %rax, 0x2e8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd3330
movq %r14, %rdi
callq 0xd3452
movq %rax, 0x20(%r14)
movq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_recur_cond_a_a_a_a_opla_laq
static s7_pointer fx_recur_cond_a_a_a_a_opla_laq(s7_scheme *sc, s7_pointer arg)
                {
#if S7_DEBUGGING
                    tc_rec_calls[OP_RECUR_COND_A_A_A_A_opLA_LAq]++;
#endif
                    sc->rec_stack = recur_make_stack(sc);
                    opinit_cond_a_a_a_a_opla_laq(sc, arg);
                    sc->value = oprec_cond_a_a_a_a_opla_laq(sc);
                    sc->rec_loc = 0;
                    return(sc->value);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd16b2
movq %rax, 0x2e8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd3ed8
movq %r14, %rdi
callq 0xd3fe5
movq %rax, 0x20(%r14)
movq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: catch_all_function
static bool catch_all_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    s7_pointer catcher;
                    catcher = stack_let(sc->stack, i);
                    sc->value = stack_args(sc->stack, i);
                    sc->op_stack_now = (s7_pointer *)(sc->op_stack + catch_all_op_loc(catcher));
                    sc->stack_end = (s7_pointer *)(sc->stack_start + catch_all_goto_loc(catcher));
                    pop_stack(sc);
                    if (is_pair(sc->value))
                    {
                        if (car(sc->value) == sc->quote_symbol)
                            sc->value = cadr(sc->value);
                        else sc->value = type;
                    }
                    else
                    {
                        if (is_symbol(sc->value))
                            sc->value = type;
                    }
                    return(true);
                }

// Assembly:
movq 0x38(%rdi), %rax
movq 0x48(%rdi), %rcx
movq 0x10(%rax), %rax
movq -0x10(%rax,%rsi,8), %r8
movq -0x8(%rax,%rsi,8), %rax
movq %rax, 0x20(%rdi)
movq 0x20(%r8), %rsi
shlq $0x3, %rsi
addq 0x60(%rdi), %rsi
movq %rsi, 0x68(%rdi)
movq 0x28(%r8), %rsi
leaq (%rcx,%rsi,8), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rdi)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0xf90f0
cmpl $0x1, %ecx
jne 0xf90f4
movq 0x8(%rax), %rcx
cmpq 0x17b0(%rdi), %rcx
jne 0xf90f0
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: catch_dw_function
static bool catch_dw_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    s7_pointer x;
                    x = stack_code(sc->stack, i);
                    if (dynamic_wind_state(x) == DWIND_BODY)
                    {
                        dynamic_wind_state(x) = DWIND_FINISH;    /* make sure an uncaught error in the exit thunk doesn't cause us to loop */
                        if (dynamic_wind_out(x) != sc->F)
                        {
                            push_stack(sc, OP_EVAL_DONE, sc->args, sc->code);
                            sc->code = dynamic_wind_out(x);
                            sc->args = sc->nil;
                            eval(sc, OP_APPLY);                  /* I guess this means no call/cc out of the exit thunk in an error-catching context */
                        }
                    }
                    return(false);
                }

// Assembly:
movq 0x38(%rdi), %rax
movq 0x10(%rax), %rax
movq -0x18(%rax,%rsi,8), %rax
cmpl $0x1, 0x20(%rax)
jne 0xf95ef
movl $0x2, 0x20(%rax)
movq 0x10(%rax), %rcx
cmpq 0x120(%rdi), %rcx
je 0xf95ef
pushq %rax
movq (%rdi), %rcx
movq 0x50(%rdi), %rdx
movq %rcx, (%rdx)
movq 0x8(%rdi), %rcx
movq 0x50(%rdi), %rdx
movq %rcx, 0x8(%rdx)
movq 0x10(%rdi), %rcx
movq 0x50(%rdi), %rdx
movq %rcx, 0x10(%rdx)
movq 0x50(%rdi), %rcx
movq $0x1df, 0x18(%rcx)      # imm = 0x1DF
addq $0x20, 0x50(%rdi)
movq 0x10(%rax), %rax
movq %rax, (%rdi)
movq 0x110(%rdi), %rax
movq %rax, 0x10(%rdi)
movl $0x198, %esi            # imm = 0x198
callq 0xfd85
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: catch_out_function
static bool catch_out_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    s7_pointer x;
                    x = stack_code(sc->stack, i);                /* "code" = port that we opened */
                    s7_close_output_port(sc, x);
                    x = stack_args(sc->stack, i);                /* "args" = port that we shadowed, if not #<unused> */
                    if (x != sc->unused)
                        sc->output_port = x;
                    return(false);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x10(%rax), %rax
movq -0x18(%rax,%rsi,8), %rsi
cmpq %rsi, 0x120(%rdi)
je 0xf962e
testb $0x1, 0x3(%rsi)
jne 0xf962e
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rax
movq -0x8(%rax,%r14,8), %rax
cmpq 0x140(%rbx), %rax
je 0xf9643
movq %rax, 0x188(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: catch_barrier_function
static bool catch_barrier_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    if (is_input_port(stack_args(sc->stack, i)))      /* (eval-string "'(1 .)") */
                    {
                        if (sc->input_port == stack_args(sc->stack, i))
                            pop_input_port(sc);
                        s7_close_input_port(sc, stack_args(sc->stack, i));
                    }
                    return(false);
                }

// Assembly:
movq 0x38(%rdi), %rcx
movq 0x10(%rcx), %rax
movq -0x8(%rax,%rsi,8), %rax
cmpb $0x23, (%rax)
jne 0xf9771
cmpq %rax, 0x170(%rdi)
jne 0xf975e
movl 0x184(%rdi), %eax
testl %eax, %eax
je 0xf9744
decl %eax
movl %eax, 0x184(%rdi)
shlq $0x3, %rax
addq 0x178(%rdi), %rax
jmp 0xf974b
leaq 0x1c8(%rdi), %rax
movq (%rax), %rax
movq %rax, 0x170(%rdi)
movq 0x10(%rcx), %rax
movq -0x8(%rax,%rsi,8), %rax
pushq %rax
movq 0x8(%rax), %rcx
movq 0x48(%rcx), %rcx
movq %rax, %rsi
callq *0x48(%rcx)
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: stdout_write_string
static void stdout_write_string(s7_scheme *sc, const char *str, s7_int len, s7_pointer port)
    {
        if (str[len] == '\0')
            fputs(str, stdout);
        else
        {
            s7_int i;
            for (i = 0; i < len; i++)
                fputc(str[i], stdout);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi,%rdx)
je 0xf98ab
movq %rdx, %r14
testq %rdx, %rdx
jle 0xf989f
xorl %r15d, %r15d
movq 0x4c747(%rip), %r12     # 0x145fd0
movsbl (%rbx,%r15), %edi
movq (%r12), %rsi
callq 0x8300
incq %r15
cmpq %r15, %r14
jne 0xf9889
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x4c71e(%rip), %rax     # 0x145fd0
movq (%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8250
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: stderr_write_string
static void stderr_write_string(s7_scheme *sc, const char *str, s7_int len, s7_pointer port)
    {
        if (str[len] == '\0')
            fputs(str, stderr);
        else
        {
            s7_int i;
            for (i = 0; i < len; i++)
                fputc(str[i], stderr);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi,%rdx)
je 0xf993a
movq %rdx, %r14
testq %rdx, %rdx
jle 0xf992e
xorl %r15d, %r15d
movq 0x4c6e0(%rip), %r12     # 0x145ff8
movsbl (%rbx,%r15), %edi
movq (%r12), %rsi
callq 0x8300
incq %r15
cmpq %r15, %r14
jne 0xf9918
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x4c6b7(%rip), %rax     # 0x145ff8
movq (%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8250
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: stdin_read_line
static s7_pointer stdin_read_line(s7_scheme *sc, s7_pointer port, bool with_eol, bool copied)
    {
        if (!sc->read_line_buf)
        {
            sc->read_line_buf_size = 1024;
            sc->read_line_buf = (char *)malloc(sc->read_line_buf_size);
        }

        if (fgets(sc->read_line_buf, sc->read_line_buf_size, stdin))
            return(s7_make_string(sc, sc->read_line_buf)); /* fgets adds the trailing '\0' */
        return(make_string_with_length(sc, NULL, 0));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4b8(%rdi), %rdi
testq %rdi, %rdi
je 0xf998f
movl 0x4c0(%rbx), %esi
jmp 0xf99b3
movq $0x400, 0x4c0(%rbx) # imm = 0x400
movl $0x400, %edi            # imm = 0x400
callq 0x8480
movq %rax, %rdi
movq %rax, 0x4b8(%rbx)
movl $0x400, %esi            # imm = 0x400
movq 0x4c61e(%rip), %rax     # 0x145fd8
movq (%rax), %rdx
callq 0x8330
testq %rax, %rax
je 0xf99db
movq 0x4b8(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xe9af
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xf99fa
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x200013, (%r14)       # imm = 0x200013
movq 0x850(%rbx), %r15
testq %r15, %r15
je 0xf9a2c
movq 0x18(%r15), %rax
movq %rax, 0x850(%rbx)
jmp 0xf9acc
movq 0x838(%rbx), %r15
testq %r15, %r15
jne 0xf9a77
movl $0x2800, %edi           # imm = 0x2800
callq 0x8480
movq %rax, %r15
movq %rax, 0x838(%rbx)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0xf9a55
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x18(%r15), %rax
movq %rax, 0x838(%rbx)
movq 0x8c8(%rbx), %rcx
leaq 0x8(%rcx), %rdx
cmpq $0x10000, %rdx          # imm = 0x10000
jbe 0xf9ab0
movl $0x10000, %edi          # imm = 0x10000
callq 0x8480
movq %rax, 0x8d0(%rbx)
movl $0x8, %edx
xorl %ecx, %ecx
jmp 0xf9ab7
movq 0x8d0(%rbx), %rax
addq %rax, %rcx
movq %rdx, 0x8c8(%rbx)
movq %rcx, (%r15)
movl $0x3, 0x8(%r15)
movq $0x1, 0x10(%r15)
movq %r15, 0x20(%r14)
movq (%r15), %rax
movq %rax, 0x10(%r14)
movb $0x0, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x18(%r14)
movq 0x738(%rbx), %rbx
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
cmpq 0x8(%rbx), %rsi
jne 0xf9b1b
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%rbx)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%rbx)
movq 0x10(%rbx), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%rbx)
movq %r14, (%rax,%rsi,8)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: find_dynamic_value
static s7_pointer find_dynamic_value(s7_scheme *sc, s7_pointer x, s7_pointer sym, int64_t *id)
    {
        for (; symbol_id(sym) < let_id(x); x = outlet(x));

        if (let_id(x) == symbol_id(sym))
        {
            (*id) = let_id(x);
            return(slot_value(local_slot(sym)));
        }
        for (; (is_let(x)) && (let_id(x) > (*id)); x = outlet(x))
        {
            s7_pointer y;
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == sym)
                {
                    (*id) = let_id(x);
                    return(slot_value(y));
                }
        }
        return(sc->unused);
    }

// Assembly:
movq 0x20(%rdx), %rax
movq 0x18(%rsi), %r8
cmpq %r8, %rax
jge 0xfa209
movq 0x10(%rsi), %rsi
jmp 0xfa1fa
cmpq %rax, %r8
jne 0xfa21b
movq %rax, (%rcx)
movq 0x18(%rdx), %rdi
addq $0x10, %rdi
jmp 0xfa25d
cmpb $0x1c, (%rsi)
jne 0xfa24a
movq (%rcx), %rax
movq 0x18(%rsi), %r8
cmpq %rax, %r8
jle 0xfa24a
movq 0x8(%rsi), %r9
testq %r9, %r9
je 0xfa241
cmpq %rdx, 0x8(%r9)
je 0xfa253
movq 0x18(%r9), %r9
jmp 0xfa230
movq 0x10(%rsi), %rsi
cmpb $0x1c, (%rsi)
je 0xfa223
addq $0x140, %rdi            # imm = 0x140
jmp 0xfa25d
movq %r8, (%rcx)
addq $0x10, %r9
movq %r9, %rdi
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: open_and_protect_input_string
static inline s7_pointer open_and_protect_input_string(s7_scheme *sc, s7_pointer str)
    {
        s7_pointer p;
        p = open_input_string(sc, string_value(str), string_length(str));
        port_gc_loc(p) = s7_gc_protect_1(sc, str);
        port_needs_unprotect(p) = true;
        return(p);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rsi
callq 0xf642
movq %rax, %r15
cmpq $0x0, 0x108(%r14)
js 0xfa2f2
movq 0xe8(%r14), %rax
jmp 0xfa3ab
movq 0xd0(%r14), %rax
movq 0xf0(%r14), %r13
leaq (,%r13,2), %rbp
movq 0x18(%rax), %rsi
movq %r13, %r12
shlq $0x4, %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x9fd6
movq $0x0, 0x20(%rax)
movq 0xd0(%r14), %rcx
movq %rax, 0x18(%rcx)
movq (%rax), %rax
movq 0xd0(%r14), %rcx
movq %rax, 0x10(%rcx)
movq 0xd0(%r14), %rax
movq %rbp, 0x8(%rax)
movq %rbp, 0xf0(%r14)
movq 0xe8(%r14), %rdi
movq %r12, %rsi
callq 0x8510
movq %rax, 0xe8(%r14)
cmpq %rbp, %r13
jge 0xfa3ab
movq 0x140(%r14), %rcx
movq %r13, %rdx
movq 0xd0(%r14), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax,%rdx,8)
movq 0xe8(%r14), %rax
movq 0x108(%r14), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x108(%r14)
movq %rdx, 0x8(%rax,%rsi,8)
incq %rdx
decq %r13
jne 0xfa376
movq 0xd0(%r14), %rcx
movq 0x108(%r14), %rdx
leaq -0x1(%rdx), %rsi
movq %rsi, 0x108(%r14)
movq (%rax,%rdx,8), %rax
movq 0x10(%rcx), %rcx
movq %rbx, (%rcx,%rax,8)
movq 0x8(%r15), %rcx
movq %rax, 0x28(%rcx)
movq 0x8(%r15), %rax
movb $0x1, 0x1(%rax)
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: input_port_if_not_loading
static s7_pointer input_port_if_not_loading(s7_scheme *sc)
    {
        s7_pointer port;
        port = sc->input_port;
        if (is_loader_port(port)) /* this flag is turned off by the reader macros, so we aren't in that context */
        {
            int32_t c;
            c = port_read_white_space(port)(sc, port);
            if (c > 0)            /* we can get either EOF or NULL at the end */
            {
                backchar(c, port);
                return(NULL);
            }
            return(sc->standard_input);
        }
        return(port);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x170(%rdi), %rbx
testb $0x4, 0x2(%rbx)
je 0xfa42e
movq %rdi, %r14
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %rbx, %rsi
callq *0x20(%rax)
testl %eax, %eax
jle 0xfa427
movsbl %al, %edi
movq %rbx, %rsi
callq 0xfb07
xorl %ebx, %ebx
jmp 0xfa42e
movq 0x1c8(%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: call_with_input
static s7_pointer call_with_input(s7_scheme *sc, s7_pointer port, s7_pointer args)
    {
        s7_pointer p;
        p = cadr(args);
        port_original_input_string(port) = car(args);
        push_stack(sc, OP_UNWIND_INPUT, sc->input_port, port);
        push_stack(sc, OP_APPLY, list_1(sc, port), p);
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rdx, 0x40(%rax)
movq 0x50(%rdi), %rax
movq %rsi, (%rax)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x50(%rdi), %rax
movq 0x170(%rdi), %rdx
movq %rdx, 0x10(%rax)
movq 0x50(%rdi), %rax
movq $0x1ee, 0x18(%rax)      # imm = 0x1EE
movq 0x50(%rdi), %rax
leaq 0x20(%rax), %rdx
movq %rdx, 0x50(%rdi)
movq %rcx, 0x20(%rax)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x90(%rdi), %rax
movq 0x110(%rdi), %r15
cmpq 0x98(%rdi), %rax
ja 0xfa4bc
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x198, 0x18(%rax)      # imm = 0x198
addq $0x20, 0x50(%rbx)
movq 0x120(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: make_simple_ratio
static inline s7_pointer make_simple_ratio(s7_scheme *sc, s7_int num, s7_int den)
    {
        s7_pointer x;
        if (den == 1)
            return(make_integer(sc, num));
        if (den == -1)
            return(make_integer(sc, -num));
        if ((den == s7_int_min) && ((num & 1) != 0))
            return(make_real(sc, (long double)num / (long double)den));
        new_cell(sc, x, T_RATIO);
        if (den < 0)
        {
            numerator(x) = -num;
            denominator(x) = -den;
        }
        else
        {
            numerator(x) = num;
            denominator(x) = den;
        }
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $-0x1, %rdx
je 0xfa637
movq %rdx, %r15
cmpq $0x1, %rdx
je 0xfa63a
testb $0x1, %r14b
je 0xfa68e
movl 0x50465(%rip), %eax     # 0x14aa28
shlq $0x3f, %rax
cmpq %r15, %rax
jne 0xfa68e
movq %r14, 0x10(%rsp)
fildll 0x10(%rsp)
movq %r15, 0x18(%rsp)
fildll 0x18(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfa617
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xa550
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0xfa6dc
negq %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xfa653
leaq 0x4c306(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xfa6dc
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfa672
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0xfa6dc
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfa6ad
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xc, (%rax)
testq %r15, %r15
js 0xfa6ce
movq %r14, 0x8(%rax)
jmp 0xfa6d8
negq %r14
movq %r14, 0x8(%rax)
negq %r15
movq %r15, 0x10(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: c_asin
static s7_pointer c_asin(s7_scheme *sc, s7_double x)
    {
        s7_double absx, recip;
        s7_complex result;

        absx = fabs(x);
        if (absx <= 1.0)
            return(make_real(sc, asin(x)));

        /* otherwise use maxima code: */
        recip = 1.0 / absx;
        result = (M_PI / 2.0) - (_Complex_I * clog(absx * (1.0 + (sqrt(1.0 + recip) * csqrt(1.0 - recip)))));
        if (x < 0.0)
            return(s7_from_c_complex(sc, -result));
        return(s7_from_c_complex(sc, result));
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movapd 0xf7ca(%rip), %xmm2     # 0x109ec0
andpd %xmm0, %xmm2
movsd 0xb92e(%rip), %xmm1     # 0x106030
ucomisd %xmm2, %xmm1
jae 0xfa7aa
movapd %xmm0, (%rsp)
movapd %xmm1, %xmm3
divsd %xmm2, %xmm1
movapd %xmm3, %xmm0
subsd %xmm1, %xmm0
addsd %xmm3, %xmm1
sqrtsd %xmm1, %xmm1
movsd %xmm1, 0x18(%rsp)
xorpd %xmm1, %xmm1
movapd %xmm2, 0x20(%rsp)
callq 0x8560
movsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
addsd 0xb8dc(%rip), %xmm0     # 0x106030
movapd 0x20(%rsp), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
callq 0x82a0
xorpd %xmm4, %xmm4
movapd %xmm0, %xmm2
movapd %xmm1, %xmm3
mulsd %xmm4, %xmm0
mulsd %xmm4, %xmm1
subsd %xmm3, %xmm0
addsd %xmm2, %xmm1
ucomisd %xmm0, %xmm0
jp 0xfa812
movsd 0xb923(%rip), %xmm2     # 0x1060b8
subsd %xmm0, %xmm2
ucomisd (%rsp), %xmm4
jbe 0xfa7f9
xorpd 0xf708(%rip), %xmm2     # 0x109eb0
jmp 0xfa801
callq 0x8630
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfa7d8
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xa550
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
addq $0x30, %rsp
popq %rbx
retq
xorpd 0xf6af(%rip), %xmm1     # 0x109eb0
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
jmp 0xd387
ucomisd %xmm1, %xmm1
jnp 0xfa78d
movsd 0xb80c(%rip), %xmm1     # 0x106030
xorpd %xmm0, %xmm0
callq 0x1051d0
xorpd %xmm4, %xmm4
jmp 0xfa78d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: c_acos
static s7_pointer c_acos(s7_scheme *sc, s7_double x)
    {
        s7_double absx, recip;
        s7_complex result;

        absx = fabs(x);
        if (absx <= 1.0)
            return(make_real(sc, acos(x)));

        /* else follow maxima again: */
        recip = 1.0 / absx;
        if (x > 0.0)
            result = _Complex_I * clog(absx * (1.0 + (sqrt(1.0 + recip) * csqrt(1.0 - recip))));
        else result = M_PI - _Complex_I * clog(absx * (1.0 + (sqrt(1.0 + recip) * csqrt(1.0 - recip))));
        return(s7_from_c_complex(sc, result));
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movapd 0xf67a(%rip), %xmm2     # 0x109ec0
andpd %xmm0, %xmm2
movsd 0xb7de(%rip), %xmm1     # 0x106030
ucomisd %xmm2, %xmm1
jae 0xfa90d
movapd %xmm1, %xmm3
divsd %xmm2, %xmm1
movapd %xmm0, (%rsp)
movapd %xmm3, %xmm0
subsd %xmm1, %xmm0
addsd %xmm3, %xmm1
sqrtsd %xmm1, %xmm1
movsd %xmm1, 0x18(%rsp)
xorpd %xmm1, %xmm1
movapd %xmm2, 0x20(%rsp)
callq 0x8560
movsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
addsd 0xb78c(%rip), %xmm0     # 0x106030
movapd 0x20(%rsp), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
callq 0x82a0
xorpd %xmm4, %xmm4
movapd %xmm0, %xmm2
movapd %xmm1, %xmm3
movapd (%rsp), %xmm0
ucomisd %xmm4, %xmm0
movapd %xmm2, %xmm0
mulsd %xmm4, %xmm0
mulsd %xmm1, %xmm4
subsd %xmm1, %xmm0
addsd %xmm2, %xmm4
jbe 0xfa95c
ucomisd %xmm0, %xmm0
jnp 0xfa97a
ucomisd %xmm4, %xmm4
jnp 0xfa97a
movsd 0xb732(%rip), %xmm1     # 0x106030
xorpd %xmm0, %xmm0
callq 0x1051d0
movapd %xmm1, %xmm4
jmp 0xfa97a
callq 0x8320
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfa93b
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xa550
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
addq $0x30, %rsp
popq %rbx
retq
ucomisd %xmm0, %xmm0
jp 0xfa98b
movsd 0xb78e(%rip), %xmm1     # 0x1060f8
subsd %xmm0, %xmm1
xorpd 0xf53a(%rip), %xmm4     # 0x109eb0
movapd %xmm1, %xmm0
movq %rbx, %rdi
movapd %xmm4, %xmm1
addq $0x30, %rsp
popq %rbx
jmp 0xd387
ucomisd %xmm4, %xmm4
jnp 0xfa962
movsd 0xb697(%rip), %xmm1     # 0x106030
xorpd %xmm0, %xmm0
callq 0x1051d0
movapd %xmm1, %xmm4
jmp 0xfa962
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_truncate
static s7_pointer s7_truncate(s7_scheme *sc, s7_pointer caller, s7_double xf)   /* can't use "truncate" -- it's in unistd.h */
    {
        if ((xf > s7_int_max) ||
                (xf < s7_int_min))
            return(simple_out_of_range(sc, caller, wrap_real(sc, xf), its_too_large_string));

        if (xf > 0.0)
            return(make_integer(sc, (s7_int)floor(xf)));
        return(make_integer(sc, (s7_int)ceil(xf)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x50251(%rip)     # 0x14ac08
jne 0xfa9bf
xorpd %xmm1, %xmm1
jmp 0xfa9c7
movsd 0xb659(%rip), %xmm1     # 0x106020
ucomisd %xmm1, %xmm0
ja 0xfa9ea
cmpb $0x0, 0x50054(%rip)     # 0x14aa28
jne 0xfa9dc
xorpd %xmm1, %xmm1
jmp 0xfa9e4
movsd 0xb644(%rip), %xmm1     # 0x106028
ucomisd %xmm0, %xmm1
jbe 0xfaa49
movq 0x8(%rsi), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0x50031(%rip), %rsi     # 0x14aa40
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x1948(%rbx), %r14
movq 0x1ef8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38dfa
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xfaa5a
callq 0x85f0
jmp 0xfaa5f
callq 0x86c0
cvttsd2si %xmm0, %r15
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0xfaa7a
leaq 0x4bedc(%rip), %rax     # 0x146950
movq (%rax,%r15,8), %r14
jmp 0xfaa40
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfaa99
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0xb, (%r14)
movq %r15, 0x8(%r14)
jmp 0xfaa40
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: r5rs_round
static s7_double r5rs_round(s7_double x)
    {
        s7_double fl, ce, dfl, dce;

        fl = floor(x);
        ce = ceil(x);
        dfl = x - fl;
        dce = ce - x;

        if (dfl > dce) return(ce);
        if (dfl < dce) return(fl);
        if (fmod(fl, 2.0) == 0.0) return(fl);
        return(ce);
    }

// Assembly:
subq $0x28, %rsp
movsd %xmm0, (%rsp)
callq 0x85f0
movaps %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x86c0
movsd (%rsp), %xmm3
movapd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm1
subsd %xmm3, %xmm0
subsd %xmm2, %xmm3
ucomisd %xmm0, %xmm3
ja 0xfab2d
ucomisd %xmm3, %xmm0
jbe 0xfaafb
movapd %xmm2, %xmm1
jmp 0xfab2d
movapd %xmm1, (%rsp)
movsd 0xb610(%rip), %xmm1     # 0x106118
movapd %xmm2, %xmm0
callq 0x82c0
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movapd 0x10(%rsp), %xmm0
andpd %xmm1, %xmm0
andnpd (%rsp), %xmm1
orpd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: c_gcd
static s7_int c_gcd(s7_int u, s7_int v)
    {
        s7_int a, b;

        if ((u == s7_int_min) || (v == s7_int_min))
        {
            /* can't take abs of these (below) so do it by hand */
            s7_int divisor = 1;
            if (u == v) return(u);
            while (((u & 1) == 0) && ((v & 1) == 0))
            {
                u /= 2;
                v /= 2;
                divisor *= 2;
            }
            return(divisor);
        }

        a = s7_int_abs(u);
        b = s7_int_abs(v);
        /* there are faster gcd algorithms but does it ever matter? */
        while (b != 0)
        {
            s7_int temp;
            temp = a % b;
            a = b;
            b = temp;
        }
        /* if (a < 0) return(-a); */ /* why this? */
        return(a);
    }

// Assembly:
movl 0x4feec(%rip), %eax     # 0x14aa28
shlq $0x3f, %rax
cmpq %rdi, %rax
setne %cl
cmpq %rsi, %rax
setne %al
testb %al, %cl
jne 0xfab5a
cmpq %rsi, %rdi
jne 0xfab85
movq %rdi, %rcx
jmp 0xfabb4
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
testq %rsi, %rsi
je 0xfabb1
movq %rsi, %rdx
negq %rdx
cmovsq %rsi, %rdx
movq %rdx, %rcx
xorl %edx, %edx
divq %rcx
movq %rcx, %rax
testq %rdx, %rdx
jne 0xfab73
jmp 0xfabb4
movl %edi, %eax
orl %esi, %eax
movl $0x1, %ecx
testb $0x1, %al
jne 0xfabb4
movq %rdi, %rax
movq %rsi, %rdx
sarq %rax
sarq %rdx
addq %rcx, %rcx
orl %esi, %edi
movq %rdx, %rsi
testb $0x2, %dil
movq %rax, %rdi
je 0xfab98
jmp 0xfabb4
movq %rax, %rcx
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: reduce_fraction
static int32_t reduce_fraction(s7_int *numer, s7_int *denom)
    {
        /* we're assuming in several places that we have a normal s7 rational after returning,
         *    so the denominator needs to be positive.
         */
        s7_int divisor;

        if (*numer == 0)
        {
            *denom = 1;
            return(T_INTEGER);
        }
        if (*denom < 0)
        {
            if (*denom == *numer)
            {
                *denom = 1;
                *numer = 1;
                return(T_INTEGER);
            }
            if (*denom == s7_int_min)
            {
                if (*numer & 1)
                    return(T_RATIO);
                *denom /= 2;
                *numer /= 2;
            }
            else
            {
                if (*numer == s7_int_min)
                {
                    if (*denom & 1)
                        return(T_RATIO);
                    *denom /= 2;
                    *numer /= 2;
                }
            }
            *denom = -*denom;
            *numer = -*numer;
        }
        divisor = c_gcd(*numer, *denom);
        if (divisor != 1)
        {
            *numer /= divisor;
            *denom /= divisor;
        }
        if (*denom == 1)
            return(T_INTEGER);
        return(T_RATIO);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0xfac11
movq %rdi, %r14
movq (%rbx), %r15
testq %r15, %r15
js 0xfac1a
movq %r12, %rdi
movq %r15, %rsi
callq 0xfab36
cmpq $0x1, %rax
je 0xfac03
movq %rax, %rcx
movq %r12, %rax
cqto
idivq %rcx
movq %rax, (%r14)
movq (%rbx), %rax
cqto
idivq %rcx
movq %rax, %r15
movq %rax, (%rbx)
xorl %eax, %eax
cmpq $0x1, %r15
setne %al
addl $0xb, %eax
jmp 0xfac2f
movq $0x1, (%rbx)
jmp 0xfac2a
cmpq %r12, %r15
jne 0xfac3b
movl $0x1, %eax
movq %rax, (%rbx)
movq %rax, (%r14)
movl $0xb, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl 0x4fde7(%rip), %eax     # 0x14aa28
shlq $0x3f, %rax
cmpq %rax, %r15
jne 0xfac61
movl $0xc, %eax
testb $0x1, %r12b
jne 0xfac2f
movabsq $-0x4000000000000000, %r15 # imm = 0xC000000000000000
jmp 0xfac74
cmpq %rax, %r12
jne 0xfac8a
movl $0xc, %eax
testb $0x1, %r15b
jne 0xfac2f
sarq %r15
movq %r15, (%rbx)
movq (%r14), %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
sarq %rcx
movq %rcx, (%r14)
negq (%rbx)
xorl %r12d, %r12d
subq (%r14), %r12
movq %r12, (%r14)
movq (%rbx), %r15
jmp 0xfabd6