LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x6bd47
leaq 0xa4c7a(%rip), %rcx     # 0x110904
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x6bd62
cvtsi2sd %rax, %xmm0
jmp 0x6bcf8
movsd 0x8(%rsi), %xmm0
jmp 0x6bcf8
movsd 0x10(%rsi), %xmm1
xorpd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd 0x8(%rsi), %xmm0
callq 0x9670
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xe101
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 0x95e0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6bd1f
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xb389
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 0xf164b(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x103001
movq 0xe2be7(%rip), %rax     # 0x14e950
jmp 0x6bd41
// File: /workspace/github_c_makefile_star2_O1/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 0x6be4d
leaq 0xa4b84(%rip), %rcx     # 0x110914
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x6be68
cvtsi2sd %rax, %xmm0
jmp 0x6bdfe
movsd 0x8(%rsi), %xmm0
jmp 0x6bdfe
movsd 0x10(%rsi), %xmm1
xorpd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd 0x8(%rsi), %xmm0
callq 0x9580
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xe101
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 0x92f0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6be25
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xb389
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 0xf1545(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x103001
movq 0xe2ae9(%rip), %rax     # 0x14e958
jmp 0x6be47
// File: /workspace/github_c_makefile_star2_O1/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 0x6bf87
leaq 0xa4a8e(%rip), %rcx     # 0x110924
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x6bff8
cvtsi2sd %rax, %xmm0
jmp 0x6bf3c
movsd 0x8(%rsi), %xmm0
jmp 0x6bf3c
movsd 0x10(%rsi), %xmm1
ucomisd 0xa31d6(%rip), %xmm1    # 0x10f0a0
jbe 0x6bfa2
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6bee8
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xe, (%rax)
xorpd %xmm0, %xmm0
movhpd 0xa311f(%rip), %xmm0    # xmm0 = xmm0[0],mem[0]
jmp 0x6bff1
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 0x94a0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6bf63
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xb389
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 0x6bfff
movq 0x15d8(%rbx), %rdx
movq 0xf140b(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x103001
movsd 0xa30fe(%rip), %xmm0    # 0x10f0a8
ucomisd %xmm1, %xmm0
jbe 0x6c005
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6bfc8
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xe, (%rax)
xorpd %xmm0, %xmm0
movhpd 0xa305f(%rip), %xmm0    # xmm0 = xmm0[0],mem[0]
movupd %xmm0, 0x8(%rax)
jmp 0x6bfff
movq 0xe2951(%rip), %rax     # 0x14e950
addq $0x20, %rsp
popq %rbx
retq
xorpd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd 0x8(%rsi), %xmm0
callq 0x93b0
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0xe101
// File: /workspace/github_c_makefile_star2_O1/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 -0xb(%rax), %edx
cmpl $0x3, %edx
ja 0x6c8ba
leaq 0xa4151(%rip), %rcx     # 0x110964
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
cmpq $0x0, 0x8(%rsi)
je 0x6c8d5
cmpb $0xd, %al
jne 0x6c832
movsd 0x8(%rsi), %xmm0
jmp 0x6c845
movq 0xe61f7(%rip), %rdi     # 0x152a30
leaq 0xa6728(%rip), %rdx     # 0x112f68
callq 0xe212
callq 0x9450
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6c86e
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
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 0x9340
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xe101
movq 0x14e0(%rbx), %rdx
movq 0xf0ad8(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x103001
movq 0xe2074(%rip), %rax     # 0x14e950
jmp 0x6c890
// File: /workspace/github_c_makefile_star2_O1/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 -0xb(%rax), %edx
cmpl $0x3, %edx
ja 0x6c9aa
leaq 0xa4071(%rip), %rcx     # 0x110974
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
cmpq $0x0, 0x8(%rsi)
je 0x6c9c5
cmpb $0xd, %al
jne 0x6c922
movsd 0x8(%rsi), %xmm0
jmp 0x6c935
movq 0xe6107(%rip), %rdi     # 0x152a30
leaq 0xa6638(%rip), %rdx     # 0x112f68
callq 0xe212
callq 0x93f0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6c95e
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
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 0x91b0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xe101
movq 0xe30(%rbx), %rdx
movq 0xf09e8(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x103001
movq 0xe1f8c(%rip), %rax     # 0x14e958
jmp 0x6c980
// File: /workspace/github_c_makefile_star2_O1/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 -0xb(%rax), %edx
cmpl $0x3, %edx
ja 0x6ca8e
leaq 0xa3f91(%rip), %rcx     # 0x110984
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
cmpq $0x0, 0x8(%rsi)
je 0x6caff
cmpb $0xd, %al
jne 0x6ca12
movsd 0x8(%rsi), %xmm0
jmp 0x6ca25
movq 0xe6017(%rip), %rdi     # 0x152a30
leaq 0xa6548(%rip), %rdx     # 0x112f68
callq 0xe212
callq 0x9610
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6ca4e
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
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 0xa261d(%rip), %xmm0    # 0x10f0a0
jbe 0x6caa9
movq 0xf09dc(%rip), %rax     # 0x15d468
jmp 0x6ca70
movq 0x15e0(%rbx), %rdx
movq 0xf0904(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x103001
movsd 0xa25f7(%rip), %xmm1    # 0x10f0a8
ucomisd %xmm0, %xmm1
jbe 0x6cb0b
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6cacf
movq %rbx, %rdi
callq 0xb389
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 0x6ca70
movq 0xe1e4a(%rip), %rax     # 0x14e950
jmp 0x6ca70
movsd 0x10(%rsi), %xmm1
xorpd %xmm2, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
callq 0x9140
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0xe101
// File: /workspace/github_c_makefile_star2_O1/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 0x6cc0a
leaq 0xa3e40(%rip), %rcx     # 0x110994
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x6cc75
cvtsi2sd %rax, %xmm0
jmp 0x6cbb5
movsd 0x8(%r14), %xmm0
jmp 0x6cbb5
movsd 0x10(%r14), %xmm1
xorpd %xmm0, %xmm0
mulsd %xmm1, %xmm0
addsd 0x8(%r14), %xmm0
callq 0x9260
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe101
cvtsi2sdq 0x8(%r14), %xmm0
cvtsi2sdq 0x10(%r14), %xmm1
divsd %xmm1, %xmm0
callq 0x9740
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6cbdc
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xb389
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 0x6cc30
movq %rbx, %rdi
callq 0xb389
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 0xf0744(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x103001
movq 0xe1cd4(%rip), %rax     # 0x14e950
jmp 0x6cbfe
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movzbl (%r14), %eax
leal -0xb(%rax), %ecx
cmpl $0x3, %ecx
ja 0x6ccbf
leaq 0xa3d01(%rip), %rdx     # 0x1109a4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpq $0x1, 0x8(%r14)
jne 0x6cd2a
movq 0xe1c96(%rip), %rax     # 0x14e950
jmp 0x6cdf3
movq 0xba0(%rbx), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x6cce5
movq %rbx, %rdi
callq 0xb389
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 0xf068f(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x103001
cmpb $0xd, %al
jne 0x6cd36
movsd 0x8(%r14), %xmm0
jmp 0x6cd4c
movq 0xe5cf3(%rip), %rdi     # 0x152a30
leaq 0xa6224(%rip), %rdx     # 0x112f68
movq %r14, %rsi
callq 0xe212
ucomisd 0xa22dc(%rip), %xmm0    # 0x10f030
jb 0x6cdad
movsd %xmm0, 0x10(%rsp)
callq 0x9680
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6cd85
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
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)
movsd 0x10(%rsp), %xmm0
ucomisd 0xa227b(%rip), %xmm0    # 0x10f030
jae 0x6cdf3
movq %r14, %rdi
callq 0xefb9
xorpd %xmm2, %xmm2
cmpb $0xe, (%r14)
xorpd %xmm1, %xmm1
jne 0x6cdd3
movsd 0x10(%r14), %xmm1
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
callq 0x96f0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe101
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq 0x8(%rsi), %r14
movzbl (%r14), %eax
cmpl $0xb, %eax
je 0x6e287
movq %rdi, %rbx
cmpl $0xd, %eax
je 0x6e1b5
cmpl $0xc, %eax
jne 0x6e22e
movq 0x8(%r14), %rax
cqto
idivq 0x10(%r14)
movq %rax, %r15
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0x6e24e
leaq 0xe07a4(%rip), %rax     # 0x14e950
movq (%rax,%r15,8), %r14
jmp 0x6e287
movsd 0x8(%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0x6e29d
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
movq 0x1620(%rbx), %rsi
cmpq %rcx, %rax
jne 0x6e290
movq 0x8(%rsi), %rax
movq 0xef454(%rip), %rcx     # 0x15d648
movq 0x1ef8(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %r14, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x1948(%rbx), %r14
movq 0x1ef8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b366
jmp 0x6e287
movq %rsi, %rcx
movq 0x1620(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0xd, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x9b739
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6e266
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0xb, (%r14)
movq %r15, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x103785
movq 0x1620(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xef391(%rip), %rcx     # 0x15d640
jmp 0x6e1f4
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %rbx
movq 0x110(%rdi), %rax
cmpq %rsi, %rax
je 0x740ea
movq %rsi, %r14
xorl %ebp, %ebp
movq %rsi, %r13
movq 0x8(%r13), %r15
cmpb $0xb, (%r15)
jne 0x7414a
orq 0x8(%r15), %rbp
movq 0x10(%r13), %r13
cmpq %rax, %r13
jne 0x740d1
jmp 0x740ec
xorl %ebp, %ebp
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0x74102
leaq 0xda854(%rip), %rax     # 0x14e950
movq (%rax,%rbp,8), %rax
jmp 0x7413b
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7411a
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %rbp, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x12a8(%rbx), %rdx
movq %r13, %rcx
testq %rbp, %rbp
je 0x741f7
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0x74173
leaq 0xda7e3(%rip), %rax     # 0x14e950
movq (%rax,%rbp,8), %r12
jmp 0x741b4
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x74191
movq %rbx, %rdi
movq %rdx, %r12
callq 0xb389
movq %r12, %rdx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0xb, (%r12)
movq %rbp, 0x8(%r12)
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x741d2
movq %rbx, %rdi
movq %rdx, %rbp
callq 0xb389
movq %rbp, %rdx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r12, 0x8(%rcx)
movq %r13, 0x10(%rcx)
movl $0x1, %r9d
cmpq %r14, %r13
je 0x7420e
incl %r9d
movq 0x10(%r14), %r14
cmpq %r13, %r14
jne 0x74202
movq %rbx, %rdi
movq %r15, %rsi
movl $0xb, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %rbx
movq 0x110(%rdi), %rax
cmpq %rsi, %rax
je 0x74268
movq %rsi, %r14
xorl %ebp, %ebp
movq %rsi, %r13
movq 0x8(%r13), %r15
cmpb $0xb, (%r15)
jne 0x742c8
xorq 0x8(%r15), %rbp
movq 0x10(%r13), %r13
cmpq %rax, %r13
jne 0x7424f
jmp 0x7426a
xorl %ebp, %ebp
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0x74280
leaq 0xda6d6(%rip), %rax     # 0x14e950
movq (%rax,%rbp,8), %rax
jmp 0x742b9
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x74298
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %rbp, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x12b8(%rbx), %rdx
movq %r13, %rcx
testq %rbp, %rbp
je 0x74375
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0x742f1
leaq 0xda665(%rip), %rax     # 0x14e950
movq (%rax,%rbp,8), %r12
jmp 0x74332
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7430f
movq %rbx, %rdi
movq %rdx, %r12
callq 0xb389
movq %r12, %rdx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0xb, (%r12)
movq %rbp, 0x8(%r12)
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x74350
movq %rbx, %rdi
movq %rdx, %rbp
callq 0xb389
movq %rbp, %rdx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r12, 0x8(%rcx)
movq %r13, 0x10(%rcx)
movl $0x1, %r9d
cmpq %r14, %r13
je 0x7438c
incl %r9d
movq 0x10(%r14), %r14
cmpq %r13, %r14
jne 0x74380
movq %rbx, %rdi
movq %r15, %rsi
movl $0xb, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %rbx
movq 0x110(%rdi), %rax
cmpq %rsi, %rax
je 0x743eb
movq %rsi, %r14
movq $-0x1, %rbp
movq %rsi, %r13
movq 0x8(%r13), %r15
cmpb $0xb, (%r15)
jne 0x74450
andq 0x8(%r15), %rbp
movq 0x10(%r13), %r13
cmpq %rax, %r13
jne 0x743d2
jmp 0x743f2
movq $-0x1, %rbp
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0x74408
leaq 0xda54e(%rip), %rax     # 0x14e950
movq (%rax,%rbp,8), %rax
jmp 0x74441
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x74420
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %rbp, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1298(%rbx), %rdx
movq %r13, %rcx
cmpq $-0x1, %rbp
je 0x744fe
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0x7447a
leaq 0xda4dc(%rip), %rax     # 0x14e950
movq (%rax,%rbp,8), %r12
jmp 0x744bb
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x74498
movq %rbx, %rdi
movq %rdx, %r12
callq 0xb389
movq %r12, %rdx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0xb, (%r12)
movq %rbp, 0x8(%r12)
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x744d9
movq %rbx, %rdi
movq %rdx, %rbp
callq 0xb389
movq %rbp, %rdx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r12, 0x8(%rcx)
movq %r13, 0x10(%rcx)
movl $0x1, %r9d
cmpq %r14, %r13
je 0x74515
incl %r9d
movq 0x10(%r14), %r14
cmpq %r13, %r14
jne 0x74509
movq %rbx, %rdi
movq %r15, %rsi
movl $0xb, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 0x74564
movq 0x8(%rsi), %r14
cmpq $-0x800, %r14           # imm = 0xF800
notq %r14
jb 0x74580
leaq 0xda3f2(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x745b9
movq 0x12b0(%rbx), %rdx
movq %rbx, %rdi
movl $0xb, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b739
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x74598
movq %rbx, %rdi
callq 0xb389
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_O1/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 0x74609
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x74621
movq 0x8(%rsi), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x105477
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0x74646
leaq 0xda34d(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x7467f
movq 0xbd8(%rbx), %rdx
movq %rbx, %rdi
movl $0xb, %r8d
movl $0x1, %r9d
jmp 0x7463a
movq 0xbd8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf1ae
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7465e
movq %rbx, %rdi
callq 0xb389
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_O1/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 0x74cdd
movq %rdi, %rbx
cmpl $0xc, %eax
je 0x74c70
cmpl $0xb, %eax
jne 0x74cec
cvtsi2sdq 0x8(%r14), %xmm0
jmp 0x74c96
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 0x74cba
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
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 0x74d12
movq %rbx, %rdi
callq 0xb389
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 0xe8662(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x103001
// File: /workspace/github_c_makefile_star2_O1/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 0x74d94
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
jns 0x74d76
notq %rdi
callq 0x10556e
movslq %eax, %r14
cmpl $0x7ff, %r14d           # imm = 0x7FF
ja 0x74db0
leaq 0xd9bc2(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x74de9
movq 0x1718(%rbx), %rdx
movq %rbx, %rdi
movl $0xb, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b739
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x74dc8
movq %rbx, %rdi
callq 0xb389
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_O1/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 0x75283
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x7529b
pushq %rbx
movq 0x8(%rax), %rcx
testq %rcx, %rcx
js 0x752b6
xorl %eax, %eax
cmpb $0x0, 0xdda09(%rip)     # 0x152c60
movl $0x3f, %edx
cmoveq %rax, %rdx
cmpq %rdx, %rcx
jge 0x7530e
movq 0x8(%rsi), %rax
xorl %edx, %edx
btq %rcx, %rax
setae %dl
movq 0x118(%rdi,%rdx,8), %rbx
jmp 0x75320
movq 0x12a0(%rdi), %rdx
movl $0xb, %r8d
movl $0x1, %r9d
jmp 0xf1ae
movq 0x12a0(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
jmp 0xf1ae
movq 0x12a0(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0xd9698(%rip), %rdx     # 0x14e960
movq 0xdd779(%rip), %rsi     # 0x152a48
movq 0x1ee8(%rdi), %r8
movq 0x10(%r8), %r8
movq %rcx, 0x8(%r8)
movq 0x10(%r8), %rcx
movq %rdx, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rsi, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ee8(%rdi), %rdx
movq %rbx, %rsi
callq 0x3b366
jmp 0x75320
xorl %eax, %eax
cmpq $0x0, 0x8(%rsi)
setns %al
movq 0x118(%rdi,%rax,8), %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_string_to_number
static s7_pointer g_string_to_number(s7_scheme *sc, s7_pointer args)
    {
#define H_string_to_number "(string->number str (radix 10)) converts str into a number. \
        If str does not represent a number, string->number returns #f.  If 'str' has an embedded radix, \
        the optional 'radix' argument is ignored: (string->number \"#x11\" 2) -> 17 not 3."
#define Q_string_to_number s7_make_signature(sc, 3, s7_make_signature(sc, 2, sc->is_number_symbol, sc->not_symbol), sc->is_string_symbol, sc->is_integer_symbol)

        return(g_string_to_number_1(sc, args, sc->string_to_number_symbol));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1560(%rdi), %rdx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x759f1
movq 0x10(%r14), %rax
movl $0xa, %r15d
cmpb $0x1, (%rax)
jne 0x75a37
movq 0x8(%rax), %rsi
cmpb $0xb, (%rsi)
jne 0x75a13
movq 0x8(%rsi), %r15
leaq -0x11(%r15), %rax
cmpq $-0x10, %rax
ja 0x75a31
movq 0x8(%rdx), %rax
movq 0xd8fba(%rip), %rcx     # 0x14e960
movq 0xe7c83(%rip), %rdx     # 0x15d630
movq 0x1ee8(%rbx), %rdi
movq 0x10(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x10(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rbx), %r12
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3b366
xorl %eax, %eax
jmp 0x75a33
movq %rbx, %rdi
movq %r14, %rcx
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf1ae
movq %rbx, %rdi
movq %r14, %rcx
movl $0xb, %r8d
movl $0x2, %r9d
callq 0xf1ae
movq %rax, %r12
xorl %eax, %eax
jmp 0x75a33
movb $0x1, %al
testb %al, %al
je 0x75a70
movq 0x8(%r14), %rax
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x75a69
cmpb $0x0, (%rsi)
je 0x75a69
movq %rbx, %rdi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x97c6d
movq %rax, %r12
movzbl (%rax), %eax
leaq 0xdcf0d(%rip), %rcx     # 0x152970
cmpb $0x0, (%rax,%rcx)
jne 0x75a70
movq 0x120(%rbx), %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_char_upcase
static s7_pointer g_char_upcase(s7_scheme *sc, s7_pointer args)
    {
#define H_char_upcase "(char-upcase c) converts the character c to upper case"
#define Q_char_upcase sc->pcl_c
        if (!s7_is_character(car(args)))
            return(method_or_bust_one_arg(sc, car(args), sc->char_upcase_symbol, args, T_CHARACTER));
        return(s7_make_character(sc, upper_character(car(args))));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x8, (%rsi)
jne 0x75a9b
movzbl 0x9(%rsi), %eax
movq 0xdcfc2(%rip), %rcx     # 0x152a58
movq (%rcx,%rax,8), %rax
retq
movq 0xdf0(%rdi), %rdx
movl $0x8, %r8d
jmp 0x9b739
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_char_downcase
static s7_pointer g_char_downcase(s7_scheme *sc, s7_pointer args)
    {
#define H_char_downcase "(char-downcase c) converts the character c to lower case"
#define Q_char_downcase sc->pcl_c
        if (!s7_is_character(car(args)))
            return(method_or_bust_one_arg(sc, car(args), sc->char_downcase_symbol, args, T_CHARACTER));
        return(s7_make_character(sc, lowers[character(car(args))]));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x8, (%rsi)
jne 0x75ad4
movzbl 0x8(%rsi), %eax
leaq 0xe79ac(%rip), %rcx     # 0x15d470
movzbl (%rax,%rcx), %eax
movq 0xdcf89(%rip), %rcx     # 0x152a58
movq (%rcx,%rax,8), %rax
retq
movq 0xdb0(%rdi), %rdx
movl $0x8, %r8d
jmp 0x9b739
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_char_to_integer
static s7_pointer g_char_to_integer(s7_scheme *sc, s7_pointer args)
    {
#define H_char_to_integer "(char->integer c) converts the character c to an integer"
#define Q_char_to_integer s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_char_symbol)

        if (!s7_is_character(car(args)))
            return(method_or_bust_one_arg(sc, car(args), sc->char_to_integer_symbol, args, T_CHARACTER));
        return(small_int(character(car(args))));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x8, (%rsi)
jne 0x75b02
movzbl 0x8(%rsi), %eax
leaq 0xd8e53(%rip), %rcx     # 0x14e950
movq (%rcx,%rax,8), %rax
retq
movq 0xde8(%rdi), %rdx
movl $0x8, %r8d
jmp 0x9b739
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_char_upper_case
static s7_pointer g_is_char_upper_case(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer arg;
#define H_is_char_upper_case "(char-upper-case? c) returns #t if the character c is in upper case"
#define Q_is_char_upper_case sc->pl_bc

        arg = car(args);
        if (!s7_is_character(arg))
            return(method_or_bust_one_arg(sc, arg, sc->is_char_upper_case_symbol, args, T_CHARACTER));
        return(make_boolean(sc, is_char_uppercase(arg)));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x8, (%rsi)
jne 0x75b39
movzbl 0x13(%rsi), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
movq 0x1028(%rdi), %rdx
movl $0x8, %r8d
jmp 0x9b739
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_char_lower_case
static s7_pointer g_is_char_lower_case(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer arg;
#define H_is_char_lower_case "(char-lower-case? c) returns #t if the character c is in lower case"
#define Q_is_char_lower_case sc->pl_bc

        arg = car(args);
        if (!s7_is_character(arg))
            return(method_or_bust_one_arg(sc, arg, sc->is_char_lower_case_symbol, args, T_CHARACTER));
        return(make_boolean(sc, is_char_lowercase(arg)));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x8, (%rsi)
jne 0x75b67
movzbl 0x14(%rsi), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
movq 0x1010(%rdi), %rdx
movl $0x8, %r8d
jmp 0x9b739
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_char_alphabetic
static s7_pointer g_is_char_alphabetic(s7_scheme *sc, s7_pointer args)
    {
#define H_is_char_alphabetic "(char-alphabetic? c) returns #t if the character c is alphabetic"
#define Q_is_char_alphabetic sc->pl_bc
        if (!s7_is_character(car(args)))
            return(method_or_bust_one_arg(sc, car(args), sc->is_char_alphabetic_symbol, args, T_CHARACTER));
        return(make_boolean(sc, is_char_alphabetic(car(args))));

        /* isalpha returns #t for (integer->char 226) and others in that range */
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x8, (%rsi)
jne 0x75b95
movzbl 0x10(%rsi), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
movq 0x1008(%rdi), %rdx
movl $0x8, %r8d
jmp 0x9b739
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_char_numeric
static s7_pointer g_is_char_numeric(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer arg;
#define H_is_char_numeric "(char-numeric? c) returns #t if the character c is a digit"
#define Q_is_char_numeric sc->pl_bc

        arg = car(args);
        if (!s7_is_character(arg))
            return(method_or_bust_one_arg(sc, arg, sc->is_char_numeric_symbol, args, T_CHARACTER));
        return(make_boolean(sc, is_char_numeric(arg)));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x8, (%rsi)
jne 0x75bc3
movzbl 0x11(%rsi), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
movq 0x1018(%rdi), %rdx
movl $0x8, %r8d
jmp 0x9b739
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_char_whitespace
static s7_pointer g_is_char_whitespace(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer arg;
#define H_is_char_whitespace "(char-whitespace? c) returns #t if the character c is non-printing character"
#define Q_is_char_whitespace sc->pl_bc

        arg = car(args);
        if (!s7_is_character(arg))
            return(method_or_bust_one_arg(sc, arg, sc->is_char_whitespace_symbol, args, T_CHARACTER));
        return(make_boolean(sc, is_char_whitespace(arg)));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x8, (%rsi)
jne 0x75bf1
movzbl 0x12(%rsi), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
movq 0x1030(%rdi), %rdx
movl $0x8, %r8d
jmp 0x9b739