LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_file_exists
static s7_pointer g_file_exists(s7_scheme *sc, s7_pointer args)
    {
#define H_file_exists "(file-exists? filename) returns #t if the file exists"
#define Q_file_exists s7_make_signature(sc, 2, sc->is_boolean_symbol, sc->is_string_symbol)

        s7_pointer name;
        name = car(args);

        if (!is_string(name))
            return(method_or_bust_one_arg(sc, name, sc->file_exists_symbol, args, T_STRING));
        return(s7_make_boolean(sc, file_probe(string_value(name))));
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x6f4f6
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1e78(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x13, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x6f521
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1bafe0
movq (%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x9c10
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_delete_file
static s7_pointer g_delete_file(s7_scheme *sc, s7_pointer args)
    {
#define H_delete_file "(delete-file filename) deletes the file filename."
#define Q_delete_file s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_string_symbol)

        s7_pointer name;
        name = car(args);

        if (!is_string(name))
            return(method_or_bust_one_arg(sc, name, sc->delete_file_symbol, args, T_STRING));
        return(make_integer(sc, unlink(string_value(name))));
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x6f589
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0x1e80(%rax), %rdx
movq 0x30(%rsp), %rcx
movl $0x13, %r8d
callq 0xcfd30
movq %rax, 0x40(%rsp)
jmp 0x6f64e
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x90a0
cltq
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x6f5c5
movq 0x20(%rsp), %rcx
leaq 0x1a6ec5(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x6f63b
jmp 0x6f5c7
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x6f5eb
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0xb, (%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_getenv
static s7_pointer g_getenv(s7_scheme *sc, s7_pointer args)
    {
#define H_getenv "(getenv var) returns the value of an environment variable."
#define Q_getenv sc->pcl_s

        s7_pointer name;
        name = car(args);

        if (!is_string(name))
            return(method_or_bust_one_arg(sc, name, sc->getenv_symbol, args, T_STRING));
        return(s7_make_string(sc, getenv(string_value(name))));
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x6f6b6
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1e88(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x13, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x6f6de
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x9030
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x14630
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_file_mtime
static s7_pointer g_file_mtime(s7_scheme *sc, s7_pointer args)
    {
#define H_file_mtime "(file-mtime file): return the write date of file"
#define Q_file_mtime s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_string_symbol)

        struct stat statbuf;
        int32_t err;
        s7_pointer name;

        name = car(args);
        if (!is_string(name))
            return(method_or_bust_one_arg(sc, name, sc->file_mtime_symbol, args, T_STRING));

        err = stat(string_value(name), &statbuf);
        if (err < 0)
            return(file_error(sc, "file-mtime", strerror(errno), string_value(name)));

        return(s7_make_integer(sc, (s7_int)(statbuf.st_mtime)));
    }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x6fd1e
movq 0xb8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0xb8(%rsp), %rax
movq 0x1ea0(%rax), %rdx
movq 0xb0(%rsp), %rcx
movl $0x13, %r8d
callq 0xcfd30
movq %rax, 0xc0(%rsp)
jmp 0x6fd96
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x20(%rsp), %rsi
callq 0x93d0
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jge 0x6fd7c
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x9090
movl (%rax), %edi
callq 0x96b0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
leaq 0x176031(%rip), %rsi    # 0x1e5d9e
callq 0x154a0
movq %rax, 0xc0(%rsp)
jmp 0x6fd96
movq 0xb8(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x120f0
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_real_part
static s7_pointer g_real_part(s7_scheme *sc, s7_pointer args)
    {
#define H_real_part "(real-part num) returns the real part of num"
#define Q_real_part s7_make_signature(sc, 2, sc->is_real_symbol, sc->is_number_symbol)

        s7_pointer p;
        p = car(args);
        switch (type(p))
        {
            case T_INTEGER:
            case T_RATIO:
            case T_REAL:
                return(p);

            case T_COMPLEX:
                return(make_real(sc, real_part(p)));

#if WITH_GMP
            case T_BIG_INTEGER:
            case T_BIG_RATIO:
            case T_BIG_REAL:
                return(p);

            case T_BIG_COMPLEX:
                {
                    s7_pointer x;

                    new_cell(sc, x, T_BIG_REAL);
                    add_big_real(sc, x);
                    mpfr_init(big_real(x));
                    mpc_real(big_real(x), big_complex(p), GMP_RNDN);

                    return(x);
                }
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, p, sc->real_part_symbol, args, a_number_string));
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0xc(%rsp)
addl $-0xb, %eax
subl $0x3, %eax
jb 0x6fdf0
jmp 0x6fde2
movl 0xc(%rsp), %eax
subl $0xe, %eax
je 0x6fdff
jmp 0x6fe88
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x6feb4
movq 0x28(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x6fe33
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0xd, (%rax)
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x6feb4
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0x1468(%rax), %rdx
movq 0x30(%rsp), %rcx
movq 0x1b5046(%rip), %r8     # 0x224ef0
callq 0x1ba7e0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_imag_part
static s7_pointer g_imag_part(s7_scheme *sc, s7_pointer args)
    {
#define H_imag_part "(imag-part num) returns the imaginary part of num"
#define Q_imag_part s7_make_signature(sc, 2, sc->is_real_symbol, sc->is_number_symbol)
        s7_pointer p;
        /* currently (imag-part +nan.0) -> 0.0 ? it's true but maybe confusing */

        p = car(args);
        switch (type(p))
        {
            case T_INTEGER:
            case T_RATIO:
                return(small_int(0));

            case T_REAL:
                return(real_zero);

            case T_COMPLEX:
                return(make_real(sc, imag_part(p)));

#if WITH_GMP
            case T_BIG_INTEGER:
            case T_BIG_RATIO:
                return(small_int(0));

            case T_BIG_REAL:
                return(real_zero);

            case T_BIG_COMPLEX:
                {
                    s7_pointer x;
                    new_cell(sc, x, T_BIG_REAL);
                    add_big_real(sc, x);
                    mpfr_init(big_real(x));
                    mpc_imag(big_real(x), big_complex(p), GMP_RNDN);

                    return(x);
                }
#endif

            default:
                return(method_or_bust_with_type_one_arg(sc, p, sc->imag_part_symbol, args, a_number_string));
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0xc(%rsp)
addl $-0xb, %eax
subl $0x2, %eax
jb 0x6ff0b
jmp 0x6fef2
movl 0xc(%rsp), %eax
subl $0xd, %eax
je 0x6ff1c
jmp 0x6fefd
movl 0xc(%rsp), %eax
subl $0xe, %eax
je 0x6ff2d
jmp 0x6ffb6
movq 0x1a656e(%rip), %rax    # 0x216480
movq %rax, 0x40(%rsp)
jmp 0x6ffe2
movq 0x1aa865(%rip), %rax    # 0x21a788
movq %rax, 0x40(%rsp)
jmp 0x6ffe2
movq 0x28(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x6ff61
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0xd, (%rax)
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x6ffe2
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0xf88(%rax), %rdx
movq 0x30(%rsp), %rcx
movq 0x1b4f18(%rip), %r8     # 0x224ef0
callq 0x1ba7e0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_numerator
static s7_pointer g_numerator(s7_scheme *sc, s7_pointer args)
    {
#define H_numerator "(numerator rat) returns the numerator of the rational number rat"
#define Q_numerator s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_rational_symbol)

        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_RATIO:       return(make_integer(sc, numerator(x)));
            case T_INTEGER:     return(x);
#if WITH_GMP
            case T_BIG_INTEGER: return(x);
            case T_BIG_RATIO:   return(mpz_to_big_integer(sc, mpq_numref(big_ratio(x))));
#endif
            default:            return(method_or_bust_with_type_one_arg(sc, x, sc->numerator_symbol, args, a_rational_string));
        }
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x14(%rsp)
subl $0xb, %eax
je 0x700f5
jmp 0x70023
movl 0x14(%rsp), %eax
subl $0xc, %eax
jne 0x70101
jmp 0x70032
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x70068
movq 0x30(%rsp), %rcx
leaq 0x1a6423(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x700df
jmp 0x7006a
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x7008e
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0xb, (%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x7012d
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x7012d
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rax
movq 0x1378(%rax), %rdx
movq 0x40(%rsp), %rcx
movq 0x1b5085(%rip), %r8     # 0x2251a8
callq 0x1ba7e0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_denominator
static s7_pointer g_denominator(s7_scheme *sc, s7_pointer args)
    {
#define H_denominator "(denominator rat) returns the denominator of the rational number rat"
#define Q_denominator s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_rational_symbol)

        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_RATIO:       return(make_integer(sc, denominator(x)));
            case T_INTEGER:     return(small_int(1));
#if WITH_GMP
            case T_BIG_INTEGER: return(small_int(1));
            case T_BIG_RATIO:   return(mpz_to_big_integer(sc, mpq_denref(big_ratio(x))));
#endif
            default:            return(method_or_bust_with_type_one_arg(sc, x, sc->denominator_symbol, args, a_rational_string));
        }
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x14(%rsp)
subl $0xb, %eax
je 0x70245
jmp 0x70173
movl 0x14(%rsp), %eax
subl $0xc, %eax
jne 0x70253
jmp 0x70182
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x701b8
movq 0x30(%rsp), %rcx
leaq 0x1a62d3(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x7022f
jmp 0x701ba
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x701de
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0xb, (%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x7027f
movq 0x1a623c(%rip), %rax    # 0x216488
movq %rax, 0x50(%rsp)
jmp 0x7027f
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rax
movq 0xe70(%rax), %rdx
movq 0x40(%rsp), %rcx
movq 0x1b4f33(%rip), %r8     # 0x2251a8
callq 0x1ba7e0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_is_even
static s7_pointer g_is_even(s7_scheme *sc, s7_pointer args)
    {
#define H_is_even "(even? int) returns #t if the integer int32_t is even"
#define Q_is_even s7_make_signature(sc, 2, sc->is_boolean_symbol, sc->is_integer_symbol)

        s7_pointer p;
        p = car(args);
        switch (type(p))
        {
            case T_INTEGER:     return(make_boolean(sc, ((integer(p) & 1) == 0)));
#if WITH_GMP
            case T_BIG_INTEGER: return(make_boolean(sc, mpz_even_p(big_integer(p))));
#endif
            default:            return(method_or_bust_one_arg(sc, p, sc->is_even_symbol, list_1(sc, p), T_INTEGER));
        }
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movb (%rax), %al
subb $0xb, %al
jne 0x702ff
jmp 0x702b9
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x702df
movq 0x58(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x702f0
movq 0x58(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x703dc
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq 0x1080(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x70363
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movl $0xb, %r8d
callq 0xcfd30
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_is_odd
static s7_pointer g_is_odd(s7_scheme *sc, s7_pointer args)
    {
#define H_is_odd "(odd? int) returns #t if the integer int32_t is odd"
#define Q_is_odd s7_make_signature(sc, 2, sc->is_boolean_symbol, sc->is_integer_symbol)

        s7_pointer p;
        p = car(args);
        switch (type(p))
        {
            case T_INTEGER:     return(make_boolean(sc, ((integer(p) & 1) == 1)));
#if WITH_GMP
            case T_BIG_INTEGER: return(make_boolean(sc, mpz_odd_p(big_integer(p))));
#endif
            default:            return(method_or_bust_one_arg(sc, p, sc->is_odd_symbol, list_1(sc, p), T_INTEGER));
        }
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movb (%rax), %al
subb $0xb, %al
jne 0x7045f
jmp 0x70419
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
andq $0x1, %rax
cmpq $0x1, %rax
jne 0x7043f
movq 0x58(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x70450
movq 0x58(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x7053c
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq 0x1128(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x704c3
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movl $0xb, %r8d
callq 0xcfd30
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_is_zero
static s7_pointer g_is_zero(s7_scheme *sc, s7_pointer args)
    {
#define H_is_zero "(zero? num) returns #t if the number num is zero"
#define Q_is_zero sc->pl_bn
        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:     return(make_boolean(sc, integer(x) == 0));
            case T_REAL:        return(make_boolean(sc, real(x) == 0.0));
            case T_RATIO:
            case T_COMPLEX:     return(sc->F);      /* ratios and complex numbers are already collapsed into integers and reals */
#if WITH_GMP
            case T_BIG_INTEGER: return(make_boolean(sc, mpz_cmp_ui(big_integer(x), 0) == 0));
            case T_BIG_REAL:    return(make_boolean(sc, mpfr_zero_p(big_real(x))));
            case T_BIG_RATIO:
            case T_BIG_COMPLEX: return(sc->F);
#endif
            default:
                                return(method_or_bust_with_type_one_arg(sc, x, sc->is_zero_symbol, list_1(sc, x), a_number_string));
        }
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
addl $-0xb, %eax
movl %eax, %ecx
movq %rcx, 0x30(%rsp)
subl $0x3, %eax
ja 0x70639
movq 0x30(%rsp), %rax
leaq 0x16e42d(%rip), %rcx    # 0x1de9c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x58(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x705bb
movq 0x68(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x705cc
movq 0x68(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x70717
movq 0x58(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x70603
jp 0x70603
movq 0x68(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x70614
movq 0x68(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x70717
movq 0x68(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x70717
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq 0x11c0(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x7069d
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rcx
movq 0x1b47e3(%rip), %r8     # 0x224ef0
callq 0x1ba7e0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0xb, %eax
je 0x7526f
jmp 0x7524f
movl 0xc(%rsp), %eax
addl $-0xc, %eax
subl $0x2, %eax
jb 0x7528e
jmp 0x7525d
movl 0xc(%rsp), %eax
subl $0xe, %eax
je 0x7531f
jmp 0x7539b
movq 0x48(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x7528c
movq 0x1a11fe(%rip), %rax    # 0x216480
movq %rax, 0x60(%rsp)
jmp 0x753c7
jmp 0x7528e
movq 0x48(%rsp), %rdi
callq 0x128d0
callq 0x9450
movsd %xmm0, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x752c7
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq $0xd, (%rax)
movsd 0x38(%rsp), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x753c7
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x48(%rsp), %rax
movsd 0x10(%rax), %xmm0
xorps %xmm3, %xmm3
movaps %xmm0, %xmm2
mulsd %xmm3, %xmm2
movsd 0x16c61a(%rip), %xmm3   # 0x1e1968
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm1
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x9340
movq (%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x1bb560
movq %rax, 0x60(%rsp)
jmp 0x753c7
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x58(%rsp), %rax
movq 0x14e0(%rax), %rdx
movq 0x50(%rsp), %rcx
movq 0x1afb33(%rip), %r8     # 0x224ef0
callq 0x1ba7e0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0xb, %eax
je 0x7542f
jmp 0x7540f
movl 0xc(%rsp), %eax
addl $-0xc, %eax
subl $0x2, %eax
jb 0x7544e
jmp 0x7541d
movl 0xc(%rsp), %eax
subl $0xe, %eax
je 0x754df
jmp 0x7555b
movq 0x48(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x7544c
movq 0x1a1046(%rip), %rax    # 0x216488
movq %rax, 0x60(%rsp)
jmp 0x75587
jmp 0x7544e
movq 0x48(%rsp), %rdi
callq 0x128d0
callq 0x93f0
movsd %xmm0, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x75487
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq $0xd, (%rax)
movsd 0x38(%rsp), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x75587
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x48(%rsp), %rax
movsd 0x10(%rax), %xmm0
xorps %xmm3, %xmm3
movaps %xmm0, %xmm2
mulsd %xmm3, %xmm2
movsd 0x16c45a(%rip), %xmm3   # 0x1e1968
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm1
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x91b0
movq (%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x1bb560
movq %rax, 0x60(%rsp)
jmp 0x75587
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x58(%rsp), %rax
movq 0xe30(%rax), %rdx
movq 0x50(%rsp), %rcx
movq 0x1af973(%rip), %r8     # 0x224ef0
callq 0x1ba7e0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x7dee4
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x19c63e(%rip), %rax    # 0x21a4a0
testb $0x1, (%rax,%rcx)
jne 0x7de99
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0xe88(%rax), %rdx
movq 0x20(%rsp), %rcx
movq 0x1a7066(%rip), %r8     # 0x224ef0
callq 0x1ba7e0
movq %rax, 0x30(%rsp)
jmp 0x7df61
movq 0x18(%rsp), %rdi
callq 0x1bb660
testb $0x1, %al
jne 0x7dea9
jmp 0x7dece
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xe88(%rax), %rsi
movq 0x20(%rsp), %rdx
callq 0x123b0
movq %rax, 0x30(%rsp)
jmp 0x7df61
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1becd0
movq %rax, 0x30(%rsp)
jmp 0x7df61
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x7df23
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq 0x20(%rsp), %rcx
callq 0x1bef10
movq %rax, 0x30(%rsp)
jmp 0x7df61
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0xe88(%rax), %rdx
callq 0x1bcbd0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x1bef10
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11340
testb $0x1, %al
jne 0x87fa4
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x38(%rsp), %rax
movq 0x12b0(%rax), %rdx
movq 0x30(%rsp), %rcx
movl $0xb, %r8d
callq 0xcfd30
movq %rax, 0x40(%rsp)
jmp 0x8806e
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x10790
xorq $-0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x87fe3
movq 0x28(%rsp), %rcx
leaq 0x18e4a8(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x8805a
jmp 0x87fe5
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x88009
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0xb, (%rax)
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0x880e0
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x58(%rsp), %rax
movq 0xbd8(%rax), %rdx
movq 0x50(%rsp), %rcx
movl $0xb, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x60(%rsp)
jmp 0x88223
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0x88136
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x58(%rsp), %rax
movq 0xbd8(%rax), %rdx
movq 0x50(%rsp), %rcx
movl $0xb, %r8d
movl $0x2, %r9d
callq 0x13c50
movq %rax, 0x60(%rsp)
jmp 0x88223
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x10790
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x10790
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x1c1880
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x88198
movq 0x38(%rsp), %rcx
leaq 0x18e2f3(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x8820f
jmp 0x8819a
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x881be
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq $0xb, (%rax)
movq 0x38(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0x889ca
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x68(%rsp), %rax
movq 0x1718(%rax), %rdx
movq 0x60(%rsp), %rcx
movl $0xb, %r8d
callq 0xcfd30
movq %rax, 0x70(%rsp)
jmp 0x88b7a
movq 0x50(%rsp), %rdi
callq 0x10790
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jge 0x88ab9
movq 0x58(%rsp), %rax
addq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edi
subq %rax, %rdi
callq 0x1c1fb0
cltq
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x88a29
movq 0x48(%rsp), %rcx
leaq 0x18da62(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x88aa0
jmp 0x88a2b
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x88a4f
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0xb, (%rax)
movq 0x48(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x88b7a
movq 0x58(%rsp), %rdi
callq 0x1c1fb0
cltq
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x88af1
movq 0x28(%rsp), %rcx
leaq 0x18d999(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x88b67
jmp 0x88af3
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x88b17
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0xb, (%rax)
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_is_exact
static s7_pointer g_is_exact(s7_scheme *sc, s7_pointer args)
    {
#define H_is_exact "(exact? num) returns #t if num is exact (an integer or a ratio)"
#define Q_is_exact sc->pl_bn

        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:
            case T_RATIO:       return(sc->T);
            case T_REAL:
            case T_COMPLEX:     return(sc->F);
#if WITH_GMP
            case T_BIG_INTEGER:
            case T_BIG_RATIO:   return(sc->T);
            case T_BIG_REAL:
            case T_BIG_COMPLEX: return(sc->F);
#endif
            default:
                                return(method_or_bust_with_type_one_arg(sc, x, sc->is_exact_symbol, args, a_number_string));
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x4(%rsp)
addl $-0xb, %eax
subl $0x2, %eax
jb 0x89e00
jmp 0x89df2
movl 0x4(%rsp), %eax
addl $-0xd, %eax
subl $0x2, %eax
jb 0x89e13
jmp 0x89e26
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x89e52
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x89e52
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1088(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x19b0a8(%rip), %r8     # 0x224ef0
callq 0x1ba7e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_is_inexact
static s7_pointer g_is_inexact(s7_scheme *sc, s7_pointer args)
    {
#define H_is_inexact "(inexact? num) returns #t if num is inexact (neither an integer nor a ratio)"
#define Q_is_inexact sc->pl_bn

        s7_pointer x;
        x = car(args);
        switch (type(x))
        {
            case T_INTEGER:
            case T_RATIO:       return(sc->F);
            case T_REAL:
            case T_COMPLEX:     return(sc->T);
#if WITH_GMP
            case T_BIG_INTEGER:
            case T_BIG_RATIO:   return(sc->F);
            case T_BIG_REAL:
            case T_BIG_COMPLEX: return(sc->T);
#endif
            default:
                                return(method_or_bust_with_type_one_arg(sc, x, sc->is_inexact_symbol, args, a_number_string));
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x4(%rsp)
addl $-0xb, %eax
subl $0x2, %eax
jb 0x89ea0
jmp 0x89e92
movl 0x4(%rsp), %eax
addl $-0xd, %eax
subl $0x2, %eax
jb 0x89eb3
jmp 0x89ec6
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x89ef2
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x89ef2
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x10b0(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x19b008(%rip), %r8     # 0x224ef0
callq 0x1ba7e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x8a387
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1028(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x8, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8a3bd
movq 0x8(%rsp), %rax
testb $0x1, 0x13(%rax)
je 0x8a3a4
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, (%rsp)
jmp 0x8a3b4
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x8a427
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1010(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x8, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8a45d
movq 0x8(%rsp), %rax
testb $0x1, 0x14(%rax)
je 0x8a444
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, (%rsp)
jmp 0x8a454
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x14430
testb $0x1, %al
jne 0x8a4c1
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x1008(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x8, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8a4fe
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x10(%rax)
je 0x8a4e3
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x8a4f4
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x8a567
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1018(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x8, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8a59d
movq 0x8(%rsp), %rax
testb $0x1, 0x11(%rax)
je 0x8a584
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, (%rsp)
jmp 0x8a594
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x8a607
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1030(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x8, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8a63d
movq 0x8(%rsp), %rax
testb $0x1, 0x12(%rax)
je 0x8a624
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, (%rsp)
jmp 0x8a634
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)