LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_angle
static s7_pointer g_angle(s7_scheme *sc, s7_pointer args)
    {
#define H_angle "(angle z) returns the angle of z"
#define Q_angle s7_make_signature(sc, 2, sc->is_real_symbol, sc->is_number_symbol)
        s7_pointer x;
        /* (angle inf+infi) -> 0.78539816339745 ?
         *   I think this should be -pi < ang <= pi
         */

        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:
                if (integer(x) < 0)
                    return(real_pi);
                return(small_int(0));

            case T_RATIO:
                if (numerator(x) < 0)
                    return(real_pi);
                return(small_int(0));

            case T_REAL:
                if (is_NaN(real(x))) return(x);
                if (real(x) < 0.0)
                    return(real_pi);
                return(real_zero);

            case T_COMPLEX:
                return(make_real(sc, atan2(imag_part(x), real_part(x))));

            default:
                return(method_or_bust_with_type_one_arg(sc, x, sc->angle_symbol, args, a_number_string));
        }
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movzbl (%rax), %edx
addl $-0xb, %edx
cmpl $0x3, %edx
ja 0x51859
leaq 0x821c4(%rip), %rcx     # 0xd3984
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
cmpq $0x0, 0x8(%rax)
js 0x517f9
movq 0xc4179(%rip), %rax     # 0x115950
jmp 0x51881
movsd 0x8(%rax), %xmm0
ucomisd %xmm0, %xmm0
jp 0x51881
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5187a
movq 0xcb6a8(%rip), %rax     # 0x11cea8
jmp 0x51881
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm0
callq 0x84e0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5183c
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%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 0x51881
movq %rsi, %rcx
movq 0xbb0(%rbx), %rdx
movq 0xd2b36(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
jmp 0xc736d
movq 0xc83d7(%rip), %rax     # 0x119c58
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_exp
static s7_pointer g_exp(s7_scheme *sc, s7_pointer args)
    {
#define H_exp "(exp z) returns e^z, (exp 1) is 2.718281828459"
#define Q_exp sc->pl_nn

        s7_pointer x;

        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:
                if (integer(x) == 0) return(small_int(1));                       /* (exp 0) -> 1 */
                return(make_real(sc, exp((s7_double)(integer(x)))));

            case T_RATIO:
                return(make_real(sc, exp((s7_double)fraction(x))));

            case T_REAL:
                return(make_real(sc, exp(real(x))));

            case T_COMPLEX:
#if HAVE_COMPLEX_NUMBERS
                return(s7_from_c_complex(sc, cexp(as_c_complex(x))));
                /* this is inaccurate for large arguments:
                 *   (exp 0+1e20i) -> -0.66491178990701-0.74692189125949i, not 7.639704044417283004001468027378811228331E-1-6.45251285265780844205811711312523007406E-1i
                 */
#else
                return(out_of_range(sc, sc->exp_symbol, small_int(1), x, no_complex_numbers_string));
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, x, sc->exp_symbol, args, a_number_string));
        }
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x51e42
leaq 0x81c0f(%rip), %rcx     # 0xd3994
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x51e5d
cvtsi2sd %rax, %xmm0
jmp 0x51df3
movsd 0x8(%rsi), %xmm0
jmp 0x51df3
movsd 0x10(%rsi), %xmm1
xorpd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd 0x8(%rsi), %xmm0
callq 0x80e0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xc152
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rax, 0x18(%rsp)
fildll 0x18(%rsp)
movq %rcx, 0x10(%rsp)
fildll 0x10(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x8720
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x51e21
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 $0x20, %rsp
popq %rbx
retq
movq 0xed0(%rbx), %rdx
movq 0xd2550(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xc736d
movq 0xc3af4(%rip), %rax     # 0x115958
jmp 0x51e3c
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_sin
static s7_pointer g_sin(s7_scheme *sc, s7_pointer args)
    {
#define H_sin "(sin z) returns sin(z)"
#define Q_sin sc->pl_nn

        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_REAL:
                return(make_real(sc, sin(real(x))));

            case T_INTEGER:
                if (integer(x) == 0) return(small_int(0));                      /* (sin 0) -> 0 */
                return(make_real(sc, sin((s7_double)integer(x))));

            case T_RATIO:
                return(make_real(sc, sin((s7_double)(fraction(x)))));

            case T_COMPLEX:
#if HAVE_COMPLEX_NUMBERS
                return(s7_from_c_complex(sc, csin(as_c_complex(x))));
#else
                return(out_of_range(sc, sc->sin_symbol, small_int(1), x, no_complex_numbers_string));
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, x, sc->sin_symbol, args, a_number_string));
        }

        /* sin is totally inaccurate over about 1e18.  There's a way to get true results,
         *   but it involves fancy "range reduction" techniques.
         *   This means that lots of things are inaccurate:
         * (sin (remainder 1e22 (* 2 pi))) -> -0.57876806033477
         * but it should be -8.522008497671888065747423101326159661908E-1
         * ---
         * (remainder 1e22 (* 2 pi)) -> 1.0057952155665e+22 !!
         *   it should be 5.263007914620499494429139986095833592117E0
         */
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x52435
leaq 0x8162c(%rip), %rcx     # 0xd39a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x52450
cvtsi2sd %rax, %xmm0
jmp 0x523e6
movsd 0x8(%rsi), %xmm0
jmp 0x523e6
movsd 0x10(%rsi), %xmm1
xorpd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd 0x8(%rsi), %xmm0
callq 0x8670
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xc152
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rax, 0x18(%rsp)
fildll 0x18(%rsp)
movq %rcx, 0x10(%rsp)
fildll 0x10(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x85e0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x52414
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 $0x20, %rsp
popq %rbx
retq
movq 0x14d8(%rbx), %rdx
movq 0xd1f5d(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xc736d
movq 0xc34f9(%rip), %rax     # 0x115950
jmp 0x5242f
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cos
static s7_pointer g_cos(s7_scheme *sc, s7_pointer args)
    {
#define H_cos "(cos z) returns cos(z)"
#define Q_cos sc->pl_nn

        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_REAL:
                return(make_real(sc, cos(real(x))));

            case T_INTEGER:
                if (integer(x) == 0) return(small_int(1));                     /* (cos 0) -> 1 */
                return(make_real(sc, cos((s7_double)integer(x))));

            case T_RATIO:
                return(make_real(sc, cos((s7_double)(fraction(x)))));

            case T_COMPLEX:
#if HAVE_COMPLEX_NUMBERS
                return(s7_from_c_complex(sc, ccos(as_c_complex(x))));
#else
                return(out_of_range(sc, sc->cos_symbol, small_int(1), x, no_complex_numbers_string));
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, x, sc->cos_symbol, args, a_number_string));
        }
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x5253b
leaq 0x81536(%rip), %rcx     # 0xd39b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x52556
cvtsi2sd %rax, %xmm0
jmp 0x524ec
movsd 0x8(%rsi), %xmm0
jmp 0x524ec
movsd 0x10(%rsi), %xmm1
xorpd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd 0x8(%rsi), %xmm0
callq 0x8580
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xc152
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rax, 0x18(%rsp)
fildll 0x18(%rsp)
movq %rcx, 0x10(%rsp)
fildll 0x10(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x82f0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5251a
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 $0x20, %rsp
popq %rbx
retq
movq 0xe28(%rbx), %rdx
movq 0xd1e57(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xc736d
movq 0xc33fb(%rip), %rax     # 0x115958
jmp 0x52535
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_tan
static s7_pointer g_tan(s7_scheme *sc, s7_pointer args)
    {
#define H_tan "(tan z) returns tan(z)"
#define Q_tan sc->pl_nn

        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_REAL:
                return(make_real(sc, tan(real(x))));

            case T_INTEGER:
                if (integer(x) == 0) return(small_int(0));                      /* (tan 0) -> 0 */
                return(make_real(sc, tan((s7_double)(integer(x)))));

            case T_RATIO:
                return(make_real(sc, tan((s7_double)(fraction(x)))));

            case T_COMPLEX:
#if HAVE_COMPLEX_NUMBERS
                if (imag_part(x) > 350.0)
                    return(c_complex(sc, 0.0, 1.0));
                if (imag_part(x) < -350.0)
                    return(c_complex(sc, 0.0, -1.0));
                return(s7_from_c_complex(sc, ctan(as_c_complex(x))));
#else
                return(out_of_range(sc, sc->tan_symbol, small_int(1), x, no_complex_numbers_string));
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, x, sc->tan_symbol, args, a_number_string));
        }
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x5263d
leaq 0x81440(%rip), %rcx     # 0xd39c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x5267f
cvtsi2sd %rax, %xmm0
jmp 0x525ee
movsd 0x8(%rsi), %xmm0
jmp 0x525ee
movsd 0x10(%rsi), %xmm1
ucomisd 0x7fae3(%rip), %xmm1    # 0xd2098
jbe 0x52658
movsd 0x7fa6d(%rip), %xmm1    # 0xd2030
jmp 0x5266e
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rax, 0x18(%rsp)
fildll 0x18(%rsp)
movq %rcx, 0x10(%rsp)
fildll 0x10(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x84a0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5261c
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 $0x20, %rsp
popq %rbx
retq
movq 0x15d8(%rbx), %rdx
movq 0xd1d55(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xc736d
movsd 0x7fa40(%rip), %xmm0    # 0xd20a0
ucomisd %xmm1, %xmm0
jbe 0x52688
movsd 0x7f9e2(%rip), %xmm1    # 0xd2050
xorpd %xmm0, %xmm0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xc75bc
movq 0xc32ca(%rip), %rax     # 0x115950
jmp 0x52637
xorpd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd 0x8(%rsi), %xmm0
callq 0x83b0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xc152
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_sinh
static s7_pointer g_sinh(s7_scheme *sc, s7_pointer args)
    {
#define H_sinh "(sinh z) returns sinh(z)"
#define Q_sinh sc->pl_nn

        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:
                if (integer(x) == 0) return(small_int(0));                    /* (sinh 0) -> 0 */

            case T_REAL:
            case T_RATIO:
                return(make_real(sc, sinh(s7_real(x))));

            case T_COMPLEX:
#if HAVE_COMPLEX_NUMBERS
                return(s7_from_c_complex(sc, csinh(as_c_complex(x))));
#else
                return(out_of_range(sc, sc->sinh_symbol, small_int(1), x, no_complex_numbers_string));
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, x, sc->sinh_symbol, args, a_number_string));
        }
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
leal -0xc(%rax), %edx
cmpl $0x2, %edx
jb 0x52df1
cmpl $0xe, %eax
je 0x52e4a
cmpl $0xb, %eax
jne 0x52e6e
cmpq $0x0, 0x8(%rsi)
je 0x52e89
movq %rsi, %rdi
callq 0xc42a
callq 0x8450
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x52e29
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%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 $0x10, %rsp
popq %rbx
retq
movsd 0x10(%rsi), %xmm1
xorpd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd 0x8(%rsi), %xmm0
callq 0x8340
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xc152
movq 0x14e0(%rbx), %rdx
movq 0xd1524(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xc736d
movq 0xc2ac0(%rip), %rax     # 0x115950
jmp 0x52e44
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cosh
static s7_pointer g_cosh(s7_scheme *sc, s7_pointer args)
    {
#define H_cosh "(cosh z) returns cosh(z)"
#define Q_cosh sc->pl_nn

        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:
                if (integer(x) == 0) return(small_int(1));                   /* (cosh 0) -> 1 */

            case T_REAL:
            case T_RATIO:
                return(make_real(sc, cosh(s7_real(x))));

            case T_COMPLEX:
#if HAVE_COMPLEX_NUMBERS
                return(s7_from_c_complex(sc, ccosh(as_c_complex(x))));
#else
                return(out_of_range(sc, sc->cosh_symbol, small_int(1), x, no_complex_numbers_string));
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, x, sc->cosh_symbol, args, a_number_string));
        }
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
leal -0xc(%rax), %edx
cmpl $0x2, %edx
jb 0x52ec5
cmpl $0xe, %eax
je 0x52f1e
cmpl $0xb, %eax
jne 0x52f42
cmpq $0x0, 0x8(%rsi)
je 0x52f5d
movq %rsi, %rdi
callq 0xc42a
callq 0x83f0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x52efd
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%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 $0x10, %rsp
popq %rbx
retq
movsd 0x10(%rsi), %xmm1
xorpd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd 0x8(%rsi), %xmm0
callq 0x81b0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xc152
movq 0xe30(%rbx), %rdx
movq 0xd1450(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xc736d
movq 0xc29f4(%rip), %rax     # 0x115958
jmp 0x52f18
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_tanh
static s7_pointer g_tanh(s7_scheme *sc, s7_pointer args)
    {
#define H_tanh "(tanh z) returns tanh(z)"
#define Q_tanh sc->pl_nn

        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:
                if (integer(x) == 0) return(small_int(0));  /* (tanh 0) -> 0 */

            case T_REAL:
            case T_RATIO:
                return(make_real(sc, tanh(s7_real(x))));

            case T_COMPLEX:
#if HAVE_COMPLEX_NUMBERS
                if (real_part(x) > 350.0)
                    return(real_one);                         /* closer than 0.0 which is what ctanh is about to return! */
                if (real_part(x) < -350.0)
                    return(make_real(sc, -1.0));              /* closer than ctanh's -0.0 */
                return(s7_from_c_complex(sc, ctanh(as_c_complex(x))));
#else
                return(out_of_range(sc, sc->tanh_symbol, small_int(1), x, no_complex_numbers_string));
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, x, sc->tanh_symbol, args, a_number_string));
        }
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
leal -0xc(%rax), %edx
cmpl $0x2, %edx
jb 0x52f95
cmpl $0xe, %eax
je 0x52fee
cmpl $0xb, %eax
jne 0x53006
cmpq $0x0, 0x8(%rsi)
je 0x53077
movq %rsi, %rdi
callq 0xc42a
callq 0x8610
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x52fcd
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%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 $0x10, %rsp
popq %rbx
retq
movsd 0x8(%rsi), %xmm0
ucomisd 0x7f09d(%rip), %xmm0    # 0xd2098
jbe 0x53021
movq 0xd1464(%rip), %rax     # 0x124468
jmp 0x52fe8
movq 0x15e0(%rbx), %rdx
movq 0xd138c(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xc736d
movsd 0x7f077(%rip), %xmm1    # 0xd20a0
ucomisd %xmm0, %xmm1
jbe 0x53083
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5304e
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x8(%rax)
jmp 0x52fe8
movq 0xc28d2(%rip), %rax     # 0x115950
jmp 0x52fe8
movsd 0x10(%rsi), %xmm1
xorpd %xmm2, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
callq 0x8140
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xc152
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_asinh
static s7_pointer g_asinh(s7_scheme *sc, s7_pointer args)
    {
#define H_asinh "(asinh z) returns asinh(z)"
#define Q_asinh sc->pl_nn
        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:
                if (integer(x) == 0) return(small_int(0));
                return(make_real(sc, asinh((s7_double)integer(x))));

            case T_RATIO:
                return(make_real(sc, asinh((s7_double)numerator(x) / (s7_double)denominator(x))));

            case T_REAL:
                return(make_real(sc, asinh(real(x))));

            case T_COMPLEX:
#if HAVE_COMPLEX_NUMBERS
#if (defined(__OpenBSD__)) || (defined(__NetBSD__))
                return(s7_from_c_complex(sc, casinh_1(as_c_complex(x))));
#else
                return(s7_from_c_complex(sc, casinh(as_c_complex(x))));
#endif
#else
                return(out_of_range(sc, sc->asinh_symbol, small_int(1), x, no_complex_numbers_string));
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, x, sc->asinh_symbol, list_1(sc, x), a_number_string));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movzbl (%r14), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x53182
leaq 0x80928(%rip), %rcx     # 0xd39f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x531ed
cvtsi2sd %rax, %xmm0
jmp 0x5312d
movsd 0x8(%r14), %xmm0
jmp 0x5312d
movsd 0x10(%r14), %xmm1
xorpd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd 0x8(%r14), %xmm0
callq 0x8260
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc152
cvtsi2sdq 0x8(%r14), %xmm0
cvtsi2sdq 0x10(%r14), %xmm1
divsd %xmm1, %xmm0
callq 0x8740
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5315b
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 $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xbe8(%rbx), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x531af
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0xd11cc(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc736d
movq 0xc275c(%rip), %rax     # 0x115950
jmp 0x53176
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_acosh
static s7_pointer g_acosh(s7_scheme *sc, s7_pointer args)
    {
#define H_acosh "(acosh z) returns acosh(z)"
#define Q_acosh sc->pl_nn
        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:
                if (integer(x) == 1) return(small_int(0));

            case T_REAL:
            case T_RATIO:
                {
                    double x1;
                    x1 = s7_real(x);
                    if (x1 >= 1.0)
                        return(make_real(sc, acosh(x1)));
                }

            case T_COMPLEX:
#if HAVE_COMPLEX_NUMBERS
#ifdef __OpenBSD__
                return(s7_from_c_complex(sc, cacosh_1(s7_to_c_complex(x))));
#else
                return(s7_from_c_complex(sc, cacosh(s7_to_c_complex(x)))); /* not as_c_complex because x might not be complex */
#endif
#else
                /* since we can fall through to this branch, we need a better error message than "must be a number, not 0.0" */
                return(out_of_range(sc, sc->acosh_symbol, small_int(1), x, no_complex_numbers_string));
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, x, sc->acosh_symbol, list_1(sc, x), a_number_string));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movzbl (%r14), %eax
leal -0xc(%rax), %ecx
cmpl $0x2, %ecx
jb 0x5322f
cmpl $0xe, %eax
je 0x53241
cmpl $0xb, %eax
jne 0x532b6
cmpq $0x1, 0x8(%r14)
jne 0x5322f
movq 0xc2723(%rip), %rax     # 0x115950
jmp 0x532aa
movq %r14, %rdi
callq 0xc42a
ucomisd 0x7edf1(%rip), %xmm0    # 0xd2030
jae 0x53261
movq %r14, %rdi
callq 0xc779f
callq 0x86f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc152
callq 0x8680
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5328f
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 $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xba0(%rbx), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x532e3
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0xd1098(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc736d
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_atanh
static s7_pointer g_atanh(s7_scheme *sc, s7_pointer args)
    {
#define H_atanh "(atanh z) returns atanh(z)"
#define Q_atanh sc->pl_nn
        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:
                if (integer(x) == 0) return(small_int(0));                    /* (atanh 0) -> 0 */

            case T_REAL:
            case T_RATIO:
                {
                    double x1;
                    x1 = s7_real(x);
                    if (fabs(x1) < 1.0)
                        return(make_real(sc, atanh(x1)));
                }

                /* if we can't distinguish x from 1.0 even with long doubles, we'll get inf.0:
                 *    (atanh 9223372036854775/9223372036854776) -> 18.714973875119
                 *    (atanh 92233720368547758/92233720368547757) -> inf.0
                 */
            case T_COMPLEX:
#if HAVE_COMPLEX_NUMBERS
#if (defined(__OpenBSD__)) || (defined(__NetBSD__))
                return(s7_from_c_complex(sc, catanh_1(s7_to_c_complex(x))));
#else
                return(s7_from_c_complex(sc, catanh(s7_to_c_complex(x))));
#endif
#else
                return(out_of_range(sc, sc->atanh_symbol, small_int(1), x, no_complex_numbers_string));
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, x, sc->atanh_symbol, list_1(sc, x), a_number_string));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movzbl (%r14), %eax
leal -0xc(%rax), %ecx
cmpl $0x2, %ecx
jb 0x53355
cmpl $0xe, %eax
je 0x53377
cmpl $0xb, %eax
jne 0x533e2
cmpq $0x0, 0x8(%r14)
je 0x5344d
movq %r14, %rdi
callq 0xc42a
movapd 0x82b5b(%rip), %xmm1    # 0xd5ec0
andpd %xmm0, %xmm1
movsd 0x7ecbf(%rip), %xmm2    # 0xd2030
ucomisd %xmm1, %xmm2
ja 0x53397
movq %r14, %rdi
callq 0xc779f
callq 0x84d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc152
callq 0x8080
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x533c5
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 0x53454
movq 0xc10(%rbx), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x5340f
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0xd0f6c(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc736d
movq 0xc24fc(%rip), %rax     # 0x115950
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_truncate
static s7_pointer g_truncate(s7_scheme *sc, s7_pointer args)
    {
#define H_truncate "(truncate x) returns the integer closest to x toward 0"
#define Q_truncate s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_real_symbol)

        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:
                return(x);

            case T_RATIO:
                return(make_integer(sc, (s7_int)(numerator(x) / denominator(x)))); /* C "/" already truncates */

            case T_REAL:
                {
                    s7_double z;
                    z = real(x);
                    if (is_NaN(z))
                        return(simple_out_of_range(sc, sc->truncate_symbol, x, its_nan_string));
                    if (is_inf(z))
                        return(simple_out_of_range(sc, sc->truncate_symbol, x, its_infinite_string));
                    return(s7_truncate(sc, sc->truncate_symbol, real(x)));
                }

            case T_COMPLEX:
            default:
                return(method_or_bust_one_arg(sc, x, sc->truncate_symbol, args, T_REAL));
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r9
movzbl (%r9), %ecx
cmpl $0xb, %ecx
je 0x5427f
movq %rdi, %rbx
cmpl $0xd, %ecx
je 0x541d2
cmpl $0xc, %ecx
jne 0x54223
movq 0x8(%r9), %rax
cqto
idivq 0x10(%r9)
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0x54246
leaq 0xc1787(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %r9
jmp 0x5427f
movsd 0x8(%r9), %xmm0
ucomisd %xmm0, %xmm0
jp 0x54299
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
movq 0x1620(%rbx), %rsi
cmpq %rcx, %rax
jne 0x5428a
movq 0x8(%rsi), %rsi
movq 0xd0437(%rip), %rcx     # 0x124648
movq %rbx, %rdi
movq %r9, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35b47
movq %rsi, %rax
movq 0x1620(%rbx), %rdx
pushq $0xd
popq %r8
movq %rbx, %rdi
movq %r9, %rsi
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x77745
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x54265
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r9
movq $0xb, (%r9)
movq %r14, 0x8(%r9)
movq %r9, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc7b1c
movq 0x1620(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xd0395(%rip), %rcx     # 0x124640
jmp 0x54211
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_divide
static s7_pointer g_divide(s7_scheme *sc, s7_pointer args)
    {
#define H_divide "(/ x1 ...) divides its first argument by the rest, or inverts the first if there is only one argument"
#define Q_divide sc->pcl_n

        s7_pointer x, y, p;

        x = car(args);
        p = cdr(args);

        if (is_null(p))            /* (/ x) */
        {
            if (!is_number(x))
                return(method_or_bust_with_type_one_arg(sc, x, sc->divide_symbol, args, a_number_string));
            if (s7_is_zero(x))     /* (/ 0) */
                return(division_by_zero_error(sc, sc->divide_symbol, args));
            return(s7_invert(sc, x));
        }
        if (is_null(cdr(p)))
            return(g_divide_xy(sc, x, cadr(args), args));

        y = g_multiply_1(sc, p, sc->divide_symbol); /* in some schemes (/ 1 0 +nan.0) is not equal to (/ 1 (* 0 +nan.0)), in s7 they're both +nan.0 */
#if WITH_GMP
        if (s7_is_bignum(y))
            return(big_divide(sc, set_plist_2(sc, x, y)));
#endif
        return(g_divide_xy(sc, x, y, args));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rsi
movq 0x110(%rdi), %rax
cmpq %rax, %rsi
je 0x56247
cmpq %rax, 0x10(%rsi)
je 0x56282
movq 0xe88(%rbx), %rdx
movq %rbx, %rdi
callq 0xc7db7
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
jmp 0x5628c
movzbl (%r14), %r12d
leaq 0xc371e(%rip), %rax     # 0x119970
cmpb $0x0, (%r12,%rax)
je 0x5629f
movq %r14, %rdi
callq 0xc77c4
testb %al, %al
je 0x562c6
movq 0xe88(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc1ff
movq 0x8(%rsi), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc877e
movq 0xe88(%rbx), %rdx
movq 0xce0f3(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc736d
addl $-0xb, %r12d
cmpl $0x3, %r12d
ja 0x5637c
leaq 0x7d7f9(%rip), %rax     # 0xd3ad4
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%r14), %rdx
pushq $0x1
popq %rsi
jmp 0x56369
movsd 0x7bd3b(%rip), %xmm0    # 0xd2030
divsd 0x8(%r14), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x56324
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 $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc9018
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc761f
movq 0xe88(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xbf5ca(%rip), %rdx     # 0x115958
movq 0x140(%rbx), %r8
movq 0xce004(%rip), %r9      # 0x1243a0
movq %rbx, %rdi
movq %r14, %rcx
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: g_logior
static s7_pointer g_logior(s7_scheme *sc, s7_pointer args)
    {
#define H_logior "(logior int32_t ...) returns the OR of its integer arguments (the bits that are on in any of the arguments)"
#define Q_logior sc->pcl_i
        s7_int result = 0;
        s7_pointer x;

        for (x = args; is_not_null(x); x = cdr(x))
        {
            if (!s7_is_integer(car(x)))
                return(method_or_bust(sc, car(x), sc->logior_symbol, (result == 0) ? x : cons(sc, make_integer(sc, result), x), T_INTEGER, position_of(x, args)));
            result |= s7_integer(car(x));
        }
        return(make_integer(sc, result));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x110(%rdi), %rax
xorl %r13d, %r13d
movq %rsi, %r15
cmpq %rax, %r15
je 0x594f2
movq 0x8(%r15), %r12
cmpb $0xb, (%r12)
jne 0x59508
orq 0x8(%r12), %r13
movq 0x10(%r15), %r15
jmp 0x594d7
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0x59538
leaq 0xbc44e(%rip), %rax     # 0x115950
movq (%rax,%r13,8), %rax
jmp 0x59571
movq 0x12a8(%rbx), %rax
movq %rax, (%rsp)
movq %r15, %rbp
testq %r13, %r13
je 0x595fa
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0x59580
leaq 0xbc421(%rip), %rax     # 0x115950
movq (%rax,%r13,8), %r13
jmp 0x595bc
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x59557
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 %r13, 0x8(%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 0x5959f
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 %r13, 0x8(%rax)
movq %rax, %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x595db
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rbp
movq $0x200001, (%rbp)       # imm = 0x200001
movq %r13, 0x8(%rbp)
movq %r15, 0x10(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x72a82
pushq $0xb
popq %r8
movq %rbx, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
movq %rbp, %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_logxor
static s7_pointer g_logxor(s7_scheme *sc, s7_pointer args)
    {
#define H_logxor "(logxor int32_t ...) returns the XOR of its integer arguments (the bits that are on in an odd number of the arguments)"
#define Q_logxor sc->pcl_i
        s7_int result = 0;
        s7_pointer x;

        for (x = args; is_not_null(x); x = cdr(x))
        {
            if (!s7_is_integer(car(x)))
                return(method_or_bust(sc, car(x), sc->logxor_symbol, (result == 0) ? x : cons(sc, make_integer(sc, result), x), T_INTEGER, position_of(x, args)));
            result ^= s7_integer(car(x));
        }
        return(make_integer(sc, result));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x110(%rdi), %rax
xorl %r13d, %r13d
movq %rsi, %r15
cmpq %rax, %r15
je 0x59665
movq 0x8(%r15), %r12
cmpb $0xb, (%r12)
jne 0x5967b
xorq 0x8(%r12), %r13
movq 0x10(%r15), %r15
jmp 0x5964a
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0x596ab
leaq 0xbc2db(%rip), %rax     # 0x115950
movq (%rax,%r13,8), %rax
jmp 0x596e4
movq 0x12b8(%rbx), %rax
movq %rax, (%rsp)
movq %r15, %rbp
testq %r13, %r13
je 0x5976d
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0x596f3
leaq 0xbc2ae(%rip), %rax     # 0x115950
movq (%rax,%r13,8), %r13
jmp 0x5972f
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x596ca
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 %r13, 0x8(%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 0x59712
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 %r13, 0x8(%rax)
movq %rax, %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5974e
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rbp
movq $0x200001, (%rbp)       # imm = 0x200001
movq %r13, 0x8(%rbp)
movq %r15, 0x10(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x72a82
pushq $0xb
popq %r8
movq %rbx, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
movq %rbp, %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_logand
static s7_pointer g_logand(s7_scheme *sc, s7_pointer args)
    {
#define H_logand "(logand int32_t ...) returns the AND of its integer arguments (the bits that are on in every argument)"
#define Q_logand sc->pcl_i
        s7_int result = -1;
        s7_pointer x;

        for (x = args; is_not_null(x); x = cdr(x))
        {
            if (!s7_is_integer(car(x)))
                return(method_or_bust(sc, car(x), sc->logand_symbol, (result == -1) ? x : cons(sc, make_integer(sc, result), x), T_INTEGER, position_of(x, args)));
            result &= s7_integer(car(x));
        }
        return(make_integer(sc, result));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x110(%rdi), %rax
pushq $-0x1
popq %r13
movq %rsi, %r15
cmpq %rax, %r15
je 0x597d9
movq 0x8(%r15), %r12
cmpb $0xb, (%r12)
jne 0x597ef
andq 0x8(%r12), %r13
movq 0x10(%r15), %r15
jmp 0x597be
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0x59820
leaq 0xbc167(%rip), %rax     # 0x115950
movq (%rax,%r13,8), %rax
jmp 0x59859
movq 0x1298(%rbx), %rax
movq %rax, (%rsp)
movq %r15, %rbp
cmpq $-0x1, %r13
je 0x598e2
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0x59868
leaq 0xbc139(%rip), %rax     # 0x115950
movq (%rax,%r13,8), %r13
jmp 0x598a4
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5983f
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 %r13, 0x8(%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 0x59887
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 %r13, 0x8(%rax)
movq %rax, %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x598c3
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rbp
movq $0x200001, (%rbp)       # imm = 0x200001
movq %r13, 0x8(%rbp)
movq %r15, 0x10(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x72a82
pushq $0xb
popq %r8
movq %rbx, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
movq %rbp, %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_lognot
static s7_pointer g_lognot(s7_scheme *sc, s7_pointer args)
    {
#define H_lognot "(lognot num) returns the negation of num (its complement, the bits that are not on): (lognot 0) -> -1"
#define Q_lognot sc->pcl_i
        if (!s7_is_integer(car(args)))
            return(method_or_bust_one_arg(sc, car(args), sc->lognot_symbol, args, T_INTEGER));
        return(make_integer(sc, ~s7_integer(car(args))));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0xb, (%rsi)
jne 0x59944
movq 0x8(%rsi), %r14
cmpq $-0x800, %r14           # imm = 0xF800
notq %r14
jb 0x5995e
leaq 0xbc012(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x59997
movq 0x12b0(%rbx), %rdx
pushq $0xb
popq %r8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x77745
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5997d
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: g_ash
static s7_pointer g_ash(s7_scheme *sc, s7_pointer args)
    {
#define H_ash "(ash i1 i2) returns i1 shifted right or left i2 times, i1 << i2, (ash 1 3) -> 8, (ash 8 -3) -> 1"
#define Q_ash sc->pcl_i
        s7_pointer x, y;

        x = car(args);
        if (!s7_is_integer(x))
            return(method_or_bust(sc, x, sc->ash_symbol, args, T_INTEGER, 1));

        y = cadr(args);
        if (!s7_is_integer(y))
            return(method_or_bust(sc, y, sc->ash_symbol, args, T_INTEGER, 2));

        return(make_integer(sc, c_ash(sc, s7_integer(x), s7_integer(y))));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0xb, (%rsi)
jne 0x599e7
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x599fb
movq 0x8(%rsi), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0xc9307
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0x59a1c
leaq 0xbbf6f(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x59a55
movq 0xbd8(%rbx), %rdx
pushq $0xb
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
jmp 0x59a10
movq 0xbd8(%rbx), %rdx
pushq $0xb
popq %r8
pushq $0x2
popq %r9
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcd70
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x59a3b
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: g_exact_to_inexact
static s7_pointer g_exact_to_inexact(s7_scheme *sc, s7_pointer args)
    {
#define H_exact_to_inexact "(exact->inexact num) converts num to an inexact number; (exact->inexact 3/2) = 1.5"
#define Q_exact_to_inexact s7_make_signature(sc, 2, sc->is_number_symbol, sc->is_number_symbol)
        /* arg can be complex -> itself! */
        return(exact_to_inexact(sc, car(args)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rsi), %r14
movzbl (%r14), %eax
leal -0xd(%rax), %ecx
cmpl $0x2, %ecx
jb 0x59fce
movq %rdi, %rbx
cmpl $0xc, %eax
je 0x59f61
cmpl $0xb, %eax
jne 0x59fdd
cvtsi2sdq 0x8(%r14), %xmm0
jmp 0x59f87
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movq %rax, 0x20(%rsp)
fildll 0x20(%rsp)
movq %rcx, 0x18(%rsp)
fildll 0x18(%rsp)
fdivrp %st, %st(1)
fstpl 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x59fb2
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0xd, (%r14)
movsd %xmm0, 0x8(%r14)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xec0(%rbx), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x5a00a
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0xca371(%rip), %r8      # 0x1243a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc736d
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_integer_length
static s7_pointer g_integer_length(s7_scheme *sc, s7_pointer args)
    {
#define H_integer_length "(integer-length arg) returns the number of bits required to represent the integer 'arg': (ceiling (log (abs arg) 2))"
#define Q_integer_length sc->pcl_i

        s7_int x;
        s7_pointer p;

        p = car(args);
        if (!s7_is_integer(p))
            return(method_or_bust_one_arg(sc, p, sc->integer_length_symbol, args, T_INTEGER));

        x = s7_integer(p);
        if (x < 0)
            return(make_integer(sc, integer_length(-(x + 1))));
        return(make_integer(sc, integer_length(x)));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0xb, (%rsi)
jne 0x5a085
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
jns 0x5a067
notq %rdi
callq 0xc93bb
movslq %eax, %r14
cmpl $0x7ff, %r14d           # imm = 0x7FF
ja 0x5a09f
leaq 0xbb8d1(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x5a0d8
movq 0x1718(%rbx), %rdx
pushq $0xb
popq %r8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x77745
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5a0be
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: g_logbit
static s7_pointer g_logbit(s7_scheme *sc, s7_pointer args)
    {
#define H_logbit "(logbit? int index) returns #t if the index-th bit is on in int, otherwise #f. The argument \
        order here follows gmp, and is the opposite of the CL convention.  (logbit? int bit) is the same as (not (zero? (logand int (ash 1 bit))))."
#define Q_logbit s7_make_circular_signature(sc, 1, 2, sc->is_boolean_symbol, sc->is_integer_symbol)

        s7_pointer x, y;
        s7_int index;      /* index in gmp is mp_bitcnt which is an unsigned long int */

        x = car(args);
        y = cadr(args);

        if (!s7_is_integer(x))
            return(method_or_bust(sc, x, sc->logbit_symbol, args, T_INTEGER, 1));
        if (!s7_is_integer(y))
            return(method_or_bust(sc, y, sc->logbit_symbol, args, T_INTEGER, 2));

        index = s7_integer(y);
        if (index < 0)
            return(out_of_range(sc, sc->logbit_symbol, small_int(2), y, its_negative_string));

#if WITH_GMP
        if (is_t_big_integer(x))
            return(make_boolean(sc, (mpz_tstbit(big_integer(x), index) != 0)));
#endif

        if (index >= s7_int_bits)           /* not sure about the >: (logbit? -1 64) ?? */
            return(make_boolean(sc, integer(x) < 0));

        /* (zero? (logand most-positive-fixnum (ash 1 63))) -> ash argument 2, 63, is out of range (shift is too large)
         *   so logbit? has a wider range than the logand/ash shuffle above.
         */

        /* all these int64_ts are necessary, else C turns it into an int, gets confused about signs etc */
        return(make_boolean(sc, ((((int64_t)(1LL << (int64_t)index)) & (int64_t)integer(x)) != 0)));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0xb, (%rsi)
jne 0x5a556
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x5a56a
movq 0x8(%rax), %rcx
testq %rcx, %rcx
js 0x5a581
cmpq $0x3e, %rcx
ja 0x5a5a2
testb $0x1, 0xbf722(%rip)     # 0x119c60
je 0x5a5a2
movq 0x8(%rsi), %rax
xorl %edx, %edx
btq %rcx, %rax
setae %dl
movq 0x118(%rdi,%rdx,8), %rax
retq
movq 0x12a0(%rdi), %rdx
pushq $0xb
popq %r8
pushq $0x1
popq %r9
jmp 0xcd70
movq 0x12a0(%rdi), %rdx
pushq $0xb
popq %r8
pushq $0x2
popq %r9
movq %rax, %rsi
jmp 0xcd70
movq 0x12a0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0xbb3cd(%rip), %rdx     # 0x115960
movq 0xbf4ae(%rip), %r8      # 0x119a48
movq %rax, %rcx
jmp 0xcb8f
xorl %eax, %eax
cmpq $0x0, 0x8(%rsi)
setns %al
movq 0x118(%rdi,%rax,8), %rax
retq