LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xc76c9
movq %rdx, %r15
cmpq $0x1, %rdx
je 0xc76cc
testb $0x1, %r14b
je 0xc7720
movl 0x523d3(%rip), %eax     # 0x119a28
shlq $0x3f, %rax
cmpq %r15, %rax
jne 0xc7720
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 0xc76a9
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x9c27
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 0xc776e
negq %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xc76e5
leaq 0x4e274(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0xc776e
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc7704
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0xc776e
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc773f
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xc, (%rax)
testq %r15, %r15
js 0xc7760
movq %r14, 0x8(%rax)
jmp 0xc776a
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_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_to_c_complex
static s7_complex s7_to_c_complex(s7_pointer p)
    {
#if HAVE_COMPLEX_NUMBERS
        return(CMPLX(s7_real_part(p), s7_imag_part(p)));
#else
        return(0.0);
#endif
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xcbc9
xorpd %xmm2, %xmm2
cmpb $0xe, (%rbx)
xorpd %xmm1, %xmm1
jne 0xc77ba
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe6c0(%rip), %xmm2     # 0xd5ec0
andpd %xmm0, %xmm2
movsd 0xa824(%rip), %xmm1     # 0xd2030
ucomisd %xmm2, %xmm1
jae 0xc78b4
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 0xa7d2(%rip), %xmm0     # 0xd2030
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 0xc791c
movsd 0xa811(%rip), %xmm2     # 0xd20b0
subsd %xmm0, %xmm2
ucomisd (%rsp), %xmm4
jbe 0xc7903
xorpd 0xe5fe(%rip), %xmm2     # 0xd5eb0
jmp 0xc790b
callq 0x8630
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc78e2
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x9c27
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 0xe5a5(%rip), %xmm1     # 0xd5eb0
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
jmp 0xc152
ucomisd %xmm1, %xmm1
jnp 0xc7897
movsd 0xa702(%rip), %xmm1     # 0xd2030
xorpd %xmm0, %xmm0
callq 0xd1640
xorpd %xmm4, %xmm4
jmp 0xc7897
// File: /workspace/github_c_makefile_star2_O2/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 0xe570(%rip), %xmm2     # 0xd5ec0
andpd %xmm0, %xmm2
movsd 0xa6d4(%rip), %xmm1     # 0xd2030
ucomisd %xmm2, %xmm1
jae 0xc7a17
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 0xa682(%rip), %xmm0     # 0xd2030
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 0xc7a66
ucomisd %xmm0, %xmm0
jnp 0xc7a84
ucomisd %xmm4, %xmm4
jnp 0xc7a84
movsd 0xa628(%rip), %xmm1     # 0xd2030
xorpd %xmm0, %xmm0
callq 0xd1640
movapd %xmm1, %xmm4
jmp 0xc7a84
callq 0x8320
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc7a45
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x9c27
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 0xc7a95
movsd 0xa614(%rip), %xmm1     # 0xd2088
subsd %xmm0, %xmm1
xorpd 0xe430(%rip), %xmm4     # 0xd5eb0
movapd %xmm1, %xmm0
movq %rbx, %rdi
movapd %xmm4, %xmm1
addq $0x30, %rsp
popq %rbx
jmp 0xc152
ucomisd %xmm4, %xmm4
jnp 0xc7a6c
movsd 0xa58d(%rip), %xmm1     # 0xd2030
xorpd %xmm0, %xmm0
callq 0xd1640
movapd %xmm1, %xmm4
jmp 0xc7a6c
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: int_pow_ok
static bool int_pow_ok(s7_int x, s7_int y)
    {
        if (s7_int_bits > 31)
            return((y < 63) &&
                    (nth_roots[y] >= s7_int_abs(x)));
        return((y < 31) &&
                (int_nth_roots[y] >= s7_int_abs(x)));
    }

// Assembly:
cmpb $0x1, 0x521a7(%rip)     # 0x119c60
jne 0xc7aca
cmpq $0x3e, %rsi
jg 0xc7aec
leaq 0xe0b8(%rip), %rax      # 0xd5b80
jmp 0xc7ad7
cmpq $0x1e, %rsi
jg 0xc7aec
leaq 0xe2a9(%rip), %rax      # 0xd5d80
leaq (%rax,%rsi,8), %rax
movq %rdi, %rcx
negq %rcx
cmovsq %rdi, %rcx
cmpq %rcx, (%rax)
setge %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: int_to_int
static s7_int int_to_int(s7_int x, s7_int n)
    {
        /* from GSL */
        s7_int value = 1;
        do {
            if (n & 1) value *= x;
            n >>= 1;
#if HAVE_OVERFLOW_CHECKS
            if (multiply_overflow(x, x, &x))
                break;
#else
            x *= x;
#endif
        } while (n);
        return(value);
    }

// Assembly:
pushq $0x1
popq %rcx
movq %rcx, %rax
movq %rax, %rdx
testb $0x1, %sil
movq %rdi, %rax
cmoveq %rcx, %rax
imulq %rdx, %rax
imulq %rdi, %rdi
seto %dl
cmpq $0x2, %rsi
jb 0xc7b1b
sarq %rsi
testb %dl, %dl
je 0xc7af5
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x520de(%rip)     # 0x119c08
jne 0xc7b32
xorpd %xmm1, %xmm1
jmp 0xc7b3a
movsd 0xa4e6(%rip), %xmm1     # 0xd2020
ucomisd %xmm1, %xmm0
ja 0xc7b5d
cmpb $0x0, 0x51ee1(%rip)     # 0x119a28
jne 0xc7b4f
xorpd %xmm1, %xmm1
jmp 0xc7b57
movsd 0xa4d1(%rip), %xmm1     # 0xd2028
ucomisd %xmm0, %xmm1
jbe 0xc7b8a
movq 0x8(%rsi), %rsi
movq 0x1f18(%rbx), %rax
movsd %xmm0, 0x8(%rax)
movq 0x1f18(%rbx), %rdx
movq 0x51ec5(%rip), %rcx     # 0x119a40
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35b47
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xc7b9b
callq 0x85f0
jmp 0xc7ba0
callq 0x86c0
cvttsd2si %xmm0, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xc7bbb
leaq 0x4dd9b(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0xc7bf4
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc7bda
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc7c74
ucomisd %xmm3, %xmm0
jbe 0xc7c42
movapd %xmm2, %xmm1
jmp 0xc7c74
movapd %xmm1, (%rsp)
movsd 0xa4d1(%rip), %xmm1     # 0xd2120
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_O2/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:
movq %rdi, %rax
movl 0x51da2(%rip), %ecx     # 0x119a28
shlq $0x3f, %rcx
cmpq %rdi, %rcx
setne %dl
cmpq %rsi, %rcx
setne %cl
testb %cl, %dl
jne 0xc7cb6
cmpq %rsi, %rax
je 0xc7cdf
pushq $0x1
popq %rcx
movl %eax, %edx
orl %esi, %edx
testb $0x1, %dl
jne 0xc7cdc
sarq %rax
sarq %rsi
addq %rcx, %rcx
jmp 0xc7ca2
movq %rax, %rcx
negq %rcx
cmovnsq %rcx, %rax
movq %rsi, %rdx
negq %rdx
cmovsq %rsi, %rdx
testq %rdx, %rdx
je 0xc7cdf
movq %rdx, %rcx
xorl %edx, %edx
divq %rcx
movq %rcx, %rax
jmp 0xc7cca
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc7d39
movq %rdi, %r14
movq (%rbx), %r15
testq %r15, %r15
js 0xc7d42
movq %r12, %rdi
movq %r15, %rsi
callq 0xc7c7d
cmpq $0x1, %rax
je 0xc7d2b
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 0xc7d53
movq $0x1, (%rbx)
jmp 0xc7d50
cmpq %r12, %r15
jne 0xc7d5f
pushq $0x1
popq %rax
movq %rax, (%rbx)
movq %rax, (%r14)
pushq $0xb
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl 0x51cc3(%rip), %eax     # 0x119a28
shlq $0x3f, %rax
cmpq %rax, %r15
jne 0xc7d80
testb $0x1, %r12b
jne 0xc7db3
movabsq $-0x4000000000000000, %r15 # imm = 0xC000000000000000
jmp 0xc7d8e
cmpq %rax, %r12
jne 0xc7d9f
testb $0x1, %r15b
jne 0xc7db3
sarq %r15
movq %r15, (%rbx)
movq (%r14), %rax
pushq $0x2
popq %rcx
cqto
idivq %rcx
movq %rax, (%r14)
negq (%rbx)
xorl %r12d, %r12d
subq (%r14), %r12
movq %r12, (%r14)
movq (%rbx), %r15
jmp 0xc7cfe
pushq $0xc
jmp 0xc7d52
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: multiply_method_or_bust
static s7_pointer multiply_method_or_bust(s7_scheme *sc, s7_pointer obj, s7_pointer caller, s7_pointer args, s7_pointer typ, int32_t num)
    {
        if (has_active_methods(sc, obj))
            return(find_and_apply_method(sc, find_let(sc, obj), sc->multiply_symbol, args));
        if (num == 0)
            return(simple_wrong_type_argument_with_type(sc, caller, obj, typ));
        return(wrong_type_argument_with_type(sc, caller, num, obj, typ));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rsi, %r14
movq %rdi, %r15
testb $0x40, 0x3(%rsi)
je 0xc86e1
cmpb $0x1, 0x24c(%r15)
jne 0xc86e1
movq %rcx, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0x1358(%r15), %rdx
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x73dc9
movq 0x8(%rdx), %r12
testl %r9d, %r9d
je 0xc8703
movslq %r9d, %r13
cmpl $0x7ff, %r9d            # imm = 0x7FF
ja 0xc8724
leaq 0x4d253(%rip), %rax     # 0x115950
movq (%rax,%r13,8), %rdx
jmp 0xc875d
movq 0x140(%r15), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd456
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0xc8743
movq %r15, %rdi
callq 0x9c27
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rdx
movq $0xb, (%rdx)
movq %r13, 0x8(%rdx)
movq 0x140(%r15), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
movq %rbx, %r9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9bbb
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: complex_invert
static s7_pointer complex_invert(s7_scheme *sc, s7_pointer p)
    {
        s7_double r2, i2, den;
        r2 = real_part(p);
        i2 = imag_part(p);
        den = (r2 * r2 + i2 * i2);
        return(s7_make_complex(sc, r2 / den, -i2 / den));
    }

// Assembly:
movsd 0x8(%rsi), %xmm0
movsd 0x10(%rsi), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
divsd %xmm3, %xmm0
xorpd 0xce6e(%rip), %xmm1     # 0xd5eb0
divsd %xmm3, %xmm1
jmp 0xc152
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: nan_with_error_check
static s7_pointer nan_with_error_check(s7_scheme *sc, s7_pointer y, s7_pointer p, s7_pointer args, s7_pointer caller)
    {
        for (; is_not_null(p); p = cdr(p))
            if (!is_real_via_method(sc, car(p)))
                return(wrong_type_argument(sc, caller, position_of(p, args), car(p), T_REAL));
        return(y);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x50944(%rip), %rbp     # 0x1199b0
cmpq 0x110(%rbx), %r14
je 0xc90cb
movq 0x8(%r14), %rsi
movzbl (%rsi), %eax
cmpb $0x0, (%rax,%rbp)
jne 0xc909d
testb $0x40, 0x3(%rsi)
je 0xc90a3
cmpb $0x1, 0x24c(%rbx)
jne 0xc90a3
movq %rbx, %rdi
callq 0xc9141
testb %al, %al
je 0xc90a3
movq 0x10(%r14), %r14
jmp 0xc906c
movq 0x8(%r15), %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x72a82
movslq %eax, %r12
cmpl $0x7ff, %r12d           # imm = 0x7FF
ja 0xc90dd
leaq 0x4c88b(%rip), %rax     # 0x115950
movq (%rax,%r12,8), %rdx
jmp 0xc9116
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc90fc
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0xb, (%rdx)
movq %r12, 0x8(%rdx)
movq 0x8(%r14), %rcx
movq 0x140(%rbx), %r8
movq 0x509a0(%rip), %r9      # 0x119ac8
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9bbb
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: c_quo_int
static inline s7_int c_quo_int(s7_scheme *sc, s7_int x, s7_int y)
    {
        if (y == 0)
            division_by_zero_error(sc, sc->quotient_symbol, set_elist_2(sc, wrap_integer1(sc, x), wrap_integer2(sc, y)));
        if ((y == -1) && (x == s7_int_min))   /* (quotient most-negative-fixnum -1) */
            simple_out_of_range(sc, sc->quotient_symbol, set_elist_2(sc, wrap_integer1(sc, x), wrap_integer2(sc, y)), its_too_large_string);
        return(x / y);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpq $-0x1, %rdx
je 0xc9248
testq %rbx, %rbx
jne 0xc92b4
movq 0x1418(%rdi), %rsi
movq 0x1f00(%rdi), %rax
movq %r14, 0x8(%rax)
movq 0x1f00(%rdi), %rax
movq 0x1f08(%rdi), %rcx
andq $0x0, 0x8(%rcx)
movq 0x1f08(%rdi), %rcx
movq 0x6e0(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%rdi), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%rdi), %rdx
callq 0xc1ff
jmp 0xc92b4
movl 0x507da(%rip), %eax     # 0x119a28
shlq $0x3f, %rax
cmpq %r14, %rax
jne 0xc92b4
movq 0x1418(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x1f00(%rdi), %rax
movq %r14, 0x8(%rax)
movq 0x1f00(%rdi), %rax
movq 0x1f08(%rdi), %rcx
orq $-0x1, 0x8(%rcx)
movq 0x1f08(%rdi), %rcx
movq 0x6e0(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%rdi), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%rdi), %rdx
movq 0x50791(%rip), %rcx     # 0x119a40
callq 0x35b47
movq %r14, %rax
cqto
idivq %rbx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: c_mod
static s7_int c_mod(s7_int x, s7_int y)
    {
        s7_int z;
        if (y == 0) return(x);     /* else arithmetic exception */
        if ((y == 1) || (y == -1)) /* else (modulo most-negative-fixnum -1) will segfault with arithmetic exception */
            return(0);
        z = x % y;
        if (((y < 0) && (z > 0)) ||
                ((y > 0) && (z < 0)))
            return(z + y);
        return(z);
    }

// Assembly:
cmpq $-0x1, %rsi
je 0xc92d8
movq %rdi, %rax
testq %rsi, %rsi
je 0xc92da
cmpq $0x1, %rsi
jne 0xc92db
xorl %eax, %eax
retq
cqto
idivq %rsi
testq %rsi, %rsi
sets %cl
movq %rdx, %rax
testq %rdx, %rdx
setg %dl
testb %dl, %cl
jne 0xc9303
testq %rsi, %rsi
setle %cl
testq %rax, %rax
setns %dl
orb %cl, %dl
jne 0xc92da
addq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: c_ash
static s7_int c_ash(s7_scheme *sc, s7_int arg1, s7_int arg2)
    {
        if (arg1 == 0) return(0);

        if (arg2 >= s7_int_bits)
        {
            if ((arg1 == -1) && (arg2 == 63))   /* (ash -1 63): most-negative-fixnum */
                return(s7_int_min);
            out_of_range(sc, sc->ash_symbol, small_int(2), wrap_integer1(sc, arg2), its_too_large_string);
        }

        if (arg2 < -s7_int_bits)
        {
            if (arg1 < 0)                      /* (ash -31 -100) */
                return(-1);
            return(0);
        }

        /* I can't see any point in protecting this: (ash 9223372036854775807 1) -> -2, but anyone using ash must know something about bits */
        if (arg2 >= 0)
        {
            if (arg1 < 0)
            {
                uint64_t z;
                z = (uint64_t)arg1;
                return((s7_int)(z << arg2));
            }
            return(arg1 << arg2);
        }
        return(arg1 >> -arg2);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xc934a
movq %rdx, %r14
movq %rsi, %rbx
movb 0x50944(%rip), %al      # 0x119c60
xorl %ecx, %ecx
testb %al, %al
pushq $0x3f
popq %rdx
cmoveq %rcx, %rdx
cmpq %r14, %rdx
jg 0xc9384
movq %rbx, %rax
notq %rax
movq %r14, %rcx
xorq $0x3f, %rcx
orq %rax, %rcx
jne 0xc934e
movl 0x506e4(%rip), %ebx     # 0x119a28
shlq $0x3f, %rbx
jmp 0xc93b0
xorl %ebx, %ebx
jmp 0xc93b0
movq 0xbd8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x4c600(%rip), %rdx     # 0x115960
movq 0x1f00(%rdi), %rax
movq %r14, 0x8(%rax)
movq 0x1f00(%rdi), %rcx
movq 0x506c7(%rip), %r8      # 0x119a40
callq 0xcb8f
movb 0x508dc(%rip), %al      # 0x119c60
xorl %ecx, %ecx
testb $0x1, %al
pushq $-0x3f
popq %rax
cmoveq %rcx, %rax
cmpq %r14, %rax
jle 0xc939a
sarq $0x3f, %rbx
jmp 0xc93b0
testq %r14, %r14
js 0xc93a7
movl %r14d, %ecx
shlq %cl, %rbx
jmp 0xc93b0
negb %r14b
movl %r14d, %ecx
sarq %cl, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: integer_length
static int32_t integer_length(s7_int a)
    {
#define I_8 256LL
#define I_16 65536LL
#define I_24 16777216LL
#define I_32 4294967296LL
#define I_40 1099511627776LL
#define I_48 281474976710656LL
#define I_56 72057594037927936LL

        /* a might be most-negative-fixnum! in Clisp: (integer-length -9223372036854775808) -> 63
        */
        if (a < 0)
        {
            if (a == s7_int_min) return(63);
            a = -a;
        }
        if (a < I_8) return(bits[a]);
        if (a < I_16) return(8 + bits[a >> 8]);
        if (a < I_24) return(16 + bits[a >> 16]);
        if (a < I_32) return(24 + bits[a >> 24]);
        if (a < I_40) return(32 + bits[a >> 32]);
        if (a < I_48) return(40 + bits[a >> 40]);
        if (a < I_56) return(48 + bits[a >> 48]);
        return(56 + bits[a >> 56]);
    }

// Assembly:
cmpq $0xff, %rdi
jg 0xc93cf
leaq 0xbb65(%rip), %rax      # 0xd4f30
movl (%rax,%rdi,4), %eax
retq
cmpq $0xffff, %rdi           # imm = 0xFFFF
ja 0xc93ea
shrq $0x8, %rdi
leaq 0xbb4d(%rip), %rax      # 0xd4f30
movl (%rax,%rdi,4), %eax
addl $0x8, %eax
retq
cmpq $0xffffff, %rdi         # imm = 0xFFFFFF
ja 0xc9405
shrq $0x10, %rdi
leaq 0xbb32(%rip), %rax      # 0xd4f30
movl (%rax,%rdi,4), %eax
addl $0x10, %eax
retq
movq %rdi, %rax
shrq $0x20, %rax
jne 0xc9420
shrq $0x18, %rdi
leaq 0xbb17(%rip), %rax      # 0xd4f30
movl (%rax,%rdi,4), %eax
addl $0x18, %eax
retq
movq %rdi, %rcx
shrq $0x28, %rcx
jne 0xc9437
leaq 0xbb00(%rip), %rcx      # 0xd4f30
movl (%rcx,%rax,4), %eax
addl $0x20, %eax
retq
movq %rdi, %rax
shrq $0x30, %rax
jne 0xc944e
leaq 0xbae9(%rip), %rax      # 0xd4f30
movl (%rax,%rcx,4), %eax
addl $0x28, %eax
retq
shrq $0x38, %rdi
jne 0xc9462
leaq 0xbad5(%rip), %rcx      # 0xd4f30
movl (%rcx,%rax,4), %eax
addl $0x30, %eax
retq
leaq 0xbac7(%rip), %rax      # 0xd4f30
movl (%rax,%rdi,4), %eax
addl $0x38, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: string_to_number
static s7_pointer string_to_number(s7_scheme *sc, char *str, int32_t radix)
    {
        s7_pointer x;
        x = make_atom(sc, str, radix, NO_SYMBOLS, WITHOUT_OVERFLOW_ERROR);
        if (s7_is_number(x))  /* only needed because str might start with '#' and not be a number (#t for example) */
            return(x);
        return(sc->F);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %ecx, %ecx
callq 0x74d92
movzbl (%rax), %ecx
leaq 0x504eb(%rip), %rdx     # 0x119970
cmpb $0x0, (%rcx,%rdx)
jne 0xc9492
movq 0x120(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: char_with_error_check
static s7_pointer char_with_error_check(s7_scheme *sc, s7_pointer x, s7_pointer args, s7_pointer caller)
    {
        s7_pointer y;
        for (y = cdr(x); is_pair(y); y = cdr(y)) /* before returning #f, check for bad trailing arguments */
            if (!is_character_via_method(sc, car(y)))
                return(wrong_type_argument(sc, caller, position_of(y, args), car(y), T_CHARACTER));
        return(sc->F);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
jne 0xc958c
movq 0x8(%r14), %r13
cmpb $0x8, (%r13)
je 0xc94ac
testb $0x40, 0x3(%r13)
je 0xc9562
cmpb $0x1, 0x24c(%rbx)
jne 0xc9562
movq %rbx, %rdi
movq %r13, %rsi
callq 0x88f3
movq 0x1020(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0xc9562
movq %rax, %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r15
cmpq 0x98(%rbx), %rax
ja 0xc952c
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r13, 0x8(%rdx)
movq %r15, 0x10(%rdx)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xa34c
cmpq 0x120(%rbx), %rax
jne 0xc94ac
movq 0x8(%r12), %r12
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x72a82
movslq %eax, %r15
cmpl $0x7ff, %r15d           # imm = 0x7FF
ja 0xc95a2
leaq 0x4c3ca(%rip), %rax     # 0x115950
movq (%rax,%r15,8), %rdx
jmp 0xc95db
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc95c1
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0xb, (%rdx)
movq %r15, 0x8(%rdx)
movq 0x8(%r14), %rcx
movq 0x140(%rbx), %r8
movq 0x504b3(%rip), %r9      # 0x119aa0
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9bbb
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_char_cmp
static s7_pointer g_char_cmp(s7_scheme *sc, s7_pointer args, int32_t val, s7_pointer sym)
    {
        s7_pointer x, y;

        y = car(args);
        if (!s7_is_character(y))
            return(method_or_bust(sc, y, sym, args, T_CHARACTER, 1));

        for (x = cdr(args); is_pair(x); x = cdr(x))
        {
            if (!s7_is_character(car(x)))
                return(method_or_bust(sc, car(x), sym, cons(sc, y, x), T_CHARACTER, position_of(x, args)));
            if (charcmp(character(y), character(car(x))) != val)
                return(char_with_error_check(sc, x, args, sym));
            y = car(x);
        }
        return(sc->T);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %r13
cmpb $0x8, (%r13)
jne 0xc967c
xorl %eax, %eax
movq %r15, %r12
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0xc9692
movq 0x8(%r12), %rbp
cmpb $0x8, (%rbp)
jne 0xc96a8
movb 0x8(%r13), %r8b
movb 0x8(%rbp), %sil
cmpb %sil, %r8b
movl $0x0, %edi
sbbl %edi, %edi
orl $0x1, %edi
cmpb %sil, %r8b
cmovel %eax, %edi
movq %rbp, %r13
cmpl %edx, %edi
je 0xc9627
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc9494
pushq $0x8
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %r13, %rsi
movq %rcx, %rdx
movq %r15, %rcx
jmp 0xc9708
movq 0x118(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, (%rsp)
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xc96cb
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200001, (%rbx)       # imm = 0x200001
movq %r13, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x72a82
pushq $0x8
popq %r8
movq %r14, %rdi
movq %rbp, %rsi
movq (%rsp), %rdx
movq %rbx, %rcx
movl %eax, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_string_cmp
static s7_pointer g_string_cmp(s7_scheme *sc, s7_pointer args, int32_t val, s7_pointer sym)
    {
        s7_pointer x, y;

        y = car(args);
        if (!is_string(y))
            return(method_or_bust(sc, y, sym, args, T_STRING, 1));

        for (x = cdr(args); is_not_null(x); x = cdr(x))
        {
            if (!is_string(car(x)))
                return(method_or_bust(sc, car(x), sym, cons(sc, y, x), T_STRING, position_of(x, args)));
            if (scheme_strcmp(y, car(x)) != val)
            {
                for (y = cdr(x); is_pair(y); y = cdr(y))
                    if (!is_string_via_method(sc, car(y)))
                        return(wrong_type_argument(sc, sym, position_of(y, args), car(y), T_STRING));
                return(sc->F);
            }
            y = car(x);
        }
        return(sc->T);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r13
cmpb $0x13, (%r13)
jne 0xc98b2
movl %edx, %r15d
movq %rcx, 0x10(%rsp)
movq 0x110(%rbx), %r12
movq %r14, 0x8(%rsp)
movq 0x10(%r14), %r14
cmpq %r12, %r14
je 0xc98c8
movq 0x8(%r14), %rbp
cmpb $0x13, (%rbp)
jne 0xc98de
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc99e3
movq %rbp, %r13
cmpl %r15d, %eax
je 0xc9863
jmp 0xc989f
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xc9a8b
testb %al, %al
je 0xc9950
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
je 0xc988b
movq 0x120(%rbx), %rax
jmp 0xc98cf
pushq $0x13
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r13, %rsi
movq %rcx, %rdx
movq %r14, %rcx
jmp 0xc993d
movq 0x118(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc98fd
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %r13, 0x8(%r15)
movq %r14, 0x10(%r15)
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x72a82
pushq $0x13
popq %r8
movq %rbx, %rdi
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rcx
movl %eax, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcd70
movq 0x10(%rsp), %rax
movq 0x8(%rax), %r15
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x72a82
movslq %eax, %r12
cmpl $0x7ff, %r12d           # imm = 0x7FF
ja 0xc997f
leaq 0x4bfd7(%rip), %rax     # 0x115950
movq (%rax,%r12,8), %rdx
jmp 0xc99b8
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc999e
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0xb, (%rdx)
movq %r12, 0x8(%rdx)
movq 0x8(%r14), %rcx
movq 0x140(%rbx), %r8
movq 0x5012e(%rip), %r9      # 0x119af8
movq %rbx, %rdi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9bbb
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: scheme_strcmp
static int32_t scheme_strcmp(s7_pointer s1, s7_pointer s2)
    {
        /* tricky here because str[i] must be treated as unsigned: (string<? (string (integer->char #xf0)) (string (integer->char #x70)))
         *   and null or lack thereof does not say anything about the string end
         */
        size_t i, len, len1, len2;
        char *str1, *str2;

        len1 = (size_t)string_length(s1);
        len2 = (size_t)string_length(s2);
        if (len1 > len2)
            len = len2;
        else len = len1;

        str1 = string_value(s1);
        str2 = string_value(s2);

        if (len < sizeof(size_t))
        {
            for (i = 0; i < len; i++)
            {
                if ((uint8_t)(str1[i]) < (uint8_t )(str2[i]))
                    return(-1);
                if ((uint8_t)(str1[i]) > (uint8_t)(str2[i]))
                    return(1);
            }
        }
        else
        {
            /* this algorithm from stackoverflow(?), with various changes (original did not work for large strings, etc) */
            size_t last, pos;
            size_t *ptr1, *ptr2;

            last = len / sizeof(size_t);
            for (ptr1 = (size_t *)str1, ptr2 = (size_t *)str2, i = 0; i < last; i++)
                if (ptr1[i] ^ ptr2[i])
                    break;

            for (pos = i * sizeof(size_t); pos < len; pos++)
            {
                if ((uint8_t)str1[pos] < (uint8_t)str2[pos])
                    return(-1);
                if ((uint8_t)str1[pos] > (uint8_t)str2[pos])
                    return(1);
            }
        }

        if (len1 < len2)
            return(-1);
        if (len1 > len2)
            return(1);
        return(0);
    }

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rsi
cmpq %rdx, %rcx
movq %rdx, %r8
cmovbq %rcx, %r8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x7, %r8
ja 0xc9a2e
xorl %r9d, %r9d
movl $0x1, %r10d
cmpq %r9, %r8
je 0xc9a78
movb (%rdi,%r9), %r11b
movb (%rsi,%r9), %bl
cmpb %bl, %r11b
jb 0xc9a89
incq %r9
cmpb %bl, %r11b
jbe 0xc9a12
jmp 0xc9a73
movq %r8, %r9
shrq $0x3, %r9
xorl %r10d, %r10d
cmpq %r10, %r9
je 0xc9a4f
movq (%rdi,%r10,8), %r11
cmpq (%rsi,%r10,8), %r11
jne 0xc9a4c
incq %r10
jmp 0xc9a38
movq %r10, %r9
shlq $0x3, %r9
movl $0x1, %r10d
cmpq %r8, %r9
jae 0xc9a78
movb (%rdi,%r9), %r11b
movb (%rsi,%r9), %bl
cmpb %bl, %r11b
jb 0xc9a89
incq %r9
cmpb %bl, %r11b
jbe 0xc9a59
movl %r10d, %eax
jmp 0xc9a89
xorl %esi, %esi
cmpq %rdx, %rcx
seta %sil
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %esi, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: is_string_via_method
static bool is_string_via_method(s7_scheme *sc, s7_pointer p)
    {
        if (s7_is_string(p))
            return(true);
        if (has_active_methods(sc, p))
        {
            s7_pointer f;
            f = find_method(sc, find_let(sc, p), sc->is_string_symbol);
            if (f != sc->undefined)
                return(is_true(sc, s7_apply_function(sc, f, cons(sc, p, sc->nil))));
        }
        return(false);
    }

// Assembly:
movb $0x1, %al
cmpb $0x13, (%rsi)
je 0xc9b4c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testb $0x40, 0x3(%rsi)
je 0xc9b3f
movq %rdi, %rbx
cmpb $0x1, 0x24c(%rdi)
jne 0xc9b3f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0x1190(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0xc9b3f
movq %rax, %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xc9b0a
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r14, 0x8(%rdx)
movq %r12, 0x10(%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa34c
cmpq 0x120(%rbx), %rax
setne %al
jmp 0xc9b41
xorl %eax, %eax
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: g_char_cmp_ci
static s7_pointer g_char_cmp_ci(s7_scheme *sc, s7_pointer args, int32_t val, s7_pointer sym)
    {
        s7_pointer x, y;

        y = car(args);
        if (!s7_is_character(y))
            return(method_or_bust(sc, y, sym, args, T_CHARACTER, 1));

        for (x = cdr(args); is_pair(x); x = cdr(x))
        {
            if (!s7_is_character(car(x)))
                return(method_or_bust(sc, car(x), sym, cons(sc, y, x), T_CHARACTER, position_of(x, args)));
            if (charcmp(upper_character(y), upper_character(car(x))) != val)
                return(char_with_error_check(sc, x, args, sym));
            y = car(x);
        }
        return(sc->T);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %r13
cmpb $0x8, (%r13)
jne 0xc9d76
xorl %eax, %eax
movq %r15, %r12
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0xc9d8c
movq 0x8(%r12), %rbp
cmpb $0x8, (%rbp)
jne 0xc9da2
movb 0x9(%r13), %r8b
movb 0x9(%rbp), %sil
cmpb %sil, %r8b
movl $0x0, %edi
sbbl %edi, %edi
orl $0x1, %edi
cmpb %sil, %r8b
cmovel %eax, %edi
movq %rbp, %r13
cmpl %edx, %edi
je 0xc9d21
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc9494
pushq $0x8
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %r13, %rsi
movq %rcx, %rdx
movq %r15, %rcx
jmp 0xc9e02
movq 0x118(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, (%rsp)
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xc9dc5
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200001, (%rbx)       # imm = 0x200001
movq %r13, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x72a82
pushq $0x8
popq %r8
movq %r14, %rdi
movq %rbp, %rsi
movq (%rsp), %rdx
movq %rbx, %rcx
movl %eax, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_string_ci_cmp
static s7_pointer g_string_ci_cmp(s7_scheme *sc, s7_pointer args, int32_t val, s7_pointer sym)
    {
        s7_pointer x, y;

        y = car(args);
        if (!is_string(y))
            return(method_or_bust(sc, y, sym, args, T_STRING, 1));

        for (x = cdr(args); is_not_null(x); x = cdr(x))
        {
            if (!is_string(car(x)))
                return(method_or_bust(sc, car(x), sym, cons(sc, y, x), T_STRING, position_of(x, args)));
            if (val == 0)
            {
                if (!scheme_strequal_ci(y, car(x)))
                    return(string_check_method(sc, sym, x, y, args));
            }
            else
            {
                if (scheme_strcasecmp(y, car(x)) != val)
                    return(string_check_method(sc, sym, x, y, args));
            }
            y = car(x);
        }
        return(sc->T);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %rbx
cmpb $0x13, (%rbx)
jne 0xc9fb7
movl %edx, %ebp
movq %rcx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x110(%rdi), %r15
movq %r14, %r12
movq 0x10(%r12), %r12
cmpq %r15, %r12
je 0xc9fca
movq 0x8(%r12), %r13
cmpb $0x13, (%r13)
jne 0xc9fe5
movq %rbx, %rdi
movq %r13, %rsi
testl %ebp, %ebp
je 0xc9f88
callq 0xca16a
movq %r13, %rbx
cmpl %ebp, %eax
je 0xc9f5a
jmp 0xc9f94
callq 0xca05b
movq %r13, %rbx
testb %al, %al
jne 0xc9f5a
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
movq %r14, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xca0a0
pushq $0x13
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rsi
movq %rcx, %rdx
movq %r14, %rcx
jmp 0xca048
movq 0x8(%rsp), %rax
movq 0x118(%rax), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r15
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0xca009
movq %r15, %rdi
callq 0x9c27
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rbp
movq $0x200001, (%rbp)       # imm = 0x200001
movq %rbx, 0x8(%rbp)
movq %r12, 0x10(%rbp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x72a82
pushq $0x13
popq %r8
movq %r15, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
movq %rbp, %rcx
movl %eax, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: scheme_strequal_ci
static bool scheme_strequal_ci(s7_pointer s1, s7_pointer s2)
    {
        /* same as scheme_strcmp -- watch out for unwanted sign! */
        s7_int i, len, len2;
        uint8_t *str1, *str2;

        len = string_length(s1);
        len2 = string_length(s2);
        if (len != len2)
            return(false);

        str1 = (uint8_t *)string_value(s1);
        str2 = (uint8_t *)string_value(s2);

        for (i = 0; i < len; i++)
            if (uppers[(int32_t)str1[i]] != uppers[(int32_t)str2[i]])
                return(false);
        return(true);
    }

// Assembly:
movq 0x8(%rdi), %rcx
cmpq 0x8(%rsi), %rcx
jne 0xca09d
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %rsi
xorl %edi, %edi
testq %rcx, %rcx
cmovleq %rdi, %rcx
leaq 0x57ba3(%rip), %r8      # 0x121c20
cmpq %rdi, %rcx
sete %al
je 0xca09c
movzbl (%rdx,%rdi), %r9d
movb (%r9,%r8), %r9b
movzbl (%rsi,%rdi), %r10d
incq %rdi
cmpb (%r10,%r8), %r9b
je 0xca07d
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: string_check_method
static s7_pointer string_check_method(s7_scheme *sc, s7_pointer sym, s7_pointer x, s7_pointer y, s7_pointer args)
    {
        for (y = cdr(x); is_pair(y); y = cdr(y))
            if (!is_string_via_method(sc, car(y)))
                return(wrong_type_argument(sc, sym, position_of(y, args), car(y), T_STRING));
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
jne 0xca0f6
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xc9a8b
testb %al, %al
jne 0xca0b4
movq 0x8(%r15), %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x72a82
movslq %eax, %r12
cmpl $0x7ff, %r12d           # imm = 0x7FF
ja 0xca109
leaq 0x4b860(%rip), %rax     # 0x115950
movq (%rax,%r12,8), %rdx
jmp 0xca142
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xca128
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0xb, (%rdx)
movq %r12, 0x8(%rdx)
movq 0x8(%r14), %rcx
movq 0x140(%rbx), %r8
movq 0x4f9a4(%rip), %r9      # 0x119af8
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9bbb
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: scheme_strcasecmp
static int32_t scheme_strcasecmp(s7_pointer s1, s7_pointer s2)
    {
        /* same as scheme_strcmp -- watch out for unwanted sign! and lack of trailing null (length sets string end).
        */
        s7_int i, len, len1, len2;
        uint8_t *str1, *str2;

        len1 = string_length(s1);
        len2 = string_length(s2);
        if (len1 > len2)
            len = len2;
        else len = len1;

        str1 = (uint8_t *)string_value(s1);
        str2 = (uint8_t *)string_value(s2);

        for (i = 0; i < len; i++)
        {
            if (uppers[(int32_t)str1[i]] < uppers[(int32_t)str2[i]])
                return(-1);
            if (uppers[(int32_t)str1[i]] > uppers[(int32_t)str2[i]])
                return(1);
        }

        if (len1 < len2)
            return(-1);
        if (len1 > len2)
            return(1);
        return(0);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
movq 0x8(%rsi), %rdx
cmpq %rdx, %rcx
movq %rdx, %r8
cmovlq %rcx, %r8
xorl %r9d, %r9d
testq %r8, %r8
cmovleq %r9, %r8
movq 0x10(%rsi), %rsi
leaq 0x57a87(%rip), %r10     # 0x121c20
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %r11d
cmpq %r9, %r8
je 0xca1cd
movzbl (%rdi,%r9), %ebx
movb (%rbx,%r10), %bl
movzbl (%rsi,%r9), %r14d
movb (%r14,%r10), %bpl
cmpb %bpl, %bl
jb 0xca1de
incq %r9
cmpb %bpl, %bl
jbe 0xca1a4
movl %r11d, %eax
jmp 0xca1de
xorl %esi, %esi
cmpq %rdx, %rcx
setg %sil
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovgel %esi, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_string_ci_cmp_not
static s7_pointer g_string_ci_cmp_not(s7_scheme *sc, s7_pointer args, int32_t val, s7_pointer sym)
    {
        s7_pointer x, y;

        y = car(args);
        if (!is_string(y))
            return(method_or_bust(sc, y, sym, args, T_STRING, 1));

        for (x = cdr(args); is_not_null(x); x = cdr(x))
        {
            if (!is_string(car(x)))
                return(method_or_bust(sc, car(x), sym, cons(sc, y, x), T_STRING, position_of(x, args)));
            if (scheme_strcasecmp(y, car(x)) == val)
                return(string_check_method(sc, sym, x, y, args));
            y = car(x);
        }
        return(sc->T);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %r13
cmpb $0x13, (%r13)
jne 0xca25f
movl %edx, %ebx
movq %rcx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x110(%rdi), %r15
movq %r14, %r12
movq 0x10(%r12), %r12
cmpq %r15, %r12
je 0xca272
movq 0x8(%r12), %rbp
cmpb $0x13, (%rbp)
jne 0xca28d
movq %r13, %rdi
movq %rbp, %rsi
callq 0xca16a
movq %rbp, %r13
cmpl %ebx, %eax
jne 0xca215
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
movq %r14, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xca0a0
pushq $0x13
popq %r8
pushq $0x1
popq %r9
movq %r13, %rsi
movq %rcx, %rdx
movq %r14, %rcx
jmp 0xca2ef
movq 0x8(%rsp), %rax
movq 0x118(%rax), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r15
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0xca2b1
movq %r15, %rdi
callq 0x9c27
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rbx
movq $0x200001, (%rbx)       # imm = 0x200001
movq %r13, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq %r12, %rdi
movq %r14, %rsi
callq 0x72a82
pushq $0x13
popq %r8
movq %r15, %rdi
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
movl %eax, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcd70